When a project is finished and must leave without a trace of the tool that helped build it, one operation removes every vibe file and reference while keeping the product and its build intact.
The agent creates the contract with `vibe scrape contract init` if the project has none and adapts it: for vibe's own trees you never edited it sets `modified = "delete"`, and it keeps a health check that fits the project. It runs `vibe scrape --plan`, which reads the contract, classifies every file the tool ever wrote or marked, and prints the complete plan without writing anything: what is deleted, what is rewritten, what is kept under a neutral name. Then it runs `vibe scrape --output` with the absolute path of the new folder, which creates the scraped copy and runs the project's health checks on it; the original is untouched. The copy is a plain project of its language: no [manifest](../glossary/index.xml#manifest), no [lock file](../glossary/index.xml#lock-file), no dependency tree, no boot files, no [managed block](../glossary/index.xml#managed-block), no source annotations that pointed at [specifications](../glossary/index.xml#specification).
1. Create the contract. The default is conservative: it names vibe's trees, refuses anything it cannot prove unmodified, and checks health with `cargo`:
2. Adapt it. A fresh project has no modification baseline for vibe's files, so the two `[[classify]]` rules refuse them as unknown. If you never edited those trees, set `modified = "delete"` on both. Replace the `[[healthcheck]]` if the project is not a Rust workspace. Then validate: `vibe scrape contract check --path hello-vibe`.
3. Look at the plan:
4. Export to a new folder, which must not exist yet and is named without `..`:
5. Or [scrape](../glossary/index.xml#scrape) in place, which is a recoverable transaction and requires explicit authorisation: `vibe scrape --in-place --assume-yes`. If it is interrupted, `vibe scrape --recover --path <root>` settles the pending transaction.
The commands in one place. `vibe scrape contract init` writes a conservative default only when none exists, and `contract check` parses and plans it without writing. `vibe scrape --plan` is read-only and, given no mode, plans the in-place form, the larger risk. `--output` creates the export in a folder that must not exist and never changes the source tree. `--in-place` runs the journaled transaction, shows the census of modified and deleted files when interactive, and unattended needs `--assume-yes` after a green plan. Planning and checking run everywhere; in this first epoch the mutating modes run on Windows only, where the safety mechanics have been proven.
What counts as vibe's and what counts as yours is not guessed from file names; a contract says it. The contract lives at `vibevm/scrape/contract.toml` in the project: `vibe scrape contract init` writes the conservative default, `vibe scrape contract check` validates one, and `--contract <file>` reads another. A contained contract is the last file removed, so the plan can be re-read until the end.
A scrape never deletes a path blindly: a build script that calls a vibe tool, generated product sources that sit beside disposable generated state, an authored specification that shares a tree with generated boot output, all are dispositioned by the contract, and untouched files stay byte-identical.
The contract is strict: unknown tables and values are rejected, `schema` is 1, and every id is unique. Files you wrote under `vibevm/vibespecs` are never taken for generated because of their folder; a contract that wants zero residue names them for deletion or relocation itself. Generated code, tests and models the project accepted are product and stay unless a row names them. Globs only select; bytes change only through typed adapters, never through a regex or a shell rewrite. Zero residue means zero registered identities, paths and markers, not the word «vibe» in your prose.
You supply the policy, the engine supplies the mechanics and the verdicts. Anything the sealed contract and the observed tree cannot decide is a blocker, never a guess. The tool does not rewrite git history, does not publish, and does not remove what was deployed to your machine; those stay explicit operations.
Scrape is not clean. `vibe clean` removes what vibe can regenerate and keeps the relationship; scrape removes the relationship itself, which is why it needs a contract, a health proof and a recoverable commit.
`--output` and `--in-place` are mutually exclusive; a plan is always available before either.
The words attach and detach are reserved for a future live-tool relationship, such as connecting a debugger; scrape is never an alias for them.