dsh-vision-router 2.0.0 → 2.1.0

package/lib/artifact-io.js

@@ -0,0 +1,220 @@
+import { randomUUID } from 'node:crypto'
+import { lstat, mkdir, realpath, rename, unlink, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import {
+  currentVisionTurnBudget,
+  currentVisionTurnBudgetSignal,
+} from './turn-budget-context.js'
+import {
+  isManagedArtifactRunName,
+  scheduleArtifactRetention,
+} from './artifact-retention.js'
+
+export const DEFAULT_ARTIFACTS_DIR = '.dsh-vision-router/artifacts'
+export const ARTIFACT_RUNS_DIR = '.runs'
+
+function isPathInside(root, candidate) {
+  const relative = path.relative(root, candidate)
+  return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative))
+}
+
+function isMissing(error) {
+  return error && (error.code === 'ENOENT' || error.code === 'ENOTDIR')
+}
+
+function artifactAbortError() {
+  const error = new Error('vision-router: artifact publication aborted')
+  error.name = 'AbortError'
+  error.code = 'ABORT_ERR'
+  return error
+}
+
+function throwIfVisionAborted() {
+  if (currentVisionTurnBudgetSignal()?.aborted) throw artifactAbortError()
+}
+
+function currentArtifactRunId() {
+  const value = currentVisionTurnBudget()?.artifactRunId
+  return isManagedArtifactRunName(value) ? value : undefined
+}
+
+export function normalizeArtifactsDir(value) {
+  if (typeof value !== 'string' || value.trim() === '') return DEFAULT_ARTIFACTS_DIR
+  const raw = value.trim()
+  if (path.isAbsolute(raw) || path.win32.isAbsolute(raw)) return DEFAULT_ARTIFACTS_DIR
+  const parts = raw.split(/[\\/]+/)
+  if (parts.some((part) => part === '..')) return DEFAULT_ARTIFACTS_DIR
+  const normalized = path.normalize(raw)
+  if (normalized === '' || normalized === '.' || normalized === path.sep) return DEFAULT_ARTIFACTS_DIR
+  return normalized
+}
+
+function normalizeRelativeArtifactPath(value) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error('vision-router: artifact path must be a non-empty relative path')
+  }
+  const raw = value.trim()
+  if (path.isAbsolute(raw) || path.win32.isAbsolute(raw)) {
+    throw new Error('vision-router: artifact path must stay inside the artifacts directory')
+  }
+  const parts = raw.split(/[\\/]+/)
+  if (parts.some((part) => part === '..')) {
+    throw new Error('vision-router: artifact path must stay inside the artifacts directory')
+  }
+  const normalized = path.normalize(raw)
+  if (normalized === '' || normalized === '.' || normalized === path.sep) {
+    throw new Error('vision-router: artifact path must name a file')
+  }
+  return normalized
+}
+
+async function realpathNearestExisting(candidate, realpathImpl) {
+  let current = candidate
+  while (true) {
+    try {
+      return await realpathImpl(current)
+    } catch (error) {
+      if (!isMissing(error)) throw error
+      const parent = path.dirname(current)
+      if (parent === current) throw error
+      current = parent
+    }
+  }
+}
+
+async function safeLstat(target, lstatImpl) {
+  try {
+    return await lstatImpl(target)
+  } catch (error) {
+    if (isMissing(error)) return undefined
+    throw error
+  }
+}
+
+/**
+ * Hardened artifact target primitive below VisionArtifactStore.
+ *
+ * P2-B gives managed tool-run artifacts their own `.runs/` namespace. The
+ * namespace is treated as infrastructure, not user-controlled path data: an
+ * existing symlink is rejected even when it points somewhere else inside the
+ * workspace. Artifacts outside a managed run keep their original root layout.
+ */
+export async function resolveArtifactTarget(workspace, artifactsDir, relativePath, deps = {}) {
+  const realpathImpl = deps.realpath ?? realpath
+  const mkdirImpl = deps.mkdir ?? mkdir
+  const lstatImpl = deps.lstat ?? lstat
+
+  throwIfVisionAborted()
+  const workspaceReal = await realpathImpl(path.resolve(String(workspace ?? '')))
+  throwIfVisionAborted()
+  const relativeBase = normalizeArtifactsDir(artifactsDir)
+  const runId = currentArtifactRunId()
+  const requestedTarget = normalizeRelativeArtifactPath(relativePath)
+  const relativeTarget = runId
+    ? normalizeRelativeArtifactPath(path.join(ARTIFACT_RUNS_DIR, runId, requestedTarget))
+    : requestedTarget
+  const lexicalBase = path.resolve(workspaceReal, relativeBase)
+  if (!isPathInside(workspaceReal, lexicalBase)) {
+    throw new Error('vision-router: artifactsDir must stay inside the session workspace')
+  }
+
+  const lexicalRunsBase = runId ? path.resolve(lexicalBase, ARTIFACT_RUNS_DIR) : undefined
+  if (lexicalRunsBase && !isPathInside(lexicalBase, lexicalRunsBase)) {
+    throw new Error('vision-router: managed artifact runs must stay inside the artifacts directory')
+  }
+  if (lexicalRunsBase) {
+    const before = await safeLstat(lexicalRunsBase, lstatImpl)
+    throwIfVisionAborted()
+    if (before?.isSymbolicLink?.()) {
+      throw new Error('vision-router: managed artifact runs directory must not be a symlink')
+    }
+    if (before !== undefined && !before.isDirectory?.()) {
+      throw new Error('vision-router: managed artifact runs path must be a directory')
+    }
+  }
+
+  const lexicalTarget = path.resolve(lexicalBase, relativeTarget)
+  if (!isPathInside(lexicalBase, lexicalTarget)) {
+    throw new Error('vision-router: artifact target must stay inside the artifacts directory')
+  }
+
+  const lexicalParent = path.dirname(lexicalTarget)
+  const existingAncestorReal = await realpathNearestExisting(lexicalParent, realpathImpl)
+  throwIfVisionAborted()
+  if (!isPathInside(workspaceReal, existingAncestorReal)) {
+    throw new Error('vision-router: artifact parent escapes the session workspace through a symlink')
+  }
+
+  await mkdirImpl(lexicalParent, { recursive: true })
+  throwIfVisionAborted()
+  const parentReal = await realpathImpl(lexicalParent)
+  const artifactsBaseReal = await realpathImpl(lexicalBase)
+  throwIfVisionAborted()
+  if (!isPathInside(workspaceReal, parentReal) || !isPathInside(workspaceReal, artifactsBaseReal)) {
+    throw new Error('vision-router: artifact parent escapes the session workspace through a symlink')
+  }
+
+  let runsBaseReal
+  if (lexicalRunsBase) {
+    const after = await safeLstat(lexicalRunsBase, lstatImpl)
+    throwIfVisionAborted()
+    if (!after?.isDirectory?.() || after.isSymbolicLink?.()) {
+      throw new Error('vision-router: managed artifact runs directory must be a real directory')
+    }
+    runsBaseReal = await realpathImpl(lexicalRunsBase)
+    throwIfVisionAborted()
+    if (!isPathInside(artifactsBaseReal, runsBaseReal)) {
+      throw new Error('vision-router: managed artifact runs directory escapes the artifacts directory')
+    }
+  }
+
+  const target = path.join(parentReal, path.basename(lexicalTarget))
+  const existing = await safeLstat(target, lstatImpl)
+  throwIfVisionAborted()
+  if (existing?.isDirectory?.()) {
+    throw new Error('vision-router: artifact target is a directory')
+  }
+  return { target, parentReal, artifactsBaseReal, runsBaseReal, existing, runId }
+}
+
+/** Hardened atomic publication primitive used by VisionArtifactStore. */
+export async function writeArtifactFile(workspace, artifactsDir, relativePath, data, deps = {}) {
+  const writeFileImpl = deps.writeFile ?? writeFile
+  const renameImpl = deps.rename ?? rename
+  const unlinkImpl = deps.unlink ?? unlink
+  const resolved = await resolveArtifactTarget(workspace, artifactsDir, relativePath, deps)
+  const temp = path.join(
+    resolved.parentReal,
+    `.dsh-vision-router-${process.pid}-${randomUUID()}.tmp`,
+  )
+  let published = false
+  try {
+    throwIfVisionAborted()
+    await writeFileImpl(temp, data, { mode: 0o600 })
+    throwIfVisionAborted()
+    if (resolved.existing !== undefined) {
+      try {
+        await unlinkImpl(resolved.target)
+      } catch (error) {
+        if (!isMissing(error)) throw error
+      }
+      throwIfVisionAborted()
+    }
+    await renameImpl(temp, resolved.target)
+    published = true
+    if (resolved.runId) {
+      // New managed runs live under `.runs`, so retention scans that directory
+      // directly. Also schedule the old artifact root so pre-P2-B direct
+      // `.vision-run-*` directories continue to age out safely.
+      if (resolved.runsBaseReal) {
+        scheduleArtifactRetention(resolved.runsBaseReal, { protectRunId: resolved.runId })
+      }
+      scheduleArtifactRetention(resolved.artifactsBaseReal, { protectRunId: resolved.runId })
+    }
+    return resolved.target
+  } finally {
+    if (!published) {
+      try { await unlinkImpl(temp) } catch { /* best effort */ }
+    }
+  }
+}

