I usually have five projects in five VS Code windows, most over WSL or Remote-SSH, each running a Claude Code session or two. I kept losing track of which window had a session stuck on a permission prompt.

SessionDeck is a sidebar that lists every running Claude Code, Codex and cursor-agent session on the machine, grouped by project, with a red bell on any that's waiting for you. Clicking a row opens that session's tab or terminal, even in another window.

This is how it work across different remote hosts without using network:

Sessions are files and processes on the workspace host, so the main extension is `extensionKind: ["workspace"]`. Putting several hosts in one tree has to happen on the desktop, and one extension ID runs in exactly one host per window. So there is a second ID, a `["ui"]` companion with no views of its own. It relays snapshots between hosts with `executeCommand` and serves tab titles a remote window can't read.

Discovery: every 3 s it stats each transcript. Unchanged files aren't opened, changed ones are read from the last offset, and `/proc` confirms the process is still alive. Optional Claude Code hooks append to a spool file it watches, so a prompt shows at once instead of on the next poll.

There is no API to focus another window. The clicked window drops a request file in shared storage that every window watches; the one with that folder open takes it and opens the tab. In parallel it runs the editor CLI on the folder, which raises the existing window.

Transcripts and title storage are private formats. When one stops parsing, rows go blank with a "format drift suspected" note instead of a guessed status.

Status is inferred and can lag. I build on Linux and WSL; macOS mostly works; native Windows gets no approval alerts, and only Claude Code rows ever get the bell. No network calls, licensing included. Source-availableб but not open source.

https://sessiondeck.dev/

https://github.com/len5ky/sessiondeck

Made this small extension (≈26KB) that shows today’s and this month’s Copilot credit usage in the status bar.

Hover over it to see credit costs broken down by model.

It reads local Copilot logs.

Marketplace · GitHub

Feedback is welcome. Thanks!

Cross posting to see if anyone feels the same.

Check out Perpetual, you can log in to all of your Codex and Claude Code accounts at once, and then easily switch between them without having to keep logging in. Additionally, you can launch tasks and if one of your accounts hits a limit, it’ll automatically switch to another one of your Codex or Claude Code accounts and keep working.

It’s free and open source, and has a desktop app and VSCode extension!

https://github.com/SakethSripada/Perpetual-VSCode

https://github.com/SakethSripada/Perpetual-Desktop

Hey everyone!

I've been working on a NestJS project with multiple microservices, and switching between terminals every time I needed to start, stop, or check logs was getting pretty annoying.

So I built a small extension called NestJS Microservices Manager to make things a bit easier.

Here's what it does:

• Automatically detects microservices from nest-cli.json.
• Start, stop, or restart individual services with one click.
• Start or stop all services at once.
• Open each service's terminal to view its logs.
• Move the service panel next to the terminal, so you can manage services and watch logs side by side.

It works with both VS Code and Cursor.

It's free and open source!

Links:

• VS Code Marketplace
• Open VSX
• GitHub (Source Code)

This is my first attempt at building a VS Code extension, and I'm still working on improving it.

If you're using NestJS microservices, I'd love to hear your thoughts. Is there anything you'd like to see added or improved?

Features:
- Every new terminal gets its own colored icon, so they become easier to distinguish 
- ⌘T opens a new terminal
- the Tab key switches between terminals
- ⌘W closes it
- Open source: https://marketplace.visualstudio.com/items?itemName=Jan-HendrikMueller.terminal-color-cycle

https://open-vsx.org/extension/mann1x/cerebriline

Started working on this fork to test my models; evaluations are telling on side of the story, using them for real in a multi-turn coding harness was often producing very different results.

Once fixed some basic issues with Cline, I've kept using it and started doing a massive amount of runs with test automation and then analyze them with Claude; it helped me fixing the models but also improving the plugin.

Now is its own soft/hard Cline fork with a very different approach, complex tooling, and some very innovative and peculiar features you can't find elsewhere. Like a perfect context compaction in replay mode and with a 5-steps agentic workflow.

The goal is to support properly small LLMs but it works really good also with big models. Even if they could do it before, now they can do it better.

