Gigai Chronicle

Build software with AI. Never lose the journey.

Git answers what changed. It has never answered what was asked.

As AI writes more of your code, that second history — the prompts, the attempts, the reasoning, the things you rejected — is scattered across tool-specific log files or thrown away. Chronicle keeps it: an append-only, plain-text record of your AI-assisted development, inside your own repo, that travels by git clone like everything else.

No account. No server. No network. It never calls a model.

$ chronicle why packages/core/src/prompts/prompts.ts

why packages/core/src/prompts/prompts.ts looks like this — 1 prompt(s):

  2026-07-17 07:33     +65 −1  "histry not like that UI make like git tree view this is very basic"
                               ⏪ chronicle restore evt_01KXQFWE3F8BCXD1MZ7K3HFNEX

git blame says you wrote those 65 lines. Chronicle says what you asked for — and can put the code back to the moment before you asked.

Plus a VS Code extension: history in the sidebar, prompt version history as a git-style graph, and Why is this file like this? in the editor.

The captured journey becomes persistent project knowledge and development intelligence — all local, deterministic, and model-free (Chronicle never calls a model):

New here? → Quick Start · Why Chronicle? · Features

Requires Node ≥ 20.19 and git.

The CLI — on npm:

npm install -g gigai-chronicle
chronicle --help

The editor extension (VS Code, Cursor, Windsurf) — grab the .vsix from Releases → Command Palette → Extensions: Install from VSIX…. (Marketplace and Open VSX listings are rolling out.)

git clone https://github.com/cbsshekhawat18-lab/gigai-chronicle.git
cd gigai-chronicle
corepack pnpm install && corepack pnpm build
cd apps/cli && npm link          # exposes `chronicle`

cd your-git-repo

chronicle init   # 3 questions, all skippable — or --yes
                 # starts live capture too (hooks merge into .claude/settings.json)

That's it. Work normally. Every prompt is now recorded — and every prompt checkpoints your code, so you can always go back.

chronicle timeline          # what happened
chronicle sessions          # who/what did the work, with model badges
chronicle why src/auth.ts   # what was ASKED that made this file
chronicle doctor            # prove it's all local and intact

Already have history? Backfill it — idempotent, reads transcripts you already have on disk:

chronicle import claude-code

--json on every command ({"apiVersion":1,…}) — the machine contract. Exit codes: 0 ok · 1 failure · 2 usage · 3 not a Chronicle project.

Your AI tool ──hooks──▶ Event Engine ──▶ .chronicle/  ──▶ Replay ──▶ CLI / VS Code
                        VALIDATE          (JSONL,           │
                        REDACT             plain text,      └─▶ why · restore
                        ENRICH             in your repo)
                        NORMALIZE

• The store is a directory in your git repo. Files are the API; git is the transport. That one choice is why there is no infrastructure to run.
• The Event Engine is the only way in. Secrets are redacted before the first byte reaches disk.
• Checkpoints are git-native. Every prompt snapshots your tree into a hidden ref (refs/chronicle/ckpt/*) in your own object store — never touching HEAD, your branches, or your history.
• The index is a disposable cache. Deleting .chronicle/.cache/ is always safe.

Deep dive: ARCHITECTURE.md.

Built for people who cannot send their prompts to a vendor.

• Zero network by default — and it proves it on demand:

  $ chronicle doctor
  egress   zero-network (no endpoints configured, telemetry: none)

• Never calls a model. Never phones home. Never stores your file contents.
• Secrets are redacted at capture, irreversibly, before anything is written — including your own shapes via capture.redaction.customPatterns.
• --metadata-only records event shapes and timings with no prompt text, for repos where the words themselves are sensitive.
• Sessions can be born private (--private-sessions) or moved off the shared record any time (chronicle session privatize).
• Never scores developers. No leaderboards, no per-author metrics. Ever.

⚠️ Understand the default: your journey is shared — it commits with your repo and pushes with it. That's the point (a teammate clones and inherits the whole story), but it means your prompts are exactly as public as your repository. Read docs/privacy.md before pushing anything sensitive.

A teammate clones and immediately has the journey — no setup, no account:

$ chronicle replay ses_01KXQGDTFD0GSQ92AWZ1E9XPJN
[07:44] you      one think, we give user only histry and version control system…
[09:40] you      check now
[09:40] tool     Bash → success

Prompts saved to the library travel the same way — review them in a PR like any other file.

Honest limit: why and restore are local-only. Checkpoints live in git refs that aren't pushed, so a fresh clone can replay the story but cannot attribute lines. Replay is the team surface; why is your personal one.

corepack pnpm install
corepack pnpm build        # turbo: all packages
corepack pnpm test         # every suite (network denied by the harness)
corepack pnpm typecheck
corepack pnpm lint         # architecture boundary checks
corepack pnpm test:scripts # repo tooling + cold-start budget

Contributions welcome — see CONTRIBUTING.md (DCO sign-off, conventional commits, tests with every PR). Security reports: SECURITY.md.

Local-first · plain text · zero network by default · never calls a model · never writes your git history · never scores developers · your data is yours.

Free and open. MIT for the code, CC-BY for the spec.