dsh-vision-router 2.1.3 → 2.1.4

package/lib/session-affinity.js

@@ -0,0 +1,93 @@
+const MAX_SESSION_AFFINITY_ID_LENGTH = 512
+
+/** Preserve DSH's in-process session identity exactly; no wire rules belong here. */
+export function rawSessionIdentity(value) {
+  if (value === undefined || value === null) return undefined
+  try {
+    return String(value)
+  } catch {
+    return undefined
+  }
+}
+
+/** Read the live DSH session id across released/alpha session shapes without rewriting it. */
+export function sessionIdentityOf(session) {
+  if (!session) return undefined
+  try {
+    const direct = rawSessionIdentity(session.id)
+    if (direct !== undefined) return direct
+  } catch {
+    /* continue to persisted/header shapes */
+  }
+  try {
+    const header = rawSessionIdentity(session.header?.id)
+    if (header !== undefined) return header
+  } catch {
+    /* continue to requestHeader() */
+  }
+  try {
+    if (typeof session.requestHeader === 'function') {
+      return rawSessionIdentity(session.requestHeader()?.id)
+    }
+  } catch {
+    /* no usable session identity */
+  }
+  return undefined
+}
+
+/**
+ * Admit an opaque identity to an HTTP header without changing it. Fetch/undici
+ * requires ByteString-compatible header values; use visible ASCII so behavior
+ * is identical across Node 22/24 and HTTP implementations. Leading/trailing
+ * whitespace is rejected because Headers would normalize it, violating the
+ * requirement to preserve the DSH identity unchanged.
+ */
+export function wireSessionAffinityId(value) {
+  const text = rawSessionIdentity(value)
+  if (text === undefined || text === '' || text.length > MAX_SESSION_AFFINITY_ID_LENGTH) return undefined
+  if (text.trim() !== text) return undefined
+  if (!/^[\x21-\x7e](?:[\x20-\x7e]*[\x21-\x7e])?$/.test(text)) return undefined
+  return text
+}
+
+export function isOfficialOpenCodeGoUrl(value) {
+  try {
+    const url = new URL(String(value))
+    return (
+      url.protocol === 'https:' &&
+      url.hostname.toLowerCase() === 'opencode.ai' &&
+      /^\/zen\/go(?:\/|$)/i.test(url.pathname)
+    )
+  } catch {
+    return false
+  }
+}
+
+export function isOpenCodeGoProvider(provider) {
+  return isOfficialOpenCodeGoUrl(provider?.baseURL ?? provider?.baseUrl ?? '')
+}
+
+function invalidAffinityError(sessionId) {
+  const raw = rawSessionIdentity(sessionId)
+  const error = new Error(
+    raw === undefined || raw === ''
+      ? 'OpenCode Go requires a stable session identity; refusing a direct request without one'
+      : 'OpenCode Go session identity is not safe for an HTTP header; refusing to rewrite or truncate it',
+  )
+  error.code = raw === undefined || raw === '' ? 'OPENCODE_SESSION_REQUIRED' : 'OPENCODE_SESSION_INVALID'
+  return error
+}
+
+export function directSessionAffinityHeaders(provider, sessionId) {
+  if (!isOpenCodeGoProvider(provider)) return {}
+  const wire = wireSessionAffinityId(sessionId)
+  if (wire === undefined) throw invalidAffinityError(sessionId)
+  return { 'x-opencode-session': wire }
+}
+
+export function openCodeSessionAffinityHeaderForUrl(url, sessionId) {
+  if (!isOfficialOpenCodeGoUrl(url)) return undefined
+  const wire = wireSessionAffinityId(sessionId)
+  if (wire === undefined) throw invalidAffinityError(sessionId)
+  return wire
+}

package/lib/tesseract-exec-compat.js

@@ -4,7 +4,6 @@ import { tmpdir } from 'node:os'
 import { createRequire, syncBuiltinESMExports } from 'node:module'
 import { promisify } from 'node:util'
 