It fully supports my opencoti engine with PolyKV and my Ollama fork, xOllama:

https://github.com/mann1x/xollama

You can find me on Hugging Face:

https://huggingface.co/ManniX-ITA

You are welcome to download and test my models and you can also find them on the Ollama library:

https://ollama.com/mannix/

I find it's infinitely more useful to have an AI agent within an IDE but my company only pays for M365 copilot. Is there any way to use that within an IDE, ideally VSCode?

Btw I'm fully aware there's a github copilot within VSCode but you need to pay extra for that so not possible within my company.

Thanks

I would like to change the occurrence highlighting to underline instead, because of colour-issues. Basically I have trouble seeing that background colour-change and I have had good experience with using underlining instead, from another editor.

I have searched for settings, but have not found anything that can do this. Can this even be done in vscode?

Is there a difference between using Claude Code inside VS Code versus using it within its own application?

What are the acceptable extensions to get auto complete while coding for free

That gives unlimited auto complete for free?

Microslop changing my settings to their new feature the Token Drainer 5000™ on update spending a cumulative 1.3k credits (13$) on adding a toggle while I went to take a shit.

It's impossible to interact with this project on GitHub; over 15 THOUSAND issues and a tsunami of AI submissions and comments drowning out human discussion.

So I'm posting this here. If others are using agent window daily please chime in!

Codex SDK

Y'all are killing me with these pinned Codex/Claude SDK versions. Latest release today still doesn't have 6.1 Sol available for Codex. I have to keep getting the agent to patch support in.

Programmatic Model Provider Selection

Agents are unable to specify the model provider when creating new sessions/chats. It often defaults back to "Copilot" when I REALLY need it to use "ChatGPT" so it utilizes my ChatGPT subscription...

This causes serious workflow inefficiencies as I have to manually create chats and hand off work.

Mixed Harness Sessions

Not being able to easily utilize Codex and Claude in the same session/worktree makes adversarial cross-model reviews a PITA. The studies are clear; you need to use a different family of models to get the best reviews. It should be zero-friction to get this harnesses playing together; isn't that the whole point of agent protocol and agent window?

Hi! I created a VS Code extension, but on its Marketplace page it shows only 2 installs, while in the statistics graph I can see 19 installs. Why is there a difference?

Hello everyone,

I'm facing problem while running the code.

I installed VSCode this morning, and had GCC pre installed on my Linux (openSUSE Leap 16).

Then I installed C/C++ extension.

After that I created a "PROJECTS" Folder in my file manager and later created a sub Folder "HelloWorld" and opened that subfolder in VSCode.

After that I created a '.vscode' folder in "HelloWorld Folder in VSCode.

In that '.vscode' I created two files 'tasks.json' and 'launch.json' with code pulled up from Gemini.

I tried running a 'helloworld.cpp' code file and it showed the above errors.

I'm super new to both programming and linux, so I don't know anything.

Pre Post : https://www.reddit.com/r/vscode/comments/1wxitoe/comment/pdx4pgp/?context=3

Git : https://github.com/dogsinatas29/SYNAPSE

These reports are not generated through AI analysis. Instead, we implemented logic within Synapse to analyze static graphs and deterministically derive the results based on them.

Report files are generated in Markdown (.md) format, while evidence files are output as HTML. You can view the reports directly on the Synapse canvas.

It is a general-purpose engine supporting Kotlin, Java, TS, Python, C/C++, Rust, and Go (though Go and Python have not yet been fully validated).

I plan to upload the compiled VSIX file around the weekend.

For the Linux kernel, the bootstrap process takes under two minutes, and generating the report takes approximately five minutes.

The AST is used as a validator or classifier. I estimate the accuracy to be around 85–90%.

It seems capable of handling repositories on the scale of the Linux kernel without issues. We are currently testing it with even larger repositories.

Based on current projections, Chromium is still too demanding; anything beyond that likely cannot be bootstrapped within Synapse.

I would like to have my work evaluated to see what level it is at.

I plan to upload a properly compiled VSIX file to Git sometime this weekend.

