opencode-agent-skill 15.1.0 → 15.1.1

package/README.md

@@ -4,7 +4,7 @@
 
 **Package:** <code>opencode-agent-skill</code>  
 **Host chính:** Pi Agent  
-**Phiên bản package hiện tại:** <code>15.1.0</code>  
+**Phiên bản package hiện tại:** <code>15.1.1</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>  
 **Runtime:** Node.js 22.19+  
@@ -1431,7 +1431,7 @@ npm pack
 Package version hiện tại trên nhánh <code>main</code> là:
 
 ~~~text
-15.1.0
+15.1.1
 ~~~
 
 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.
@@ -1439,7 +1439,7 @@ Stable npm public hiện vẫn là <code>15.1.0</code>. V15.3 DEEP Speed giảm
 Test file packed với Pi:
 
 ~~~cmd
-pi install .\opencode-agent-skill-15.1.0.tgz
+pi install .\opencode-agent-skill-15.1.1.tgz
 pi list
 ~~~
 

package/docs/V15-MANAGED-RUNTIME.md

@@ -126,3 +126,21 @@ The planning watchdog is progress-aware rather than a fixed wall-clock kill swit
 Architect structured planning is JSON-first. A complete graph emitted before a late transport timeout can be recovered only through deterministic normalization/validation and must still pass the independent plan-checker.
 
 High-risk execution and verification retain the original evidence ceiling. Only read-only planning context is role-bounded to reduce first-token latency and duplicate repository ingestion.
+
+
+## Managed LSP V2
+
+Code Intelligence now treats language servers as a bounded accelerator rather than a mandatory dependency.
+
+- Persistent subprocesses are lazy-started and isolated by workspace, provider, and project-configuration fingerprint.
+- Warm requests reuse the initialized server; document content is hash-tracked and synchronized with full-text `didChange` versions after edits.
+- Diagnostics are fenced by document version so a delayed notification cannot silently prove an older source revision.
+- The pool is bounded by global/per-workspace limits, idle TTL, and LRU eviction. Transient transport/startup failures receive at most the configured bounded restart budget.
+- Non-transient request rejection does not destroy an otherwise healthy warm session.
+- Windows npm shims are resolved through the existing safe Windows command resolver instead of attempting to execute `.cmd` wrappers directly.
+- Pi child shutdown stops pooled language servers alongside managed services.
+- If the persistent path is disabled, saturated, or unhealthy, Code Intelligence falls back to the existing ephemeral LSP path; semantic index/search remains independent of LSP availability.
+
+Runtime tuning is optional through `UES_LSP_PERSISTENT`, `UES_LSP_IDLE_TTL_MS`, `UES_LSP_MAX_SERVERS`, `UES_LSP_MAX_PER_WORKSPACE`, `UES_LSP_REQUEST_TIMEOUT_MS`, `UES_LSP_STARTUP_TIMEOUT_MS`, and `UES_LSP_MAX_RESTARTS`.
+
+Use `npm run bench:lsp` for a deterministic cold/warm protocol benchmark. The benchmark uses a mock language server so it measures pool overhead and reuse, not the indexing cost of a particular external language server.

package/global-config/agents/verifier.md

@@ -16,7 +16,11 @@ Return exactly these sections:
 Command/check, exit/result, and what claim it proves.
 
 ## Acceptance criteria proven
-Criterion-by-criterion evidence.
+Criterion-by-criterion evidence. Prefix each criterion with exactly one evidence status:
+- `VERIFIED:` only when fresh direct evidence proves it.
+- `INFERRED:` when it is only supported by reasoning or indirect evidence.
+- `UNKNOWN:` when it was not checked or evidence is insufficient.
+Any requested criterion marked `INFERRED:` or `UNKNOWN:` must also appear under **Unresolved gaps** and cannot support PASS.
 
 ## Failures
 Actual failed checks or unmet criteria. If none, write exactly `None`.
@@ -30,4 +34,4 @@ What was skipped and why. Put optional or out-of-scope checks here rather than t
 ## Completion evidence
 A concise statement limited to what the fresh evidence supports.
 
-Do not infer success from another agent's report or from compilation alone.
+Do not infer success from another agent's report or from compilation alone. A semantic claim about code, behavior, or an interface must be backed by an inspected path/symbol or fresh executable evidence before it can be marked VERIFIED.

