# Your editor never breaks

> How Awaitful patches the thinking line safely: byte-exact backups, atomic writes, verification, and a fail-safe that quietly falls back to the status bar.

- Source: https://awaitful.com/docs/editor-safety
- Updated: August 7, 2026

The thinking line and the chat banner modify two files inside Claude Code, and modifying another program's files is exactly as dangerous as it sounds. So the patch engine is built like deployment infrastructure: byte-exact backups, hash verification before and after, atomic writes, and a fail-safe that prefers earning less over breaking anything.

*Figure: The patch applies both-or-neither, and every failure path in the engine ends at the same place: your editor as it was, with the status bar still earning.*

## Before anything is touched

The engine trusts nothing but hashes. A file is only patched if its content hash matches a known-good original for that exact Claude Code build - a file modified by anything else is left alone. Before writing, the original bytes are backed up into Awaitful's own private storage, never as stray files next to Claude Code, and a Claude Code update naturally invalidates old backups because the build changes.

## The write itself

Writes are atomic: the patched content goes to a uniquely named temporary file which is then renamed into place, an operation the filesystem performs completely or not at all. A crash mid-write, or two editor windows patching simultaneously, cannot publish half a file.

## Verified after, or rolled back entirely

After applying, every patched file is read back, the patch is stripped out, and the result is re-hashed - it must reproduce the original exactly. If any file fails that check, all of them are rolled back together; the patch applies both-or-neither. Any error at any point triggers the same restore.

## The fail-safe

Every failure path - unknown build, unfamiliar bytes, a conflicting extension, a failed verification - ends the same way: your editor left untouched or restored, and Awaitful quietly earning from the status bar instead. A failed patch never takes the product down with it; the fallback is itself a working surface. What that looks like in practice is described in [Thinking line fell back to the status bar](https://awaitful.com/docs/thinking-line-fallback).

**Honest even about failure**

If a rollback itself could not be confirmed, the panel says so and points to the fix, rather than claiming safety it cannot prove. ["Restore original files"](https://awaitful.com/docs/turn-it-off) in the panel reverts everything at any time, and "Pause Earning" restores your editor and only reports success when the restore was verified.

## Updates, and other extensions

When Claude Code updates, Awaitful re-applies automatically - with a fleet-verified recipe when one exists, or a provisional recipe built and hash-checked on your own machine and labelled provisional in the panel. Every check above applies either way. If another extension overwrites the same files, Awaitful reclaims them a bounded number of times and then yields - it earns from the status bar and tells you about the conflict rather than fighting a write war inside your editor. That budget is counted per Claude Code build and survives window reloads, so a tool that rewrites the file on every reload cannot restart the fight indefinitely.

Awaitful never touches another extension's files, and never removes or disables one on its own. When another tool is holding Claude Code, the panel can hand you a one-click removal - but it is your click, on a button that says exactly what it will remove, and nothing is chained or automatic. When it clears another tool's change out of Claude Code, it does not cut that tool's code out of the file, which would be guesswork on a format we do not own. It replaces Claude Code's file in full with bytes checked against the genuine original. If it has no verified original to write, it does nothing and says so.

One consequence worth knowing: uninstalling an extension does not undo the file changes it already made. Another tool's sponsored line can keep appearing after you remove it, because the code it injected is sitting in Claude Code's own file. Awaitful's take-over is what clears it, and "Restore original files" puts Claude Code back either way.

All of this is public code, not a description you have to trust - start at [Verify it yourself](https://awaitful.com/docs/verify-it-yourself). And consent is per surface: nothing here happens unless you turned a patch surface on in [Choose where the line appears](https://awaitful.com/docs/choose-your-surfaces).