package/lib/artifact-retention.js

@@ -1,4 +1,4 @@
-import { lstat, readdir, rm } from 'node:fs/promises'
+import { lstat, opendir, rm } from 'node:fs/promises'
 import path from 'node:path'
 
 export const ARTIFACT_RUN_PREFIX = '.vision-run-'
@@ -6,26 +6,30 @@ export const DEFAULT_ARTIFACT_TTL_MS = 30 * 24 * 60 * 60 * 1000
 export const DEFAULT_ARTIFACT_MAX_BYTES = 2 * 1024 * 1024 * 1024
 export const DEFAULT_ARTIFACT_MAX_RUNS = 512
 export const DEFAULT_ARTIFACT_CLEANUP_INTERVAL_MS = 5 * 60 * 1000
+export const DEFAULT_ARTIFACT_SCAN_MAX_ENTRIES = 8_192
+export const DEFAULT_ARTIFACT_SCAN_MAX_DEPTH = 32
+export const DEFAULT_ARTIFACT_SCAN_MAX_MS = 2_000
 
 const cleanupState = new Map()
+const activeArtifactRuns = new Map()
 const MAX_TRACKED_ROOTS = 64
 
 export function isManagedArtifactRunName(name) {
   return typeof name === 'string' && /^\.vision-run-[A-Za-z0-9._-]+$/.test(name)
 }
 
