When Grok proposes an edit, hit open diff → to review it in VS Code's native diff editor, then Allow once / always or Reject. The file is written only after you approve.

Switch from the bottom toolbar. Plan is enforced by the extension, not the CLI — workspace writes and non-read-only commands are genuinely blocked until you approve the plan (see How it works). Auto accept approves actions automatically, and flips on or off mid-session.

Type /imagine <prompt> (or /imagine-video <prompt>) and the result renders inline — images as thumbnails, videos with playback controls, Copy path / Open in VS Code on hover. Editing a reference photo works too. Both are subscription-only Grok features, and both survive a session resume.

Ctrl+V a screenshot, drag-drop an image, or attach one with the + picker (png/jpg/gif/webp, up to 20 MiB) — it's sent as vision input, so you can ask "what's wrong with this UI?" about a dialog you just captured. Disk imports keep their file path so Grok can also act on the real file, and chips restore when you reopen the session.

The microphone button dictates speech via xAI's Speech-to-Text API — words appear live as you talk. Say "grok send" to submit hands-free and keep dictating; messages spoken while Grok responds queue and flush when it finishes.

It works out of the box once you're signed in (your grok login token is reused automatically) — you only need ffmpeg installed to record. Setup, devices, and costs: docs/voice-setup.md.

The active editor rides along automatically; add more by dragging from the Explorer, right-click → Grok: Send File, Alt+G, or the + button. Chips send as @/path references, so content stays current and history stays small. Shift-drag embeds the file inline instead.

The clock icon lists this project's sessions, newest first. Click a row to resume — images, plans, and reasoning intact — or hover to rename or delete it. The search box filters your whole history, older sessions load as you scroll, and Clear all history sweeps everything but the current session.

Sessions run in parallel: start a new one with + while another is mid-turn and switch between them from this list — the one you leave keeps working in the background, and switching back is instant, with no reload. Each row's status dot tells you what it's doing:

The green/red dot is an unread badge — it survives a VS Code restart and clears when you open the session, so after firing off a few agents the green dots are exactly the results waiting for you.

A message you send mid-turn never cancels anything. By default it queues — a pending block at the end of the chat (Edit / Remove), sent the moment the turn ends; type more and it merges into the same message. Hit Steer on it to redirect Grok now instead: the text goes straight into the running turn without losing the tool work in flight. Prefer that always? Turn on Steer by default (gear → Config & debug).

Gear → Fork conversation copies the conversation into a new session named (Fork) <the original's name> and opens it — try a tangent or a different approach while the original stays byte-for-byte unchanged in your history. It branches the conversation, not your code: files on disk are untouched.

Click the context donut for the exact used / window (%), plus what the conversation has billed — input, cache read, output — as a session total and a per-turn split with its model calls. Compact conversation lives here too, right next to the number that tells you when you need it.

When Grok delegates work to a subagent, the chat shows a card with the task and a live timer, then the subagent's output when it finishes — background subagents included, whose result folds back into the card when it lands.

Every action appears as a category-iconed row, batched and summarized ("Explored 5 items", "Edited 2 files"); a failed tool turns red with the reason. Edits show a +N −M change count and expand to an inline diff at the file's real line numbers; shell commands expand to an IN/OUT block with the full command and its complete output — exactly what Grok received, exit code included. To audit an Auto-accept run, pre-expand everything with grok.expandCommandOutputs, or Grok: Expand All Tool Details from the Command Palette.

LaTeX in answers — inline \(…\), display \[…\], matrices, integrals, Greek — renders as real typeset math via MathJax, bundled so it works offline. Hover a display equation to copy its source or export it as PNG or SVG. (Bare $…$ is deliberately not a delimiter — it would mangle "it costs $5".)

A ```mermaid block renders as a real diagram via Mermaid — bundled, offline, themed to your light/dark mode. Hover to copy the source or export it as PNG or SVG; while it's still streaming, or if it's malformed, the readable source is shown instead.

Click the model name in the gear popover. The list comes from your CLI; switching is live in most cases. (A few models belong to a different agent and need a quick restart — the extension detects that and carries your context forward.)

Gear → the effort dots next to the model, none → xhigh. On recent CLIs it applies live to the running session; older ones restart, with an optional Summarize & Restart that carries context forward.

VS Code commands (not Grok slash commands):

Grok's own slash commands (/imagine, /compact, …) autocomplete in the composer when you type /, sourced live from your installed CLI version. Reference snapshot: docs/SLASH-COMMANDS.md.

npm install
npm test         # grok-free unit/DOM/integration suite — exactly what CI runs
npm run package  # → grok-vscode-phuryn-<version>.vsix

npm test is grok-free, so local ≡ CI — it never spawns the real binary. A separate, on-demand npm run test:live drives the actual grok end-to-end (handshake, restore, plan-mode, image/video gen) and is run before a release, not on every commit. Full test taxonomy and what's deferred to a future @vscode/test-electron suite: TESTS.md. Architecture and module map: docs/architecture.md.

Repo conventions: direct-to-main, no feature branches; commits explain the why; no speculative abstractions; the grok-free suite is the floor — every change keeps it green.