CLI built today

One loop.
Four steps.

Time Machine saves your project while agents work. It checks each save point in a separate copy, finds the newest one that works, and brings it back on a new branch. Your folder is never touched.

See the commands Read the verdicts

01 Save10:42:07

$ tm checkpoint -m "Added dark mode"

Saved cp-0003 "Added dark mode"

Code, 1 file, 2 config keys

Not saved: secret values

Not checked yet.

Turn the knob or press a key. Output from a real tm demo run, shortened.

Save. Check.
Find. Recover.

Each step is one command. With the Claude Code hooks installed, the first two happen on their own while your agent works.

01 Save

Save the whole project.

A save point records your code, including uncommitted changes, files not in Git yet, config key names, and dependency and environment fingerprints. It is stored outside your project.
```
$ tm checkpoint -m "Added dark mode"
Saved cp-0003  "Added dark mode"
Not checked yet.
```
02 Check

Run your check in a safe copy.

Time Machine rebuilds the save point in a separate Git worktree and runs your own check there, like npm test, with a clean environment and a time limit.
```
$ tm verify cp-0003
PASS  cp-0003 works
(host mode, network on, 1.4 s)
```
03 Find

Find the last version that works.

When something breaks, find-good checks save points from newest to oldest and stops at the first one that passes.
```
$ tm find-good
cp-0004   FAIL
cp-0003   PASS
PASS  cp-0003 is the newest
      version that works.
```
04 Recover

Bring it back on a new branch.

Recover saves your current state first. Then it makes a new branch and a recovery copy next to your project. It never switches your folder, and never pushes, merges or deploys.
```
$ tm recover cp-0003
Branch      tm/recover/cp-0003
Saved first cp-0007
Not restored: secret values
```

Switching to the recovery is up to you. The recovery report gives you the two Git commands to do it. It also lists every secret key you need to set again by hand, and what was never captured, like databases and deployed versions.

What it holds.
What it does not.

Every save point lists what it did not save. So does every recovery. Nothing that was missed is ever shown as safe.

Saved

Code, with uncommitted changes. Pinned at refs/tm/<id> and written as a Git bundle into the store.
Files not in Git yet, unless .gitignore skips them, plus anything you list in capture.include.
Config key names and a fingerprint, so a changed value shows up in tm diff. Values only for keys you mark as plain.
Fingerprints of lockfiles and environment files, and the Node, Git and platform versions.

Not saved

Secret values. A file that looks like it holds a secret is skipped and listed. You set secret values again by hand.
Files over the size limit (5 MB by default) and symbolic links. Both are listed as missing.
Installed dependencies like node_modules. Only the lockfile fingerprint is kept.
Files your .gitignore skips, like dist/. Each save point lists them.
Databases, deployed versions, emails, payments and anything else outside your project folder.

Where it lives ~/.timemachine, or $TM_HOME, one folder per project. Deleting your project folder does not delete its save points. How the store works

Five verdicts.
Fixed exit codes.

tm verify and tm find-good exit with the verdict code, so scripts and agents can act on it. A save point that was never checked is shown as not checked, never as working.

Verdict	Exit	In the app	Meaning	What to do
PASS	0	Works	The check passed.	Safe to recover to.
FAIL	1	Broken	The check failed.	Run `tm find-good`. Read the log path shown.
INCOMPLETE	2	Couldn't check	Something saved is missing, or setup failed, so the check did not run.	See the listed files. Raise `capture.maxFileMB`, or skip the file in `.gitignore`.
BLOCKED	3	Needs something	The check cannot run yet. For example, no check is set up, or the network should be off and no sandbox can enforce it.	Fix the reason shown.
ERROR	4	Check crashed	The check crashed, timed out, or the save point failed its integrity check.	Raise `verify.timeoutSeconds`, check the command is installed, or pick another save point.

