IDE and editors

Half of the time you’ll be using SprintLoop from the workspace web app. The other half, you’ll be in your editor — and you’ll want the lane you’re in to be the lane the editor knows about. The SprintLoop editor extension closes that gap.

The extension is published for VS Code (and forks: Cursor, Codium, Windsurf, Trae) and is the same package across all four. It does five things:

1. Presence. When you open a file, the workspace knows you’re looking at it. Other people in your workspace see your cursor in their lane panel; you see theirs in yours.
2. Lane sync. The editor’s status bar shows which lane (if any) the current file belongs to and whether you’re inside the lane’s claimed scope.
3. Dispatch. Right-click → SprintLoop: Dispatch lane on selection opens a dispatch dialog inline, pre-filled with the file path and the selected lines.
4. Reviewer inline. When you check out a lane locally, the Review Committee’s verdicts render as gutter annotations on the changed lines.
5. Tool log inline. While a lane is running, the agent’s tool calls render in a side panel — the same view you’d see in the web app, but pinned to the file that’s open.

Install

The extension is published at the standard marketplace URLs:

• VS Code Marketplace — https://marketplace.visualstudio.com/items?itemName=sprintloop.sprintloop
• Open VSX (Codium, Windsurf) — https://open-vsx.org/extension/sprintloop/sprintloop
• Cursor extension panel — search for “SprintLoop” in the Cursor extensions tab.

After install, run the SprintLoop: Sign in command from the command palette (Cmd+Shift+P / Ctrl+Shift+P). The extension opens a browser tab to authorize against your workspace; on success, the browser tab closes and the editor status bar shows your workspace handle.

If you’re behind a corporate proxy or your editor is sandboxed (devcontainers, Codespaces), use the SprintLoop: Sign in with code command instead. The command shows a 6-digit code; paste it into the auth page in any browser to complete sign-in.

Connecting a repo

The extension auto-detects the connected SprintLoop workspace based on the git remote of the repo you have open. If the remote matches a workspace you have access to, the status bar shows that workspace’s handle. If it matches multiple, you’re prompted to pick one.

If the repo isn’t connected to any SprintLoop workspace, the extension is mostly inert — you’ll see a “Connect this repo” CTA in the status bar. Click it to open the connect flow in the web app.

Working inside a lane

When you check out a lane’s branch locally (git checkout sprintloop/<workspace>/<lane-id>), the extension recognizes it and pins the lane’s context to the editor:

• The status bar turns cyan (In lane: lane-id).
• The Lane panel (Cmd+Shift+L by default) shows the lane’s brief, scope claim, tool log, and current diff.
• Files outside the lane’s scope claim are dimmed in the Explorer with a “lane-readonly” tooltip — you can read them, but writing through the SprintLoop tooling is blocked. (Vanilla git writes still work — the storage-layer guard is on the workspace side, not the local file system.)
• The Review Committee verdicts (if the lane is past the review stage) render inline as gutter annotations.

If you start editing a file outside the lane’s scope, the extension surfaces a banner asking whether you want to (a) widen the lane’s scope to include this file, (b) start a new sibling lane for the new file, or (c) just edit locally without scoping. Most teams pick (a) for incidental changes and (b) for anything that warrants its own audit chain.

Dispatching from the editor

The fastest way to dispatch from the editor:

1. Highlight the lines (or the whole file) you want to change.
2. Right-click → SprintLoop: Dispatch lane on selection.
3. Type a one-line title.
4. Pick a harness (or leave it on the workspace’s default).
5. Hit Dispatch.

The lane opens in the workspace and the editor switches to its branch automatically. You can also dispatch from the command palette without a selection — it’ll prompt for a path scope.

Tool log inline

While a lane is running, the SprintLoop: Show tool log command opens a side panel that streams the agent’s actions. Each entry is signed and timestamped. Click any entry to jump to the file and line the agent touched (if it’s a write) or to the model call detail (if it’s a model invocation).

This is the most useful debugging surface when an agent is doing something unexpected. You can pause the lane from the panel, send an interrupt note, or kill it outright.

Cursor-specific notes

Cursor users sometimes want to use Cursor Compose as the harness SprintLoop dispatches into. That works — the harness adapter for Cursor is bundled in the extension. When you dispatch a lane and pick “Cursor Compose,” the dispatch is sent through your local Cursor instance, not a server-side runtime. This means:

• Your Cursor settings, model keys, and prompt template are used.
• The lane’s tool log is reconstructed from Cursor’s emit stream after the run completes.
• The lane is still bounded by the workspace’s policy and scope rules — Cursor cannot write outside the lane’s scope.

The trade-off is that Cursor-as-harness lanes only run while your editor is open. If you close Cursor mid-run, the lane pauses until you re-open and resume.

Codium, Windsurf, and other forks

Any VS Code-API-compatible fork should work. We test on the named four. If you hit a fork-specific bug — usually around the auth flow or the panel rendering — file an issue at https://github.com/sprintloop/editor-extension/issues with the fork name and version.

Keybindings (default)

Action	Keybinding
Open lane panel	Cmd+Shift+L
Show tool log	Cmd+Shift+T
Dispatch lane on selection	Cmd+Shift+D
Approve current lane	Cmd+Shift+A
Open SprintLoop in browser	Cmd+Shift+O

All of these are rebindable from the editor’s keyboard shortcuts UI. The defaults try not to clash with Cursor or Copilot shortcuts but YMMV.