Conversation Asset Management

After the AI modifies files in your workspace, the core questions become "what changed, how do I roll back, and which version is broken". Astrion provides three layers of asset protection: version control (conversation-level checkpoints), modify history (task-level diffs), and the Git status bar (real-time awareness). They are independent of each other and can be layered on top of one another.

1. Version Control

A conversation-level file checkpoint system that gives every round of AI changes a snapshot you can roll back to.

Toggle and Backup Methods

Enabled by default for new conversations (the default can be changed in Personal Space);
A single conversation can be toggled temporarily via the + menu → "Version Control";
One of two backup methods (choice made in Personal Space):
- Shallow backup (default): tracks only files edited by the AI via write_file / edit_file, backing up the current content automatically before each edit — fast and space-efficient, sufficient for the vast majority of scenarios. ⚠️ Note the boundary: files changed by the AI through commands run via run_command (such as sed, redirection, script writes) are not within the tracking scope of shallow backup;
- Full backup: a snapshot of the entire workspace — the most robust, but noticeably slower and more space-hungry on large projects.

Checkpoint Granularity: Per User Message

Each time you manually send a message, the system records a checkpoint after that message finishes processing, referencing the latest backup version of all tracked files at that time — in other words, the smallest unit you can roll back to is "one manually-sent user message", not a single file edit;
Viewing a checkpoint's diff = the difference between that message's snapshot and the previous message's snapshot;
Rolling back to a checkpoint = restoring all tracked files to their state at that message (overwrite; confirm that current changes are saved elsewhere or committed before rolling back).

Relationship with Other Mechanisms

Version control tracks filesystem state, which is unrelated to conversation messages;
It does not conflict with Git: the AI never commits for you. Version control is another safety net alongside Git, suited to the scenario of "files broke before you had time to commit".

2. Modify History

Task-level net modification records, enabled by default.

After each task round completes, all files edited by the AI in that round are written to disk as a unified diff at: <workspace>/.astrion/modify_history/<conversation ID>/;
One .diff file per task; the file name includes a summary of that task's user input and the start time;
The "edit summary card" in the conversation shows the list of files edited in that round; clicking it shows the diff. When the card appears is configurable in Personal Space (by default it shows after the work completes; it can also be changed to show in real time during execution).

Manual Recovery with Diff Files

History files can be operated on directly with git tools:

cd <workspace>
git apply <diff-file>     # Redo this change
git apply -R <diff-file>  # Revert this change

Typical scenario: version control was off, Git had no commit, and git checkout accidentally overwrote the AI's work — go to modify_history, find the diff for the corresponding task, and git apply to recover.

This directory is maintained automatically by the system; do not add or remove files in it manually. It can be disabled entirely in Personal Space (when disabled, nothing is written to disk and no prompts are injected).

3. Git Status Bar

A status bar above the input bar that shows a real-time summary of the current workspace's Git status (current branch, amount of uncommitted changes, etc.), so you can tell "how dirty the workspace is and how much the AI changed" without leaving the conversation.

Shown by default; can be quickly toggled via the + menu → "Git Status Bar", with the same setting available in Personal Space;
Not shown when the workspace is not a Git repository.

4. How to Choose Among the Three Layers

Need	Layer to use
Real-time awareness of workspace changes	Git status bar
Roll back to a point in time in the conversation	Version control
Precisely restore/undo one task round's changes	Modify history diff
Long-term, serious, large-scale development	Still use Git commit — the first three layers are safety nets, not a replacement for version management

Recommended practice: for important projects keep "version control on + modify history on + commit regularly"; with all three nets layered, no matter how much the AI churns things up, nothing gets lost.

4.7 KiB Raw Blame History