opencode-agent-skill 15.1.1 → 15.1.2

package/README.md

@@ -4,9 +4,9 @@
 
 **Package:** <code>opencode-agent-skill</code>  
 **Host chính:** Pi Agent  
-**Phiên bản package hiện tại:** <code>15.1.1</code>  
+**Phiên bản package hiện tại:** <code>15.1.2</code>  
 **Nhánh phát triển hiện tại:** V15.19 Finalization Hardening  
-**Stable npm hiện tại:** <code>15.1.0</code>  
+**Stable npm hiện tại:** <code>15.1.1</code>  
 **Runtime:** Node.js 22.19+  
 **License:** MIT
 
@@ -1431,15 +1431,15 @@ npm pack
 Package version hiện tại trên nhánh <code>main</code> là:
 
 ~~~text
-15.1.1
+15.1.2
 ~~~
 
-Stable npm public hiện vẫn là <code>15.1.0</code>. V15.3 DEEP Speed giảm exploration trùng lặp ở long-horizon bằng diagnosis deduplication và bounded specialist exploration, nhưng giữ nguyên plan/verifier/integration gates. V15.4 ACP-safe child runtime ngăn UES spawn lại ACP/Zed entrypoint; child specialist luôn được chạy bằng Pi CLI thật. V15.5 Per-Leaf Turbo cho phép leaf task nhỏ trong DEEP plan tự xuống FAST, giữ failure delta task-local, và tái sử dụng context theo root namespace + workspace fingerprint để giảm retry/rebuild latency. V15.6 Fast Planning đặt soft-steer/hard-idle budget riêng cho architect/plan-checker, recovery từ warm context thay vì scan lại, và lease/cleanup sandbox orphan an toàn sau crash/Stop. V15.7 Lightweight Sandbox Cleanup thu hồi worktree theo trace ngay khi /ues-run kết thúc, dọn metadata mồ côi, giảm legacy grace xuống 30 phút và cung cấp /ues-clean để dọn stale artifacts an toàn mà không đụng sandbox đang active. V15.8 Plan Gate Recovery bổ sung soft-steer + bounded recovery cho plan-checker và quét cả detached physical sandbox folders mà Git worktree registry đã quên. V15.9 Runtime Artifact Isolation loại .ues-traces/.ues-cache/.ues-services/.ues-work và runtime state khác khỏi task delta, write-scope conflict và sandbox integration, nhưng vẫn giữ safety gate cho source/config thật như apps/mobile/package.json. V15.10 Adaptive Stability Runtime thay hard-timeout tuyệt đối bằng activity-aware bounded deadlines, giữ absolute cap chống treo, salvage plan JSON đã validate từ partial output, phát graph trước prose, và role-bound context cho read-only planner trong task high-risk mà không giảm evidence budget của executor/verifier. V15.1 bắt đầu bằng deterministic <code>/ues-run</code> admission và Managed Background Services để model yếu không thể bỏ qua controller và không bị treo bởi dev server foreground.
+Stable npm public hiện là <code>15.1.1</code>. V15.3 DEEP Speed giảm exploration trùng lặp ở long-horizon bằng diagnosis deduplication và bounded specialist exploration, nhưng giữ nguyên plan/verifier/integration gates. V15.4 ACP-safe child runtime ngăn UES spawn lại ACP/Zed entrypoint; child specialist luôn được chạy bằng Pi CLI thật. V15.5 Per-Leaf Turbo cho phép leaf task nhỏ trong DEEP plan tự xuống FAST, giữ failure delta task-local, và tái sử dụng context theo root namespace + workspace fingerprint để giảm retry/rebuild latency. V15.6 Fast Planning đặt soft-steer/hard-idle budget riêng cho architect/plan-checker, recovery từ warm context thay vì scan lại, và lease/cleanup sandbox orphan an toàn sau crash/Stop. V15.7 Lightweight Sandbox Cleanup thu hồi worktree theo trace ngay khi /ues-run kết thúc, dọn metadata mồ côi, giảm legacy grace xuống 30 phút và cung cấp /ues-clean để dọn stale artifacts an toàn mà không đụng sandbox đang active. V15.8 Plan Gate Recovery bổ sung soft-steer + bounded recovery cho plan-checker và quét cả detached physical sandbox folders mà Git worktree registry đã quên. V15.9 Runtime Artifact Isolation loại .ues-traces/.ues-cache/.ues-services/.ues-work và runtime state khác khỏi task delta, write-scope conflict và sandbox integration, nhưng vẫn giữ safety gate cho source/config thật như apps/mobile/package.json. V15.10 Adaptive Stability Runtime thay hard-timeout tuyệt đối bằng activity-aware bounded deadlines, giữ absolute cap chống treo, salvage plan JSON đã validate từ partial output, phát graph trước prose, và role-bound context cho read-only planner trong task high-risk mà không giảm evidence budget của executor/verifier. V15.1 bắt đầu bằng deterministic <code>/ues-run</code> admission và Managed Background Services để model yếu không thể bỏ qua controller và không bị treo bởi dev server foreground.
 
 Test file packed với Pi:
 
 ~~~cmd