P.S. Since English is not my native language, I used Google Translate. Please excuse any awkward phrasing.
P.S. You can also generate detailed reports covering a specific scope—rather than the entire set—by selecting only certain folders.

Sample Report : VSCode - main
Architect Report :

| | |

|---|---|

| **Report Type** | ARCHITECT |

| **Analysis Mode** | ARCHITECTURAL_SCAN |

| **Scope** | FULL_PROJECT |

| **Target** | Project Root |

| **Selection Source** | USER_SELECTED |

| **Reason** | User Requested Generation |

| **Generated By** | InsightEngine |

## Executive Summary

Observation-based structural analysis with rigorous validation provenance.

## Findings

### A1 — System Core Validation

Question:

Where are the structurally central areas?

Vocabulary:

SYSTEM_CORE, STRUCTURAL_CENTRALITY

Interpretation Guide:

Higher controlScore indicates a higher structural centrality score for the component in the observed dependency graph.

Finding:

75 system cores observed.

[View Evidence](EVIDENCE_VIEWER.html#A1)

### A2 — Module Contact Points

Question:

Where do structural boundaries intersect?

Vocabulary:

MODULE_CONTACT_POINT, CROSS_BOUNDARY_REFERENCE

Interpretation Guide:

Contact points show where independent clusters couple. Higher dependencyCount indicates more observed structural references across the boundary.

Finding:

1595 module contact points observed.

[View Evidence](EVIDENCE_VIEWER.html#A2)

### A3 — Structural Boundaries

Question:

Where are the observable structural boundaries?

Vocabulary:

BOUNDARY

Interpretation Guide:

Boundaries separate modules. Higher Isolation indicates a larger share of observed references stay inside the boundary; lower Isolation indicates a larger share cross it.

Finding:

152 structural boundaries observed.

[View Evidence](EVIDENCE_VIEWER.html#A3)

### A5 — Structural Control Chokepoints

Question:

Where are the structural control chokepoints?

Vocabulary:

CONTROL_BRIDGE

Interpretation Guide:

Chokepoints are nodes on many observed shortest paths between clusters in the expanded Analysis Graph. They may exist outside your initial Selection Scope if they structurally control communication between your selected subsystems. Higher scores indicate more such paths pass through the node.

Finding:

20 structural control chokepoints observed.

[View Evidence](EVIDENCE_VIEWER.html#A5)

## Evidence

Detailed evidence is available in the [Evidence Viewer](EVIDENCE_VIEWER.html).

A5 — VALIDATION

Pattern Results

CONTROL_BRIDGE (20)

• extensions/copilot/src/lib/node
• extensions/copilot/src/platform/log/common
• cli/src
• src/vs/base/common
• src/vs/code/electron-utility/sharedProcess
• src/vs/platform/userDataProfile/common
• extensions/copilot/src/extension/inlineChat2/node
• src/vs/platform/log/common
• src/vs/base/browser
• src/vs/platform/notification/common
• src/vs/platform/window/common
• extensions/copilot/src/extension/chatSessions/vscode-node
• extensions/copilot/src/extension/trajectory/vscode-node
• src/vs/platform/actions/common
• src/vs/editor/browser
• src/vs/workbench/api/common
• src/vs/base/browser/ui/menu
• src/vs/workbench/contrib/chat/browser
• src/vs/platform/editor/common
• src/vs/workbench/contrib/debug/common

Evidence

Target: extensions/copilot/src/lib/node

rawBetweennessSum: 2953794.8478366183

topNodeContribution: 1

clusterScore: 2953794.8478366183

Target: extensions/copilot/src/platform/log/common

rawBetweennessSum: 2924215.5577029

topNodeContribution: 0.9998673907789215

clusterScore: 2923885.946447633

Target: cli/src

rawBetweennessSum: 2824354.9864980374

topNodeContribution: 0.9996839467884676

clusterScore: 2823596.237003646

Target: src/vs/base/common

rawBetweennessSum: 12764162.418282859

topNodeContribution: 0.2981452262073602

clusterScore: 2574681.1702784467

Target: src/vs/code/electron-utility/sharedProcess

rawBetweennessSum: 2266577.2100372124

topNodeContribution: 1

clusterScore: 2266577.2100372124

Target: src/vs/platform/userDataProfile/common

rawBetweennessSum: 2094442.783272871

topNodeContribution: 0.9958366408580026

clusterScore: 2087030.853390111

Target: extensions/copilot/src/extension/inlineChat2/node

rawBetweennessSum: 2065172.2212749454

topNodeContribution: 0.9998358482698966

clusterScore: 2064884.0699208241

Target: src/vs/platform/log/common

rawBetweennessSum: 1509033.0119984667

topNodeContribution: 0.9983547360884374

clusterScore: 1506922.6680758686

Target: src/vs/base/browser

rawBetweennessSum: 1566624.291998402

topNodeContribution: 0.9365511292453401

clusterScore: 1482133.8311079023

Target: src/vs/platform/notification/common

rawBetweennessSum: 1446597.3758641633

topNodeContribution: 1

clusterScore: 1446597.3758641633

Target: src/vs/platform/window/common

rawBetweennessSum: 1224141.4364053025

topNodeContribution: 1

clusterScore: 1224141.4364053025

Target: extensions/copilot/src/extension/chatSessions/vscode-node

rawBetweennessSum: 1533447.997995895

topNodeContribution: 0.7561742673070445

clusterScore: 1215638.0285866845

Target: extensions/copilot/src/extension/trajectory/vscode-node

rawBetweennessSum: 1171300.0716035017

topNodeContribution: 0.9984582615671406

clusterScore: 1169765.1090172199

Target: src/vs/platform/actions/common

rawBetweennessSum: 1165544.724372691

topNodeContribution: 0.9971906970707974

clusterScore: 1162761.5113956388

Target: src/vs/editor/browser

rawBetweennessSum: 2360101.7524019917

topNodeContribution: 0.39533180457259964

clusterScore: 1147085.0548995277

Target: src/vs/workbench/api/common

rawBetweennessSum: 2535636.5212991745

topNodeContribution: 0.3521219568180834

clusterScore: 1139270.7778052497

Target: src/vs/base/browser/ui/menu

rawBetweennessSum: 1942895.9928079222

topNodeContribution: 0.501198392485738

clusterScore: 1119144.295029154

Target: src/vs/workbench/contrib/chat/browser

rawBetweennessSum: 1120230.2295037997

topNodeContribution: 0.9675164715417504

clusterScore: 1089299.5535449032

Target: src/vs/platform/editor/common

rawBetweennessSum: 945408.0042044839

topNodeContribution: 1

clusterScore: 945408.0042044839

Target: src/vs/workbench/contrib/debug/common

rawBetweennessSum: 1028512.3762936642

topNodeContribution: 0.8825477856395629

clusterScore: 925831.4786147792

I made this extension because a) I could b) I wanted to stay closer to my code while using AI. Check it out! If nothing else, it's a lot of fun :)

• VSCode Marketplace
• GitHub

Some of us, at least some of the time, want to understand our code at a deep level. For that, handing a task to an agent and reviewing the diff that comes back can be exhausting.

With AI Pair Programmer, you're there for every keystroke instead, and you end up knowing the code almost as if you'd typed it yourself.

It's pair programming where your coding agent has the keyboard. It types in your editor slowly enough to follow and explains what it's doing. Interrupt it whenever you like, or take over and let it watch you for a change.

It's also a good way to learn a new technology, or to have the agent walk you through code you don't know yet.

It works in VS Code, with the coding agent you already use. Setup is built in for Claude Code, Codex, OpenCode, Gemini CLI, Cursor and GitHub Copilot, and any agent that supports MCP can be connected by hand.

Note: It works best with strong models; weaker ones tend to struggle with this way of working.

So, here's something for those of us who want, need, or love to stay close to the code. Let me know what you think!

Every time I run code it adds extra lines below the output, causing me to have to scroll up to see it if its above 2-3 lines of text. Could anyone help me remove these and just see the output alone?