package/lib/affected-tests.mjs

@@ -11,6 +11,22 @@ const AFFECTED_TEST_CACHE = new Map()
 const AFFECTED_TEST_INFLIGHT = new Map()
 const TEST_CONTENT_CACHE = new Map()
 
+async function mapLimit(items, limit, worker) {
+  if (!items.length) return []
+  const output = new Array(items.length)
+  let cursor = 0
+  const width = Math.min(items.length, Math.max(1, Number(limit || 1)))
+  const runners = Array.from({ length: width }, async () => {
+    while (true) {
+      const index = cursor++
+      if (index >= items.length) return
+      output[index] = await worker(items[index], index)
+    }
+  })
+  await Promise.all(runners)
+  return output
+}
+
 function git(root, args) {
   return spawnSync("git", args, { cwd: root, encoding: "utf8", maxBuffer: 8 * 1024 * 1024 })
 }
@@ -228,8 +244,8 @@ export async function resolveAffectedTests(root = process.cwd(), options = {}) {
       .map((file) => normalize(path.relative(root, file)))
       .filter((file) => TEST_RE.test(file))
 
-    const ranked = []
-    for (const testFile of tests) {
+    const ioConcurrency = Math.max(1, Math.min(32, Number(options.ioConcurrency ?? 12)))
+    const scoredTests = await mapLimit(tests, ioConcurrency, async (testFile) => {
       const info = await stat(path.join(root, testFile)).catch(() => null)
       const content = await cachedTestContent(path.join(root, testFile), info)
       let best = { score: 0, reasons: [], changedFile: null }
@@ -237,8 +253,9 @@ export async function resolveAffectedTests(root = process.cwd(), options = {}) {
         const current = scoreTest(testFile, changedFile, content)
         if (current.score > best.score) best = { ...current, changedFile }
       }
-      if (best.score > 0) ranked.push({ path: testFile, ...best })
-    }
+      return best.score > 0 ? { path: testFile, ...best } : null
+    })
+    const ranked = scoredTests.filter(Boolean)
 
     ranked.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
     const selected = ranked.slice(0, limit)

package/lib/capability-fabric.mjs

@@ -1,12 +1,77 @@
 import { existsSync } from "node:fs"
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
-import { spawnSync } from "node:child_process"
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises"
 import path from "node:path"
+import { commandExists } from "./executable-probe.mjs"
 
 const HEALTH_WEIGHT = { healthy: 40, degraded: 15, unknown: 0, unavailable: -1000 }
 const COST_PENALTY = { low: 0, medium: 5, high: 12 }
 const LATENCY_PENALTY = { fast: 0, medium: 3, slow: 8 }
 const OBSERVATION_FILE = "CAPABILITY-OBSERVATIONS.json"
+const OBSERVATION_WRITE_TAILS = new Map()
+const OBSERVATION_LOCK_STALE_MS = 15_000
+const OBSERVATION_LOCK_WAIT_MS = 20_000
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function observationLockPath(root) {
+  return path.join(path.resolve(root), ".ues-learning", ".capability-observations.lock")
+}
+
+async function withCrossProcessObservationLock(root, fn) {
+  const lockDir = observationLockPath(root)
+  await mkdir(path.dirname(lockDir), { recursive: true })
+  const deadline = Date.now() + OBSERVATION_LOCK_WAIT_MS
+  let delayMs = 8
+
+  while (true) {
+    try {
+      await mkdir(lockDir)
+      break
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error
+      const info = await stat(lockDir).catch(() => null)
+      if (info && Date.now() - info.mtimeMs > OBSERVATION_LOCK_STALE_MS) {
+        const confirmed = await stat(lockDir).catch(() => null)
+        if (
+          confirmed &&
+          confirmed.ino === info.ino &&
+          confirmed.mtimeMs === info.mtimeMs
+        ) {
+          await rm(lockDir, { recursive: true, force: true }).catch(() => {})
+          continue
+        }
+      }
+      if (Date.now() >= deadline) throw new Error("Timed out waiting for capability observation lock")
+      await sleep(delayMs)
+      delayMs = Math.min(100, delayMs * 2)
+    }
+  }
+
+  try {
+    return await fn()
+  } finally {
+    await rm(lockDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+async function withObservationWriteLock(root, fn) {
+  const key = path.resolve(root)
+  const previous = OBSERVATION_WRITE_TAILS.get(key) || Promise.resolve()
+  let release
+  const barrier = new Promise((resolve) => { release = resolve })
+  const tail = previous.catch(() => {}).then(() => barrier)
+  OBSERVATION_WRITE_TAILS.set(key, tail)
+
+  await previous.catch(() => {})
+  try {
+    return await withCrossProcessObservationLock(root, fn)
+  } finally {
+    release()
+    if (OBSERVATION_WRITE_TAILS.get(key) === tail) OBSERVATION_WRITE_TAILS.delete(key)
+  }
+}
 
 function observationPath(root) {
   return path.join(path.resolve(root), ".ues-learning", OBSERVATION_FILE)
@@ -25,27 +90,29 @@ export async function readCapabilityObservations(root = process.cwd()) {
 }
 export async function recordCapabilityObservation(root, capability, providerId, input = {}) {
   if (!capability || !providerId) throw new Error("capability observation requires capability and provider id")
-  const state = await readCapabilityObservations(root)
-  const previous = state.capabilities?.[capability]?.[providerId] || {}
-  const success = input.success === true, failure = input.success === false
-  const samples = Number(previous.samples || 0) + (success || failure ? 1 : 0)
-  const successes = Number(previous.successes || 0) + (success ? 1 : 0)
-  const failures = Number(previous.failures || 0) + (failure ? 1 : 0)
-  const latencyMs = Number.isFinite(Number(input.latencyMs)) ? Math.max(0, Number(input.latencyMs)) : null
-  const previousLatencySamples = Number(previous.latencySamples || 0)
-  const latencySamples = previousLatencySamples + (latencyMs == null ? 0 : 1)
-  const avgLatencyMs = latencyMs == null ? (previous.avgLatencyMs ?? null) : ((Number(previous.avgLatencyMs || 0) * previousLatencySamples) + latencyMs) / Math.max(1, latencySamples)
-  const next = {
-    samples, successes, failures,
-    successRate: samples ? successes / samples : 0,
-    failureRate: samples ? failures / samples : 0,
-    latencySamples, avgLatencyMs: avgLatencyMs == null ? null : Number(avgLatencyMs.toFixed(2)),
-    lastLatencyMs: latencyMs, lastObservedAt: new Date().toISOString(),
-    lastError: input.error ? String(input.error).slice(0, 500) : null,
-  }
-  const capabilities = { ...state.capabilities, [capability]: { ...(state.capabilities?.[capability] || {}), [providerId]: next } }
-  await atomicJson(observationPath(root), { schemaVersion: 1, updatedAt: next.lastObservedAt, capabilities })
-  return next
+  return withObservationWriteLock(root, async () => {
+    const state = await readCapabilityObservations(root)
+    const previous = state.capabilities?.[capability]?.[providerId] || {}
+    const success = input.success === true, failure = input.success === false
+    const samples = Number(previous.samples || 0) + (success || failure ? 1 : 0)
+    const successes = Number(previous.successes || 0) + (success ? 1 : 0)
+    const failures = Number(previous.failures || 0) + (failure ? 1 : 0)
+    const latencyMs = Number.isFinite(Number(input.latencyMs)) ? Math.max(0, Number(input.latencyMs)) : null
+    const previousLatencySamples = Number(previous.latencySamples || 0)
+    const latencySamples = previousLatencySamples + (latencyMs == null ? 0 : 1)
+    const avgLatencyMs = latencyMs == null ? (previous.avgLatencyMs ?? null) : ((Number(previous.avgLatencyMs || 0) * previousLatencySamples) + latencyMs) / Math.max(1, latencySamples)
+    const next = {
+      samples, successes, failures,
+      successRate: samples ? successes / samples : 0,
+      failureRate: samples ? failures / samples : 0,
+      latencySamples, avgLatencyMs: avgLatencyMs == null ? null : Number(avgLatencyMs.toFixed(2)),
+      lastLatencyMs: latencyMs, lastObservedAt: new Date().toISOString(),
+      lastError: input.error ? String(input.error).slice(0, 500) : null,
+    }
+    const capabilities = { ...state.capabilities, [capability]: { ...(state.capabilities?.[capability] || {}), [providerId]: next } }
+    await atomicJson(observationPath(root), { schemaVersion: 1, updatedAt: next.lastObservedAt, capabilities })
+    return next
+  })
 }
 
 function clamp(value, min = 0, max = 1, fallback = 0) {
@@ -53,21 +120,6 @@ function clamp(value, min = 0, max = 1, fallback = 0) {
   return Number.isFinite(number) ? Math.max(min, Math.min(max, number)) : fallback
 }
 
-const COMMAND_PROBE_TTL_MS = 60_000
-const commandProbeCache = new Map()
-
-function commandExists(command) {
-  if (!command) return false
-  const now = Date.now()
-  const cached = commandProbeCache.get(command)
-  if (cached && now - cached.checkedAt < COMMAND_PROBE_TTL_MS) return cached.available
-  const finder = process.platform === "win32" ? "where" : "which"
-  const result = spawnSync(finder, [command], { stdio: "ignore", windowsHide: true })
-  const available = result.status === 0
-  commandProbeCache.set(command, { available, checkedAt: now })
-  return available
-}
-
 async function packageDeclared(root, name) {
   try {
     const pkg = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"))
@@ -348,20 +400,27 @@ export async function capabilityFabricStatus(root = process.cwd(), options = {})
   const persistedObservations = options.observations ? null : await readCapabilityObservations(root)
   const capabilities = {}
   const rows = []
-  for (const [name, providers] of Object.entries(registry.capabilities || {})) {
-    const probed = []
-    for (const provider of providers || []) probed.push(await probeCapabilityProvider(provider, root))
+  const entries = Object.entries(registry.capabilities || {})
+  const evaluated = await Promise.all(entries.map(async ([name, providers]) => {
+    const probed = await Promise.all((providers || []).map((provider) => probeCapabilityProvider(provider, root)))
     const selected = selectCapabilityProvider(name, probed, {
       observations: options.observations?.[name] || persistedObservations?.capabilities?.[name] || {},
       allowUnknown: options.allowUnknown,
     })
-    capabilities[name] = selected
-    rows.push({
-      capability: name,
-      selected: selected.selected?.id || null,
-      status: selected.selected?.status || "unavailable",
-      fallbacks: selected.fallbacks.map((item) => item.id),
-    })
+    return {
+      name,
+      selected,
+      row: {
+        capability: name,
+        selected: selected.selected?.id || null,
+        status: selected.selected?.status || "unavailable",
+        fallbacks: selected.fallbacks.map((item) => item.id),
+      },
+    }
+  }))
+  for (const item of evaluated) {
+    capabilities[item.name] = item.selected
+    rows.push(item.row)
   }
   return {
     schemaVersion: 1,

package/lib/code-intelligence/index.mjs

@@ -1,24 +1,12 @@
 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 { anchoredLines, applyAnchoredEdits } from "./edit-anchor.mjs"
-import { diagnoseCode, lspOperation, lspProviderStatus, LSP_OPERATIONS } from "./lsp-provider.mjs"
+import { diagnoseCode, lspOperation, lspPoolStatus, lspProviderStatus, shutdownLspPool, LSP_OPERATIONS } from "./lsp-provider.mjs"
 
 const AST_COMMANDS = ["ast-grep", "sg"]
-const commandCache = new Map()
-const COMMAND_TTL_MS = 60_000
-
-function commandExists(command) {
-  const now = Date.now()
-  const cached = commandCache.get(command)
-  if (cached && now - cached.at < COMMAND_TTL_MS) return cached.available
-  const finder = process.platform === "win32" ? "where" : "which"
-  const available = spawnSync(finder, [command], { stdio: "ignore", windowsHide: true }).status === 0
-  commandCache.set(command, { available, at: now })
-  return available
-}
-
 function inside(root, target) { return target === root || target.startsWith(root + path.sep) }
 
 async function safeFile(root, relative) {
@@ -93,4 +81,4 @@ export async function searchCodeIntelligence(root, query, options = {}) {
   }
 }
 
-export { diagnoseCode, lspOperation, lspProviderStatus, LSP_OPERATIONS } from "./lsp-provider.mjs"
+export { diagnoseCode, lspOperation, lspPoolStatus, lspProviderStatus, shutdownLspPool, LSP_OPERATIONS } from "./lsp-provider.mjs"