-pi install .\opencode-agent-skill-15.1.1.tgz
+pi install .\opencode-agent-skill-15.1.2.tgz
 pi list
 ~~~
 

package/lib/affected-tests.mjs

@@ -3,10 +3,14 @@ import { readFile, readdir, stat } from "node:fs/promises"
 import path from "node:path"
 import { spawnSync } from "node:child_process"
 import { runtimeWorkspaceFingerprint } from "./workspace-fingerprint.mjs"
+import { UES_RUNTIME_DIRS, isUesRuntimeArtifactPath, sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
 const TEST_RE = /(?:^|[/.\\])(?:__tests__|tests?|spec)(?:[/.\\]|$)|\.(?:test|spec|e2e-spec)\.[cm]?[jt]sx?$/i
 const SOURCE_EXT = new Set([".js",".jsx",".mjs",".cjs",".ts",".tsx",".py",".java",".kt",".kts",".cs",".go",".rs",".dart",".swift"])
-const SKIP = new Set([".git","node_modules",".next","dist","build","coverage",".venv","venv","target","Pods","DerivedData",".gradle",".ues-cache",".ues-work",".ues-sandboxes",".ues-traces",".ues-learning",".ues-dashboard",".ues-memory",".ues-evals",".ues-services"])
+const SKIP = new Set([
+  ".git","node_modules",".next","dist","build","coverage",".venv","venv","target","Pods","DerivedData",".gradle",
+  ...UES_RUNTIME_DIRS,
+])
 const AFFECTED_TEST_CACHE = new Map()
 const AFFECTED_TEST_INFLIGHT = new Map()
 const TEST_CONTENT_CACHE = new Map()
@@ -65,7 +69,7 @@ async function walk(root, options = {}) {
 }
 
 async function projectFiles(root, options = {}) {
-  const indexed = git(root, ["ls-files", "-co", "--exclude-standard", "-z"])
+  const indexed = git(root, ["ls-files", "-co", "--exclude-standard", "-z", "--", ...sourceGitPathspecs()])
   if (indexed.status === 0) {
     const files = String(indexed.stdout || "")
       .split("\0")
@@ -110,7 +114,7 @@ export function gitChangedFiles(root = process.cwd()) {
     if (result.status !== 0) continue
     for (const row of String(result.stdout || "").split(/\r?\n/)) {
       const file = normalize(row.trim())
-      if (file) names.add(file)
+      if (file && !isUesRuntimeArtifactPath(file)) names.add(file)
     }
   }
   return [...names]

package/lib/code-intelligence/index.mjs

@@ -1,9 +1,11 @@
 import { lstat, readFile, realpath, rename, rm, writeFile } from "node:fs/promises"
-import { spawnSync } from "node:child_process"
 import path from "node:path"
 import { commandExists } from "../executable-probe.mjs"
-import { querySemanticIndex } from "../semantic-index.mjs"
+import { runSupervisedProcess } from "../process-supervisor.mjs"
+import { resolveWindowsCommand } from "../windows-shim.mjs"
+import { buildSemanticIndexCached, querySemanticIndex } from "../semantic-index.mjs"
 import { anchoredLines, applyAnchoredEdits } from "./edit-anchor.mjs"
+import { runtimeWorkspaceSnapshot } from "../workspace-fingerprint.mjs"
 import { diagnoseCode, lspOperation, lspPoolStatus, lspProviderStatus, shutdownLspPool, LSP_OPERATIONS } from "./lsp-provider.mjs"
 
 const AST_COMMANDS = ["ast-grep", "sg"]
@@ -54,29 +56,65 @@ export async function applyAnchoredFileEdits(root, relative, edits, options = {}
   return { ...result, file: relativeFile, dryRun: false }
 }
 
-function runAstGrep(root, pattern, language, limit) {
+async function runAstGrep(root, pattern, language, limit) {
   const command = AST_COMMANDS.find(commandExists) || null
   if (!command || !String(pattern || "").trim()) return { provider: null, results: [], error: null }
   const args = ["run", "--pattern", String(pattern), "--json=stream"]
   if (language) args.push("--lang", String(language))
   args.push(".")
-  const result = spawnSync(command, args, { cwd: path.resolve(root), encoding: "utf8", timeout: 20_000, maxBuffer: 4 * 1024 * 1024, windowsHide: true })
-  if (result.status !== 0) return { provider: command, results: [], error: String(result.stderr || ("ast-grep exit " + result.status)).trim().slice(0, 1000) }
+  const resolved = process.platform === "win32" ? resolveWindowsCommand(command) : null
+  const executable = resolved?.executable || command
+  const executionArgs = [...(resolved?.argsPrefix || []), ...args]
+  const result = await runSupervisedProcess(executable, executionArgs, {
+    cwd: path.resolve(root),
+    hardTimeoutMs: 20_000,
+    idleTimeoutMs: 10_000,
+    stdoutLimit: 4 * 1024 * 1024,
+    stderrLimit: 64 * 1024,
+    drainTimeoutMs: 500,
+  })
+  if (result.exitCode !== 0) {
+    const reason = result.stopReason ? `ast-grep ${result.stopReason}` : `ast-grep exit ${result.exitCode}`
+    return {
+      provider: command,
+      results: [],
+      error: String(result.stderr || reason).trim().slice(0, 1000),
+    }
+  }
   const rows = String(result.stdout || "").split(/\r?\n/).filter(Boolean).slice(0, limit).map((line) => {
     try { return JSON.parse(line) } catch { return { raw: line } }
   })
-  return { provider: command, results: rows, error: null }
+  return { provider: command, results: rows, error: null, truncated: result.stdoutTruncated === true }
 }
 
 export async function searchCodeIntelligence(root, query, options = {}) {
+  root = path.resolve(root)
   const maxResults = Math.max(1, Math.min(50, Number(options.maxResults || 12)))
-  const semantic = await querySemanticIndex(root, query, { maxFiles: options.maxFiles || 6000, limit: maxResults })
-  const structural = options.structuralPattern ? runAstGrep(root, options.structuralPattern, options.language, maxResults) : { provider: null, results: [], error: null }
+  const maxFiles = options.maxFiles || 6000
+  const workspace = runtimeWorkspaceSnapshot(root, {
+    workspaceState: options.workspaceState,
+  })
+  const semanticSnapshot = await buildSemanticIndexCached(root, {
+    maxFiles,
+    workspaceFingerprint: workspace.cacheable ? workspace.fingerprint : "",
+  })
+  const semantic = await querySemanticIndex(root, query, {
+    maxFiles,
+    limit: maxResults,
+    builtIndex: semanticSnapshot,
+  })
+  const structural = options.structuralPattern ? await runAstGrep(root, options.structuralPattern, options.language, maxResults) : { provider: null, results: [], error: null }
   return {
     schemaVersion: 1,
     query: String(query || ""),
+    workspaceFingerprint: workspace.cacheable ? workspace.fingerprint : null,
     providers: probeCodeIntelligence(options.file || ""),
-    semantic: { ...semantic, results: (semantic.results || []).slice(0, maxResults) },
+    semantic: {
+      ...semantic,
+      runtimeCacheHit: semanticSnapshot.runtimeCacheHit === true,
+      runtimeCacheCoalesced: semanticSnapshot.runtimeCacheCoalesced === true,
+      results: (semantic.results || []).slice(0, maxResults),
+    },
     structural,
   }
 }

package/lib/code-intelligence/lsp-pool.mjs

@@ -15,14 +15,19 @@ const DEFAULT_MAX_RESTARTS = 1
 const CONFIG_MAX_BYTES = 512 * 1024
 
 const POOL = new Map()
+const STARTUPS = new Map()
+let poolMutationTail = Promise.resolve()
 const METRICS = {
   coldStarts: 0,
   warmHits: 0,
+  startupJoins: 0,
   restarts: 0,
   evictions: 0,
   fallbacks: 0,
   operations: 0,
+  acquisitionLatencyMs: 0,
   operationLatencyMs: 0,
+  totalLatencyMs: 0,
 }
 let sweepTimer = null
 
@@ -32,6 +37,19 @@ function bounded(value, fallback, min, max) {
   return Math.max(min, Math.min(max, Math.trunc(number)))
 }
 
+async function withPoolMutation(fn) {
+  const previous = poolMutationTail
+  let release
+  const gate = new Promise((resolve) => { release = resolve })
+  poolMutationTail = previous.catch(() => {}).then(() => gate)
+  await previous.catch(() => {})
+  try {
+    return await fn()
+  } finally {
+    release()
+  }
+}
+
 function configured(options = {}) {
   return {
     enabled: options.persistent !== false && String(process.env.UES_LSP_PERSISTENT || "1") !== "0",
@@ -86,41 +104,48 @@ function inside(base, target) {
 
 async function configurationFingerprint(base, file, provider) {
   const names = providerConfigNames(provider?.id)
-  const found = []
+  const candidates = []
   let dir = path.dirname(file)
 
   while (inside(base, dir)) {
-    for (const name of names) {
-      const candidate = path.join(dir, name)
-      const info = await stat(candidate).catch(() => null)
-      if (!info?.isFile()) continue
-      found.push({ file: candidate, size: info.size, mtimeMs: Math.trunc(info.mtimeMs) })
-    }
+    for (const name of names) candidates.push(path.join(dir, name))
     if (dir === base) break
     const parent = path.dirname(dir)
     if (parent === dir || !inside(base, parent)) break
     dir = parent
   }
 
+  // Config discovery is on every managed-LSP acquisition. Probe independent
+  // paths concurrently, then restore deterministic path order before hashing.
+  // This preserves exact fingerprint semantics while avoiding serial Windows
+  // filesystem round trips in deep monorepos.
+  const found = (await Promise.all(candidates.map(async (candidate) => {
+    const info = await stat(candidate).catch(() => null)
+    if (!info?.isFile()) return null
+    return { file: candidate, size: info.size, mtimeMs: Math.trunc(info.mtimeMs) }
+  }))).filter(Boolean)
   found.sort((a, b) => a.file.localeCompare(b.file))
+
+  const contents = await Promise.all(found.map(async (item) => {
+    if (item.size > CONFIG_MAX_BYTES) return null
+    return readFile(item.file).catch(() => null)
+  }))
+
   const hash = createHash("sha256")
   hash.update(String(provider?.id || "unknown"))
   hash.update("\0")
   hash.update(String(provider?.command || ""))
   hash.update("\0")
   hash.update(JSON.stringify(provider?.initializationOptions || null))
-  for (const item of found) {
+  for (let index = 0; index < found.length; index += 1) {
+    const item = found[index]
     hash.update(path.relative(base, item.file).replaceAll("\\", "/"))
     hash.update("\0")
     hash.update(String(item.size))
     hash.update("\0")
-    if (item.size <= CONFIG_MAX_BYTES) {
-      const content = await readFile(item.file).catch(() => null)
-      if (content) hash.update(content)
-      else hash.update(String(item.mtimeMs))
-    } else {
-      hash.update(String(item.mtimeMs))
-    }
+    const content = contents[index]
+    if (content) hash.update(content)
+    else hash.update(String(item.mtimeMs))
     hash.update("\0")
   }
   return hash.digest("hex").slice(0, 24)
@@ -443,6 +468,22 @@ class ManagedLspSession {
 
   async stop(reason = "shutdown") {
     if (this.closed) return
+
+    const child = this.child
+    // LSP protocol requires shutdown request before exit notification. Attempt
+    // this only when no operation is in flight; teardown must never wait behind
+    // a busy request forever.
+    if (
+      child &&
+      child.exitCode == null &&
+      this.busy === 0 &&
+      this.state === "READY"
+    ) {
+      try {
+        await this.request("shutdown", null, Math.min(750, this.options.requestTimeoutMs))
+      } catch {}
+    }
+
     this.state = "EVICTING"
     this.closed = true
     const error = errorWithCode("LSP session closed: " + reason, "LSP_SESSION_CLOSED")
@@ -458,12 +499,38 @@ class ManagedLspSession {
       }
     }
     this.notificationWaiters.clear()
+
     try {
-      if (this.child?.stdin?.writable) {
-        this.child.stdin.write(encodeMessage({ jsonrpc: "2.0", method: "exit", params: null }))
+      if (child?.stdin?.writable) {
+        child.stdin.write(encodeMessage({ jsonrpc: "2.0", method: "exit", params: null }))
       }
     } catch {}
-    if (this.child) terminateProcessTree(this.child, { graceMs: 500 })
+
+    let closedNaturally = !child || child.exitCode != null || child.signalCode != null
+    if (child && !closedNaturally) {
+      closedNaturally = await new Promise((resolve) => {
+        let settled = false
+        const finish = () => {
+          if (settled) return
+          settled = true
+          clearTimeout(timer)
+          child.removeListener("close", finish)
+          resolve(true)
+        }
+        child.once("close", finish)
+        const timer = setTimeout(() => {
+          if (settled) return
+          settled = true
+          child.removeListener("close", finish)
+          resolve(false)
+        }, 350)
+        timer.unref?.()
+      })
+    }
+
+    if (child && !closedNaturally) {
+      terminateProcessTree(child, { graceMs: 500 })
+    }
     this.state = "CLOSED"
   }
 }
@@ -476,6 +543,22 @@ function sessionsForWorkspace(base) {
   return [...POOL.values()].filter((session) => session.base === base && session.alive())
 }
 
+function occupiesCapacity(session) {
+  return Boolean(
+    session &&
+    !session.closed &&
+    !["CRASHED", "CLOSED", "EVICTING"].includes(session.state),
+  )
+}
+
+function capacitySessions() {
+  return [...POOL.values()].filter(occupiesCapacity)
+}
+
+function capacitySessionsForWorkspace(base) {
+  return capacitySessions().filter((session) => session.base === base)
+}
+
 async function removeSession(key, reason) {
   const session = POOL.get(key)
   if (!session) return
@@ -486,7 +569,11 @@ async function removeSession(key, reason) {
 async function evictExpired(options) {
   const now = Date.now()
   const targets = [...POOL.entries()]
-    .filter(([, session]) => session.busy === 0 && now - session.lastUsedAt >= options.idleTtlMs)
+    .filter(([, session]) =>
+      session.state !== "STARTING" &&
+      session.busy === 0 &&
+      now - session.lastUsedAt >= options.idleTtlMs
+    )
   for (const [key] of targets) {
     METRICS.evictions += 1
     await removeSession(key, "idle-ttl")
@@ -495,7 +582,7 @@ async function evictExpired(options) {
 
 async function evictLru(candidates, reason) {
   const idle = candidates
-    .filter((session) => session.busy === 0)
+    .filter((session) => session.state !== "STARTING" && session.busy === 0)
     .sort((a, b) => a.lastUsedAt - b.lastUsedAt)
   const victim = idle[0]
   if (!victim) return false
@@ -509,13 +596,13 @@ async function evictLru(candidates, reason) {
 async function ensureCapacity(base, options) {
   await evictExpired(options)
 
-  while (sessionsForWorkspace(base).length >= options.maxPerWorkspace) {
-    const evicted = await evictLru(sessionsForWorkspace(base), "workspace-lru")
+  while (capacitySessionsForWorkspace(base).length >= options.maxPerWorkspace) {
+    const evicted = await evictLru(capacitySessionsForWorkspace(base), "workspace-lru")
     if (!evicted) return false
   }
 
-  while ([...POOL.values()].filter((session) => session.alive()).length >= options.maxServers) {
-    const evicted = await evictLru([...POOL.values()], "global-lru")
+  while (capacitySessions().length >= options.maxServers) {
+    const evicted = await evictLru(capacitySessions(), "global-lru")
     if (!evicted) return false
   }
   return true
@@ -525,7 +612,7 @@ function ensureSweeper() {
   if (sweepTimer) return
   sweepTimer = setInterval(() => {
     const options = configured()
-    void evictExpired(options).catch(() => {})
+    void withPoolMutation(() => evictExpired(options)).catch(() => {})
   }, 30_000)
   sweepTimer.unref?.()
 }
@@ -534,38 +621,70 @@ async function acquire(target, provider, options) {
   ensureSweeper()
   const fingerprint = await configurationFingerprint(target.base, target.file, provider)
   const key = sessionKey(target.base, provider, fingerprint)
-  const existing = POOL.get(key)
-  if (existing?.alive()) {
-    METRICS.warmHits += 1
-    existing.lastUsedAt = Date.now()
-    return { key, session: existing, poolHit: true }
-  }
-  if (existing) await removeSession(key, "stale-session")
 
-  for (const [otherKey, session] of POOL) {
-    if (
-      session.base === target.base &&
-      session.provider.id === provider.id &&
-      session.configFingerprint !== fingerprint &&
-      session.busy === 0
-    ) {
-      METRICS.evictions += 1
-      await removeSession(otherKey, "config-changed")
+  const decision = await withPoolMutation(async () => {
+    const pending = STARTUPS.get(key)
+    if (pending) {
+      METRICS.startupJoins += 1
+      return { kind: "startup-join", promise: pending }
     }
-  }
 
-  if (!await ensureCapacity(target.base, options)) return null
-  const session = new ManagedLspSession(target.base, provider, fingerprint, options)
-  POOL.set(key, session)
-  try {
-    await session.start()
-    METRICS.coldStarts += 1
-    return { key, session, poolHit: false }
-  } catch (error) {
-    POOL.delete(key)
-    await session.stop("startup-failed").catch(() => {})
-    throw error
+    const existing = POOL.get(key)
+    if (existing?.alive() && existing.state !== "STARTING") {
+      METRICS.warmHits += 1
+      existing.lastUsedAt = Date.now()
+      return {
+        kind: "ready",
+        acquired: { key, session: existing, poolHit: true, startupJoin: false },
+      }
+    }
+    if (existing) await removeSession(key, "stale-session")
+
+    for (const [otherKey, session] of POOL) {
+      if (
+        session.base === target.base &&
+        session.provider.id === provider.id &&
+        session.configFingerprint !== fingerprint &&
+        session.state !== "STARTING" &&
+        session.busy === 0
+      ) {
+        METRICS.evictions += 1
+        await removeSession(otherKey, "config-changed")
+      }
+    }
+
+    if (!await ensureCapacity(target.base, options)) {
+      return { kind: "capacity" }
+    }
+
+    const session = new ManagedLspSession(target.base, provider, fingerprint, options)
+    POOL.set(key, session)
+    let startupPromise
+    startupPromise = (async () => {
+      try {
+        await session.start()
+        METRICS.coldStarts += 1
+        return { key, session, poolHit: false, startupJoin: false }
+      } catch (error) {
+        if (POOL.get(key) === session) POOL.delete(key)
+        await session.stop("startup-failed").catch(() => {})
+        throw error
+      } finally {
+        if (STARTUPS.get(key) === startupPromise) STARTUPS.delete(key)
+      }
+    })()
+    STARTUPS.set(key, startupPromise)
+    return { kind: "startup", promise: startupPromise }
+  })
+
+  if (decision.kind === "ready") return decision.acquired
+  if (decision.kind === "capacity") return null
+
+  const acquired = await decision.promise
+  if (decision.kind === "startup-join") {
+    return { ...acquired, poolHit: true, startupJoin: true }
   }
+  return acquired
 }
 
 export async function withManagedLspSession(target, provider, inputOptions = {}, operation) {
@@ -575,11 +694,15 @@ export async function withManagedLspSession(target, provider, inputOptions = {},
     return { ok: false, reason: "persistent-disabled", error: null }
   }
 
+  const totalStartedAt = Date.now()
   let attempt = 0
   while (attempt <= options.maxRestarts) {
     let acquired
+    let acquisitionDurationMs = 0
     try {
+      const acquisitionStartedAt = Date.now()
       acquired = await acquire(target, provider, options)
+      acquisitionDurationMs = Date.now() - acquisitionStartedAt
       if (!acquired) {
         METRICS.fallbacks += 1
         return { ok: false, reason: "pool-capacity-busy", error: null }
@@ -603,19 +726,25 @@ export async function withManagedLspSession(target, provider, inputOptions = {},
         return operation(adapter)
       })
 
+      const totalDurationMs = Date.now() - totalStartedAt
       METRICS.operations += 1
+      METRICS.acquisitionLatencyMs += acquisitionDurationMs
       METRICS.operationLatencyMs += executed.durationMs
+      METRICS.totalLatencyMs += totalDurationMs
       return {
         ok: true,
         result: executed.result,
         meta: {
           persistent: true,
           poolHit: acquired.poolHit,
-          warm: acquired.poolHit,
+          warm: acquired.poolHit && !acquired.startupJoin,
+          startupJoin: Boolean(acquired.startupJoin),
           sessionId: session.id,
           state: session.state,
           coldStartMs: acquired.poolHit ? 0 : session.coldStartMs,
+          acquisitionDurationMs,
           operationDurationMs: executed.durationMs,
+          totalDurationMs,
           requestCount: session.requestCount,
           configFingerprint: session.configFingerprint,
         },
@@ -662,11 +791,19 @@ export function lspPoolStatus(options = {}) {
     },
     active: sessions.length,
     busy: sessions.filter((session) => session.busy > 0).length,
+    sessionCount: sessions.length,
+    sessionsIncluded: options.includeSessions !== false,
     metrics: {
       ...METRICS,
+      averageAcquisitionLatencyMs: METRICS.operations
+        ? Number((METRICS.acquisitionLatencyMs / METRICS.operations).toFixed(2))
+        : null,
       averageOperationLatencyMs: METRICS.operations
         ? Number((METRICS.operationLatencyMs / METRICS.operations).toFixed(2))
         : null,
+      averageTotalLatencyMs: METRICS.operations
+        ? Number((METRICS.totalLatencyMs / METRICS.operations).toFixed(2))
+        : null,
     },
     sessions: options.includeSessions === false ? [] : sessions.map((session) => session.publicStatus()),
   }

package/lib/code-intelligence/lsp-provider.mjs

@@ -7,6 +7,9 @@ import { resolveWindowsCommand } from "../windows-shim.mjs"
 import { lspPoolStatus as managedLspPoolStatus, shutdownLspPool as shutdownManagedLspPool, withManagedLspSession } from "./lsp-pool.mjs"
 import { fileURLToPath, pathToFileURL } from "node:url"
 
+const TYPESCRIPT_FALLBACK_CACHE_TTL_MS = 60_000
+let typescriptFallbackCache = null
+
 const PROVIDERS = [
   { id: "typescript-language-server", extensions: new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]), commands: [["typescript-language-server", ["--stdio"]]], languageId: (ext) => [".ts", ".tsx"].includes(ext) ? "typescript" : "javascript" },
   { id: "pyright-langserver", extensions: new Set([".py"]), commands: [["pyright-langserver", ["--stdio"]], ["pylsp", []]], languageId: () => "python" },
@@ -41,14 +44,11 @@ async function safeFile(root, relative) {
   return { base, file: actual, info }
 }
 
-export function resolveTypeScriptTsserverFallback(options = {}) {
-  const explicit = String(options.explicitPath ?? process.env.UES_TYPESCRIPT_TSSERVER_PATH ?? "").trim()
-  if (explicit && existsSync(path.resolve(explicit))) return path.resolve(explicit)
-
-  const platform = String(options.platform || process.platform)
-  if (platform !== "win32") return null
+export function clearTypeScriptTsserverFallbackCache() {
+  typescriptFallbackCache = null
+}
 
-  const execution = options.execution || resolveWindowsCommand("tsserver")
+function deriveTypeScriptTsserverFallback(execution) {
   const candidates = [
     execution?.entry,
     ...(Array.isArray(execution?.argsPrefix) ? execution.argsPrefix : []),
@@ -67,6 +67,43 @@ export function resolveTypeScriptTsserverFallback(options = {}) {
   return null
 }
 
+export function resolveTypeScriptTsserverFallback(options = {}) {
+  const explicit = String(options.explicitPath ?? process.env.UES_TYPESCRIPT_TSSERVER_PATH ?? "").trim()
+  if (explicit && existsSync(path.resolve(explicit))) return path.resolve(explicit)
+
+  const platform = String(options.platform || process.platform)
+  if (platform !== "win32") return null
+
+  // Explicit injected executions are deterministic probes used by tests/callers;
+  // do not mix them into the host PATH cache.
+  if (options.execution) return deriveTypeScriptTsserverFallback(options.execution)
+
+  const cacheKey = [
+    explicit,
+    String(process.env.PATH || ""),
+    String(process.env.PATHEXT || ""),
+  ].join("\u0000")
+  const ttlMs = Math.max(0, Math.min(
+    5 * 60_000,
+    Number(options.cacheTtlMs ?? process.env.UES_LSP_PROVIDER_PROBE_TTL_MS ?? TYPESCRIPT_FALLBACK_CACHE_TTL_MS),
+  ))
+  const now = Date.now()
+  if (
+    typescriptFallbackCache &&
+    typescriptFallbackCache.key === cacheKey &&
+    now - typescriptFallbackCache.checkedAt < ttlMs
+  ) {
+    return typescriptFallbackCache.value
+  }
+
+  const resolver = typeof options.resolveCommand === "function"
+    ? options.resolveCommand
+    : resolveWindowsCommand
+  const value = deriveTypeScriptTsserverFallback(resolver("tsserver"))
+  typescriptFallbackCache = { key: cacheKey, checkedAt: now, value }
+  return value
+}
+
 function providerRuntimeOptions(provider) {
   if (provider?.id !== "typescript-language-server") return {}
   const fallbackPath = resolveTypeScriptTsserverFallback()