perf(vscode): flatten cold-reload startup cost

v0.4.1

Pass over the activate() critical path and the cockpit refresh
loop. None of the changes here need to be opted into — they apply
on every reload.

Persisted hot-path snapshots across window reloads via a new
core/persistedCache.ts helper (workspaceState wrapper). Bazel
disk-cache size, environment versions, and cmk-dev-install-site
state are read synchronously from yesterday's snapshot on first
paint and revalidated in the background — the user no longer
stares at empty Environment tiles while du and a fistful of
--version subprocesses spin up.

Bazel disk-cache probe short-circuits via fs.statSync on the
cache dir mtime; when it is unchanged since the last probe, the
expensive du -sb walk is skipped entirely.

loadConfig() now caches the parsed JSON keyed by file mtime, so
the repeated reads in refreshStateCache and the settings dialog
collapse to a single parse.

registerBazelTestController + registerBazelTestsConfigView are
deferred until the first Python / TypeScript editor activates or
10 s elapse, freeing the activate() path for vscode.git and
Pylance startup.

checkVersionMismatch and showWhatsNewIfNeeded are deferred by 2 s
so neither can pop a modal during the activate window.

The 5 s cockpit auto-refresh tick is skipped whenever the cockpit
webview is hidden — eliminates ~720 HTML rebuilds per hour of
editor work where the sidebar is not visible.

refreshOverview() now re-reads the gitState and bazelCache stale-
while-revalidate slices before rendering. Without this, the 5 s
tick (and the SWR callbacks) read back the frozen snapshot from
the last full refreshStateCache(), so re-enabling the pre-commit
hook would leave the cockpit's "bypassed" chip stuck on the
previous state until the user triggered refreshAll().

New invalidateGitState() helper plus a .git/hooks/pre-commit*
file watcher in sidebar.ts: the watcher invalidates gitState's
SWR cache and calls refreshAll() so the cockpit's "pre-commit
bypassed" chip flips within ~100 ms of toggling the hook instead
of waiting out the 5 s TTL.

The startup-regression cockpit chip now requires cmk.benchmark-
Startup to be on so stale history from a previous experiment
cannot surface a phantom warning after the flag is turned off.

The cmk.fixQaTestDataSubmodule reset now reads the tracked gitlink
SHA from the parent index and checks the submodule worktree out at
that SHA directly. The previous `git submodule update --init
--force` path fell back to the relative ../qa-test-data URL in
.gitmodules, which git 2.38+ refuses over the file:// transport —
the action used to fail with "fatal: transport 'file' not allowed"
even when the submodule was already correct.

AI-Generated: true
Change-Id: I2956fb7080eb5ee00f36f848a50f088672e6fcf5

Author: otAAAh

.ide/vscode/changelog/v0.4.1.md

@@ -0,0 +1,35 @@
+## v0.4.1
+
+> **Note:** Startup-perf pass aimed at flattening cold-reload cost. None of
+> the changes below need to be opted into — they apply on every reload.
+
+### Persistence across window reloads
+
+- **perf**: persist the Bazel disk-cache size snapshot in `workspaceState`; the next reload returns yesterday's value synchronously instead of waiting for `du -sb` to complete
+- **perf**: persist the environment-versions snapshot (Python / Node / Bazel / Bazelisk / Docker / GCC) so the Environment grid paints from the previous session immediately
+- **perf**: persist the `cmk-dev-install-site` install state so the OMD section's "Create Site" button is correct on first paint without re-shelling out
+- New `src/core/persistedCache.ts` helper centralises the load/save of these workspace-state snapshots
+
+### Skip work that hasn't changed
+
+- **perf**: short-circuit the Bazel disk-cache probe when the cache directory's mtime is unchanged since the last run — `du -sb` is replaced by a single `fs.statSync` on hot paths
+- **perf**: `loadConfig()` reads the JSON file only when its mtime changes; subsequent calls (every `refreshStateCache`, every settings dialog) return the cached parsed object
+
+### Activate critical path
+
+- **perf**: defer `registerBazelTestController` + `registerBazelTestsConfigView` until the first Python / TypeScript editor activates, or 10 s elapse — whichever fires first
+- **perf**: defer `checkVersionMismatch` + `showWhatsNewIfNeeded` by 2 s so neither can pop a modal during the activate window
+
+### Sidebar churn
+
+- **perf**: the 5 s cockpit auto-refresh tick is skipped while the cockpit webview is hidden — saves ~720 HTML rebuilds per hour of editor work
+
+### Cockpit freshness
+
+- **fix**: `refreshOverview()` now re-reads the gitState and bazelCache stale-while-revalidate slices before rendering — re-enabling the pre-commit hook (or any other state covered by a SWR getter) clears the cockpit chip on the next 5 s tick instead of being stuck on the frozen snapshot from the last full state refresh
+- **fix**: new `.git/hooks/pre-commit*` watcher invalidates gitState's TTL and triggers `refreshAll()` on toggle, so the cockpit chip flips within ~100 ms instead of waiting for the next 5 s tick
+- **fix**: `cmk.fixQaTestDataSubmodule` no longer shells out to `git submodule update --init --force --checkout`, which on git 2.38+ falls back to the relative `../qa-test-data` URL in `.gitmodules` and fails with `fatal: transport 'file' not allowed`. Reads the tracked gitlink SHA via `git ls-tree HEAD tests/qa-test-data` and checks the submodule worktree out at that SHA directly, fetching only when the SHA is not already local
+
+### Startup regression banner
+
+- **fix**: the cockpit's "Startup performance" regression chip now only fires when the benchmark setting is on; stale history from a previous experiment can no longer surface a phantom warning

