Read Windsurf Cascade Chat History as Real Documents

Windsurf's Cascade panel is where the interesting work happens. You paste a stack trace, Cascade proposes a plan, you accept a few edits, argue back, accept a few more, and half an hour later the bug is fixed. The record of that back-and-forth is often more useful than the final diff. It captures the reasoning, the dead ends, and the exact prompts that unstuck the model. The problem is that Cascade keeps that record trapped inside the IDE, inside a scrolling side panel that was never designed for long-form reading.

If you want to reread a Cascade session the way you would reread a design doc, you need to get it out of the panel and into something that treats it like prose. A chat panel is tuned for the next message, not for the last forty. Fonts are small, line lengths are cramped, and there is no table of contents. This guide walks through how to export Windsurf Cascade chat history, how to clean it up, and how to read it in a viewer that respects code blocks, diffs, and long threads.

Where Windsurf stores Cascade history

Windsurf is a fork of VS Code, so it follows the same storage conventions. On macOS the Cascade transcripts live under ~/Library/Application Support/Windsurf/User/globalStorage/ and on Linux under ~/.config/Windsurf/User/globalStorage/. Inside that folder you will find a subdirectory owned by the Cascade extension with a set of SQLite databases and JSON blobs. Each conversation is stored as a sequence of turns, with the user message, the model response, any tool calls (file reads, edits, terminal runs), and the resulting diffs.

You should not edit those files directly. Windsurf holds a lock on them while it is running, and a corrupted database will lose your entire chat history with no undo. Quit Windsurf first, then copy the folder somewhere safe before you start extracting. Treat the copy as your working set and leave the originals untouched, so a bad script does not force you to rebuild history from scratch. A quick cp -R into a dated folder is usually enough.

Getting a clean transcript out

The fastest way to pull a single conversation out is to open the Cascade panel, right-click the conversation title, and pick the export option. Depending on the Windsurf build you are on, this gives you either a JSON dump or a markdown file. Markdown is what you want, because it preserves the code fences and the structure of tool calls without extra parsing work. Save the file with a name that includes the date and a short slug of the task, so you can find it later without opening five files in a row.

If your build only exports JSON, run a small script that walks the turns array, prefixes each turn with a heading like ## User or ## Cascade, wraps code payloads in triple backticks with the right language tag, and writes the result to a single .md file. Keep the tool-call outputs. A Cascade session without its file reads and terminal outputs is like a code review with the diffs removed. If you use several coding agents, the same cleanup pattern applies to Claude Code and Cursor agent transcripts, and you can share one script across all of them.

Reading long Cascade sessions without the IDE

Once you have a markdown file, the goal is to read it somewhere that is not a chat panel. You want a document view: a sensible measure of around 70 characters per line, real paragraph spacing, proper code block styling, and a table of contents you can jump around in. The IDE cannot give you any of that without a pile of extensions, and even then the rendering is compromised by the surrounding chrome. A dedicated reader lets you forget the tool and focus on the content.

Prism MD renders your Cascade export as a real document. Code blocks keep their syntax highlighting, tool-call output is grouped visually with its trigger, and headings become a nav you can scan. The coral-on-dark theme is easier on the eyes than the default IDE contrast, especially if you are rereading a long session on your phone after hours. The same reader also handles long Claude conversations and ChatGPT exports as beautiful documents, so your archive stays in one format regardless of which model wrote the answer.

What to look for on a reread

The point of rereading is not nostalgia. It is finding the specific prompt or clarification that turned a struggling session into a working one. When you reread, mark two things. Mark the prompts where Cascade jumped from wrong to right, and mark the moments where you gave up on a direction that was close to correct. Both are training data for your next session, and both tend to be invisible in the moment.

Keep those marks in a running notes file. Over a month you will build a personal style guide for prompting Cascade that is worth more than any tutorial. Look for patterns in when a file read changed the plan, when adding a constraint saved a session, and when accepting a bad edit cost you an hour of untangling. Patterns beat one-off tricks, and only a written archive will show them to you.

• Prompts where you added a constraint Cascade did not have.
• Moments where a file read changed the plan.
• Points where you accepted an edit you should have rejected.
• Points where you rejected an edit you should have accepted.

Sharing a Cascade session with a teammate

Sending someone a screenshot of your Cascade panel is a bad look. They cannot copy the code, they cannot search the text, and they cannot see the tool outputs that produced a particular edit. Export to markdown, drop the file into a shared reader, and send them a link they can open on any device. That link works the same on a laptop review, a phone commute, or a tablet at a standing desk.

If the session touched sensitive filenames or API keys, run a quick find-and-replace before sharing. Windsurf sometimes captures environment output that includes tokens, and those will sit in the transcript unless you strip them. A three-line sed pipeline handles the common cases: API keys, bearer tokens, and any absolute paths that point at private repos. The share an AI conversation with your team guide has a cleaner workflow for team review, including a light redaction step and a way to leave inline comments without editing the original.

FAQ

Does Windsurf sync Cascade history between machines?

Not by default. Cascade history lives in local application storage, and Windsurf's cloud sync covers settings and extensions but not conversation history. If you want your Cascade sessions on two machines, export them yourself and store the markdown files in a synced folder like iCloud or Dropbox. That way the archive is portable and does not depend on any single vendor's sync layer.

Can I read Cascade transcripts on my phone?

Yes, once they are exported. The IDE has no mobile client, but a markdown file opens anywhere. Push the file to a folder your phone can reach, then open it in a reader that renders code blocks properly. A plain notes app will strip the formatting, so pick a viewer built for markdown.

Will exporting delete the Cascade history in the IDE?

No. Export is a read operation. Your original conversation stays inside Windsurf and remains searchable in the Cascade panel. You can export the same session as many times as you want without changing anything on disk inside the app's storage.

Is there a way to bulk export every conversation?

Not through the UI yet. You can script it against the SQLite database while Windsurf is closed, but that is a fragile workaround that breaks with schema updates. A per-session export is more resilient, and it forces you to decide which sessions are worth keeping instead of hoarding every scratch conversation. Reserve bulk export for a full backup and use per-session export for the ones you plan to reread.