Daybook — Daily Change Tracker

Records every file you or an AI agent changes, bucketed by date, and copies them into dated snapshot folders.

No git required. No dev server. Any language, any framework.

Why

You need to hand over what changed today — to a client, a reviewer, a deployment folder. On a machine without git, in a project that isn't JavaScript, without remembering to start anything.

Daybook watches through VS Code itself, so it works the moment you open a folder.

What it does

• Records saves, autosaves, creates and renames as they happen
• Reconciles anything written by an agent (Claude, Codex, Cursor …), an external tool, or while VS Code was closed — automatically, on an interval
• Filters in one of two modes you switch from the status bar — ignore (record all but .daybookignore) or approve (record only .daybookapprove), gitignore syntax, per-workspace or global
• Copies a date's files into <store>/2026-09-09/<original path>, structure preserved, optionally zipped, with a manifest

How it works, start to finish

1. Open a folder. Daybook activates. Nothing to start, nothing to configure.

2. Work. Every save, autosave, create and rename is recorded into changes.json, bucketed by local date and deduped — a file edited fifty times today is one entry. The status bar shows ⟳ 12 today.

3. An agent edits files. Claude Code, Codex, Cursor, a script, a git pull in a terminal — files changed with no editor event. Every 60 seconds Daybook walks the project for anything modified since its watermark and records those too. It also runs on startup and when the window regains focus, so edits made while VS Code was closed are picked up the next time you open it.

4. Check what's there. Click the status bar, or run Daybook: Show Today's Changes — a quick pick of today's files, click to open. Something you never want recorded? Right-click it → Untrack This File.

5. Copy Changes. Pick today, a past date, or all. Daybook reconciles first, so the snapshot is never stale, then writes:

<store>/2026-09-09/
├── src/api/authApi.ts        original folder structure preserved
├── src/components/Table.tsx
└── _manifest.json            path, size, mtime, sha1, copiedAt
2026-09-09.zip                if copyFormat is zip or both

Result: 18 copied · 2 missing · zip ok. A file that was recorded but deleted before the copy is flagged "missing": true in the manifest rather than silently absent — a gap in a handoff should be visible.

6. Hand the folder over. That's the deliverable.

Where files go

Your choice, in Settings (Ctrl+, → daybook):

• In the workspace — <project>/changes/ (default)
• Global — any path you define, e.g. ~/Daybook/<project>/, leaving the repository completely untouched. Supports ~, ${userHome}, ${workspaceFolder} and ${env:VAR}.

In global mode each project gets its own subfolder, named <project>-<hash> by default so two projects with the same folder name never merge. Set store.projectFolder to a literal name for a readable handoff folder.

Not sure where it landed? Daybook: Reveal Store Path.

Settings

Store settings are per-project overridable — set a global default in User settings, override it in .vscode/settings.json.

Two modes: ignore or approve

Daybook filters in one of two modes, and they are mutually exclusive — only one file is ever read, so "why was this recorded?" has exactly one answer.

The mode is yours to set, never inferred from a file existing. Click the mode indicator in the status bar — ⚙ ignore / 🛡 approve — or run Daybook: Switch Mode.

The mode is per project. It is always written to this workspace's .vscode/settings.json, so switching one project to approve mode never touches any other project. Every project starts in ignore mode.

The filter files themselves have two layers each: a project copy at the workspace root, and a machine-wide copy — both reachable through the Edit commands. A shared global approve list plus a per-project mode means you can keep one allowlist and turn it on only where you want it.

Both files use gitignore syntax with ! negation, and both reload the moment you save them.

Writing an approve list

Patterns match the same way gitignore does — per path component, so a folder entry is fully recursive. All four of these record every file under src, at any depth:

src/          ← clearest
src
src/*
src/**

So src/* is not "direct children only" — src/api/deep/c.ts matches too. Use negation to subtract, since .daybookignore is not read in this mode:

src/
!src/**/*.test.ts
package.json
*.md

An approve file with no entries records nothing. That is the literal reading of the mode, so the status bar marks it approve (empty) with a warning colour rather than quietly falling back.

node_modules, .git, dist, out, build and Daybook's own store are excluded in both modes and cannot be approved or negated back in. Directories are pruned during the scan, so a 100k-file project never descends into node_modules — and in approve mode pruning uses only those built-ins, so approving src/api/** still reaches the files even though src/ itself is not on the list.

Commands

The one honest limitation

Nothing runs while VS Code is closed. An agent working at 2am is recorded the next time you open the folder, via the modification-time watermark — correct, just not live.

And because the ledger stores paths rather than content, copying a past date gives you those files as they are now. Content history is git's job. Copy daily if that matters.

License

MIT © 2026 Walli Ahmad