.ide/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "cmk-vscode",
   "displayName": "CMK Dev Tools for VS Code",
   "description": "Build commands and helpers for Checkmk development",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "publisher": "checkmk",
   "engines": {
     "vscode": "^1.85.0"

.ide/vscode/src/build/bazelCache.ts

@@ -9,6 +9,7 @@ import * as path from 'path'
 import * as vscode from 'vscode'
 
 import { error, log, notifyError, notifyInfo } from '../core/log'
+import { loadPersisted, savePersisted } from '../core/persistedCache'
 import { safeExecAsync } from '../core/shell'
 import { runCommand, waitForTask } from '../core/tasks'
 
@@ -21,6 +22,13 @@ export interface BazelCacheSnapshot {
 
 const DEFAULT_THRESHOLD_GIB = 50
 const TTL_MS = 5 * 60 * 1000
+const PERSIST_KEY = 'cmk.bazelCache.snapshot'
+
+interface PersistedSnapshot {
+  snapshot: BazelCacheSnapshot
+  cacheDirMtimeMs: number
+  timestamp: number
+}
 
 const EMPTY: BazelCacheSnapshot = {
   sizeBytes: null,
@@ -31,8 +39,28 @@ const EMPTY: BazelCacheSnapshot = {
 
 let _snapshot: BazelCacheSnapshot = EMPTY
 let _lastUpdated = 0
+let _lastCacheDirMtimeMs = 0
 let _inflight: Promise<void> | null = null
 let _onRefresh: (() => void) | null = null
+let _hydrated = false
+
+function hydrateFromPersisted(): void {
+  if (_hydrated) return
+  _hydrated = true
+  const persisted = loadPersisted<PersistedSnapshot>(PERSIST_KEY)
+  if (!persisted) return
+  _snapshot = persisted.snapshot
+  _lastUpdated = persisted.timestamp
+  _lastCacheDirMtimeMs = persisted.cacheDirMtimeMs
+}
+
+function cacheDirMtimeMs(cachePath: string): number {
+  try {
+    return fs.statSync(cachePath).mtimeMs
+  } catch {
+    return 0
+  }
+}
 
 export function setBazelCacheRefreshCallback(cb: (() => void) | null): void {
   _onRefresh = cb
@@ -89,6 +117,8 @@ function shellQuote(s: string): string {
  * the probe completes and triggers `_onRefresh`.
  */
 export function getBazelCacheSnapshot(): BazelCacheSnapshot {
+  hydrateFromPersisted()
+
   const wsPath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
   if (!wsPath) return EMPTY
 
@@ -106,6 +136,28 @@ export function getBazelCacheSnapshot(): BazelCacheSnapshot {
         if (!cachePath || !fs.existsSync(cachePath)) {
           _snapshot = { ...EMPTY, thresholdGiB, cachePath }
           _lastUpdated = Date.now()
+          _lastCacheDirMtimeMs = 0
+          persistSnapshot()
+          _onRefresh?.()
+          return
+        }
+        // Cheap mtime stat: if the cache dir hasn't been touched since the
+        // last probe, the bytes count cannot have changed and we can skip
+        // the expensive `du -sb` walk entirely.
+        const dirMtime = cacheDirMtimeMs(cachePath)
+        if (
+          dirMtime > 0 &&
+          dirMtime === _lastCacheDirMtimeMs &&
+          _snapshot.sizeBytes !== null &&
+          _snapshot.cachePath === cachePath
+        ) {
+          _snapshot = {
+            ..._snapshot,
+            thresholdGiB,
+            overThreshold: _snapshot.sizeBytes > thresholdGiB * 1024 ** 3
+          }
+          _lastUpdated = Date.now()
+          persistSnapshot()
           _onRefresh?.()
           return
         }
@@ -117,6 +169,8 @@ export function getBazelCacheSnapshot(): BazelCacheSnapshot {
           overThreshold: sizeBytes !== null && sizeBytes > thresholdGiB * 1024 ** 3
         }
         _lastUpdated = Date.now()
+        _lastCacheDirMtimeMs = dirMtime
+        persistSnapshot()
         _onRefresh?.()
       } catch (err) {
         error(`bazelCache probe failed: ${(err as Error).message}`)
@@ -129,6 +183,14 @@ export function getBazelCacheSnapshot(): BazelCacheSnapshot {
   return view
 }
 
+function persistSnapshot(): void {
+  savePersisted<PersistedSnapshot>(PERSIST_KEY, {
+    snapshot: _snapshot,
+    cacheDirMtimeMs: _lastCacheDirMtimeMs,
+    timestamp: _lastUpdated
+  })
+}
+
 export function registerBazelCache(): vscode.Disposable[] {
   return [
     vscode.commands.registerCommand('cmk.bazel.cleanDiskCache', async () => {

.ide/vscode/src/core/config.ts

@@ -64,17 +64,36 @@ export function shellEscape(s: string): string {
   return "'" + String(s).replace(/'/g, "'\\''") + "'"
 }
 
+interface ConfigCacheEntry {
+  path: string
+  mtimeMs: number
+  parsed: unknown
+}
+const _configCache = new Map<string, ConfigCacheEntry>()
+
+function readConfigCached(filePath: string): unknown {
+  let mtimeMs: number
+  try {
+    mtimeMs = fs.statSync(filePath).mtimeMs
+  } catch {
+    throw new Error(`config not found: ${filePath}`)
+  }
+  const cached = _configCache.get(filePath)
+  if (cached && cached.mtimeMs === mtimeMs) return cached.parsed
+  const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+  _configCache.set(filePath, { path: filePath, mtimeMs, parsed })
+  return parsed
+}
+
 export function loadConfig<T = unknown>(name: string): T {
   // Prefer workspace config (branch-aware, always fresh)
   const wsPath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
   if (wsPath) {
     const wsConfig = path.join(wsPath, '.ide', 'vscode', 'config', `${name}.json`)
-    if (fs.existsSync(wsConfig)) {
-      return JSON.parse(fs.readFileSync(wsConfig, 'utf8'))
-    }
+    if (fs.existsSync(wsConfig)) return readConfigCached(wsConfig) as T
   }
   // Fallback to bundled config in installed VSIX
-  return JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'config', `${name}.json`), 'utf8'))
+  return readConfigCached(path.join(__dirname, '..', 'config', `${name}.json`)) as T
 }
 
 /**

.ide/vscode/src/core/persistedCache.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (C) 2026 Checkmk GmbH - License: GNU General Public License v2
+ * This file is part of Checkmk (https://checkmk.com). It is subject to the terms and
+ * conditions defined in the file COPYING, which is part of this source code package.
+ */
+import type * as vscode from 'vscode'
+
+/**
+ * Thin typed wrapper around `context.workspaceState` used to keep
+ * stale-while-revalidate snapshots warm across window reloads, so the first
+ * paint after a window reload renders from yesterday's value instead of
+ * waiting on a subprocess.
+ */
+let _context: vscode.ExtensionContext | null = null
+
+export function bindPersistedCacheContext(context: vscode.ExtensionContext): void {
+  _context = context
+}
+
+export function loadPersisted<T>(key: string): T | null {
+  if (!_context) return null
+  return _context.workspaceState.get<T>(key, null as unknown as T) ?? null
+}
+
+export function savePersisted<T>(key: string, value: T): void {
+  if (!_context) return
+  void _context.workspaceState.update(key, value)
+}

.ide/vscode/src/extension.ts

@@ -18,6 +18,7 @@ import {
   writeSetting
 } from './core/config'
 import { error, log, notifyInfo, registerErrorHandlers } from './core/log'
+import { bindPersistedCacheContext } from './core/persistedCache'
 import { checkVersionMismatch } from './core/versionCheck'
 import { checkForUpdates, isInstalledAsync as isDevSiteInstalledAsync } from './omd/devSiteTools'
 import { registerLogs } from './omd/logs'
@@ -91,6 +92,7 @@ function toggleSettings(
 export function activate(context: vscode.ExtensionContext): void {
   log('Extension activating')
   registerErrorHandlers()
+  bindPersistedCacheContext(context)
   const commands = loadConfig<Record<string, CommandEntry>>('commands')
   const extensionSets = loadConfig<ExtensionSets>('extensions')
   const settingsSets = loadConfig<Record<string, SettingsEntry>>('settings')
@@ -156,8 +158,38 @@ export function activate(context: vscode.ExtensionContext): void {
     })
   )
 
-  // Bazel test discovery + runner — always on; serves both py_test and vitest_test targets.
-  context.subscriptions.push(...registerBazelTestController(), ...registerBazelTestsConfigView())
+  // Bazel test discovery + runner — deferred until the first Python /
+  // TypeScript editor activates, or 10 s elapse, whichever fires first. The
+  // test controller's own discovery is already lazy, but the registration
+  // itself does enough work to be worth keeping off the activate() path.
+  let bazelTestsRegistered = false
+  const registerBazelTestsOnce = (): void => {
+    if (bazelTestsRegistered) return
+    bazelTestsRegistered = true
+    disposeBazelTestsTriggers()
+    context.subscriptions.push(...registerBazelTestController(), ...registerBazelTestsConfigView())
+  }
+  const bazelTestsTriggers: vscode.Disposable[] = []
+  const disposeBazelTestsTriggers = (): void => {
+    for (const d of bazelTestsTriggers) {
+      try {
+        d.dispose()
+      } catch {
+        // ignore
+      }
+    }
+  }
+  bazelTestsTriggers.push(
+    vscode.window.onDidChangeActiveTextEditor((ed) => {
+      if (!ed) return
+      const lang = ed.document.languageId
+      if (lang === 'python' || lang === 'typescript' || lang === 'typescriptreact')
+        registerBazelTestsOnce()
+    })
+  )
+  const bazelTestsFallback = setTimeout(registerBazelTestsOnce, 10_000)
+  bazelTestsTriggers.push({ dispose: () => clearTimeout(bazelTestsFallback) })
+  context.subscriptions.push(...bazelTestsTriggers)
 
   // --- Family-gated features ---
 
@@ -231,12 +263,19 @@ export function activate(context: vscode.ExtensionContext): void {
   profileManager.setOnRefresh(refreshAll)
   profileManager.init(context)
   registerProfileDetector(context)
-  checkVersionMismatch(context)
 
   context.subscriptions.push(...registerWhatsNew(context))
-  showWhatsNewIfNeeded(context).catch((err) =>
-    error(`What's new failed: ${(err as Error).message}`)
-  )
+
+  // Defer the version-mismatch dialog and the What's New popup by 2 s —
+  // neither needs to land before the user can interact, and both can pop
+  // blocking modals that drag the perceived activate path.
+  const deferred = setTimeout(() => {
+    checkVersionMismatch(context)
+    showWhatsNewIfNeeded(context).catch((err) =>
+      error(`What's new failed: ${(err as Error).message}`)
+    )
+  }, 2000)
+  context.subscriptions.push({ dispose: () => clearTimeout(deferred) })
 
   context.subscriptions.push(...registerStartupBenchmarks(context))
 

.ide/vscode/src/omd/devSiteTools.ts

@@ -6,6 +6,7 @@
 import * as vscode from 'vscode'
 
 import { error, log } from '../core/log'
+import { loadPersisted, savePersisted } from '../core/persistedCache'
 import { safeExecAsync } from '../core/shell'
 import { runCommand, waitForTask } from '../core/tasks'
 import { versionNewer } from '../core/version'
@@ -70,19 +71,29 @@ export interface DevSiteToolsState {
 }
 
 const EMPTY_STATE: DevSiteToolsState = { installed: false, installedVersion: '' }
+const PERSIST_KEY = 'cmk.devSite.snapshot'
 
 let _stateCache: { state: DevSiteToolsState; timestamp: number } | null = null
 let _stateFetchPromise: Promise<void> | null = null
 let _onDevSiteRefresh: (() => void) | null = null
+let _devSiteHydrated = false
 
 export function setDevSiteRefreshCallback(cb: () => void): void {
   _onDevSiteRefresh = cb
 }
 
+function hydrateDevSiteFromPersisted(): void {
+  if (_devSiteHydrated) return
+  _devSiteHydrated = true
+  const persisted = loadPersisted<{ state: DevSiteToolsState; timestamp: number }>(PERSIST_KEY)
+  if (persisted) _stateCache = persisted
+}
+
 /** Sync getter used during sidebar render. Returns the last known value (or
  *  empty placeholders) immediately and triggers a background refresh that
  *  re-renders the sidebar when the new value lands. */
 export function getDevSiteToolsState(): DevSiteToolsState {
+  hydrateDevSiteFromPersisted()
   if (_stateCache && Date.now() - _stateCache.timestamp < DEV_SITE_CACHE_TTL) {
     return _stateCache.state
   }
@@ -100,6 +111,7 @@ async function scheduleDevSiteRefresh(): Promise<void> {
         installedVersion
       }
       _stateCache = { state, timestamp: Date.now() }
+      savePersisted(PERSIST_KEY, _stateCache)
       _onDevSiteRefresh?.()
     } catch (err) {
       error(`devSiteTools refresh failed: ${(err as Error).message}`)

.ide/vscode/src/scm/gitState.ts

@@ -33,6 +33,16 @@ export function setGitStateRefreshCallback(cb: (() => void) | null): void {
   _onRefresh = cb
 }
 
+/**
+ * Force the next `getGitState()` to re-probe, regardless of TTL. Used by
+ * external watchers (e.g. the `.git/hooks/pre-commit*` watcher in sidebar.ts)
+ * that already know the underlying state has changed and want the cockpit
+ * to converge on the next refresh without waiting for the 5 s TTL.
+ */
+export function invalidateGitState(): void {
+  _state = { ..._state, lastUpdated: 0 }
+}
+
 /**
  * Hard-reset `tests/qa-test-data` to the gitlink tracked by the parent repo,
  * discarding any local changes inside the submodule. Asks for confirmation
@@ -89,13 +99,20 @@ export function registerGitFixers(): vscode.Disposable[] {
       )
       if (choice !== 'Reset') return
       log('git: hard-resetting tests/qa-test-data to tracked gitlink')
-      // Reset the submodule's working tree to HEAD, drop untracked files, then
-      // pull the gitlink commit checked out forcefully. Done as one task in a
-      // visible terminal so the user can see what happened.
+      // Read the tracked gitlink SHA from the parent's index and checkout the
+      // submodule worktree at exactly that SHA. Avoids `git submodule update
+      // --init --force` because that falls back to the relative `../qa-test-
+      // data` URL declared in .gitmodules, which git 2.38+ refuses over the
+      // `file://` transport — so the action would fail with "fatal: transport
+      // 'file' not allowed" even when the submodule is already correct.
+      // If the tracked SHA happens to be missing locally, we fetch first.
       const inner = [
+        "TRACKED_SHA=$(git ls-tree HEAD tests/qa-test-data | awk '{print $3}')",
+        'test -n "$TRACKED_SHA" || { echo "qa-test-data not tracked in HEAD"; exit 1; }',
         'git -C tests/qa-test-data reset --hard',
         'git -C tests/qa-test-data clean -fdx',
-        'git submodule update --init --force --checkout tests/qa-test-data'
+        'git -C tests/qa-test-data cat-file -e "$TRACKED_SHA" 2>/dev/null || git -C tests/qa-test-data fetch origin',
+        'git -C tests/qa-test-data checkout --force --detach "$TRACKED_SHA"'
       ].join(' && ')
       const exec = runCommand('Reset tests/qa-test-data', inner)
       if (!exec) {