opencode-agent-skill 15.0.0 → 15.1.1

package/scripts/benchmark-lsp-pool.mjs

@@ -0,0 +1,128 @@
+import { performance } from "node:perf_hooks"
+import { mkdtemp, rm, stat, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import {
+  lspPoolStatus,
+  resetLspPoolMetrics,
+  shutdownLspPool,
+  withManagedLspSession,
+} from "../lib/code-intelligence/lsp-pool.mjs"
+
+const MOCK_SERVER = `
+let buffer = Buffer.alloc(0)
+function encode(payload) {
+  const body = Buffer.from(JSON.stringify(payload), "utf8")
+  return Buffer.concat([Buffer.from("Content-Length: " + body.length + "\\r\\n\\r\\n", "ascii"), body])
+}
+function send(payload) { process.stdout.write(encode(payload)) }
+function dispatch(message) {
+  const method = String(message?.method || "")
+  if (message?.id != null) {
+    if (method === "initialize") {
+      send({ jsonrpc: "2.0", id: message.id, result: { capabilities: { documentSymbolProvider: true } } })
+      return
+    }
+    if (method === "textDocument/documentSymbol") {
+      send({ jsonrpc: "2.0", id: message.id, result: [{ name: "benchSymbol", kind: 12, range: null, selectionRange: null }] })
+      return
+    }
+    send({ jsonrpc: "2.0", id: message.id, result: null })
+    return
+  }
+  if (method === "exit") process.exit(0)
+}
+function parse() {
+  while (true) {
+    const headerEnd = buffer.indexOf("\\r\\n\\r\\n")
+    if (headerEnd < 0) return
+    const header = buffer.subarray(0, headerEnd).toString("ascii")
+    const match = header.match(/Content-Length:\\s*(\\d+)/i)
+    if (!match) { buffer = buffer.subarray(headerEnd + 4); continue }
+    const length = Number(match[1])
+    const start = headerEnd + 4
+    if (buffer.length < start + length) return
+    const body = buffer.subarray(start, start + length).toString("utf8")
+    buffer = buffer.subarray(start + length)
+    try { dispatch(JSON.parse(body)) } catch {}
+  }
+}
+process.stdin.on("data", (chunk) => {
+  buffer = Buffer.concat([buffer, Buffer.from(chunk)])
+  parse()
+})
+`
+
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b)
+  const middle = Math.floor(sorted.length / 2)
+  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2
+}
+
+async function main() {
+  const root = await mkdtemp(path.join(os.tmpdir(), "ues-lsp-bench-"))
+  try {
+    resetLspPoolMetrics()
+    const server = path.join(root, "mock-lsp.mjs")
+    const source = path.join(root, "demo.ts")
+    await writeFile(server, MOCK_SERVER, "utf8")
+    await writeFile(source, "export const benchmarkValue = 1\n", "utf8")
+
+    const provider = {
+      id: "typescript-benchmark",
+      command: process.execPath,
+      args: [server],
+      languageId: "typescript",
+    }
+    const target = { base: root, file: source, info: await stat(source) }
+    const run = async () => {
+      const started = performance.now()
+      const result = await withManagedLspSession(
+        target,
+        provider,
+        { maxServers: 1, maxPerWorkspace: 1, timeoutMs: 2000, startupTimeoutMs: 3000 },
+        async (session) => session.request("textDocument/documentSymbol", {
+          textDocument: { uri: session.uri },
+        }),
+      )
+      if (!result.ok) throw new Error("LSP benchmark failed: " + String(result.reason || result.error || "unknown"))
+      return {
+        totalMs: performance.now() - started,
+        poolHit: result.meta.poolHit,
+        coldStartMs: result.meta.coldStartMs,
+        operationDurationMs: result.meta.operationDurationMs,
+      }
+    }
+
+    const cold = await run()
+    const warm = []
+    for (let index = 0; index < 8; index += 1) warm.push(await run())
+    const warmTotals = warm.map((item) => item.totalMs)
+    const status = lspPoolStatus()
+
+    console.log(JSON.stringify({
+      schemaVersion: 1,
+      kind: "ues-lsp-pool-benchmark",
+      node: process.version,
+      platform: process.platform,
+      cold: {
+        totalMs: Number(cold.totalMs.toFixed(3)),
+        coldStartMs: cold.coldStartMs,
+        operationDurationMs: cold.operationDurationMs,
+      },
+      warm: {
+        samples: warm.length,
+        medianTotalMs: Number(median(warmTotals).toFixed(3)),
+        minTotalMs: Number(Math.min(...warmTotals).toFixed(3)),
+        maxTotalMs: Number(Math.max(...warmTotals).toFixed(3)),
+        allPoolHits: warm.every((item) => item.poolHit === true),
+      },
+      pool: status.metrics,
+    }, null, 2))
+  } finally {
+    await shutdownLspPool(root)
+    await rm(root, { recursive: true, force: true })
+  }
+}
+
+await main()

package/scripts/check-release-consistency.mjs

@@ -142,8 +142,20 @@ export function checkReleaseConsistency(root = DEFAULT_ROOT) {
 
   if (pkg) {
     const scripts = pkg.scripts || {}
-    if (scripts.test !== "node --test") errors.push("package.json: npm test must run portable full Node test discovery")
-    if (scripts["test:pi"] !== "node --test test/pi-package.test.mjs") errors.push("package.json: missing focused test:pi script")
+    if (scripts.test !== "node scripts/run-test-suite.mjs") {
+      errors.push("package.json: npm test must run the bounded per-file test runner")
+    }
+    const focusedPi = String(scripts["test:pi"] || "").trim().split(/\s+/).filter(Boolean)
+    if (
+      focusedPi[0] !== "node" ||
+      focusedPi[1] !== "scripts/run-test-suite.mjs" ||
+      !focusedPi.includes("test/pi-package.test.mjs")
+    ) {
+      errors.push("package.json: missing bounded focused test:pi script")
+    }
+    if (scripts["test:node"] !== "node --test") {
+      errors.push("package.json: test:node must preserve raw Node test discovery for diagnosis")
+    }
     if (scripts["docs:check"] !== "node scripts/check-release-consistency.mjs") errors.push("package.json: missing docs:check release-consistency script")
     if (scripts["release:check-tag"] !== "node scripts/check-release-tag.mjs") errors.push("package.json: missing release:check-tag script")
     if (scripts["eval:pi"] !== "node scripts/eval-pi.mjs") errors.push("package.json: missing Pi-native eval:pi script")
@@ -160,10 +172,10 @@ export function checkReleaseConsistency(root = DEFAULT_ROOT) {
     ]
     if (
       focusedV15[0] !== "node" ||
-      focusedV15[1] !== "--test" ||
+      focusedV15[1] !== "scripts/run-test-suite.mjs" ||
       !requiredFocusedV15Tests.every((file) => focusedV15.includes(file))
     ) {
-      errors.push("package.json: focused eval:v15 must run the current V15 runtime, disk-safety, intelligence and Pi-package regression set")
+      errors.push("package.json: focused eval:v15 must use the bounded runner and include the current V15 runtime, disk-safety, intelligence and Pi-package regression set")
     }
     if (!String(scripts.ci || "").includes("npm run integrity")) errors.push("package.json: ci must include source-integrity gate")
     if (scripts["runtime:exports"] !== "node scripts/check-runtime-exports.mjs") errors.push("package.json: missing runtime:exports import/export gate")

package/scripts/check-source-integrity.mjs

@@ -11,6 +11,12 @@ const CONTRACTS = [
     minBytes: 80_000,
     startsWith: "import { spawn }",
     required: [
+      "ues_code",
+      "UES Code Intelligence Lite",
+      "parent-lite",
+      "controllerStarted",
+      "childSpawned",
+      "shutdownLspPool",
       'name: "ues_cli"',
       'name: "ues_execute"',
       'name: "ues_dispatch"',
@@ -35,6 +41,18 @@ const CONTRACTS = [
       "void directControllerRunner",
       "UES_AUTO_ADMIT",
       "UES_PARENT_TOOL_NAMES",
+      "ALWAYS_ON_PARENT_TOOLS",
+      'pi.on("agent_before_settle"',
+      "ues-parent-provider-recovery",
+      "parentRunToolCalls",
+      "parentProviderRecoveryConsecutive",
+      "parentProviderRecoveryTotal",
+      "parentProviderRecoveryPending",
+      "PARENT_PROVIDER_RECOVERY_MAX_CONSECUTIVE",
+      "PARENT_PROVIDER_RECOVERY_MAX_TOTAL",
+      "Do not restart the task and do not repeat tool calls that already completed",
+      'new Set(["ues_code"])',
+      '!ALWAYS_ON_PARENT_TOOLS.has(toolName)',
       "pi.getActiveTools",
       "pi.setActiveTools",
       "deactivateParentUesTools",
@@ -118,6 +136,7 @@ const CONTRACTS = [
       'process.env.UES_CHILD_PROCESS !== "1"',
       "looksLikeLongRunningServiceCommand",
       "stopAllServices",
+      "shutdownLspPool",
       "applyAnchoredFileEdits",
       "diagnoseCode",
       "recordVerification",
@@ -402,7 +421,28 @@ const CONTRACTS = [
     file: "lib/code-intelligence/lsp-provider.mjs",
     minBytes: 5_000,
     startsWith: "import ",
-    required: ["diagnoseCode", "lspProviderStatus", "publishDiagnostics"],
+    required: ["diagnoseCode", "lspProviderStatus", "lspPersistencePolicy", "short-lived-default", "pi-child-runtime", "publishDiagnostics", "withManagedLspSession", "fallbackFrom", "shutdownLspPool", "resolveTypeScriptTsserverFallback", "UES_TYPESCRIPT_TSSERVER_PATH", "initializationOptions", "fallbackPath", "resolveWindowsCommand"],
+  },
+  {
+    file: "lib/code-intelligence/lsp-pool.mjs",
+    minBytes: 12_000,
+    startsWith: "import ",
+    required: [
+      "withManagedLspSession",
+      "shutdownLspPool",
+      "lspPoolStatus",
+      "pool-capacity-busy",
+      "bounded-restart",
+      "config-changed",
+      "textDocument/didChange",
+      "UES_LSP_MAX_SERVERS",
+      "UES_LSP_IDLE_TTL_MS",
+      "resolveWindowsCommand",
+      "managed-lsp-request-rejected",
+      "initializationOptions",
+      "JSON.stringify(provider?.initializationOptions || null)",
+    ],
+    forbidden: ["\\nimport { resolveWindowsCommand }"],
   },
   {
     file: "lib/execution-contract.mjs",
@@ -657,6 +697,20 @@ const CONTRACTS = [
     ],
   },
 
+  {
+    file: "scripts/run-test-suite.mjs",
+    minBytes: 3_000,
+    startsWith: "import ",
+    required: [
+      "runSupervisedProcess",
+      "UES_TEST_FILE_TIMEOUT_MS",
+      "UES_TEST_CONCURRENCY",
+      "HANG/TIMEOUT",
+      "hardTimeoutMs: timeoutMs",
+      "UES_BOUNDED_TEST_RUNNER",
+      "Failing or leaking test files",
+    ],
+  },
   {
     file: "scripts/eval-pi.mjs",
     minBytes: 15_000,
@@ -702,6 +756,11 @@ for (const contract of CONTRACTS) {
       problems.push(`${contract.file}: missing integrity marker ${JSON.stringify(marker)}`)
     }
   }
+  for (const marker of contract.forbidden || []) {
+    if (source.includes(marker)) {
+      problems.push(`${contract.file}: forbidden integrity marker ${JSON.stringify(marker)}`)
+    }
+  }
 }
 
 assert.deepEqual(

package/scripts/run-test-suite.mjs

@@ -0,0 +1,143 @@
+import { readdir } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { runSupervisedProcess } from "../lib/process-supervisor.mjs"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const testRoot = path.join(root, "test")
+
+function bounded(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+async function walk(dir) {
+  const entries = await readdir(dir, { withFileTypes: true })
+  const output = []
+  for (const entry of entries) {
+    const absolute = path.join(dir, entry.name)
+    if (entry.isDirectory()) output.push(...await walk(absolute))
+    else if (entry.isFile() && entry.name.endsWith(".test.mjs")) output.push(absolute)
+  }
+  return output
+}
+
+function relative(file) {
+  return path.relative(root, file).replaceAll("\\", "/")
+}
+
+function selectedFiles(allFiles) {
+  const positional = process.argv.slice(2).filter((arg) => !arg.startsWith("--"))
+  if (!positional.length) return allFiles
+  const requested = new Set(positional.map((item) => path.resolve(root, item)))
+  return allFiles.filter((file) => requested.has(path.resolve(file)))
+}
+
+function parseFlag(name, fallback) {
+  const direct = process.argv.find((arg) => arg.startsWith(name + "="))
+  if (!direct) return fallback
+  return direct.slice(name.length + 1)
+}
+
+const cpuDefault = Math.max(2, Math.min(6, os.availableParallelism?.() || os.cpus().length || 4))
+const concurrency = bounded(
+  parseFlag("--concurrency", process.env.UES_TEST_CONCURRENCY),
+  cpuDefault,
+  1,
+  12,
+)
+const timeoutMs = bounded(
+  parseFlag("--timeout-ms", process.env.UES_TEST_FILE_TIMEOUT_MS),
+  45_000,
+  5_000,
+  10 * 60_000,
+)
+const files = selectedFiles((await walk(testRoot)).sort((a, b) => relative(a).localeCompare(relative(b))))
+
+if (!files.length) {
+  console.error("No matching test files.")
+  process.exitCode = 2
+} else {
+  console.log(`UES bounded test runner: ${files.length} files; concurrency=${concurrency}; perFileTimeoutMs=${timeoutMs}`)
+
+  let cursor = 0
+  let passed = 0
+  const failures = []
+  const startedAt = Date.now()
+
+  async function worker(workerId) {
+    while (true) {
+      const index = cursor++
+      if (index >= files.length) return
+      const file = files[index]
+      const label = relative(file)
+      const ordinal = index + 1
+      console.log(`[${ordinal}/${files.length}] RUN  ${label}`)
+
+      const result = await runSupervisedProcess(
+        process.execPath,
+        ["--test", file],
+        {
+          cwd: root,
+          hardTimeoutMs: timeoutMs,
+          idleTimeoutMs: 0,
+          killGraceMs: 500,
+          drainTimeoutMs: 2_000,
+          stdoutLimit: 8 * 1024 * 1024,
+          stderrLimit: 4 * 1024 * 1024,
+          env: {
+            ...process.env,
+            UES_BOUNDED_TEST_RUNNER: "1",
+          },
+        },
+      )
+
+      if (result.exitCode === 0 && !result.stopReason) {
+        passed += 1
+        console.log(`[${ordinal}/${files.length}] PASS ${label} (${result.durationMs}ms)`)
+        continue
+      }
+
+      const timedOut = result.stopReason === "hard-timeout"
+      const reason = timedOut
+        ? `HANG/TIMEOUT after ${timeoutMs}ms`
+        : result.stopReason
+          ? `STOPPED: ${result.stopReason}`
+          : `EXIT ${result.exitCode}`
+      failures.push({
+        file: label,
+        reason,
+        exitCode: result.exitCode,
+        stopReason: result.stopReason,
+        durationMs: result.durationMs,
+      })
+
+      console.error(`[${ordinal}/${files.length}] FAIL ${label}: ${reason}`)
+      const stdout = String(result.stdout || "").trim()
+      const stderr = String(result.stderr || "").trim()
+      if (stdout) console.error("\n--- stdout: " + label + " ---\n" + stdout.slice(-64_000))
+      if (stderr) console.error("\n--- stderr: " + label + " ---\n" + stderr.slice(-32_000))
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(concurrency, files.length) }, (_, index) => worker(index + 1)))
+
+  const durationMs = Date.now() - startedAt
+  console.log("")
+  console.log("UES bounded test summary")
+  console.log(`files: ${files.length}`)
+  console.log(`pass: ${passed}`)
+  console.log(`fail: ${failures.length}`)
+  console.log(`duration_ms: ${durationMs}`)
+
+  if (failures.length) {
+    console.error("")
+    console.error("Failing or leaking test files:")
+    for (const failure of failures) {
+      console.error(`- ${failure.file}: ${failure.reason}; duration=${failure.durationMs}ms`)
+    }
+    process.exitCode = 1
+  }
+}

package/scripts/smoke-package-closure.mjs

@@ -39,6 +39,8 @@ for (const required of [
   "pi/extensions/ues-child-runtime.ts",
   "docs/V14.2-TURBO-WEAK-MODEL-RUNTIME.md",
   "lib/process-supervisor.mjs",
+  "lib/executable-probe.mjs",
+  "lib/code-intelligence/lsp-pool.mjs",
   "lib/pi-rpc-pool.mjs",
   "lib/adaptive-context-budget.mjs",
   "lib/skill-compiler.mjs",
@@ -51,6 +53,8 @@ for (const required of [
   "lib/runtime-config.mjs",
   "scripts/eval-pi.mjs",
   "scripts/eval-report.mjs",
+  "scripts/benchmark-lsp-pool.mjs",
+  "scripts/run-test-suite.mjs",
   "evals/live/tasks.json",
   "global-config/AGENTS.md",
   "global-config/commands/run.md",