-async function treeBytes(target) {
-  let info
-  try { info = await lstat(target) } catch { return 0 }
-  if (info.isSymbolicLink()) return 0
-  if (!info.isDirectory()) return Number(info.size) || 0
-  let total = 0
-  let entries
-  try { entries = await readdir(target, { withFileTypes: true }) } catch { return 0 }
-  for (const entry of entries) {
-    total += await treeBytes(path.join(target, entry.name))
+/** Keep one run protected for the entire vision-tool lifetime. */
+export function retainArtifactRun(runId) {
+  if (!isManagedArtifactRunName(runId)) return () => {}
+  activeArtifactRuns.set(runId, (activeArtifactRuns.get(runId) ?? 0) + 1)
+  let released = false
+  return () => {
+    if (released) return
+    released = true
+    const remaining = (activeArtifactRuns.get(runId) ?? 1) - 1
+    if (remaining <= 0) activeArtifactRuns.delete(runId)
+    else activeArtifactRuns.set(runId, remaining)
   }
-  return total
 }
 
 function finitePositive(value, fallback) {
@@ -33,69 +37,307 @@ function finitePositive(value, fallback) {
   return Number.isFinite(number) && number > 0 ? number : fallback
 }
 
+function finitePositiveInteger(value, fallback) {
+  return Math.max(1, Math.floor(finitePositive(value, fallback)))
+}
+
+function createScanBudget({ maxEntries, maxDepth, maxMs, clock }) {
+  const startedAt = Number(clock())
+  return {
+    maxEntries: finitePositiveInteger(maxEntries, DEFAULT_ARTIFACT_SCAN_MAX_ENTRIES),
+    maxDepth: finitePositiveInteger(maxDepth, DEFAULT_ARTIFACT_SCAN_MAX_DEPTH),
+    maxMs: finitePositive(maxMs, DEFAULT_ARTIFACT_SCAN_MAX_MS),
+    clock,
+    startedAt: Number.isFinite(startedAt) ? startedAt : Date.now(),
+    entries: 0,
+    limited: false,
+    exhausted: false,
+  }
+}
+
+function createScanBudgets(options = {}) {
+  const clock = typeof options.scanClock === 'function' ? options.scanClock : Date.now
+  return {
+    discovery: createScanBudget({
+      maxEntries: options.maxDiscoveryEntries ?? options.maxScanEntries,
+      maxDepth: 1,
+      maxMs: options.maxDiscoveryMs ?? options.maxScanMs,
+      clock,
+    }),
+    measurement: createScanBudget({
+      maxEntries: options.maxScanEntries,
+      maxDepth: options.maxScanDepth,
+      maxMs: options.maxScanMs,
+      clock,
+    }),
+  }
+}
+
+function scanTimedOut(budget) {
+  const current = Number(budget.clock())
+  if (!Number.isFinite(current)) return false
+  return current - budget.startedAt >= budget.maxMs
+}
+
+function admitScanEntry(budget) {
+  if (budget.exhausted) return false
+  if (budget.entries >= budget.maxEntries || scanTimedOut(budget)) {
+    budget.exhausted = true
+    budget.limited = true
+    return false
+  }
+  budget.entries += 1
+  return true
+}
+
+function protectedRunSet(options = {}) {
+  const shared = options.protectRunIds instanceof Set
+    ? options.protectRunIds
+    : new Set(Array.isArray(options.protectRunIds) ? options.protectRunIds : [])
+  if (isManagedArtifactRunName(options.protectRunId)) shared.add(options.protectRunId)
+  return shared
+}
+
+function runProtected(name, protectedRuns) {
+  return protectedRuns.has(name) || activeArtifactRuns.has(name)
+}
+
+async function collectManagedRuns(root, budget) {
+  let directory
+  try {
+    directory = await opendir(root)
+  } catch (error) {
+    const missing = error?.code === 'ENOENT' || error?.code === 'ENOTDIR'
+    if (!missing) budget.limited = true
+    return { runs: [], complete: missing }
+  }
+  const runs = []
+  let complete = true
+  try {
+    for await (const entry of directory) {
+      if (!admitScanEntry(budget)) {
+        complete = false
+        break
+      }
+      if (!entry.isDirectory() || !isManagedArtifactRunName(entry.name)) continue
+      const target = path.join(root, entry.name)
+      let info
+      try {
+        info = await lstat(target)
+      } catch {
+        budget.limited = true
+        complete = false
+        continue
+      }
+      if (!info.isDirectory() || info.isSymbolicLink()) continue
+      runs.push({
+        name: entry.name,
+        target,
+        mtimeMs: Number(info.mtimeMs) || 0,
+        bytes: 0,
+        scanComplete: false,
+      })
+    }
+  } catch {
+    budget.limited = true
+    complete = false
+  }
+  return { runs, complete }
+}
+
+/**
+ * Measure one managed run with a bounded streaming traversal. `complete=false`
+ * means the size is unknown; callers must never reinterpret uncertainty as
+ * evidence that destructive byte eviction is safe.
+ */
+async function treeBytesBounded(target, budget, byteCeiling) {
+  const stack = [{ target, depth: 0 }]
+  let total = 0
+  let complete = true
+
+  while (stack.length > 0) {
+    if (budget.exhausted || scanTimedOut(budget)) {
+      budget.exhausted = true
+      budget.limited = true
+      return { bytes: total, complete: false }
+    }
+    const current = stack.pop()
+    let directory
+    try {
+      directory = await opendir(current.target)
+    } catch {
+      budget.limited = true
+      return { bytes: total, complete: false }
+    }
+
+    try {
+      for await (const entry of directory) {
+        if (!admitScanEntry(budget)) return { bytes: total, complete: false }
+        if (entry.isSymbolicLink()) continue
+        const child = path.join(current.target, entry.name)
+        let info
+        try {
+          info = await lstat(child)
+        } catch {
+          budget.limited = true
+          complete = false
+          continue
+        }
+        if (info.isSymbolicLink()) continue
+        if (info.isDirectory()) {
+          const nextDepth = current.depth + 1
+          if (nextDepth > budget.maxDepth) {
+            complete = false
+            budget.limited = true
+            continue
+          }
+          stack.push({ target: child, depth: nextDepth })
+          continue
+        }
+        total += Math.max(0, Number(info.size) || 0)
+        if (total > byteCeiling) {
+          return { bytes: byteCeiling + 1, complete: true, saturated: true }
+        }
+      }
+    } catch {
+      complete = false
+      budget.limited = true
+    }
+  }
+
+  return { bytes: total, complete }
+}
+
+function cleanupResult(scanned, removed, bytes, scan, includeScanDiagnostics) {
+  const result = { scanned, removed, bytes: Math.max(0, bytes) }
+  if (includeScanDiagnostics === true) {
+    result.scan = {
+      entries: scan.discovery.entries + scan.measurement.entries,
+      limited: scan.discovery.limited === true || scan.measurement.limited === true,
+      exhausted: scan.discovery.exhausted === true || scan.measurement.exhausted === true,
+      discoveryEntries: scan.discovery.entries,
+      measurementEntries: scan.measurement.entries,
+      discoveryComplete: scan.discoveryComplete === true,
+      bytesComplete: scan.bytesComplete === true,
+    }
+  }
+  return result
+}
+
 /**
  * Delete only Vision Router run directories. Unknown files, legacy artifacts,
  * symlinks and user-created directories are intentionally outside this policy.
+ *
+ * TTL can act on each discovered run independently. maxRuns and maxBytes are
+ * global policies, so they run only when discovery is complete; byte eviction
+ * additionally requires every surviving run size to be known. Uncertainty is
+ * therefore fail-safe for user data rather than being treated as over-budget.
  */
 export async function cleanupArtifactRuns(root, options = {}) {
   const ttlMs = finitePositive(options.ttlMs, DEFAULT_ARTIFACT_TTL_MS)
   const maxBytes = finitePositive(options.maxBytes, DEFAULT_ARTIFACT_MAX_BYTES)
-  const maxRuns = Math.max(1, Math.floor(finitePositive(options.maxRuns, DEFAULT_ARTIFACT_MAX_RUNS)))
+  const maxRuns = finitePositiveInteger(options.maxRuns, DEFAULT_ARTIFACT_MAX_RUNS)
   const now = Number.isFinite(Number(options.now)) ? Number(options.now) : Date.now()
-  const protect = typeof options.protectRunId === 'string' ? options.protectRunId : undefined
+  const protectedRuns = protectedRunSet(options)
+  const budgets = createScanBudgets(options)
 
-  let entries
-  try { entries = await readdir(root, { withFileTypes: true }) } catch { return { scanned: 0, removed: 0, bytes: 0 } }
-  const runs = []
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !isManagedArtifactRunName(entry.name)) continue
-    const target = path.join(root, entry.name)
-    let info
-    try { info = await lstat(target) } catch { continue }
-    if (!info.isDirectory() || info.isSymbolicLink()) continue
-    runs.push({
-      name: entry.name,
-      target,
-      mtimeMs: Number(info.mtimeMs) || 0,
-      bytes: await treeBytes(target),
-      protected: entry.name === protect,
-    })
+  const discovery = await collectManagedRuns(root, budgets.discovery)
+  const runs = discovery.runs
+  let bytesComplete = discovery.complete
+  if (runs.length === 0) {
+    return cleanupResult(0, 0, 0, {
+      ...budgets,
+      discoveryComplete: discovery.complete,
+      bytesComplete,
+    }, options.includeScanDiagnostics)
   }
 
   runs.sort((a, b) => b.mtimeMs - a.mtimeMs)
   const remove = new Set()
+  const byteEvictions = new Set()
   for (const run of runs) {
-    if (!run.protected && now - run.mtimeMs >= ttlMs) remove.add(run)
+    if (!runProtected(run.name, protectedRuns) && now - run.mtimeMs >= ttlMs) remove.add(run)
   }
 
   const survivors = () => runs.filter((run) => !remove.has(run))
   let live = survivors()
-  while (live.length > maxRuns) {
-    const candidate = [...live].reverse().find((run) => !run.protected)
-    if (!candidate) break
-    remove.add(candidate)
-    live = survivors()
+  if (discovery.complete) {
+    while (live.length > maxRuns) {
+      const candidate = [...live].reverse().find((run) => !runProtected(run.name, protectedRuns))
+      if (!candidate) break
+      remove.add(candidate)
+      live = survivors()
+    }
   }
 
-  let totalBytes = live.reduce((sum, run) => sum + run.bytes, 0)
-  while (totalBytes > maxBytes) {
-    const candidate = [...live].reverse().find((run) => !run.protected)
-    if (!candidate) break
-    remove.add(candidate)
-    totalBytes -= candidate.bytes
-    live = survivors()
+  let totalBytes = 0
+  if (discovery.complete) {
+    for (const run of live) {
+      const measured = await treeBytesBounded(run.target, budgets.measurement, maxBytes)
+      run.bytes = measured.bytes
+      run.scanComplete = measured.complete === true
+      if (!run.scanComplete) bytesComplete = false
+    }
+    totalBytes = live.reduce((sum, run) => sum + run.bytes, 0)
+
+    if (bytesComplete) {
+      while (totalBytes > maxBytes) {
+        const candidate = [...live].reverse().find((run) => !runProtected(run.name, protectedRuns))
+        if (!candidate) break
+        remove.add(candidate)
+        byteEvictions.add(candidate)
+        totalBytes -= candidate.bytes
+        live = survivors()
+      }
+    }
   }
 
   let removed = 0
   for (const run of remove) {
+    // Protection is checked again immediately before deletion so a concurrent
+    // tool that became active after cleanup started cannot lose its run.
+    if (runProtected(run.name, protectedRuns)) {
+      if (byteEvictions.has(run)) totalBytes += run.bytes
+      else bytesComplete = false
+      continue
+    }
     try {
       await rm(run.target, { recursive: true, force: true })
       removed += 1
     } catch {
+      if (byteEvictions.has(run)) totalBytes += run.bytes
+      else bytesComplete = false
       // Retention is best-effort and must never make the foreground tool fail.
     }
   }
-  return { scanned: runs.length, removed, bytes: Math.max(0, totalBytes) }
+
+  return cleanupResult(runs.length, removed, totalBytes, {
+    ...budgets,
+    discoveryComplete: discovery.complete,
+    bytesComplete,
+  }, options.includeScanDiagnostics)
+}
+
+function addScheduledProtection(state, options = {}) {
+  if (isManagedArtifactRunName(options.protectRunId)) state.protectedRunIds.add(options.protectRunId)
+  if (options.protectRunIds instanceof Set || Array.isArray(options.protectRunIds)) {
+    for (const runId of options.protectRunIds) {
+      if (isManagedArtifactRunName(runId)) state.protectedRunIds.add(runId)
+    }
+  }
+}
+
+function trimCleanupState() {
+  while (cleanupState.size > MAX_TRACKED_ROOTS) {
+    let evicted
+    for (const [root, state] of cleanupState) {
+      if (state.promise) continue
+      evicted = root
+      break
+    }
+    if (evicted === undefined) break
+    cleanupState.delete(evicted)
+  }
 }
 
 /** Coalesce cleanup work per artifact root so foreground tools only schedule it. */
@@ -104,21 +346,31 @@ export function scheduleArtifactRetention(root, options = {}) {
   const now = Date.now()
   let state = cleanupState.get(root)
   if (!state) {
-    state = { lastStartedAt: 0, promise: undefined }
+    state = { lastStartedAt: 0, promise: undefined, protectedRunIds: new Set() }
     cleanupState.set(root, state)
   }
+
+  if (state.promise) {
+    addScheduledProtection(state, options)
+    return
+  }
+
   const intervalMs = finitePositive(options.intervalMs, DEFAULT_ARTIFACT_CLEANUP_INTERVAL_MS)
-  if (state.promise || now - state.lastStartedAt < intervalMs) return
+  if (now - state.lastStartedAt < intervalMs) return
+
+  addScheduledProtection(state, options)
   state.lastStartedAt = now
-  state.promise = cleanupArtifactRuns(root, options)
+  state.promise = cleanupArtifactRuns(root, {
+    ...options,
+    protectRunIds: state.protectedRunIds,
+  })
     .catch(() => undefined)
-    .finally(() => { state.promise = undefined })
+    .finally(() => {
+      state.promise = undefined
+      state.protectedRunIds.clear()
+    })
 
   cleanupState.delete(root)
   cleanupState.set(root, state)
-  while (cleanupState.size > MAX_TRACKED_ROOTS) {
-    const oldest = cleanupState.keys().next().value
-    if (oldest === undefined) break
-    cleanupState.delete(oldest)
-  }
+  trimCleanupState()
 }

package/lib/catalog-corrections.js

@@ -15,6 +15,7 @@ import {
   readResponseTextBounded,
 } from './http-body-limit.js'
 import { stripTrailingSlashes } from './string-normalization.js'
+import { currentVisionProviderTransport } from './vision-provider-transport.js'
 
 export const CATALOG_ROUTING_CORRECTIONS = [
   {
@@ -254,7 +255,11 @@ export async function callAnthropicCompatible(provider, messages, options = {})
   const url = `${stripTrailingSlashes(provider.baseURL)}/v1/messages`
   let response
   try {
-    response = await fetch(url, {
+    const transport = currentVisionProviderTransport()
+    const requestFetch = transport
+      ? (input, init) => transport.fetch(input, init, { providerName: provider.name, allowProxy: true })
+      : fetch
+    response = await requestFetch(url, {
       method: 'POST',
       headers,
       body: JSON.stringify(system === undefined ? body : { ...body, system }),