find-good keeps going past FAIL, INCOMPLETE and ERROR. It stops at the first PASS, or at BLOCKED. Other commands exit 0 on success and 4 on an error. Usage errors exit 64, so they never look like INCOMPLETE. The app words are what the web app shows.

PASS

Works

The check passed.

Verdict

Press a code to light up its row.

One engine.
Two ways in.

The web app and the command line call the same engine. They can never disagree about what works.

Built. Open with tm ui

For builders

You build with Claude Code (automatic saves) or another agent (save by hand), and you would rather not live in a terminal. The web app puts the same loop behind plain buttons. It runs on your computer, in your browser. Nothing is hosted.

A history of save points, each marked Works, Broken or Not checked yet.
Save point detail, with what was saved and what was not.
Rewind and Compare, on the same engine as the CLI.
$50 once for the license key, any number of your own computers and projects. The CLI stays open source (MIT), and restores are never behind the paywall.

The Time Machine web app on the synthetic Marigold Tips project. The newest save point failed its check. A Go back button leads to the last version that passed. The history shows each save point's own verdict.

Real web app screen on a synthetic project, opened with tm ui from a source install.

Built

For developers

The tm command, Claude Code hooks and an MCP server. Every engine command takes --json, and the JSON and the human output come from the same result.

See the whole rescue in a minute

$ tm demo

Builds a small synthetic app, Marigold Tips, breaks it the way an agent might, then finds and recovers the last working version with the real engine.

On your own project

$ tm init
$ tm checkpoint -m "first save point"
$ tm verify
$ tm find-good
$ tm recover cp-0003

Claude Code hooks

$ tm hook install

Claude Code's own rewind does not track files that only Bash commands changed. These hooks save your project before each prompt, and before risky shell commands like rm -rf, git reset --hard, git clean -f or DROP TABLE. For other shell changes, like mv or sed -i, you can go back to the save point taken before that prompt. At the end of each turn it saves and runs your check. If a working state just broke, it tells Claude which save point last worked. The hooks never block your agent because of their own errors.

MCP server

$ claude mcp add timemachine -- tm mcp

Seven tools: checkpoint, timeline, diff, verify, find_good, recover and log. Same engine, same answers.

Install Not on npm yet

git clone https://github.com/ShadowEsu/Time-Machine.git
cd Time-Machine
pnpm install && pnpm build
npm install -g ./packages/cli
tm demo

Needs Node 22 or newer and Git. No pnpm? Run npm install -g pnpm first. Keep the Time-Machine folder. The tm command runs from it. The package will be timetm, and the command is tm. npx timetm init does not work yet.

Every command.

Fifteen commands, all built and tested. -h, --help and --version work everywhere.

tm init: Writes timemachine.yml with a guessed check, like npm test. Keeps an existing file.
tm status: Says whether this project is set up and its check approved on this computer.
tm checkpoint: Saves a save point. -m adds a note. --if-changed skips it when nothing changed.
tm timeline: Lists save points, newest first, with their verdicts.
tm diff a b: Compares code, files, config keys, dependencies and environment.
tm open cp: Rebuilds a save point in a separate folder.
tm verify [cp]: Runs your check on a save point. The newest by default.
tm find-good: Checks from newest to oldest until one passes.
tm recover cp: Saves your current state, then makes a recovery branch and copy.
tm log: Shows the append-only audit log.
tm demo: Builds the Marigold Tips demo and runs the rescue.
tm hook install: Adds the Claude Code hooks to .claude/settings.json. Your other settings stay.
tm mcp: Runs the MCP server over stdio.
tm ui: Opens the web app in your browser, served from your own computer.
tm license [key]: Shows, saves or forgets the web app license on this computer. The CLI itself never needs one.

Build with
a way back.

We write to the list when the CLI is on npm. Nothing else.

One loop.Four steps.

Save. Check.Find. Recover.

Save the whole project.

Run your check in a safe copy.

Find the last version that works.

Bring it back on a new branch.

What it holds.What it does not.