Skip to content

Editor integrations

Your editor should tell you three things at a glance: which change you are working on, which files you have touched, and whether you are in sync. TOVIO's editor integrations put exactly that in front of you --- a status-bar change ID, modified-file indicators on your files, and a sync action you can click --- without pulling you out to a terminal for the routine stuff.

This page covers the two editor surfaces: the VS Code extension (deliberately minimal) and the JetBrains plugin (its port for the IntelliJ family, at the same feature tier). Both are built from source in the repository; neither is on a marketplace yet.

Marketplace availability

The VS Code extension (tovio-vscode-ext) and the JetBrains plugin (tovio-jetbrains-plugin) are built in the TOVIO repository but are not yet published to their marketplaces or an accepted release page. No public editor package is currently available. Contributors with an authorized source checkout can exercise their development artifacts; the tovio CLI exposes the same status facts from that checkout.

The VS Code extension

The VS Code extension is intentionally small. It is not a second UI for everything TOVIO can do --- it surfaces the few things you want while you are editing and gets out of the way. It exposes three capabilities.

Status-bar change ID

The current change ID sits in the status bar, with its description a hover away in the tooltip. Because a TOVIO change ID is stable across history rewrites, this is the same identifier whether you just created the change or have amended it five times --- the editor shows you the work's identity, not a commit hash that moves under you.

Modified-file indicators

Files you have changed since the change opened are badged in the Explorer and on editor tabs, in your theme's SCM colors. TOVIO has no staging area --- the working copy auto-snapshots into the current change --- so these indicators answer "what is in my change right now," not "what have I remembered to stage."

Sync action

A sync button in the status bar runs the equivalent of tovio sync: it reconciles your lane with the remote. Divergence that happened while you were offline is reconciled automatically, and any conflicts are stored as first-class objects rather than blocking you --- the same fearless behavior you get from the CLI, one click away.

Beyond the basics

A handful of quality-of-life surfaces ride along without changing the extension's deliberately small footprint:

  • A Source Control view — your changes and conflicts as native SCM resource groups, with one-click diffs against the committed version.
  • Quick-diff gutter bars while you type — the same live change bars Git gets, served from TOVIO's committed content.
  • The rationale hover — hovering a line shows the change that owns it and, when one was recorded, that change's attested rationale: the why behind the code, cryptographically signed at commit time. A rationale sealed to a protected policy decrypts only for its recipients; everyone else sees a locked marker, never the content.
  • A lane switcher — clicking the status-bar item opens a quick-pick of your lanes (with create-new). Switching moves HEAD only; your files on disk are untouched, so it is safe on a dirty tree.
  • Kind-aware conflict resolution — a conflicted file's context menu offers an ours ↔ theirs diff of the two sides and a resolve pick limited to the strategies that fit that conflict's kind. A resolution is recorded as one undoable commit (TOVIO has no staging area): tovio undo reverts it, nothing is destroyed.
  • A landability check — an on-demand tovio health that tells you whether your lane lands into the target clean, as a fast-forward, or with conflicts (and which kinds), before you land.
  • Agent awareness — the status tooltip lists active agent sessions, expiring capability tokens, and held path locks, and warns once when a token is about to expire — the editor-side window onto agent-native TOVIO.
  • Inline blame — an off-by-default, per-line annotation of the change that last touched the current line, toggled from the command palette.

Two of the extension's local write operations --- switching lanes and resolving a conflict --- create supported op-log entries: a switch moves HEAD, and a resolution is recorded as one commit. While those entries remain retained, tovio undo can reverse the local mutation. Discarding a file's edits from the Source Control view is the exception: it runs tovio restore, which throws uncommitted edits away rather than recording an operation, so tovio undo does not bring them back. A file that was only added is not restored at all --- the extension moves it to your OS Trash, and says so in the confirmation dialog. Peer observations and external effects are outside that boundary; higher-risk maintenance stays in the CLI (below).

Install it

There is no supported public installation channel yet. Marketplace and evidence-bound .vsix instructions will appear only after the package-publication gate passes. Do not substitute a guessed Marketplace ID or download URL. Contributors may use the extension's development workflow from an authorized source checkout; that is a development path, not a published product install.

The extension finds the tovio binary on your PATH. If TOVIO is installed somewhere unusual, set the path in your settings:

{
  "tovio.executablePath": "/usr/local/bin/tovio"
}

Open a folder that contains a TOVIO repository (or any subdirectory of one) and the status bar populates moments later --- the extension reads tovio status itself on activation.

It reads the same engine the CLI does

The extension does not re-implement anything --- it drives the tovio CLI's structured --json output, acting as you under your own identity. The change ID, the indicators, and the sync result are identical to what tovio status and tovio sync would show you in the terminal --- because they are the same commands.

The JetBrains plugin

The JetBrains plugin (IntelliJ IDEA, WebStorm, RustRover, PyCharm, GoLand, and the rest of the family) carries the same display surfaces as the VS Code extension --- a status-bar indicator, modified-file decorations, a quick-diff gutter, the rationale hover, a Changes/Conflicts view, a lane switcher, and kind-aware conflict resolution --- so moving between editors feels the same. Its action menu goes further than the VS Code extension's: alongside sync and switch it registers land, amend, undo/redo, push/pull, clone, new change, file lock/unlock, and agent-token issuance as IDE actions. Like the VS Code extension it drives the tovio CLI directly: it locates the binary, reads its --json contract, and acts under your local CLI identity; keys never enter the JVM, and a protected path the CLI refuses is shown as uniformly absent. Its settings (Settings → Tools → TOVIO) cover the executable path, the status-bar and decoration toggles, the refresh debounce, the rationale hover, and token warnings.

Built from source, not yet on the JetBrains Marketplace

The plugin lives in the repository as tovio-jetbrains-plugin and builds with ./gradlew buildPlugin (JDK 17+). Marketplace publication has not started; it follows the same release gates as the VS Code extension, and this page will carry the install steps then.

What the editors deliberately do not do

The editor integrations are a window onto TOVIO, not a replacement for understanding it. A few things stay in the CLI on purpose:

  • Destructive and policy-changing operations. Obliterating an object or editing a permission policy is a typed, deliberate act --- not a button you can hit by accident.
  • Anything an agent must not do silently. The editor follows the same boundary the rest of TOVIO does: structured, auditable operations stay explicit.

If you want the full command surface, that is what the CLI reference is for. For the bigger picture of changes, conflicts, and protected files, see core concepts.

Last reviewed September 9, 2026

Suggest an improvement to this page Not for security reports — see disclosure