adom-vscode

macOS line. This is adom/adom-vscode-macos (repo adom-inc/adom-vscode-macos), the build Hydrogen installs on a Mac: native arm64 for the Hydrogen workspace machine, same extension id, CLI and :8821 API as adom/adom-vscode, without the AI title bar (Hydrogen's agent bar and AI accounts popup own the editor title bar there). Windows and cloud containers keep adom/adom-vscode. Upstream changes are merged in; the delta is cli/src/main.rs (no title-bar injection, strips upstream's, writes ~/.local/share/adom-vscode/flavor) and page-macos/.

Adom VS Code Extension for Adom workspaces running Coder's code-server — a cloud container, or the Hydrogen workspace machine on Windows (WSL2) and macOS (a systemd-nspawn machine in a Lima VM).

A single Rust binary that ships a VS Code extension + CLI for controlling code-server from any process inside the Adom workspace. AI agents (Claude Code, Codex, Kimi, Antigravity) and scripts use this to open files, manage extensions, control the layout, change settings live, run workspace commands, and pass events to the Hydrogen Desktop / Hydrogen Web frontend. The binary embeds the VSIX, the bash completions and the AI title-bar script, so adom-vscode install sets up the entire thing.

Since v1.1.0 the extension is also the native replacement for host-side workspace plumbing: settings apply live through the VS Code API (no window reload, no dropped Claude sessions), and shell commands run inside the workspace via /exec instead of an out-of-band host spawn (wsl.exe on Windows; limactl/nsenter or the Hydrogen control API's POST /workspace/exec on macOS).

What it does

• Open files in VS Code tabs (images, text, anything)
• Reveal files/folders in the Explorer sidebar
• Preview Markdown files in rendered view
• Settings, live: get/set any VS Code setting, theme, fonts, font sizes. Changes apply immediately via ConfigurationTarget.Global (no reload, active AI sessions survive)
• Exec: run shell commands in the container as the workspace user, streamed (SSE) or buffered
• Event queue: any container process pushes events; the HD/HW frontend pulls them when it wants (login-refresh needed, long-job progress, anything)
• Workspace identity: query whether this is an hd (local Hydrogen workspace — WSL2 on Windows, the workspace machine on macOS) or hw (Adom cloud) container, OS, kernel, key env vars
• API key: check the health of /var/run/adom/api-key and inject a fresh key after a frontend login refresh
• Extensions: list installed extensions (with a Claude/Codex/Kimi/Antigravity summary), query one extension's version + running state + pending update, update one or all, search, install
• Start new Claude Code conversations
• Modes: switch VS Code into different full-screen experiences (claudecode, claudetty, tty)
• Control layout: sidebar, panel, terminal, activity bar (show/hide/toggle)
• Run any VS Code command (generic escape hatch)
• Activity bar icon: Adom icon with accordion sidebar showing every verb and AI prompts

Install

# The wiki package is the only channel (the GitHub releases stopped at v1.0.6). It ships the
# binary (embedded VSIX + completions + AI title-bar script), the skills, and runs
# `adom-vscode install` for you. Hydrogen's bootstrap depends on it, so every Adom user has it.
adom-wiki pkg install adom/adom-vscode      # or: adom-wiki pkg update adom/adom-vscode

Port discovery

The extension serves its HTTP API on 127.0.0.1:8821. If 8821 is already taken it walks 8822..8831, then takes an ephemeral port, and writes the truth to:

~/.local/share/adom-vscode/port.json    # { "port": N, "preferredPort": 8821, "pid": ..., "version": ..., "startedAt": ... }

External services that expect the well-known port should read that file when 8821 does not answer. The CLI already does (resolution order: ADOM_VSCODE_PORT env var, then port.json, then 8821). GET /health reports both port (actual) and preferredPort.

HTTP API (the verb surface)

Everything the CLI does is a plain HTTP call, so HD, HW, and any script can hit the API directly. GET /health returns {version, port, preferredPort, portFile, verbs: [...]} so callers can feature-detect instead of gating on versions.

Verb	Method + route	What it does
health	GET /health	Liveness, version, actual port, full verb roster
open	POST /open {path}	Open a file in a tab
reveal	POST /reveal {path}	Reveal in Explorer sidebar
preview-markdown	POST /preview-markdown {path}	Rendered Markdown preview
config.get	GET /config?key=<dotted.key>	Effective value + default/global/workspace layers
config.set	POST /config {key, value}	Set in User (Global) settings, applies live, no reload
theme.get	GET /theme	Active theme, preferred dark/light, all installed themes
theme.set	POST /theme {theme}	Switch color theme live
fonts.get	GET /fonts	All font settings (editor, terminal, chat prose chat.fontFamily, chat code chat.editor.fontFamily) plus the RESOLVED families the renderer actually shows (via document.fonts.check)
fonts.set	POST /fonts {editorFamily?, proseFamily?, proseCodeFamily?, editorSize?, terminalSize?, proseSize?, proseCodeSize?}	Set any subset live
exec	POST /exec {command, cwd?, timeoutSec?}	Buffered: run bash -lc as the workspace user, return {exitCode, stdout, stderr, timedOut}. local-workspace only (kind:hd): the WSL2 workspace on Windows and the Hydrogen workspace machine on macOS. A cloud (hw) container refuses with exec_disabled_on_cloud
exec.stream	POST /exec/stream {command, cwd?, timeoutSec?}	Streaming: SSE events start, stdout, stderr, exit {exitCode, timedOut}. local-workspace only, same policy
fs.write	POST /fs/write {path, base64 | text, mkdir?}	Write a file as the workspace user, atomically (temp file plus rename); path is absolute under the home directory or relative to ~/project. Returns {ok, path, bytes}. local-workspace only, same policy as exec. Hydrogen Desktop lands screenshots and recordings through this instead of spawning wsl.exe
stats	GET /stats	Kernel counters in one read: memory (total, available, swap), cumulative CPU ticks, core count, the OOM-kill count, load average, uptime. Hydrogen Desktop's meter and its OOM notice read this instead of running a probe through wsl.exe
queue.push	POST /queue/push {topic?, type?, payload?, ttlSec?}	Push an event for the frontend; returns {id, depth}
queue.pull	GET/POST /queue/pull {topic?, max?, peek?}	Pull (consume) events; peek reads without consuming
queue.status	GET /queue/status	Depth + per-topic counts
queue.clear	POST /queue/clear {topic?}	Drop all events, or one topic
container.info	GET /container	kind: hd|hw|unknown, cloud flag, OS, kernel, hostname, carbon URL, VS Code proxy URI, detection markers
apikey.status	GET /apikey	/var/run/adom/api-key: exists, readable, size, age, sha256 fingerprint
apikey.set	POST /apikey {value}	Write a fresh key (root-owned path, goes through passwordless sudo)
extensions.list	GET /extensions (?all=1 incl. builtins, ?id=x&latest=1 for one + gallery check)	Installed extensions + ai summary for claude/codex/kimi/antigravity
extensions.update	POST /extensions/update {id?}	Update one extension, or all when id omitted
extensions.search	POST /extensions/search {query}	Open Extensions sidebar with a query
extensions.install	POST /extensions/install {id}	Install by marketplace id
terminal.tui	POST /terminal/tui {name, command?, shellPath?, shellArgs?, env?, cwd?, viewColumn?, icon?, color?} (icon: a codicon id, or adom:claude / adom:codex / adom:kimi for the vendor marks the AI launch bar uses; vendor marks carry their own colour)	Open a NAMED terminal as an EDITOR TAB running a command (AI CLIs for the Hydrogen AI Threads panel); returns a handle {id}. icon is a codicon name, color a theme color id (terminal.ansi*), so per-AI tabs are distinguishable. Never touches terminal.integrated.defaultLocation. Capability marker terminal.tui.icon in the /health roster
terminal.tui.list	GET /terminal/tui/list	Handles: id, name, command, running state
terminal.tui.dispose	POST /terminal/tui/dispose {id?, name?}	Close a named TUI terminal by handle
claude.new	POST /claude/new	New Claude Code conversation
ai.providers	GET /ai/providers	Which AIs are installed here (Claude Code, Codex, Kimi, Antigravity), the command a new tab runs, and which icons the user shows
ai.install	POST /ai/install	Install a missing AI's extension from the title bar ({type}: claude, codex, kimi, antigravity); the reply names the CLI the TUI still needs
ai.new	POST /ai/new {type, tui?, group?, surface?}	Open a new thread for that AI in an editor group (default: the active one) and keep it there; tui:true puts the AI's CLI in a terminal tab instead. Antigravity: its extension is a side-bar view that can also host the conversation in an editor panel (its unlisted antigravity.moveBetweenEditorAndSidebar), so the default is a TAB with a new conversation in it while the side bar keeps its own conversation (two at most); surface:"sidebar" sends it back
tabs.close	POST /tabs/close {label?, kind?, group?}	Close every tab matching an exact label and/or kind (claude, codex, kimi, terminal, ...), optionally in one group; the cleanup half of a ralph test
tabs.list	GET /tabs	Event-driven tab census from the extension host (window.tabGroups): every tab with kind (claude | codex | kimi | terminal | other), label, group/tab index, active flags; Codex rows carry sessionId from the editor URI. No DOM, no CDP
tabs.events	GET /tabs/events (SSE)	The same census pushed on every tab open/close/move/focus change (event: census), plus event: claude-session when the SessionStart hook reports a new Claude session. Hydrogen holds one stream per workspace instead of polling the iframes
claude.session-start	POST /claude/session-start {session_id, transcript_path?, cwd?, source?}	Ingest for a Claude SessionStart hook: records the session (last 100) and broadcasts it on /tabs/events
claude.sessions	GET /claude/sessions	The recorded Claude sessions (id, transcript path, cwd, source, time)
claude.open-session	POST /claude/open-session {sessionId, prompt?, retagEntrypoint?}	Open an EXISTING Claude conversation as an editor tab and CONFIRM it bound (bound:true once a CLI resumes that id), instead of the fire-and-forget claude-vscode.editor.open. Rewrites a programmatic transcript entrypoint (sdk-cli/sdk-ts/sdk-py -> claude-vscode) first, because the Claude extension silently declines to restore those and opens a fresh tab
claude.context	GET /claude/context	Live AI session stats (context %, cache, tools, compactions)
command	POST /command {command, args?}	Any VS Code command (escape hatch)
notify	POST /notify {message, level?}	Toast notification
mode.*	POST /mode/claudecode|claudetty|tty|reset	Full-screen mode switching
paste-screenshot	POST /paste-screenshot (raw image body)	Save clipboard image to /tmp/shots/

The event queue survives window reloads (persisted to ~/.local/share/adom-vscode/queue.json, capped at 1000 items, optional per-item TTL).

Why the settings verbs matter

POST /config uses vscode.workspace.getConfiguration().update(key, value, ConfigurationTarget.Global), which applies immediately with no window reload. That is the fix for two long-standing HD bugs at once: font-size changes that silently never landed when the wsl.exe settings.json merge hung, and theme changes that needed a full workbench reload (which dropped the user's Claude sessions).

For fonts, GET /fonts reports the resolved family the renderer actually shows (checked with document.fonts.check in the workbench), not just the configured stack. The configured chain often names a font that is not installed on the rendering side; HD needs the true value for its readout.

CLI quick start

adom-vscode health                        # Liveness + version + verb roster
adom-vscode open /path/to/file.png        # Open file in VS Code tab
adom-vscode reveal /path/to/folder/       # Reveal in Explorer sidebar
adom-vscode preview /path/to/README.md    # Markdown preview

# Settings (all apply live, no reload)
adom-vscode config get workbench.colorTheme
adom-vscode config set editor.fontSize 14
adom-vscode theme get                     # active + available themes
adom-vscode theme set "Adom Studio Dark"   # see `theme get` for the installed labels
adom-vscode font get                      # all font settings + resolved families
adom-vscode font set --editor-size 14 --prose-family Inter
adom-vscode font-size get
adom-vscode font-size set --editor 14 --terminal 13 --prose 15

# Exec (streams live by default; --json for buffered)
adom-vscode exec "ls -la" --cwd /home/adom/project
adom-vscode exec "npm test" --timeout 600
adom-vscode exec "uname -a" --json

# Event queue (container process -> HD/HW frontend)
adom-vscode queue push login --type refresh-needed --payload '{"expiresInHours":24}'
adom-vscode queue pull --topic login      # consume
adom-vscode queue pull --peek             # read without consuming
adom-vscode queue status
adom-vscode queue clear --topic progress

# Container identity + API key
adom-vscode container                     # kind (hd/hw/unknown), OS, env, markers, execAllowed
adom-vscode apikey status
adom-vscode apikey set --stdin < new-key.txt

# Extensions
adom-vscode extensions list               # + claude/codex/kimi/antigravity AI summary
adom-vscode extensions status anthropic.claude-code --latest
adom-vscode extensions update anthropic.claude-code
adom-vscode extensions update             # update all
adom-vscode extensions search "python"
adom-vscode extensions install ms-python.python

# AI threads and tabs
adom-vscode ai providers                            # installed? command? icon shown?
adom-vscode ai new '{"type":"codex"}'               # a Codex thread in the active group
adom-vscode ai new '{"type":"claude","group":2}'    # in editor group 2 (1-based)
adom-vscode tabs list                               # tab census: label, kind, group, resource
adom-vscode tabs close '{"label":"Claude Code"}'    # close by label, kind or resource_contains

# Layout, misc
adom-vscode claude new                    # New Claude Code chat
adom-vscode sidebar toggle                # Toggle sidebar
adom-vscode panel toggle                  # Toggle bottom panel
adom-vscode terminal new                  # New terminal
adom-vscode notify "Build complete"       # Toast notification
adom-vscode reload                        # Reload VS Code window (drops AI sessions!)
adom-vscode command <any-vscode-command>  # Generic escape hatch
adom-vscode --help                        # All commands

Modes

Modes take over VS Code's full screen for a focused experience. Use mode reset to return to normal.

adom-vscode mode claudecode               # Claude Code panel UI
adom-vscode mode claudetty                # Full-screen terminal + claude CLI
adom-vscode mode tty                      # Blank full-screen terminal
adom-vscode mode tty -c "echo hello" -n "Demo"  # TTY with auto-command
adom-vscode mode reset                    # Exit any mode

URL auto-trigger

Add ?mode=X to any VS Code URL to auto-enter a mode on page load. Perfect for sharing onboarding links with new users.

URL param	Mode
?mode=claudecode	Claude Code panel UI
?mode=claudetty	Full-screen terminal + claude CLI
?mode=tty	Blank full-screen terminal
?mode=tty&cmd=echo%20hello	TTY with auto-command

Examples:

• Cloud: https://<slug>.adom.cloud/?mode=claudecode&folder=/home/adom/project
• Hydrogen workspace (Windows/macOS), where code-server is served locally: http://127.0.0.1:7380/?mode=claudecode&folder=/home/adom/project

Paste-screenshot interceptor — REMOVED (2026-09-03)

The Ctrl+V-an-image-into-a-terminal interceptor is gone: the Claude CLI handles image paste on its own. adom-vscode install still strips a previously injected block from workbench.html, which is the last thing this tool can ask sudo for, and only on a machine patched before 1.1.x. The one block it writes today is browser/ai-titlebar.js (AI thread icons in the title bar).

Activity bar

The extension adds an Adom icon to the VS Code activity bar. Click it to open a sidebar with accordion sections covering the full verb surface:

• Overview: what the extension does
• Commands: file, layout, and utility commands with hover tooltips
• AI Prompts: sample prompts to paste into Claude Code chat
• Settings & Theme: live config/theme/font control
• Exec & Queue: container exec and the frontend event queue
• Workspace & Keys: hd/hw identity and api-key health
• Extensions: list/status/update, incl. the AI assistants

The skill pack

The page ships a parent skill plus six sub-skills so any AI in the Adom ecosystem can discover and drive every verb. adom-vscode install (and adom-wiki pkg install) deploys all of them to ~/.claude/skills/:

Skill	Covers
adom-vscode (parent)	Mental model, file ops, workspace scoping, port discovery, management
adom-vscode-settings	Live config/theme/font get+set, resolved font families
adom-vscode-exec	Streamed + buffered workspace exec, timeouts, the in-workspace-instead-of-host-spawn rationale
adom-vscode-queue	The container-to-frontend event queue, topics/TTL/peek, patterns
adom-vscode-container	hd/hw identity, api-key status/inject, port discovery, /health feature detection
adom-vscode-extensions	Extension list/status/update, the AI-assistant summary, the AI thread icons

Architecture

Claude Code / scripts / HD frontend
    ↓  runs CLI or hits HTTP directly
adom-vscode open /foo/bar.png
    ↓  HTTP POST to localhost:8821 (see Port discovery)
Adom VS Code Extension (inside code-server)
    ↓  vscode.* API / child_process
VS Code UI + container shell

See ARCHITECTURE.md — a HISTORICAL March 2026 design document, not current: it predates the wiki-registry install channel, the port fallback and most of today's verb surface. This README and GET /health are the current truth. See COMMANDS.md for all VS Code commands usable with adom-vscode command <id>.

Development

# Build everything locally
bash build.sh

# Release: publish to the wiki registry, the only channel users install from. The script
# assembles the page layout, refuses to publish unless VERSION, extension/package.json,
# cli/Cargo.toml, the built binary, and its embedded VSIX all agree (1.1.25 shipped with a
# 1.1.23 binary inside; never again), pushes the page repo, publishes, then downloads the
# published tarball and checks the binary version inside it.
bash scripts/release-wiki.sh

Version

The version lives in VERSION (single source of truth) and flows to:

• extension/package.json
• cli/Cargo.toml
• VSIX manifest (via build.sh)
• Activity bar sidebar footer
• Health endpoint response
• CLI --version flag

v1.1.10 added: live config/theme/font verbs, streamed exec, the frontend event queue, container identity, api-key status/inject, extension query/update, port fallback + port.json discovery, and verb-roster feature detection on /health.

v1.1.11 added: the skill pack (parent + 6 sub-skills) installed by both adom-vscode install and the wiki package.

v1.1.12: exec verbs are local-workspace only (disabled on cloud hw containers, errorCode exec_disabled_on_cloud); /health reports execAllowed and omits exec verbs where disabled.

v1.1.13: extension-dir GC on every install (prunes stale version dirs VS Code's startup GC never reaps on long-lived windows; keeps current, live-process, and running-server versions), and install now pushes a system/update-pending queue event so the frontend can reload at a safe moment. \nv1.1.15: version realignment and the issue #642 fix (platform-scoped extensions --latest with allPlatforms matrix, --platform flag, honest 'already current' update). \nv1.1.16: extensions install --vsix <path|url> installs a VSIX directly via code-server's CLI with the extension-host env stripped (absorbs the CODE_SERVER_PARENT_PID / not-spawned-with-IPC trap from issue #642).

v1.1.17: named TUI terminals as editor tabs with real handles (POST /terminal/tui, /terminal/tui/dispose, GET /terminal/tui/list; CLI terminal tui / tui-list / tui-dispose), built for the Hydrogen AI Threads panel; /command now passes a non-array args value as a single argument instead of silently dropping it, and reports argsShape.

v1.1.18: terminal.tui accepts optional icon (codicon name -> ThemeIcon) and color (theme color id -> ThemeColor) so AI TUI tabs match the AI Threads panel identities; tui-list echoes them; /health roster gains the terminal.tui.icon capability marker.

v1.1.19: terminal.tui accepts shellPath/shellArgs/env (createTerminal semantics): the CLI runs AS the terminal process, no shell underneath, no echoed launch line pinned atop the TUI, no quoting constraints, and the tab closes when the process exits. shellPath wins over command; a missing or non-executable shellPath fails explicitly (errorCode shell_path_not_executable) instead of falling back to a bare prompt. Capability marker terminal.tui.shell in the /health roster.

v1.1.20: /command returns errorCode command_not_found (HTTP 400) with did-you-mean suggestions when a command id is unknown (args-taking commands often use the bare id, e.g. moveActiveEditor); terminal.tui injects ADOM_VSCODE_TUI_ID into the terminal env and tui-list reports processId, giving callers a DOM-free identity chain (pid -> /proc environ -> registry id).

v1.1.21: event-driven tab census + Claude session identity (John 2026-09-03: never poll the iframes again). GET /tabs and the SSE stream GET /tabs/events publish the extension host's own tabGroups census on every change; POST /claude/session-start ingests the Claude SessionStart hook (id + transcript path, before the jsonl is flushed) and GET /claude/sessions lists it; POST /claude/open-session opens an existing conversation by id and confirms the bind (retagging sdk-cli transcripts, which the Claude extension otherwise declines). Capability markers in /health: tabs.list, tabs.events, claude.open-session, claude.session-start, claude.sessions.

v1.1.93 (Kyle Bergstedt, PRs #2 and #3): the local-workspace detector is no longer WSL2-only — /etc/profile.d/hydrogen-env.sh and ADOM_HYDROGEN_MACHINE count as kind:"hd" alongside hd-env.sh and the WSL kernel, so the macOS Hydrogen workspace machine (systemd-nspawn inside Lima) stops reporting kind:"unknown" and stops refusing exec/fs.write; both new markers are ignored when VSCODE_PROXY_URI is .adom.cloud, and markers gains hydrogenEnvSh/hydrogenMachine. CLI: ai providers|new|icons and tabs list|close subcommands exist (routes and skill had them, the clap enum did not); a policy 403 prints the server's own error/hint instead of "install, then reload", and exec --json exits non-zero on ok:false. The Codex Sessions side bar matches VS Code's own list density (editor tokens, keyboard access). Docs: platform wording corrected (Windows: labels with the macOS path beside), dead wiki host replaced.

v1.1.82: the usage widgets live on 27011 and 27012, well away from the 8000s where apps land (John 2026-09-15); a widget is a side panel and must never take a port an app wants.

v1.1.80: a failed poll keeps the last numbers dimmed and retries in 5, 15 and 45 seconds before the normal interval, instead of "no data" for three minutes.

v1.1.79: no polling while a token is expired (the widget waits for the sign-in file to change, fifteen minutes as the safety net); a widget can tick on a time boundary instead of an interval.

v1.1.78: an expired provider token is never "sign in again": the usage widgets say the token is waiting for Claude Code or Codex to refresh it, keep the last good numbers on screen dimmed, and retry every minute; the Claude widget skips the call when the file already says the token is expired.

v1.1.77: a new AI thread unlocks the active editor group first (VS Code keeps a group locked after its terminal tab closes and then refuses the new tab).

v1.1.76: an expired provider sign-in (HTTP 401 or 403) reads "sign in to Codex again" in the slot instead of the raw HTTP error.

v1.1.75: the full Title Bar layout is a third as wide (short gauge bars, about 90 px for Claude with three rows); a widget with no mark no longer reserves the mark space (the clock had 20 px of nothing left of the time).

v1.1.74: the helper measures a widget on a hidden max-content clone (any markup, never fed by the slot width; the clock had asked for 361 px); the tall label clip applies to bar rows only; /preview?h= follows the width the widget asks for; crisp pictures of both layouts on the widgets page.

v1.1.73: widget pages measure their intrinsic content, so a slot shrinks to what is shown (Codex in the compact bar) and grows to fit (Claude in the compact bar, three rows narrow when tall).

v1.1.72: the widget helper serves /preview?w=&h= for clean docs screenshots of a widget at slot size.

v1.1.71: widget pages tell Hydrogen the width they need in the current layout (narrow when tall, wide when compact); the widgets page explains shipping several widgets from one repo.

v1.1.70: the usage widgets describe themselves for Hydrogen's hover card (about, refresh fields in the manifest).

v1.1.69: the widget helper retries its bind for five seconds, so a port a stopped instance is still releasing never fails the launch.

v1.1.68: tall layout never clips: natural-width columns with the bar taking the rest, tall widths set in the manifest, and the page re-renders on its own resize event.

v1.1.67: each widget names its own page (docs: widgets/README.md, shipped with the package) so the Hydrogen Widgets pulldown row links to what it shows, its manifest and files, and how to make your own.

v1.1.66: widget pages have two layouts chosen by the slot height: rows stacked in the full Title Bar (like the meter), one horizontal row when it is compact.

v1.1.65: the Claude usage widget reads the structured limits list, so model-scoped weekly limits (Fable limit 93 percent) show with their own name and the provider severity colour, next to the session and weekly bars.

v1.1.64: the usage widgets ask their provider at most once every three minutes, pause while the window is hidden, back off on errors (doubling to 15 minutes), and re-read the sign-in file only when it changes.

v1.1.63: the Claude and Codex usage widgets carry their vendor marks (the launch bar artwork) so you can tell them apart at a glance, in the slot and in the Widgets pulldown.

v1.1.62: the widget pages size themselves to their slot, so they fit the full Title Bar and the compact one.

v1.1.61: the usage widgets say "sign in to Claude Code / Codex in this workspace" instead of a raw file error when there is no sign-in yet.

v1.1.60: ships two Hydrogen title-bar widgets as a hydrogen-widget.json facet (adom/hydrogen#17): claude-usage (5-hour, weekly and model-bucket percent used from the Claude Code sign-in) and codex-usage (the plan's rate-limit window from the Codex sign-in). Their scripts install to ~/.local/bin with the package; Hydrogen's Widgets pulldown opens them.

v1.1.59: GET /stats also names the most recent out-of-memory victim (process, pid, rss) when the kernel log is readable, so Hydrogen Desktop can say what Linux killed. Read at most once per kill.

v1.1.58: POST /fs/write (atomic file write as the workspace user) and GET /stats (memory, CPU ticks, OOM-kill count, load) so Hydrogen Desktop never spawns wsl.exe to land a screenshot or read its meter (adom/hydrogen#50, #76). Capability markers fs.write and stats in the /health roster; fs.write is hidden on cloud containers like exec. v1.1.57: a slow first Claude open (cold start after an extension-host restart, ~30 s) is no longer reported as a failure: 60 s budgets on New AI thread end to end, a toast at 6 s saying it is still starting, a 30 s tab wait.

v1.1.56: the Codex warm-up no longer starts on its own (this extension also runs in Hydrogen Web, where recovery is not its business); Hydrogen Desktop asks for it with POST /codex/warm when a restarted extension host appears and its Recovery switch is on. The adom-vscode.codexWarmOnReload setting is gone.

v1.1.55: the Codex warm-up starts 8 s after activation (Hydrogen has re-attached by then, so its start line reaches the recovery log) and its done frame carries when it started and how long it took.

v1.1.54: when two hosts report the same tab census (the old host and its replacement right after a reload), the title bar picks the newest by startedAt, closing the first-90-seconds gap the detached flag cannot cover.

v1.1.53: stale-host guard. After an editor reload VS Code keeps the old extension host alive for hours; it kept answering /health and swallowing new-thread commands into a window that no longer existed. The host now probes its window every 30 s, marks itself detached after three misses, closes its HTTP server and drops its port file; the title bar skips any host reporting detached.

v1.1.52: setting adom-vscode.codexWarmOnReload (default on) switches the Codex warm-up off; Hydrogen's Settings > Wake drives it.

v1.1.51: the Codex renderer warm-up after an editor reload announces itself on the tab event stream (codex-warm start/done), so Hydrogen's wake indicator can say why the Codex tabs are cycling.

v1.1.50: two hot paths tamed (John: "any loops slowing VS Code?"): the title-bar observer only reacts to the title bar and tab strips instead of every keystroke and terminal write; the Codex Sessions watcher ignores appends to a running rollout and re-reads at most every 5 s.

v1.1.49: the Codex Sessions side bar carries a muted one-line note at the bottom saying it is an Adom feature (Codex conversations as first-class VS Code tabs); hover or click for the why.

v1.1.48: the title-bar AI menu paints from the last answer and refreshes behind itself (no wait on the extension host), is capped to the window height, folds the icon checklist and vendor-button toggles behind Customize, shows a Terminal (TUI) row and icon only when that AI's CLI is on PATH (tui_available, cli_path on /ai/providers), and offers Install rows for the AIs that are not here (POST /ai/install). Published to the wiki by scripts/release-wiki.sh, which refuses a mis-stamped package.

v1.1.26: AI thread icons in the window title bar (John 2026-09-06), the layout-controls row at the top right. VS Code has no contribution point there, so browser/ai-titlebar.js rides workbench.html (written by adom-vscode install, back on every reload) and calls this extension over /proxy/<port>/ai/*: one icon per INSTALLED AI in the vendor's own colour (Claude Code, Codex, and Kimi or Antigravity when their extension is present), a sparkle menu listing every installed AI plus its TUI (the CLI in a terminal tab), and a VS Code-style checklist of which icons to show (saved as adom-vscode.aiIcons; TUIs off by default). A click opens the thread in THIS window's active group (each Hydrogen VS Code tab is its own window and extension host; the script matches its visible tabs against every candidate port's census, so the thread never lands in another window) and moves it back if the AI extension split the editor. GET /ai/providers, POST /ai/new {type, tui?, group?} (a TUI goes through the /terminal/tui registry with the AI Threads panel's icon and colour), POST /ai/icons {icons}, POST /tabs/close {label|kind}. The icons are drawn as a real monaco-toolbar (VS Code's own action-item markup, hover and active styling) with monaco-hover tooltips; the menu glyph is a plus with a dropdown chevron. Also: extensions install --vsix and adom-vscode install used the remote-cli wrapper, which only works inside a VS Code terminal and reported success while installing nothing; both now use the code-server binary and require its own "successfully installed" line.