Build across
the whole stack.

• Open files in tabs, split your workspace and retain drafts.
• Use language-server completion, diagnostics, navigation, rename and formatting, including supported Razor/Blazor projects.
• Read rendered Markdown, blame and file history.
• Ask a helper or existing agent about selected code, with a context preview.

Language intelligence depends on the language server and project setup. Your project SDKs and dependencies still matter.

• Use Files, Solution, Packages and Tests as lenses in the Explorer rail.
• Edit the selected repository and peek into files from other open roots.
• Reveal the active file and navigate nested folders.
• Search across the workspace with Ctrl/⌘+Shift+F.

The global search surface is a command, rather than a separate legacy Search panel.

• Browse .sln and .slnx solutions, solution folders and projects.
• Expand project files, dependencies and target frameworks.
• Choose between solutions in the same repository.
• Open a project’s packages or its run and debug actions.

Solution discovery is specific to supported .NET project formats; the file explorer remains available for every repository.

• Search registries and install, update, remove or restore packages.
• Check outdated references and review updates before running them.
• Inspect vulnerability reports and follow advisory links.
• See when a centrally managed NuGet version affects other projects.

Registry access needs a network connection. Package changes use the project’s tools and respect Workspace Trust and execution policy.

• Navigate project references and transitive packages.
• Scope source exploration by folder, project or search.
• Follow a file’s imports and source evidence.
• Distinguish inventory, analyzed content and unresolved relationships.

Source analysis is bounded and language-dependent. An unscanned file is not evidence that it has no dependencies.

• Read split or unified diffs with word-level changes.
• Stage and unstage files, hunks or individual lines.
• Edit beside the diff and inspect changes before discarding them.
• Compose a commit message, with optional AI assistance when configured.

Git actions operate on your local repository. AI-assisted messages use your configured provider and require opt-in.

• Inspect commits, changed files and their diffs.
• Search history by message, author, path or diff.
• Compare references and use contextual cherry-pick, revert and reset actions.
• Use interactive rebase and reflog recovery when rewriting or recovering work.

History-changing operations retain their confirmations and repository checks.

• Create, switch, rename and remove branches.
• Inspect ahead/behind state and compare branch histories.
• Start merge and rebase workflows with an explicit direction.
• Resolve conflicts in the guided conflict editor.

Remote operations use your configured remotes and credentials.

• Create, open, lock, prune and remove linked worktrees.
• See changed files, branch state and associated agent sessions.
• Jump from a worktree into its editor, diff, Changes or History.
• Review agent worktrees, land or discard their work, and clean up merged ones.

Removing a worktree starts with a safe removal; forcing removal needs confirmation.

• List requests, inspect details and create a new request.
• Read review threads and write inline comments or replies.
• Resolve or reopen supported threads and submit review verdicts.
• Complete a request and open its build details in CI.

Available review and completion actions depend on the forge, permissions and repository configuration.

• Filter recent runs to the current branch or view all branches.
• Open a run, drill into jobs and inspect log output.
• Follow in-flight work while the window is visible.
• Use supported run actions and connect Google Cloud from the panel.

CI needs a connected provider. Run actions and detail coverage vary by provider.

• Switch between assigned, recent and open items.
• Inspect an item’s description, state and discussion.
• Use the actions offered by the connected tracker.

Tracker support and permissions determine the available data and actions.

• Browse test projects and discovered tests.
• Run selected tests or affected project suites; debug supported tests, including JUnit and PHPUnit.
• Inspect failures and navigate to their source.
• Read coverage and flaky-run evidence when available.

Provider tools determine capabilities. Java debugging needs its adapter; PHPUnit needs Xdebug. Affected runs select project suites.

• Run shell commands in terminal sessions that survive panel changes.
• Launch project build, run and test tasks.
• Read task output and diagnostics in the terminal dock.
• Inspect local processes and listening ports through system tools.

Commands run on your machine and remain subject to Workspace Trust and execution confirmation.

• Choose targets and share .branchhelm/debug/configs.json launch recipes.
• Run workspace projects together and select members to debug.
• Launch, attach and step where supported; apply saved edits with .NET Hot Reload.
• Arrange debug panels and save your layout.

Capabilities depend on installed tools. Hot Reload needs the shipped proxy, .NET 10 SDK/runtime and an eligible C# .NET 8+ Debug DLL with portable PDBs.

• Choose a thread and inspect its frames.
• Open a frame’s source location, including read-only generated or in-memory source supplied by the adapter.
• Move between caller and callee and return to the stopped location.

Stack and thread information comes from the active debug adapter.

• Expand nested variables or copy loaded values as JSON.
• Distinguish loading, empty scopes and failed reads; edit adapter-supported values.
• Explicitly request lazy values when evaluation may run code.

Values belong to the selected stop and frame. Changing context refreshes inspection; JSON includes only loaded values.

• Add and remove watch expressions.
• Inspect results independently as evaluations finish.
• Use expression completion when the adapter offers it.

Evaluation behavior and side effects depend on the debug adapter and expression.

• Enable, disable, remove and navigate source breakpoints.
• Set conditions, hit counts and log messages.
• Use function and data breakpoints where the adapter supports them.

The active adapter determines which breakpoint features are available.

• Configure the exception filters offered by the adapter.
• Read exception information from the selected stop.
• Navigate from the failure into its stack and source.

Exception filters and detail differ between debug runtimes.

• Read output from the active debug session.
• Evaluate expressions through the adapter’s REPL.
• Use supported completion in the selected inspection context.

Evaluating an expression can execute code in the target.

• Capture supported browser CPU and heap profiles.
• Collect .NET counters, traces and GC dumps.
• Click a browser CPU function to open its source while keeping Debug in view.
• Explore bounded neighborhoods of V8 heap references.

Capture tools and target connectivity must be available. Browser and .NET profiling have different capabilities.

• Read paused target memory as hex and ASCII, with address and offset navigation.
• Page through instructions around a frame’s instruction pointer.
• Set instruction breakpoints where the adapter supports them.

Raw-memory and instruction listings are read-only and bounded. They depend on adapter capabilities; managed heap analysis belongs in the Profiler.

• Browse module names, versions, paths and symbol status when supplied.
• Page module results and follow adapter-reported module changes.
• Refresh the loaded-source snapshot and open a file or adapter-backed source.

These views require the corresponding adapter capabilities. Loaded sources are a snapshot that you can refresh.

• Check the adapter, transport, resolved path and session phase.
• Read the last recorded failure and available adapter error output.
• Inspect advertised capabilities and export a protocol trace when tracing is enabled.

Protocol tracing is opt-in. The panel explains the debugger session and its available evidence.

• Preview loopback URLs and keep pages alive across panel switches.
• During supported browser debugging, interact with the app-owned browser surface.
• Pick a supported React/Vite element, review its border-radius diff and apply it with hot-reload verification.

Design mode needs opt-in instrumentation and a supported inline border-radius value. Preview is for local development servers.

• Inspect session presence, repository, branch and resource signals.
• Use overview, map and worktree views to follow parallel work.
• Read available provider history, prompts, replies and tool activity.
• Launch, chat with and control supported sessions after accepting agent-control consent.

Detection, history and control are different capabilities. Provider integration and session setup determine which ones are available.

• Follow supported file and editing activity.
• Inspect the session’s changes in the surrounding repository.
• Move into review with the relevant files and diff at hand.

Exact live activity requires a cooperative session or supported integration; process detection alone cannot supply it.

• Select a session and inspect page status and screenshots.
• Read captured console and network activity.
• Inspect a retained response body and assertion evidence.

This panel observes a verification session. It does not remotely control the browser, and retained evidence is bounded.

• Discover connections, save credentials securely and test setup.
• Browse tables or collections and run queries.
• Inspect SQL query plans and paginated results.
• Enable writes explicitly to edit supported keyed tables or create PostgreSQL tables.

Connections start read-only. Row edits require a writable connection and a supported table; views and keyless tables do not offer row editing.

• Format and transform data, generate types or schemas, and inspect documents or media.
• Import project files, return to their source and save generated output into your project.
• Use project-bound database connections and move query results or HTTP responses into Data tools.
• Preview HTML/CSS and adjust styles on an element or shared class.

HTML/CSS previews block authored scripts and remote resources. HTTP and databases use your chosen destinations; database writes require opt-in. Document inspection and persisted pads are bounded.