opencode-agent-skill 15.1.0 → 15.1.2

package/lib/pi-rpc-pool.mjs

@@ -180,6 +180,95 @@ class RpcWorker {
     return { accepted: true }
   }
 
+  async followUp(message) {
+    if (!this.proc || this.dead || !this.active) {
+      return { accepted: false, reason: "worker-not-active" }
+    }
+    await this.send(
+      { type: "follow_up", message: String(message || "") },
+      { timeoutMs: RPC_CONTROL_TIMEOUT_MS },
+    )
+    return { accepted: true }
+  }
+
+  async getState() {
+    if (!this.proc || this.dead) return null
+    const response = await this.send(
+      { type: "get_state" },
+      { timeoutMs: RPC_CONTROL_TIMEOUT_MS },
+    )
+    return response?.data || null
+  }
+
+  async clearQueue() {
+    if (!this.proc || this.dead) return { steering: [], followUp: [] }
+    const response = await this.send(
+      { type: "clear_queue" },
+      { timeoutMs: RPC_CONTROL_TIMEOUT_MS },
+    )
+    return response?.data || { steering: [], followUp: [] }
+  }
+
+  async setModel(provider, modelId) {
+    if (!this.proc || this.dead) throw new Error("Pi RPC worker is not available")
+    const response = await this.send(
+      { type: "set_model", provider: String(provider || ""), modelId: String(modelId || "") },
+      { timeoutMs: RPC_CONTROL_TIMEOUT_MS },
+    )
+    return response?.data || null
+  }
+
+  async setThinkingLevel(level) {
+    if (!this.proc || this.dead) throw new Error("Pi RPC worker is not available")
+    await this.send(
+      { type: "set_thinking_level", level: String(level || "") },
+      { timeoutMs: RPC_CONTROL_TIMEOUT_MS },
+    )
+    return { level: String(level || "") }
+  }
+
+  async compact(customInstructions = "") {
+    if (!this.proc || this.dead) throw new Error("Pi RPC worker is not available")
+    const response = await this.send(
+      {
+        type: "compact",
+        ...(String(customInstructions || "").trim()
+          ? { customInstructions: String(customInstructions).trim() }
+          : {}),
+      },
+      { timeoutMs: Math.max(RPC_CONTROL_TIMEOUT_MS, 5 * 60_000) },
+    )
+    return response?.data || null
+  }
+
+  async waitForIdle(timeoutMs = 30_000) {
+    if (!this.proc || this.dead) {
+      return { idle: true, state: null, reason: "worker-unavailable" }
+    }
+    const timeout = clamp(timeoutMs, 30_000, 500, 30 * 60_000)
+    const deadline = Date.now() + timeout
+    let state = await this.getState()
+    let pollMs = 100
+
+    while (
+      state &&
+      (
+        state.isStreaming === true ||
+        state.isCompacting === true ||
+        Number(state.pendingMessageCount || 0) > 0
+      )
+    ) {
+      if (Date.now() >= deadline) {
+        return { idle: false, state, reason: "timeout" }
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollMs))
+      pollMs = Math.min(500, Math.max(100, Math.trunc(pollMs * 1.6)))
+      state = await this.getState()
+    }
+
+    return { idle: true, state, reason: null }
+  }
+
   async abortTransport() {
     if (!this.proc || this.dead) return false
     try {
@@ -216,7 +305,7 @@ class RpcWorker {
     const execute = async () => {
       try {
         await this.start()
-        if (this.runs > 0) {
+        if (this.runs > 0 && options.reuseSession !== true) {
           await this.send({ type: "new_session" }, { timeoutMs: 30_000 })
         }
       } catch (error) {
@@ -380,6 +469,17 @@ export class PiRpcWorkerPool {
   constructor(options = {}) {
     this.maxWorkers = Math.max(1, Math.min(16, Number(options.maxWorkers || 8)))
     this.workers = new Map()
+    this.reservations = new Map()
+  }
+
+  reserve(key) {
+    this.reservations.set(key, (this.reservations.get(key) || 0) + 1)
+  }
+
+  release(key) {
+    const next = Math.max(0, (this.reservations.get(key) || 0) - 1)
+    if (next > 0) this.reservations.set(key, next)
+    else this.reservations.delete(key)
   }
 
   async pruneIdleWorkers(protectedKey = null) {
@@ -387,7 +487,7 @@ export class PiRpcWorkerPool {
       let candidateKey = null
       let candidate = null
       for (const [key, worker] of this.workers.entries()) {
-        if (key === protectedKey) continue
+        if (key === protectedKey || this.reservations.has(key)) continue
         if (!worker || worker.dead) {
           candidateKey = key
           candidate = worker
@@ -405,32 +505,56 @@ export class PiRpcWorkerPool {
   }
 
   async run(key, spec, message, options = {}) {
-    let worker = this.workers.get(key)
-    let workerReused = Boolean(worker && !worker.dead && worker.runs > 0)
-    if (!worker || worker.dead) {
-      if (worker) {
-        await worker.stop().catch(() => {})
+    this.reserve(key)
+    let worker = null
+    let workerReused = false
+    let staleStop = null
+
+    try {
+      worker = this.workers.get(key)
+      workerReused = Boolean(worker && !worker.dead && worker.runs > 0)
+      if (options.reuseSession === true && !workerReused) {
+        const error = new Error("Pi RPC same-session resume unavailable")
+        error.code = "UES_RPC_SESSION_UNAVAILABLE"
+        throw error
+      }
+
+      if (!worker || worker.dead) {
+        const staleWorker = worker
+        if (staleWorker) this.workers.delete(key)
+
+        // Publish the replacement synchronously before any await. Concurrent
+        // callers for the same key must see this worker rather than allocate a
+        // second untracked process while the stale worker is being reaped.
+        worker = new RpcWorker(spec)
+        workerReused = false
+        this.workers.set(key, worker)
+        if (staleWorker) staleStop = staleWorker.stop().catch(() => {})
+      } else {
+        // Refresh insertion order so the bounded worker map behaves as an LRU.
         this.workers.delete(key)
+        this.workers.set(key, worker)
       }
-      worker = new RpcWorker(spec)
-      workerReused = false
-      this.workers.set(key, worker)
-      await this.pruneIdleWorkers(key)
-    } else {
-      // Refresh insertion order so the bounded worker map behaves as an LRU.
-      this.workers.delete(key)
-      this.workers.set(key, worker)
-    }
 
-    try {
-      const result = await worker.run(message, options)
+      // Queue the run before pruning. The reservation prevents another
+      // concurrent key from treating this not-yet-active worker as idle during
+      // the small window before RpcWorker.execute sets active=true.
+      const runPromise = worker.run(message, options)
       await this.pruneIdleWorkers(key)
+      if (staleStop) await staleStop
+
+      const result = await runPromise
       return { ...result, workerReused }
     } catch (error) {
-      this.workers.delete(key)
-      await worker.stop().catch(() => {})
+      if (worker && this.workers.get(key) === worker) {
+        this.workers.delete(key)
+        await worker.stop().catch(() => {})
+      }
       await this.pruneIdleWorkers().catch(() => {})
       throw error
+    } finally {
+      this.release(key)
+      await this.pruneIdleWorkers(key).catch(() => {})
     }
   }
 
@@ -443,19 +567,90 @@ export class PiRpcWorkerPool {
       }))
   }
 
-  async steerActive(message) {
+  selectSingleActive() {
     const active = [...this.workers.entries()]
       .filter(([, worker]) => worker && !worker.dead && worker.active)
     if (active.length !== 1) {
       return {
-        accepted: false,
+        ok: false,
         reason: active.length === 0 ? "no-active-worker" : "multiple-active-workers",
         active: active.length,
       }
     }
     const [key, worker] = active[0]
-    const result = await worker.steer(message)
-    return { ...result, key, active: 1 }
+    return { ok: true, key, worker, active: 1 }
+  }
+
+  async controlActive(action, input = {}) {
+    const name = String(action || "").trim().toLowerCase()
+    if (name === "status") return { ok: true, action: name, ...this.status() }
+
+    const selected = this.selectSingleActive()
+    if (!selected.ok) return { ...selected, action: name }
+    const { key, worker } = selected
+    let data
+
+    if (name === "get-state") {
+      data = await worker.getState()
+    } else if (name === "steer") {
+      data = await worker.steer(input.message)
+    } else if (name === "follow-up") {
+      data = await worker.followUp(input.message)
+    } else if (name === "abort") {
+      data = { aborted: await worker.abort() }
+    } else if (name === "clear-queue") {
+      data = await worker.clearQueue()
+    } else if (name === "set-model") {
+      if (!String(input.provider || "").trim() || !String(input.modelId || "").trim()) {
+        return { ok: false, action: name, reason: "provider-and-model-required", active: 1, key }
+      }
+      data = await worker.setModel(input.provider, input.modelId)
+    } else if (name === "set-thinking") {
+      if (!String(input.level || "").trim()) {
+        return { ok: false, action: name, reason: "thinking-level-required", active: 1, key }
+      }
+      data = await worker.setThinkingLevel(input.level)
+    } else if (name === "compact") {
+      data = await worker.compact(input.customInstructions)
+    } else if (name === "wait") {
+      data = await worker.waitForIdle(input.timeoutMs)
+    } else {
+      return { ok: false, action: name, reason: "unknown-control-action", active: 1, key }
+    }
+
+    return { ok: true, action: name, key, active: 1, data }
+  }
+
+  async steerActive(message) {
+    const result = await this.controlActive("steer", { message })
+    if (!result.ok) {
+      return {
+        accepted: false,
+        reason: result.reason,
+        active: result.active || 0,
+      }
+    }
+    return {
+      accepted: result.data?.accepted !== false,
+      key: result.key,
+      active: 1,
+    }
+  }
+
+  async followUpActive(message) {
+    const result = await this.controlActive("follow-up", { message })
+    if (!result.ok) {
+      return {
+        accepted: false,
+        reason: result.reason,
+        active: result.active || 0,
+      }
+    }
+    return {
+      accepted: result.data?.accepted !== false,
+      key: result.key,
+      active: 1,
+    }
   }
 
   async abortActive() {
@@ -478,6 +673,7 @@ export class PiRpcWorkerPool {
     return {
       workers: this.workers.size,
       activeWorkers: active.length,
+      reservedWorkers: this.reservations.size,
       keys: [...this.workers.keys()],
       active,
     }

package/lib/provider-recovery.mjs

@@ -0,0 +1,51 @@
+const EMPTY_PROVIDER_SIGNAL = /(?:provider\s+returned\s+an?\s+empty\s+response|empty\s+provider\s+response|empty\s+response\s*\(no\s+content\s+emitted\)|no\s+content\s+emitted)/i
+
+function finiteInt(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+export function classifyProviderFailure(result = {}) {
+  const output = String(result.output || "").trim()
+  const diagnostics = [result.errorMessage, result.stderr]
+    .filter(Boolean)
+    .map(String)
+    .join("\n")
+  const toolCalls = Math.max(0, Number(result.toolCalls || 0))
+  const explicitEmpty = EMPTY_PROVIDER_SIGNAL.test(diagnostics)
+  const missingAssistant =
+    result.noAssistantMessage === true ||
+    /^\(no assistant output\)$/i.test(output) ||
+    /^\(no output\)$/i.test(output)
+  const transient =
+    explicitEmpty ||
+    missingAssistant ||
+    result.providerFailure === "empty-provider-response"
+  const reason = transient
+    ? explicitEmpty || result.providerFailure === "empty-provider-response"
+      ? "empty-provider-response"
+      : "missing-assistant-output"
+    : null
+
+  return {
+    transient,
+    reason,
+    safeReplay: transient && toolCalls === 0,
+    safeSessionResume: transient && toolCalls > 0,
+    toolCalls,
+    stopReason: String(result.stopReason || ""),
+    message: transient
+      ? toolCalls === 0
+        ? "Provider produced no usable assistant content before any tool side effect; a bounded fresh-session retry is safe."
+        : "Provider produced no usable assistant content after tool execution; blind replay is blocked, but the same live RPC session may continue without repeating completed side effects."
+      : null,
+  }
+}
+
+export function providerRecoveryBackoffMs(retryNumber, options = {}) {
+  const attempt = finiteInt(retryNumber, 1, 1, 8)
+  const baseMs = finiteInt(options.baseMs, 250, 0, 10_000)
+  const maxMs = finiteInt(options.maxMs, 2_000, baseMs, 30_000)
+  return Math.min(maxMs, baseMs * (2 ** (attempt - 1)))
+}

package/lib/repo-graph.mjs

@@ -1,12 +1,12 @@
 import { readFile, readdir, stat } from "node:fs/promises"
 import path from "node:path"
 import { runtimeWorkspaceFingerprint } from "./workspace-fingerprint.mjs"
+import { UES_RUNTIME_DIRS } from "./runtime-artifacts.mjs"
 
 const SKIP = new Set([
   ".git", "node_modules", ".next", "dist", "build", "coverage", ".venv", "venv",
   "Pods", "DerivedData", ".gradle", ".idea", ".cache", ".turbo", "target", "obj",
-  ".ues-work", ".ues-cache", ".ues-traces", ".ues-learning", ".ues-dashboard",
-  ".ues-sandboxes", ".ues-memory", ".ues-evals", ".ues-services",
+  ...UES_RUNTIME_DIRS,
 ])
 
 const SOURCE_EXTENSIONS = new Set([
@@ -31,6 +31,22 @@ async function walk(root, maxFiles = 2500, maxDepth = 8) {
   return files
 }
 
+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 rel(root, file) {
   return path.relative(root, file).replaceAll("\\", "/")
 }
@@ -84,29 +100,46 @@ export async function buildRepoGraph(root = process.cwd(), options = {}) {
   const nodes = []
   const edges = []
   const external = new Map()
+  const ioConcurrency = Math.max(1, Math.min(32, Number(options.ioConcurrency ?? 12)))
 
-  for (const file of files) {
+  const scanned = await mapLimit(files, ioConcurrency, async (file) => {
     const info = await stat(file).catch(() => null)
-    if (!info || info.size > 768 * 1024) continue
+    if (!info || info.size > 768 * 1024) return null
     const source = await readFile(file, "utf8").catch(() => "")
     const relative = rel(root, file)
     const ext = path.extname(file).toLowerCase()
     const imports = importsFor(source, ext)
     const local = []
+    const fileEdges = []
+    const externalKeys = []
 
     for (const specifier of imports) {
       const resolved = resolveRelativeImport(root, file, specifier, fileSet)
       if (resolved) {
         local.push(resolved)
-        edges.push({ from: relative, to: resolved, kind: "local-import" })
+        fileEdges.push({ from: relative, to: resolved, kind: "local-import" })
       } else {
         const parts = specifier.split("/")
         const key = parts[0].startsWith("@") ? parts.slice(0, 2).join("/") : parts[0]
-        external.set(key, (external.get(key) || 0) + 1)
+        if (key) externalKeys.push(key)
       }
     }
 
-    nodes.push({ path: relative, imports: imports.length, localImports: [...new Set(local)].sort() })
+    return {
+      node: { path: relative, imports: imports.length, localImports: [...new Set(local)].sort() },
+      edges: fileEdges,
+      externalKeys,
+    }
+  })
+
+  // Preserve discovery-order aggregation so concurrency changes latency, not graph output.
+  for (const result of scanned) {
+    if (!result) continue
+    nodes.push(result.node)
+    edges.push(...result.edges)
+    for (const key of result.externalKeys) {
+      external.set(key, (external.get(key) || 0) + 1)
+    }
   }
 
   const incoming = new Map()

package/lib/repo-inspect.mjs

@@ -2,11 +2,12 @@ import { existsSync } from "node:fs"
 import { readFile, readdir, stat } from "node:fs/promises"
 import path from "node:path"
 import { spawnSync } from "node:child_process"
+import { UES_RUNTIME_DIRS, sourceGitPathspecs } from "./runtime-artifacts.mjs"
 
 const SKIP_DIRS = new Set([
   ".git", "node_modules", ".next", "dist", "build", "coverage", ".venv", "venv",
   "Pods", "DerivedData", ".gradle", ".idea", ".cache", ".turbo", "target", "bin", "obj",
-  ".ues-services",
+  ...UES_RUNTIME_DIRS,
 ])
 
 const TEXT_EXTENSIONS = new Set([
@@ -231,7 +232,7 @@ export async function impactMap(root = process.cwd(), query = "") {
 
 export async function checkWorkingTree(root = process.cwd()) {
   root = path.resolve(root)
-  const status = runGit(root, ["status", "--porcelain=v1", "--branch"])
+  const status = runGit(root, ["status", "--porcelain=v1", "--branch", "--", ...sourceGitPathspecs()])
   if (status.status !== 0) {
     return { root, git: false, error: (status.stderr || status.stdout || "").trim() }
   }

package/lib/runtime-events.mjs

@@ -4,6 +4,25 @@ import { appendFile, readFile, stat, writeFile } from "node:fs/promises"
 const DEFAULT_MAX_EVENT_FILE_BYTES = 4 * 1024 * 1024
 const DEFAULT_RETAIN_EVENT_BYTES = 2 * 1024 * 1024
 
+const EVENT_WRITE_TAILS = new Map()
+
+async function withEventWriteLock(file, fn) {
+  const key = String(file)
+  const previous = EVENT_WRITE_TAILS.get(key) || Promise.resolve()
+  let release
+  const barrier = new Promise((resolve) => { release = resolve })
+  const tail = previous.catch(() => {}).then(() => barrier)
+  EVENT_WRITE_TAILS.set(key, tail)
+
+  await previous.catch(() => {})
+  try {
+    return await fn()
+  } finally {
+    release()
+    if (EVENT_WRITE_TAILS.get(key) === tail) EVENT_WRITE_TAILS.delete(key)
+  }
+}
+
 async function compactRuntimeEventFile(file, options = {}) {
   const maxBytes = Math.max(
     256 * 1024,
@@ -33,16 +52,18 @@ async function compactRuntimeEventFile(file, options = {}) {
 }
 
 export async function appendRuntimeEvent(file, type, data = {}) {
-  await compactRuntimeEventFile(file).catch(() => false)
-  const event = {
-    schemaVersion: 1,
-    id: randomUUID(),
-    type: String(type || "unknown"),
-    at: new Date().toISOString(),
-    ...data,
-  }
-  await appendFile(file, JSON.stringify(event) + "\n", "utf8")
-  return event
+  return withEventWriteLock(file, async () => {
+    await compactRuntimeEventFile(file).catch(() => false)
+    const event = {
+      schemaVersion: 1,
+      id: randomUUID(),
+      type: String(type || "unknown"),
+      at: new Date().toISOString(),
+      ...data,
+    }
+    await appendFile(file, JSON.stringify(event) + "\n", "utf8")
+    return event
+  })
 }
 
 export async function readRuntimeEvents(file, options = {}) {

package/lib/semantic-index.mjs

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs"
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises"
 import path from "node:path"
+import { UES_RUNTIME_DIRS } from "./runtime-artifacts.mjs"
 
 const SCHEMA_VERSION = 1
 const CACHE_DIR = ".ues-cache"
@@ -12,7 +13,7 @@ const SOURCE_EXTENSIONS = new Set([
 const SKIP_DIRS = new Set([
   ".git", "node_modules", ".next", "dist", "build", "coverage", ".venv", "venv",
   "Pods", "DerivedData", ".gradle", ".idea", ".cache", ".turbo", "target", "obj",
-  ".ues-work", ".ues-learning", ".ues-memory", ".ues-dashboard", ".ues-sandboxes", ".ues-cache", ".ues-traces", ".ues-services",
+  ...UES_RUNTIME_DIRS,
 ])
 const STOP_IDENTIFIERS = new Set([
   "const","let","var","function","class","interface","type","export","import","from","return",
@@ -45,6 +46,28 @@ async function atomicJson(file, value) {
   }
 }
 
+function indexIoConcurrency(value) {
+  const fallback = process.platform === "win32" ? 12 : 16
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback
+  return Math.max(1, Math.min(32, Math.trunc(parsed)))
+}
+
+async function mapLimit(items, limit, worker) {
+  if (!items.length) return []
+  const results = new Array(items.length)
+  let next = 0
+  const runners = Array.from({ length: Math.min(Math.max(1, limit), items.length) }, async () => {
+    while (true) {
+      const index = next++
+      if (index >= items.length) return
+      results[index] = await worker(items[index], index)
+    }
+  })
+  await Promise.all(runners)
+  return results
+}
+
 async function walk(root, options = {}) {
   const maxFiles = Math.max(100, Number(options.maxFiles || 6000))
   const maxDepth = Math.max(2, Number(options.maxDepth || 14))
@@ -164,32 +187,55 @@ export async function buildSemanticIndex(root = process.cwd(), options = {}) {
   let reparsed = 0
   let skippedLarge = 0
   const maxFileBytes = Math.max(64 * 1024, Number(options.maxFileBytes || 1024 * 1024))
+  const ioConcurrency = indexIoConcurrency(options.ioConcurrency)
 
-  for (const full of discovered.files) {
+  const indexed = await mapLimit(discovered.files, ioConcurrency, async (full) => {
     const info = await stat(full).catch(() => null)
-    if (!info?.isFile()) continue
+    if (!info?.isFile()) return null
     const relative = rel(root, full)
     const signature = info.size + ":" + Math.trunc(info.mtimeMs)
     const old = previous?.files?.[relative]
+    const tooLarge = info.size > maxFileBytes
+
+    // Reuse only when the current size policy makes the same parse/skip choice.
     if (old?.signature === signature) {
-      nextFiles[relative] = old
-      reused += 1
-      continue
+      const wasTooLarge = old?.skipped === "too-large"
+      if (wasTooLarge === tooLarge) {
+        return { relative, entry: old, outcome: "reused" }
+      }
     }
-    if (info.size > maxFileBytes) {
-      nextFiles[relative] = { signature, bytes: info.size, skipped: "too-large", symbols: [], identifiers: {} }
-      skippedLarge += 1
-      continue
+
+    if (tooLarge) {
+      return {
+        relative,
+        entry: { signature, bytes: info.size, skipped: "too-large", symbols: [], identifiers: {} },
+        outcome: "skipped-large",
+      }
     }
+
     const source = await readFile(full, "utf8").catch(() => "")
-    const parsed = source ? parseSource(source, path.extname(relative).toLowerCase()) : { symbols: [], identifiers: {} }
-    nextFiles[relative] = {
-      signature,
-      bytes: info.size,
-      symbols: parsed.symbols,
-      identifiers: parsed.identifiers,
+    const parsed = source
+      ? parseSource(source, path.extname(relative).toLowerCase())
+      : { symbols: [], identifiers: {} }
+    return {
+      relative,
+      entry: {
+        signature,
+        bytes: info.size,
+        symbols: parsed.symbols,
+        identifiers: parsed.identifiers,
+      },
+      outcome: "reparsed",
     }
-    reparsed += 1
+  })
+
+  // Keep cache JSON deterministic even though file I/O is concurrent.
+  for (const row of indexed) {
+    if (!row) continue
+    nextFiles[row.relative] = row.entry
+    if (row.outcome === "reused") reused += 1
+    else if (row.outcome === "skipped-large") skippedLarge += 1
+    else reparsed += 1
   }
 
   const removed = previous
@@ -217,6 +263,7 @@ export async function buildSemanticIndex(root = process.cwd(), options = {}) {
       truncated: discovered.truncated,
       cacheFile: rel(root, cachePath(root)),
       durationMs: Date.now() - started,
+      ioConcurrency,
     },
   }
 }
@@ -323,14 +370,15 @@ const RUNTIME_SEMANTIC_INFLIGHT = new Map()
 export async function buildSemanticIndexCached(root = process.cwd(), options = {}) {
   root = path.resolve(root)
   const fingerprint = String(options.workspaceFingerprint || "")
-  if (!fingerprint || fingerprint === "unknown") {
-    return buildSemanticIndex(root, options)
+  if (!fingerprint || fingerprint === "unknown" || options.rebuild === true) {
+    const value = await buildSemanticIndex(root, options)
+    return { ...value, runtimeCacheHit: false }
   }
 
   const maxFiles = Number(options.maxFiles ?? 6000)
   const maxDepth = Number(options.maxDepth ?? 14)
-  const maxBytes = Number(options.maxBytes ?? 768 * 1024)
-  const key = [root, fingerprint, maxFiles, maxDepth, maxBytes].join("\u0000")
+  const maxFileBytes = Math.max(64 * 1024, Number(options.maxFileBytes ?? 1024 * 1024))
+  const key = [root, fingerprint, maxFiles, maxDepth, maxFileBytes].join("\u0000")
   if (RUNTIME_SEMANTIC_CACHE.has(key)) {
     const value = RUNTIME_SEMANTIC_CACHE.get(key)
     RUNTIME_SEMANTIC_CACHE.delete(key)