-import { rewriteWindowsScreenshotExecArgs } from './windows-screenshot-dpi-compat.js'
 
 const require = createRequire(import.meta.url)
 const childProcess = require('node:child_process')
@@ -127,38 +126,12 @@ export function createTesseractPromisifyCompat(execFileImpl, originalCustom, opt
 }
 
 /**
- * Compose every Vision Router execFile compatibility transform behind ONE
- * promisify.custom function. The screenshot transform changes only the exact
- * legacy Windows VirtualScreen/CopyFromScreen invocation emitted by core;
- * every other child-process call remains byte-for-byte delegated.
+ * Historical public helper name retained for compatibility. Screenshot capture
+ * no longer participates in this process-wide seam (#409); only the Tesseract
+ * stdin compatibility behavior remains.
  */
 export function createVisionRouterExecFilePromisifyCompat(execFileImpl, originalCustom, options = {}) {
-  const tesseractCompat = createTesseractPromisifyCompat(execFileImpl, originalCustom, options)
-  let active = true
-
-  async function visionRouterExecFilePromisifyCompat(file, args, execOptions) {
-    if (!active) return tesseractCompat(file, args, execOptions)
-    const rewrittenArgs = rewriteWindowsScreenshotExecArgs(file, args, {
-      platform: options.platform ?? (typeof process !== 'undefined' ? process.platform : ''),
-    })
-    return tesseractCompat(file, rewrittenArgs, execOptions)
-  }
-
-  Object.defineProperty(visionRouterExecFilePromisifyCompat, 'deactivate', {
-    configurable: false,
-    enumerable: false,
-    value() {
-      active = false
-      tesseractCompat.deactivate?.()
-    },
-  })
-  Object.defineProperty(visionRouterExecFilePromisifyCompat, 'active', {
-    configurable: false,
-    enumerable: false,
-    get() { return active },
-  })
-
-  return visionRouterExecFilePromisifyCompat
+  return createTesseractPromisifyCompat(execFileImpl, originalCustom, options)
 }
 
 function canReplaceCustomPromisify(execFileImpl) {
@@ -207,7 +180,7 @@ function syncIfBuiltin(moduleObject) {
 function warnInstallDegraded(ctx, reason) {
   try {
     ctx?.logger?.warn?.(
-      'vision-router: execFile compatibility could not be installed (%s); continuing without local OCR / Windows DPI capture shims',
+      'vision-router: execFile compatibility could not be installed (%s); continuing without local OCR stdin compatibility',
       reason,
     )
   } catch {
@@ -216,10 +189,10 @@ function warnInstallDegraded(ctx, reason) {
 }
 
 /**
- * Install the single process-wide execFile compatibility boundary used by
- * Vision Router. The public runtime still calls the historical
- * installTesseractExecFileCompat alias; keeping one owner prevents cleanup
- * order bugs between independently stacked wrappers.
+ * Install the process-wide execFile compatibility boundary used only by the
+ * historical local Tesseract stdin path. Windows desktop capture is direct and
+ * intentionally independent of this lifecycle. The public runtime still calls
+ * the historical installTesseractExecFileCompat alias.
  */
 export function installVisionRouterExecFileCompat(ctx, options = {}) {
   const moduleObject = options.childProcessModule ?? childProcess

package/lib/vision-backend-runtime-policy.js

@@ -241,6 +241,7 @@ function directStream(ctx, core, plan, call, logger, source) {
           {
             maxTokens: call.maxTokens ?? 4096,
             signal: call.signal,
+            sessionId: call.sessionId,
             resolveCredential: async (ref) => ref === keyRef ? apiKey : undefined,
           },
         )

package/lib/vision-background-benchmark.js

@@ -7,15 +7,11 @@ import {
 } from './vision-capability-benchmark-service.js'
 import { withHardDeadline } from './vision-capability-benchmark-hardening.js'
 import { resolveVisionRoutingAuthority } from './vision-routing-authority.js'
-import { resolveVisionCredential } from './vision-capability-identity.js'
 import { redactDiagnosticText } from './diagnostic-redaction.js'
 import { injectVisionExactCheckClient } from './vision-exact-check-client.js'
 import { createImageInputVerdictStore } from './vision-image-input-verdict.js'
 import { createBackgroundBenchmarkStopStore } from './vision-background-stop-store.js'
-import {
-  backgroundFailurePolicy,
-  credentialFingerprintChanged,
-} from './vision-background-failure-policy.js'
+import { backgroundFailurePolicy } from './vision-background-failure-policy.js'
 import { isLocalUiRequest } from './web-capability-boundary.js'
 
 const FOREGROUND_VISION_TOOLS = new Set([
@@ -43,6 +39,11 @@ const MODEL_WIDE_NON_RETRYABLE_BACKGROUND_FAILURES = new Set([
   'protocol',
   'unavailable',
 ])
+const TRANSPORT_WIDE_BACKGROUND_FAILURES = new Set([
+  'auth',
+  'protocol',
+  'rate-limit',
+])
 const PERMANENT_MODEL_UNAVAILABLE_CODES = new Set([
   'MODEL_NOT_FOUND',
   'MODEL_DOES_NOT_EXIST',
@@ -145,6 +146,21 @@ function backoffKey(candidate, axis) {
   return `${candidate?.key ?? ''}\u0000${candidate?.endpointFingerprint ?? ''}\u0000${axis}`
 }
 
+function backgroundTransportScope(candidate) {
+  const provider = typeof candidate?.provider === 'string' ? candidate.provider.trim() : ''
+  const endpoint = normalizedEndpoint(candidate?.endpoint)
+  if (!provider || !endpoint) return undefined
+  const api = typeof candidate?.endpointConfig?.api === 'string' ? candidate.endpointConfig.api.trim().toLowerCase() : ''
+  const credentialRef = typeof candidate?.endpointCredentialRef === 'string' ? candidate.endpointCredentialRef.trim() : ''
+  return JSON.stringify([provider, endpoint, api, credentialRef])
+}
+
+function transportFailureScope(candidate, errorClass) {
+  return TRANSPORT_WIDE_BACKGROUND_FAILURES.has(errorClass)
+    ? backgroundTransportScope(candidate)
+    : undefined
+}
+
 function classifyUnavailable(value) {
   const status = Number(value?.status)
   const code = String(value?.code ?? '').toUpperCase()
@@ -192,26 +208,14 @@ function publicExcludedEntries(excluded) {
     .map((entry) => ({ key: entry.key, reason: entry.reason }))
 }
 
-async function candidateCredentialFingerprint(ctx, candidate) {
-  const ref = typeof candidate?.endpointCredentialRef === 'string'
-    ? candidate.endpointCredentialRef.trim()
-    : ''
-  if (!ref) return undefined
-  try {
-    return (await resolveVisionCredential(ctx, ref)).fingerprint
-  } catch {
-    return 'unresolved'
-  }
-}
 
-async function pruneBackoff(backoff, candidates, ctx, at) {
+async function pruneBackoff(backoff, candidates, _ctx, at) {
   const valid = new Set()
   const byKey = new Map()
   for (const candidate of candidates) {
     byKey.set(candidate.key, candidate)
     for (const axis of orderedAxes()) valid.add(backoffKey(candidate, axis))
   }
-  const credentialCache = new Map()
   for (const [key, entry] of backoff.entries()) {
     if (!valid.has(key)) {
       backoff.delete(key)
@@ -222,16 +226,11 @@ async function pruneBackoff(backoff, candidates, ctx, at) {
       backoff.delete(key)
       continue
     }
-    if (entry?.errorClass !== 'auth' || !entry.credentialFingerprint) continue
-    const candidate = byKey.get(entry.key)
-    if (!candidate) continue
-    let currentFingerprint = credentialCache.get(candidate.key)
-    if (currentFingerprint === undefined) {
-      currentFingerprint = await candidateCredentialFingerprint(ctx, candidate)
-      credentialCache.set(candidate.key, currentFingerprint ?? null)
-    }
-    if (credentialFingerprintChanged(entry.credentialFingerprint, currentFingerprint ?? undefined)) {
-      backoff.delete(key)
+    if (entry?.errorClass === 'auth') {
+      const currentRef = typeof byKey.get(entry.key)?.endpointCredentialRef === 'string'
+        ? byKey.get(entry.key).endpointCredentialRef.trim()
+        : ''
+      if ((entry.credentialRef ?? '') !== currentRef) backoff.delete(key)
     }
   }
 }
@@ -243,7 +242,6 @@ async function restorePersistentStops(backoff, candidates, backgroundStopStore,
   if (!Array.isArray(stops) || stops.length === 0) return
   const byKey = new Map(candidates.map((candidate) => [candidate.key, candidate]))
   const axes = new Set(orderedAxes())
-  const credentialCache = new Map()
   for (const stop of stops) {
     const candidate = byKey.get(stop?.key)
     if (!candidate || candidate.endpointFingerprint !== stop?.fingerprint || !axes.has(stop?.axis)) continue
@@ -251,24 +249,14 @@ async function restorePersistentStops(backoff, candidates, backgroundStopStore,
       try { await backgroundStopStore.clearStop?.(stop.fingerprint, stop.axis) } catch {}
       continue
     }
-    if (stop.errorClass === 'auth' && stop.credentialFingerprint) {
-      let currentFingerprint = credentialCache.get(candidate.key)
-      if (currentFingerprint === undefined) {
-        currentFingerprint = await candidateCredentialFingerprint(ctx, candidate)
-        credentialCache.set(candidate.key, currentFingerprint ?? null)
-      }
-      if (credentialFingerprintChanged(stop.credentialFingerprint, currentFingerprint ?? undefined)) {
-        try { await backgroundStopStore.clearStop?.(stop.fingerprint, stop.axis) } catch {}
-        continue
-      }
-    }
+    const transportScope = transportFailureScope(candidate, stop.errorClass)
     backoff.set(backoffKey(candidate, stop.axis), {
       key: candidate.key,
       fingerprint: candidate.endpointFingerprint,
       axis: stop.axis,
       errorClass: stop.errorClass,
       ...(stop.errorCode ? { errorCode: stop.errorCode } : {}),
-      ...(stop.credentialFingerprint ? { credentialFingerprint: stop.credentialFingerprint } : {}),
+      ...(transportScope ? { transportScope } : {}),
       retryable: false,
       until: Number(stop.expiresAt),
       persisted: true,
@@ -276,14 +264,26 @@ async function restorePersistentStops(backoff, candidates, backgroundStopStore,
   }
 }
 
-function candidateBlockedByNonRetryableFailure(backoff, candidate, at) {
+function candidateBlockedByFailure(backoff, candidate, at) {
   if (!candidate?.endpointFingerprint) return false
+  const transportScope = backgroundTransportScope(candidate)
   for (const entry of backoff.values()) {
-    if (entry?.retryable !== false) continue
     const until = Number(entry?.until)
     if (Number.isFinite(until) && until <= at) continue
-    if (entry?.key !== candidate.key || entry?.fingerprint !== candidate.endpointFingerprint) continue
-    if (MODEL_WIDE_NON_RETRYABLE_BACKGROUND_FAILURES.has(entry.errorClass)) return true
+
+    if (
+      entry?.retryable === false &&
+      entry?.key === candidate.key &&
+      entry?.fingerprint === candidate.endpointFingerprint &&
+      MODEL_WIDE_NON_RETRYABLE_BACKGROUND_FAILURES.has(entry.errorClass)
+    ) return true
+
+    if (
+      transportScope &&
+      entry?.transportScope === transportScope &&
+      TRANSPORT_WIDE_BACKGROUND_FAILURES.has(entry.errorClass) &&
+      (entry.retryable === false || (Number.isFinite(until) && until > at))
+    ) return true
   }
   return false
 }
@@ -307,7 +307,7 @@ async function chooseNextWork({ ctx, config, core, store, now, backoff, excluded
       excluded.set(candidate.key, { key: candidate.key, reason: 'measured-text-only' })
       continue
     }
-    if (candidateBlockedByNonRetryableFailure(backoff, candidate, now)) continue
+    if (candidateBlockedByFailure(backoff, candidate, now)) continue
     const eligibility = unattendedEligibility(ctx, candidate, authority.backgroundMeasurement, core)
     if (eligibility.eligible) {
       candidates.push(candidate)
@@ -674,6 +674,21 @@ export function createBackgroundCapabilityProfiler({
     }
   }
 
+  const credentialsChanged = (ref) => {
+    const changedRef = typeof ref === 'string' ? ref.trim() : ''
+    for (const [key, entry] of backoff.entries()) {
+      if (entry?.errorClass !== 'auth') continue
+      if (changedRef && entry.credentialRef && entry.credentialRef !== changedRef) continue
+      backoff.delete(key)
+    }
+    topologyDirty = true
+    yieldBackground('credential reference changed')
+    if (!runningController) {
+      topologyDirty = false
+      schedule(0)
+    }
+  }
+
   const tick = async () => {
     if (stopped || runningController) return
     const currentNow = Number(now())
@@ -784,22 +799,24 @@ export function createBackgroundCapabilityProfiler({
           : undefined
         const until = failure.retryable
           ? failureAt + transientDelay
-          : policy.persist === true && persistentTtl !== undefined
+          : persistentTtl !== undefined
             ? failureAt + persistentTtl
             : undefined
-        const credentialFingerprint = policy.credentialScoped === true
-          ? await candidateCredentialFingerprint(ctx, work.candidate)
-          : undefined
 
         if (failure.errorClass === 'unsupported-image') {
           await markCandidateUnsupported(work.candidate)
         } else {
+          const transportScope = transportFailureScope(work.candidate, failure.errorClass)
+          const credentialRef = failure.errorClass === 'auth' && typeof work.candidate.endpointCredentialRef === 'string'
+            ? work.candidate.endpointCredentialRef.trim()
+            : ''
           backoff.set(key, {
             key: work.candidate.key,
             fingerprint: work.candidate.endpointFingerprint,
             axis: work.axis,
             ...failure,
-            ...(credentialFingerprint ? { credentialFingerprint } : {}),
+            ...(transportScope ? { transportScope } : {}),
+            ...(credentialRef ? { credentialRef } : {}),
             ...(until !== undefined ? { until } : {}),
           })
         }
@@ -819,7 +836,6 @@ export function createBackgroundCapabilityProfiler({
               axis: work.axis,
               errorClass: failure.errorClass,
               errorCode: failure.errorCode,
-              credentialFingerprint,
               recordedAt: failureAt,
               expiresAt: until,
             })
@@ -886,6 +902,7 @@ export function createBackgroundCapabilityProfiler({
     wake,
     settingsChanged,
     topologyChanged,
+    credentialsChanged,
     stop,
     foregroundStart,
     foregroundEnd,
@@ -980,11 +997,21 @@ export function installBackgroundCapabilityProfiling(ctx, config, core, store, o
     if (namespace === undefined || String(namespace) === 'vision-router') profiler.settingsChanged()
   }
   const wakeForModels = () => profiler.topologyChanged()
+  const credentialAliasLatch = new Set()
+  const wakeForCredentials = (ref) => {
+    const key = typeof ref === 'string' && ref.trim() !== '' ? ref.trim() : '*'
+    if (credentialAliasLatch.has('*') || credentialAliasLatch.has(key) || (key === '*' && credentialAliasLatch.size > 0)) return
+    credentialAliasLatch.add(key)
+    queueMicrotask(() => { credentialAliasLatch.delete(key) })
+    profiler.credentialsChanged(ref)
+  }
   try {
     if (typeof ctx?.on === 'function') {
       for (const [event, handler] of [
         ['settings/updated', wakeForSettings],
         ['settings/document-updated', wakeForSettings],
+        ['credentials/reference-updated', wakeForCredentials],
+        ['credentials/updated', wakeForCredentials],
         ['llm/adapters-updated', wakeForModels],
       ]) {
         const stop = ctx.on(event, handler)

package/lib/vision-background-failure-policy.js

@@ -7,44 +7,37 @@ const DEFAULT_POLICY = Object.freeze({
   persist: false,
   retryAfterMs: undefined,
   ttlMs: undefined,
-  credentialScoped: false,
 })
 
 const POLICIES = Object.freeze({
   auth: Object.freeze({
     retryable: false,
-    persist: true,
+    persist: false,
     ttlMs: BACKGROUND_AUTH_STOP_TTL_MS,
-    credentialScoped: true,
   }),
   protocol: Object.freeze({
     retryable: false,
     persist: true,
     ttlMs: BACKGROUND_ENDPOINT_STOP_TTL_MS,
-    credentialScoped: false,
   }),
   unavailable: Object.freeze({
     retryable: false,
     persist: true,
     ttlMs: BACKGROUND_ENDPOINT_STOP_TTL_MS,
-    credentialScoped: false,
   }),
   'unsupported-image': Object.freeze({
     retryable: false,
     persist: false,
-    credentialScoped: false,
   }),
   'visual-proof': Object.freeze({
     retryable: true,
     persist: false,
     retryAfterMs: BACKGROUND_TRANSIENT_RETRY_MS,
-    credentialScoped: false,
   }),
   infrastructure: Object.freeze({
     retryable: true,
     persist: false,
     retryAfterMs: BACKGROUND_TRANSIENT_RETRY_MS,
-    credentialScoped: false,
   }),
 })
 
@@ -52,19 +45,3 @@ const POLICIES = Object.freeze({
 export function backgroundFailurePolicy(errorClass) {
   return POLICIES[String(errorClass ?? '')] ?? DEFAULT_POLICY
 }
-
-function unresolvedFingerprint(value) {
-  return typeof value !== 'string' || value === '' || value === 'unresolved'
-}
-
-/**
- * Credential transitions are intentionally asymmetric. Losing visibility of a
- * previously resolved credential is not proof that the account changed, so the
- * old stop remains conservative. Gaining a concrete fingerprint after an
- * unresolved state is observable recovery and must release the stale stop.
- */
-export function credentialFingerprintChanged(stored, current) {
-  if (unresolvedFingerprint(current)) return false
-  if (unresolvedFingerprint(stored)) return true
-  return stored !== current
-}

package/lib/vision-background-stop-store.js

@@ -4,13 +4,13 @@ import process from 'node:process'
 import { resolveDshHome } from './doctor.js'
 import { CAPABILITY_BENCHMARK_SUITE_REVISION } from './vision-capability-benchmark.js'
 
-// v1 stops had no expiry and could poison a backend forever. Do not migrate
-// them: a cache-version bump intentionally drops that stale authority.
-const CACHE_VERSION = 2
+// v1 stops had no expiry; v2 AUTH stops also persisted a secret-derived
+// credential fingerprint. Do not migrate either format: v3 persists only
+// non-secret endpoint/model stop evidence.
+const CACHE_VERSION = 3
 const MAX_ENTRIES = 256
 const AXES = new Set(['ocr', 'general', 'document', 'structured', 'grounding'])
-const CLASSES = new Set(['auth', 'unavailable', 'protocol'])
-const CREDENTIAL_FINGERPRINT_RE = /^(?:cred_[0-9a-f]{24}|unresolved|none)$/
+const CLASSES = new Set(['unavailable', 'protocol'])
 
 function cleanText(value, max = 256) {
   return typeof value === 'string' && value.trim() !== '' ? value.trim().slice(0, max) : ''
@@ -27,13 +27,11 @@ function cleanStop(value) {
   const axis = cleanText(value.axis, 32)
   const errorClass = cleanText(value.errorClass, 48)
   const errorCode = cleanText(value.errorCode, 96)
-  const credentialFingerprint = cleanText(value.credentialFingerprint, 64)
   const recordedAt = Number(value.recordedAt)
   const expiresAt = Number(value.expiresAt)
   if (!key || !provider || !model || !AXES.has(axis) || !CLASSES.has(errorClass)) return undefined
   if (!Number.isFinite(recordedAt) || recordedAt <= 0) return undefined
   if (!Number.isFinite(expiresAt) || expiresAt <= recordedAt) return undefined
-  if (credentialFingerprint && !CREDENTIAL_FINGERPRINT_RE.test(credentialFingerprint)) return undefined
   return {
     fingerprint,
     key,
@@ -42,7 +40,6 @@ function cleanStop(value) {
     axis,
     errorClass,
     ...(errorCode ? { errorCode } : {}),
-    ...(errorClass === 'auth' && credentialFingerprint ? { credentialFingerprint } : {}),
     recordedAt,
     expiresAt,
     suiteRevision: CAPABILITY_BENCHMARK_SUITE_REVISION,
@@ -61,11 +58,13 @@ async function load(file, fsOps, at) {
   try {
     const raw = await fsOps.readFile(file, 'utf8')
     const body = JSON.parse(raw)
-    if (!body || body.version !== CACHE_VERSION || !Array.isArray(body.stops)) return new Map()
-    const records = body.stops
+    if (!body || !Array.isArray(body.stops) || ![2, CACHE_VERSION].includes(body.version)) return new Map()
+    const records = new Map(body.stops
       .map(cleanStop)
       .filter((item) => item && item.expiresAt > at)
-    return new Map(records.map((item) => [recordKey(item), item]))
+      .map((item) => [recordKey(item), item]))
+    if (body.version === 2) await save(file, records, fsOps, at)
+    return records
   } catch (error) {
     if (error?.code === 'ENOENT') return new Map()
     return new Map()
@@ -132,7 +131,6 @@ export function createBackgroundBenchmarkStopStore(options = {}) {
       axis,
       errorClass,
       errorCode,
-      credentialFingerprint,
       recordedAt = Number(now()),
       expiresAt,
     } = {}) {
@@ -146,7 +144,6 @@ export function createBackgroundBenchmarkStopStore(options = {}) {
         axis,
         errorClass,
         errorCode,
-        credentialFingerprint,
         recordedAt,
         expiresAt,
         suiteRevision: CAPABILITY_BENCHMARK_SUITE_REVISION,

package/lib/vision-capability-benchmark-service.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto'
 import {
   capabilityProfileAxisMeasuredAt,
   createCapabilityProfileStore,
@@ -11,6 +12,8 @@ import {
 } from './vision-capability-benchmark.js'
 import { resolveVisionCredential } from './vision-capability-identity.js'
 import { redactDiagnosticText } from './diagnostic-redaction.js'
+import { wireSessionAffinityId } from './session-affinity.js'
+import { streamWithVisionSessionAffinity } from './session-affinity-runtime.js'
 import {
   hardenCapabilityBenchmarkFixture,
   verifyAndStripBenchmarkVisualProof,
@@ -248,6 +251,14 @@ export function createExactCapabilityInvoker(ctx, core, candidate, config, optio
     core.callOpenAICompatible(provider, messages, callOptions))
   const streamExact = options.streamExact ?? ((callOptions) => ctx.llm.stream(callOptions))
   const now = typeof options.now === 'function' ? options.now : Date.now
+  // Benchmarks need routing affinity but are not DSH Sessions. Keep the two
+  // identities separate: direct transports receive affinityId, while Host
+  // adapters run inside the scoped wire compatibility boundary without a fake
+  // GenerateOptions.sessionId that session-aware middleware could mistake for
+  // a persisted conversation.
+  const requestedAffinityId = wireSessionAffinityId(options.affinityId)
+  const benchmarkAffinityId = requestedAffinityId ??
+    `vision-benchmark-${(typeof options.randomUUID === 'function' ? options.randomUUID() : randomUUID())}`
   const prepared = new Map()
 
   const prepareFixture = async (fixture) => {
@@ -294,6 +305,7 @@ export function createExactCapabilityInvoker(ctx, core, candidate, config, optio
           callDirect(exactHttpProvider, openAIMessages(assets.png, assets.prompt), {
             maxTokens: benchmarkMaxTokensForProvider(exactHttpProvider),
             signal: callSignal,
+            affinityId: benchmarkAffinityId,
             resolveCredential: (ref) => resolvedCredentialValue(ctx, ref),
           }),
           fixtureTimeoutMs,
@@ -318,14 +330,14 @@ export function createExactCapabilityInvoker(ctx, core, candidate, config, optio
         const started = Number(now())
         try {
           output = await withHardDeadline(
-            collectStreamText(streamExact({
+            collectStreamText(streamWithVisionSessionAffinity(benchmarkAffinityId, () => streamExact({
               provider: candidate.provider,
               model: candidate.model,
               messages: assets.messages,
               maxTokens: DEFAULT_BENCHMARK_MAX_TOKENS,
               reasoningEffort: undefined,
               signal: callSignal,
-            })),
+            }))),
             fixtureTimeoutMs,
             'capability benchmark adapter fixture timed out',
           )

package/lib/vision-tool-runtime-boundary.js

@@ -167,11 +167,28 @@ function createRuntimeState(initialConfig = {}) {
   }
 }
 
-function stateFor(name, exec) {
+function configuredVisionTaskSignal(config) {
+  const timeoutMs = Number(config?.visionTaskTimeoutMs)
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return undefined
+  return AbortSignal.timeout(Math.max(1, Math.floor(timeoutMs)))
+}
+
+function stateFor(name, exec, config) {
+  const ambient = currentVisionTurnBudget()
   return {
     name,
     cwd: sessionCwd(exec),
-    signal: usableSignal(exec?.signal),
+    // Own the complete wall-clock task budget at the outermost runtime seam.
+    // Some Host services (notably AttachmentStore.saveImage in DSH 0.1.3) do
+    // not accept an AbortSignal. executeAbortable still races this signal so a
+    // hung Host promise cannot keep the user turn open forever; every wrapped
+    // fs/LLM call also observes the same merged cancellation after a late
+    // continuation settles.
+    signal: combineSignals(
+      ambient?.signal,
+      usableSignal(exec?.signal),
+      configuredVisionTaskSignal(config),
+    ),
     artifactRunId: `.vision-run-${Date.now().toString(36)}-${randomUUID()}`,
     disableCoreCache: name === 'vision_describe',
     // Every model call made from a Vision Router tool is a real authority
@@ -557,7 +574,7 @@ async function executeVisionTool(def, args, exec, execute, wrappedCtx, runtimeSt
   const liveConfig = runtimeState.config()
   if (liveConfig?.tool === false) throw toolDisabledError(def.name)
 
-  const state = stateFor(def.name, exec)
+  const state = stateFor(def.name, exec, liveConfig)
   const releaseArtifactRun = retainArtifactRun(state.artifactRunId)
   try {
     return await toolRuntime.run(state, () => withMergedTurnSignal(state, () =>