Skip to content
| Marketplace
Sign in
Visual Studio Code>Visualization>AI OS CareNew to Visual Studio Code? Get it now.
AI OS Care

AI OS Care

Preview

RemSoftDev

|
12 installs
| (0) | Free
Shows what the wsl-care daemon measures inside WSL — memory, swap, disk, containers and the cleanup candidates — and runs a cleanup only after you confirm it. Windows with WSL only; the daemon is installed separately.
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

AI OS Care

Preview. A view of what the wsl-care daemon measures inside WSL: memory, swap, disk, containers, the biggest holders and what each cleanup would free — in the status bar and in a side panel — and the daemon's cleanups, each run only after you confirm it. Windows with WSL only; the daemon is installed separately, inside the distribution (the panel's Install daemon types the command for you).

What you see

  • The status bar — WSL RAM <used>% · swap <x>G · <n> containers, coloured by the worst memory or kernel warning the daemon reports; "WSL stopped" when the distribution is not running. A click opens the panel.

  • The panel (the AI OS Care icon in the activity bar) — Memory, Top holders, Swap, Disk, Folders, Containers, Container starts, Cleanup (what each cleanup would free, with Clean, Select, Clean selected and Run full check now), Health, AI agents, Last cleanup. AI agents shows the daemon's AI-session archive: the folder it archives into, per agent what is old enough to be archived, and a warning when an agent's own cleanup deletes its sessions sooner than the archive would take them — with Choose archive folder…, Stop archiving and Archive now…. A figure the daemon could not read says why ("unavailable — reason"); a row this version cannot fill yet says so; nothing is shown as a made-up 0.

  • The Logs page (Logs in the panel's title, or beside Last cleanup) — what the runs of a period did: This run, Today, Yesterday, a day or a range of your LOCAL days (the 90 the daemon keeps). Totals, runs with and without a cleanup, the runs that freed the most and the least, each figure's max and min, the MemAvailable and swap trend, and the run list — Show objects lists every object a run removed, and every command it ran with its exit. The archive's actions are named — "archive of AI sessions" (its detail per agent), "restore of archived sessions" (the sessions put back), "stop of client-gone relays". Shown exactly as the daemon answers; the chosen period survives a reload.

  • The Archive page (Open archive… in AI agents, or AI OS Care: Open the AI-session archive) — what this distribution's archive holds: per agent, per month, each archived session with its files, size, status (still at its source, removed there, partly back, restored …), whether it is verified, and when it was archived. A session's path is shortened to its file name until you press Show full session paths — it holds a project's folder name. An unverified session removed at its source says how to restore it in a terminal (--accept-unverified). Browsing changes nothing; the Windows archive is shown by a later version.

  • Restore (on the Archive page) — Select verified sessions removed at their source (or Select month: the newest that fit) and press Restore. The page says how many one restore takes. A modal first names what comes back, and nothing is restored before you press Restore; the daemon copies the files back into the agent's folder as your user and never overwrites one. The page shows Restoring… while it runs — also after a reload — and reads the archive again when it ends, so the restored sessions read restored. An unverified session is restored only in a terminal.

  • A GPU that is not working (since 2026-10-10) — Windows' display adapters are read on their own (unelevated, at start, on panel open and Refresh, and every wslCare.gpu.checkMinutes). Any adapter whose Device Manager code is not 0 is an ALERT at the very top of the panel — its name, the code and its meaning, the fix in plain words (whether it needs a restart), what it costs (local models such as Ollama run on the CPU or do not start) and Ollama's own last choice from its server.log — and · GPU off on the status bar in the error colour; a check that could not run reads · GPU ?. A disabled adapter (code 22) gets Enable : a modal shows the exact elevated script and the program it elevates first, then ONE elevated PowerShell (one UAC prompt) re-checks the device and runs Enable-PnpDevice for exactly it, and the panel says what Windows reports afterwards ("enabled — code 0", or the code it still has and whether to restart) and which engine ran: PowerShell 7 — the MSI install, or else the Store build by its resolved package path under %ProgramFiles%\WindowsApps, each one only when the extension's own read of Windows verified its Microsoft signature (at every read, and once more right before the launch) — or Windows PowerShell 5.1 when neither is there. While a check runs the Health section says so; the last answer stays on screen.

What it runs, and when

  • Reading — it asks the daemon four questions: status --json, preview --all --json, doctor --json and --version — and, for the cleanups' results and the Logs page, three about runs: runs show <run> --json, runs --from <instant> --to <instant> --json and logs --from <instant> --to <instant> --json — and, for the archive, archive status --json, archive preview --json and archive check-base <folder> --json, and for the Archive page archive list --json. They run as your own user and change nothing.
  • One setting, and only when you choose it. Choose archive folder… opens a folder dialog; the daemon checks the folder (as your user, the one that will write the archive) and says why when it cannot hold the archive — then nothing is written. An accepted folder is shown with the daemon's warnings, and only Use this folder writes it, as config set archive.baseFolder <the folder> — as your own user, never as root. Stop archiving writes the empty value; nothing already archived is touched. Nothing is moved when you choose: the daemon archives a session only once it is old enough.
  • Archive now… runs the daemon's archive at once instead of waiting for its timer. It is a cleanup-like root call (act A13 --preview, then act A13 --confirm --manual --detach): a modal first names each agent's sessions and bytes, and nothing is moved before you press Archive. The daemon moves the sessions as your user with its own binary, and a session leaves its agent's folder only after its archived copy was verified. The panel follows the run to its result, across a reload, as it follows a cleanup. A first archive over a slow network folder can take longer than wslCare.cleanup.followCeilingMinutes (30 by default): the notice then says the run's state is unknown and names the daemon's runs show, while the section keeps reading Archiving… from the daemon's own status until the run ends — the run goes on in the daemon's unit; nothing is stuck.
  • Cleaning — only after you confirm, and only through seven calls. A cleanup needs root inside the distribution, so the extension has exactly seven root calls, all built in one place and nowhere else: a cleanup's preview (act <ids> --preview), its run once you confirmed (act <ids> --confirm --manual --detach, with the list of volumes the preview showed handed over on stdin), stopping a wedged run (act --stop <run>), Run full check now (collect --detach), a root check (--version), and Restore's preview and run (act A20 --preview --entry -, act A20 --confirm --manual --detach --entry -, the archived sessions' ids handed over on stdin). It never sends the timer's mark, never changes a daemon setting other than the archive folder above, and never acts on an action the daemon does not offer. A confirmed cleanup runs in the daemon's own systemd unit, so reloading the window does not cut it off: the panel writes the run down before it starts and follows it to its result — "Cleaning… A4" after a reload, then what it freed; a run that died says interrupted. (Whether the run also survives closing every WSL window is measured before the first release.)
  • Each cleanup shows its preview first — a modal with what each action removes and how much, and a second one for the actions that touch your own data or force downloads (A5, A6Unused, A8, A11, A12), naming the setting they use. A preview older than five minutes when you confirm is taken again. Clean selected runs all ticked rows as one run.
  • The daemon must be new enough to clean. Whether it may act is decided by what the daemon says it can do; an older one reads "Update daemon" and nothing is run.
  • A stopped WSL is never started. Before each question it asks wsl.exe whether the distribution is running; when it is not, nothing is called in it. Start WSL and check in the panel is the one button that starts it.
  • Only the focused VS Code window polls, every wslCare.refreshSeconds seconds (default 120), and only for status.
  • No telemetry and no network calls of its own.

The Windows tasks

Two opt-in scheduled tasks run the bundled Windows daemon for you, in a Task Scheduler folder named for the wsl-care daemon: watch (samples the Windows MCP servers into the daemon's CPU ledger every few minutes) and archive (archives the Windows side's aged AI sessions). The panel's Health section has three buttons — Install the Windows watch task, Install the Windows archive task and Remove the Windows tasks, and Run the Windows watch now / Archive Windows sessions now (a press on a task that is not installed says so) (also in the command palette, each ending "(as you, not elevated)…"). A start-now asks Task Scheduler to run the registered task exactly as its next trigger would; if the task is already running nothing new is started and the panel says so.

  • One PowerShell, as you. It is not elevated, Windows asks nothing, and the task runs as your own account with an interactive token at the least privilege — never SYSTEM. It runs only while you are logged on.
  • A verified copy. An install first asks the daemon to copy its bundled exe to a staging folder under %LOCALAPPDATA% (one folder per SHA-256 digest) and to read the copy back; the task starts THAT copy, never the extension folder. The modal says the copy is already there; a decline leaves it, and Remove the Windows tasks deletes it.
  • You read what runs. The exact PowerShell script — with the task definition the daemon rendered inside it — opens in a read-only tab beside the modal, and the modal names the program (PowerShell 7 when it is installed and verified, else Windows PowerShell 5.1), the triggers, the deadlines and the dry-run state. The extension checks the render before it shows it: your own account, an interactive token, the staged path — nothing else is registered.
  • Dry first. Until the dry run ends the tasks only sample or preview. This extension never writes the daemon's settings; to turn the dry run off, run the Windows daemon's own config set dryRun false (the exe in the extension's bin folder) in a terminal once you have read the dry week.
  • Remove deletes both tasks, then the folder only when nothing else is in it (the Windows Time guard's task keeps it), then every staged copy; a copy whose exe is still executing is kept and named, and the next install or removal retries it.

Install the daemon

The extension shows what the daemon reports; the daemon itself is installed in the distribution by its release's install.sh. When the panel says daemon not installed, Install daemon (also AI OS Care: Install daemon… in the command palette) shows the exact command and what the distribution needs, then opens a terminal in that distribution with the command typed but not run — you read it and press Enter:

curl -fsSL https://raw.githubusercontent.com/oleksandrdubyna88/wsl_care/refs/tags/daemon-v0.1.2/install.sh | sudo sh -s -- --version 0.1.2

The distribution needs systemd, Ubuntu 24.04 or newer (glibc 2.39), gh 2.56.0 or newer from GitHub's apt repository (the installer verifies the release's build-provenance attestation with it; no gh login is needed) and sudo. The installer checks each of these and stops before it changes anything when one is missing.

Settings

All are user settings only ("scope": "application"), so a repository's .vscode/settings.json cannot change them:

Setting Default Meaning
wslCare.distro empty The distribution to show. Empty means WSL's default distribution. A name wsl.exe --list does not report is refused before anything starts.
wslCare.refreshSeconds 120 How often the focused window asks for status, in seconds (at least 30).

wslCare.timeouts.windowsTasksSeconds (60, 10–600) bounds the ONE PowerShell of an install or removal of the Windows tasks, and wslCare.windowsTasks.busyRetrySeconds (3, 1–60) is the wait before the ONE retry when the daemon's run lock is busy.

Every other number the extension uses is a setting too — each with its range; a value outside it is clamped. A call's ceiling can never be set at or below the daemon's own worst case for that call: its minimum is that worst case plus 10 s.

Setting Default Range Meaning
wslCare.timeouts.statusSeconds 20 12–600 How long status --json may take before wsl.exe is stopped and the call reads "timed out", in seconds.
wslCare.timeouts.windowsStatusSeconds 20 12–600 How long status --json of the bundled Windows daemon may take before it is stopped and the reading reads "timed out", in seconds — it waits one MCP CPU window and starts no process.
wslCare.timeouts.versionSeconds 20 10–600 How long --version may take (also the privileged check before a cleanup), in seconds.
wslCare.timeouts.doctorSeconds 120 119–3600 How long doctor --json may take, in seconds — at least its worst case: four systemctl show, systemctl --version and docker version, each to its ceiling.
wslCare.timeouts.previewSeconds 350 340–7200 How long preview --all --json (one Docker snapshot, up to 100 containers) may take, in seconds.
wslCare.timeouts.previewPerDockerRowSeconds 350 340–7200 A cleanup's preview (act <ids> --preview) takes ONE Docker snapshot per Docker row (A4–A7): its ceiling is this many seconds per Docker row, plus A9's snap listing and a margin.
wslCare.timeouts.runReadSeconds 20 10–600 How long runs show, runs and logs may take, in seconds — and the archive calls that start no child: archive status, archive check-base and the archive folder write (config set archive.baseFolder, which judges the folder again). Raise it when the archive folder is on a slow network share.
wslCare.timeouts.archivePreviewSeconds 630 610–7200 How long archive preview --json (what the AI-session archive would move) and archive list --json (what it holds, the Archive page) may take, in seconds — above the daemon ceiling archive.previewTimeoutSeconds at its maximum (600).
wslCare.timeouts.detachSeconds 690 681–7200 How long a cleanup's confirm or Run full check now may take to hand the run to its unit, in seconds — at least the daemon's worst case: the shown list, one systemctl show per queued request (up to 32), the start and one more systemctl show. A detach that outruns it is followed as "outcome unknown", never reported as failed.
wslCare.timeouts.wslListSeconds 15 5–300 How long each of the three wsl.exe --list questions asked before a daemon call may take, in seconds (measured: about 50 ms each, warm).
wslCare.timeouts.stopSeconds 150 134–3600 How long Stop (act --stop, one systemctl stop) may take, in seconds.
wslCare.cleanup.followPollSeconds 4 2–60 While a cleanup is in flight, how often the focused window asks status, in seconds.
wslCare.cleanup.unknownDetachFollowSeconds 60 10–600 A detach whose outcome is unknown and named no run id: how long the panel looks for its run in status.running before it hands the question to the durable poll, in seconds.
wslCare.cleanup.followCeilingMinutes 30 5–1440 How long a cleanup is followed before it reads "state unknown" with its run id, in minutes (after one last read of its record).
wslCare.cleanup.requestGraceSeconds 90 70–900 How long a confirm whose run id was never seen waits before it is resolved from the run history, in seconds (above the daemon's own 60 s request grace).
wslCare.cleanup.previewRounds 3 1–10 How many times a preview that expired before the last confirmation is taken again before the cleanup is given up, saying so.
wslCare.cleanup.previewExpiryMinutes 5 1–60 A preview older than this when you confirm is taken again first, in minutes.
wslCare.cleanup.recordReadTries 3 1–10 How many times the record of a finished cleanup is read (runs show, runs) before it reads "the record could not be read".
wslCare.cleanup.recordReadBackoffSeconds 8 1–300 How much longer each new try of a failed record read waits than the one before, in seconds (the first try at once).
wslCare.cleanup.settleAtOnce 4 1–32 How many followed cleanups are settled at the same time in one poll.
wslCare.cleanup.tombstoneMinutes 10 1–1440 How long a cleanup another window removed from the shared journal is remembered as removed, so a stale list in a second window does not write it back, in minutes.
wslCare.cleanup.resultsKept 5 1–50 How many past cleanup results Last cleanup in the panel lists (newest first; the daemon keeps them all).
wslCare.cleanup.journalEntries 32 4–256 How many started cleanups whose result has not appeared yet the extension keeps following; past it a new cleanup is refused, none dropped.
wslCare.timeouts.gpuQuerySeconds 20 5–120 How long the read-only query of Windows' display adapters behind the panel's GPU alert may take, in seconds (measured: 0.6–1.5 s, once 6.2 s).
wslCare.timeouts.gpuEnableSeconds 120 30–600 How long Enable may take, in seconds — it waits for YOU at the UAC prompt, then enables one display adapter.
wslCare.gpu.checkMinutes 15 0–1440 How often Windows' display adapters are read for the GPU alert, in minutes, besides when the panel opens or is refreshed (0 = only then). Each read starts one Windows PowerShell.
wslCare.gpu.enableSettleSeconds 3 0–60 How long Enable 's elevated script waits after Enable-PnpDevice before it ends, so the re-read that follows sees the driver started, in seconds.
wslCare.gpu.ollamaLogTailKiB 256 16–4096 How much of the end of Ollama's server.log is read for the device it last chose, in KiB.
wslCare.logs.maxRunIndex 9999 100–100000 The largest run-list index the Logs page may name (a bound on its messages; the host still checks the index against the list it read).

Some numbers are NOT settings, because they mirror the daemon and a second copy could drift: the days of history it keeps, the clock skew and grace it allows a request, how long it waits after a killed command and for systemctl stop. They are read from the daemon's own status answer (limits), each with its default until a daemon says otherwise — and every call's ceiling is raised, when needed, to stay above the daemon's worst case under them.

Workspace trust

AI OS Care works in untrusted (Restricted Mode) workspaces too, and that is deliberate: no input from the workspace reaches a root call. Every setting it reads is "scope": "application" — a user setting, which a repository's .vscode/settings.json cannot set — and none of its calls takes a value from the open folder, its files or its tasks. What a cleanup acts on comes from the daemon's own preview and your confirmation in a VS Code dialog, never from the workspace, so trusting or not trusting a folder changes nothing about what it can run.

Requirements

  • Windows 10/11 with WSL 2. The extension runs on the Windows side (also in a Remote – WSL window); on any other system it says "Windows + WSL only" and asks nothing.
  • VS Code 1.85 or newer.
  • The wsl-care daemon in the distribution (see above).

Source, issues and licence

Source and issues: github.com/oleksandrdubyna88/wsl_care. MIT licence. Every release's .vsix is also attached to its GitHub release, with a build-provenance attestation.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft