Accuracy note (2026-07-29 audit): This post was reviewed against current official documentation in July 2026 and contains inaccuracies relative to the current state of the tools described. The post is retained for its workflow reasoning; the specific factual issues are:

The Chronicle data inventory below (‘key decisions’ field, ‘full chat transcripts off by default’) does not match the VS Code 1.123 documentation. Per the official release notes, synced sessions capture the conversation, files touched, repository context, and referenced PRs/issues/commits. The cited /docs/copilot/chronicle URL is not a valid documentation path. Refer to the official Session Sync and Chronicle documentation.

Reference docs to verify against:

  • VS Code 1.123 — Session Sync and Chronicle — https://code.visualstudio.com/updates/v1_123#_session-sync-and-chronicle

You are working on a bug fix. You remember having a similar problem two months ago, and you know Copilot helped you think through it. But where?

Is it in a git commit message? A pull request? A Slack thread? A session chat you never saved?

In the past, you would either:

  • Dig through git history
  • Search your terminal history (painful)
  • Recreate the reasoning from scratch

In May 2026, VS Code added Chronicle—a searchable index of your prior Copilot sessions. Instead of hunting through logs, you ask: “What did I work on related to database connection pooling?”

Chronicle surfaces the session, the files changed, and the reasoning behind the decision.

The problem Chronicle solves

AI sessions are like conversations with a colleague. They are valuable in the moment, but they evaporate. A month later, when the same problem comes up:

  • The session chat is buried in VS Code’s history
  • The files changed might be in git, but not the reasoning
  • You end up rediscovering the solution instead of learning from it

Chronicle makes prior sessions discoverable and reusable.

How Chronicle works

Chronicle is a searchable database of your Copilot chat history. When enabled:

  1. Each session is indexed with its context: files discussed, decisions made, commands run
  2. You can search by: topic, filename, technology, date range
  3. When you find a relevant session, you can:
    • Reread the full conversation
    • See which files were changed and how
    • Reference it in a new session (“Based on my Chronicle entry ‘async patterns in Node,’ here is the update…”)

It is not git blame. It is more like a searchable memory of your reasoning process.

Searching Chronicle in VS Code

In VS Code 1.120+, Copilot → Chronicle (or press Cmd/Ctrl+K → “Chronicle”):

Search: [Enter topic, keyword, or filename]
├─ Results show sessions in reverse chronological order
│  ├─ Session Title
│  ├─ Date
│  ├─ Files touched
│  └─ Key decisions

Example searches:

  • database connection pooling
  • React state management bugs
  • filename: auth.ts
  • after:2026-04-01

Chronicle returns matching sessions. Click one to reread it.

Practical workflows where Chronicle saves time

Scenario 1: Pattern repetition

You are debugging a TypeScript error: “Property ‘x’ does not exist on type ‘any’”. You feel like you have solved this before.

Search Chronicle: type any property error

Up comes a session from 6 weeks ago where you and Copilot worked through the exact issue. You reread it and remember the pattern: use as unknown as T or be more specific about your types.

No need to re-reason it. You apply the old decision in seconds.

Scenario 2: Onboarding or knowledge transfer

A new team member is joining. You want them to understand your team’s patterns for async error handling in Express.

Instead of writing a document, you say: “Look at my Chronicle for ‘Express async error handling middleware.’”

They see a full session: the reasoning, the edge cases discussed, the final decision. It is a real conversation, not a document.

Scenario 3: Validating a change before you commit

You are about to refactor an auth module. Before you do, you want to remember what constraints you agreed on in the original design session.

Search Chronicle: auth module design

You find the original session. It mentions: “Stateless JWT only, no sessions.” That constraint shapes the refactor you are about to do.

What Chronicle captures

Chronicle indexes:

  • Session topic (first message and title, if you named it)
  • Files touched (which files were edited or discussed)
  • Commands run (shell commands, git operations)
  • Key decisions (topics of discussion)
  • Timestamps (when the session happened)

What it does NOT capture:

  • Secrets or sensitive data (filtered out)
  • Private key material (redacted)
  • Full chat transcripts by default (configurable in settings if you enable verbose logging)

Privacy and storage

Chronicle is stored in your GitHub account (if session sync is enabled). If you are not using session sync, Chronicle is local-only and does not upload to GitHub.

You can delete entries from Chronicle:

  1. Right-click a session in the search results
  2. “Delete from Chronicle”
  3. It is gone (not recoverable)

When NOT to use Chronicle

Use git log instead of Chronicle for:

  • Seeing exactly what code changed and when
  • Blaming a specific line to the commit that introduced it
  • Tracking when a bug was introduced
  • Reproducible, auditable history (git is immutable; sessions can be deleted)

Use Chronicle for:

  • Remembering the reasoning behind a decision
  • Finding a pattern or approach you used before
  • Onboarding or documentation
  • Searching by topic, not by commit

Git and Chronicle complement each other. Git is the immutable record. Chronicle is your searchable memory.

Setting up Chronicle

In VS Code 1.120+:

  1. Enable session sync (Settings → Copilot → Session Sync → On)
  2. Chronicle is automatically enabled
  3. Your sessions start being indexed immediately

To search:

  • Open Copilot chat
  • Click “Chronicle” or press the search icon
  • Type your query

A few caveats

Search is limited to your own sessions. If a colleague solved a problem in their session, you cannot search their Chronicle. This is intentional (privacy), but it means you lose cross-team pattern discovery. Your team might manually share links to useful sessions.

Indexing can take time. If you have hundreds of sessions, the first Chronicle search might take a few seconds as it builds the index.

Older sessions may not be indexed. If you enabled Chronicle after months of working with Copilot, your prior sessions might not be fully indexed. New sessions are indexed immediately.

The bigger picture

Chronicle is the first real attempt to make AI sessions something other than ephemeral chat.

By indexing and searching them, you get:

  • Faster onboarding (new team member sees the reasoning, not just the code)
  • Reduced duplicated thinking (you do not re-solve solved problems)
  • A searchable record of your team’s decisions and patterns

That is powerful. It is also why privacy and deletion controls matter—sessions are now a form of institutional memory.

Sources