@anionex/dsh-vision-toolkit 0.1.31 → 0.1.33

package/src/client/model-variants-hider.ts

@@ -0,0 +1,159 @@
+/**
+ * Transparent routing for the host model selector: when `imageInputVariants.hidden`
+ * is enabled, variant routes keep the upstream provider/model display names and
+ * the browser hides the upstream text-only entries that have a variant twin.
+ * Users then see one entry per model — the original name — while the session
+ * actually runs on the image-capable variant, so pasted images, history with
+ * images, and the built-in `read_image` tool all keep working on text-only
+ * models without exposing `(Vision Toolkit)` routes.
+ *
+ * The host selector renders one `[role=group]` per provider whose group title
+ * id is `:<react-radix>:-<providerId>`, and one `[role=menuitemradio]` per
+ * model. We key groups by that provider id (variant routes carry the
+ * `vision-toolkit-` prefix) and hide every upstream entry whose display name
+ * matches a variant twin, collapsing fully-hidden upstream groups.
+ *
+ * The hiding decision is purely DOM-local: transparent mode is exactly the
+ * case where a variant twin keeps the upstream display name, while explicit
+ * mode appends `(Vision Toolkit)` and therefore never matches. No display-config
+ * round-trip is needed before the selector can be tidied, so the first paint
+ * of an opened menu already shows the merged list instead of flashing the
+ * duplicate upstream group.
+ * @module dsh-vision-toolkit/model-variants-hider
+ */
+
+const VARIANT_PROVIDER_PREFIX = 'vision-toolkit-'
+
+/** Elements we hid and their original inline display value, for restoration. */
+const hiddenElements = new Map<HTMLElement, string>()
+
+let active = false
+let observer: MutationObserver | undefined
+let tidyQueued = false
+
+/** Derive the provider id from a group's `aria-labelledby` title id. */
+function providerIdOf(group: Element): string | undefined {
+  const labelledBy = group.getAttribute('aria-labelledby')
+  if (labelledBy === null || labelledBy === '') return undefined
+  const titleId = document.getElementById(labelledBy)?.id ?? labelledBy
+  const reactPrefixed = /^:[^:]+:-(.+)$/u.exec(titleId)
+  if (reactPrefixed !== null) return reactPrefixed[1]
+  return titleId.replace(/^-/u, '')
+}
+
+function modelNames(group: Element): string[] {
+  return [...group.querySelectorAll<HTMLElement>('[role="menuitemradio"]')]
+    .map(button => (button.title || (button.textContent ?? '')).trim())
+    .filter(Boolean)
+}
+
+function hideElement(element: HTMLElement): void {
+  if (!hiddenElements.has(element)) hiddenElements.set(element, element.style.display)
+  element.style.display = 'none'
+}
+
+function restoreHidden(): void {
+  for (const [element, display] of hiddenElements) {
+    element.style.display = display
+  }
+  hiddenElements.clear()
+}
+
+/**
+ * Hide upstream text-only entries that have a variant twin. Group keys come
+ * from `aria-labelledby` ids so provider identity is reliable even when the
+ * variant provider name equals the upstream name (transparent mode).
+ */
+export function tidyModelSelector(): void {
+  if (document.querySelector('[role="menu"]') === null) return
+  // The host re-renders selectors while sessions stay open; drop bookkeeping
+  // for entries that already left the DOM so the map cannot grow unboundedly.
+  for (const element of [...hiddenElements.keys()]) {
+    if (!element.isConnected) hiddenElements.delete(element)
+  }
+  const groups = [...document.querySelectorAll<HTMLElement>('[role="menu"] [role="group"]')]
+  const byProvider = new Map<string, HTMLElement[]>()
+  for (const group of groups) {
+    const provider = providerIdOf(group)
+    if (provider === undefined) continue
+    const entries = byProvider.get(provider)
+    if (entries === undefined) byProvider.set(provider, [group])
+    else entries.push(group)
+  }
+
+  const shouldHide = new Set<HTMLElement>()
+  for (const [provider, providerGroups] of byProvider) {
+    if (!provider.startsWith(VARIANT_PROVIDER_PREFIX)) continue
+    const upstream = provider.slice(VARIANT_PROVIDER_PREFIX.length)
+    const twinNames = new Set(providerGroups.flatMap(modelNames))
+    if (twinNames.size === 0) continue
+    for (const upstreamGroup of byProvider.get(upstream) ?? []) {
+      const buttons = [...upstreamGroup.querySelectorAll<HTMLElement>('[role="menuitemradio"]')]
+      const matched: HTMLElement[] = []
+      for (const button of buttons) {
+        const name = (button.title || (button.textContent ?? '')).trim()
+        if (twinNames.has(name)) matched.push(button)
+      }
+      if (matched.length === 0) continue
+      for (const button of matched) shouldHide.add(button)
+      // Collapse the whole group only when every model has a variant twin;
+      // otherwise a partially matched group keeps its unmatched entries.
+      if (matched.length === buttons.length) shouldHide.add(upstreamGroup)
+    }
+  }
+
+  // Restore entries whose twin disappeared (e.g. transparent routing was
+  // disabled and the wrapper rebuilt with explicit `(Vision Toolkit)` names).
+  for (const [element, display] of [...hiddenElements]) {
+    if (!shouldHide.has(element)) {
+      element.style.display = display
+      hiddenElements.delete(element)
+    }
+  }
+  for (const element of shouldHide) hideElement(element)
+}
+
+/**
+ * Install the transparent-routing integrator. It watches the document for
+ * model-selector renderings and re-tidies them whenever the host re-renders.
+ * Tidy runs in a microtask (before the browser paints) and is coalesced across
+ * the render batch, so opening the selector never shows the upstream twins.
+ * @returns the disposer that stops observation and restores hidden entries.
+ */
+export function installModelVariantsHider(): () => void {
+  if (observer !== undefined) {
+    // A previous install is still active; a duplicate effect must not tear
+    // down the integrator while its original owner still expects it.
+    return () => {}
+  }
+  let disposed = false
+  const tidySoon = (): void => {
+    if (tidyQueued || disposed) return
+    tidyQueued = true
+    queueMicrotask(() => {
+      tidyQueued = false
+      if (disposed) return
+      active = true
+      tidyModelSelector()
+    })
+  }
+
+  observer = new MutationObserver(tidySoon)
+  observer.observe(document.body, { childList: true, subtree: true })
+  active = true
+  tidyModelSelector()
+
+  return () => {
+    disposed = true
+    observer?.disconnect()
+    observer = undefined
+    tidyQueued = false
+    restoreHidden()
+    active = false
+  }
+}
+
+/** Test seam: expose whether the integrator is currently installed. */
+export function isModelVariantsHiderActive(): boolean {
+  return active
+}

package/src/client/paste-images.tsx

@@ -5,6 +5,7 @@ import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
 import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type { InputTriggerSource } from '@deepseek-ai/dsh-client-ui-input-trigger/client'
 import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
+import { readDisplayConfig } from './display-config.ts'
 
 const SOURCE = 'vision-toolkit-pasted-image'
 export const PASTE_IMAGES_ROUTE = '/_dsh/vision-toolkit/paste-images'
@@ -488,7 +489,10 @@ export class PasteImageController {
     const input = this.inputFor(sessionId)
     try {
       await this.switchModel(sessionId, route)
-      input.notify('info', `Switched to ${route.label || `${route.model} (Vision Toolkit)`}; pasted images now keep the native attachment flow`)
+      const { hidden } = await readDisplayConfig()
+      input.notify('info', hidden
+        ? 'Visual enhancement active: pasted images keep the native attachment flow'
+        : `Switched to ${route.label || `${route.model} (Vision Toolkit)`}; pasted images now keep the native attachment flow`)
     } catch (error) {
       input.notify('error', `Model switch failed; images will be sent as workspace paths: ${message(error)}`)
       this.takeoverPaste(sessionId, target, files, text)

package/src/config.ts

@@ -100,6 +100,15 @@ export interface VisionToolkitConfig {
      * keeps the path-only takeover instead (default true).
      */
     autoSwitch?: boolean
+    /**
+     * Transparent routing: variant routes keep the upstream provider and model
+     * display names, and the browser integration hides the upstream text-only
+     * entries that have a variant twin, so the model selector shows one entry
+     * per model and sessions stay on the image-capable variant without users
+     * seeing or switching a `(Vision Toolkit)` route. Off (default) keeps the
+     * explicit sibling entries and the current behavior.
+     */
+    hidden?: boolean
   }
 }
 
@@ -128,6 +137,7 @@ export const Config: Schema<VisionToolkitConfig> = z.object({
     enabled: z.boolean().default(true),
     providers: z.array(z.string()).default([]),
     autoSwitch: z.boolean().default(true),
+    hidden: z.boolean().default(false),
   }),
 })
 
@@ -156,6 +166,7 @@ export interface ResolvedVisionToolkitConfig {
     enabled: boolean
     providers: string[]
     autoSwitch: boolean
+    hidden: boolean
   }
 }
 
@@ -265,6 +276,7 @@ export function resolveConfig(config: VisionToolkitConfig = {}): ResolvedVisionT
       enabled: imageInputVariants.enabled ?? true,
       providers: variantProviders,
       autoSwitch: imageInputVariants.autoSwitch ?? true,
+      hidden: imageInputVariants.hidden ?? false,
     },
   }
 }

package/src/image-input-variants.ts

@@ -41,6 +41,12 @@ export const VARIANT_SUFFIX = ' (Vision Toolkit)'
 /** Promise-cache bound for image descriptions, so a long-lived Web profile cannot hoard evidence text. */
 const EVIDENCE_CACHE_LIMIT = 64
 
+/** Periodic self-heal sweep for image-input variant routes. */
+const VARIANT_SWEEP_INTERVAL_MS = 10_000
+
+/** How long an upstream must stay absent before its wrapper is released. */
+const VARIANT_RELEASE_GRACE_MS = 10_000
+
 /**
  * Media types the Vision Toolkit glance pipeline accepts, by declared media
  * type. Narrower than the paste-to-workspace route (which stores any image
@@ -540,12 +546,16 @@ export class ImageInputVariantAdapter extends LlmAdapter {
     private readonly upstreamName: string,
     private readonly runtime: () => VisionToolkitRuntime | undefined,
     private readonly cache: EvidenceCache,
+    private readonly hidden: () => boolean = () => false,
   ) {
     super()
   }
 
   override providerInfo(provider: string): LlmProviderInfo {
-    return { id: provider, name: `${this.upstreamName}${VARIANT_SUFFIX}` }
+    return {
+      id: provider,
+      name: this.hidden() ? this.upstreamName : `${this.upstreamName}${VARIANT_SUFFIX}`,
+    }
   }
 
   override async listModels(provider: string): Promise<readonly LlmModelInfo[]> {
@@ -553,7 +563,7 @@ export class ImageInputVariantAdapter extends LlmAdapter {
     return models.filter(shouldWrapModel).map((model) => ({
       provider,
       id: model.id,
-      name: `${model.name}${VARIANT_SUFFIX}`,
+      name: this.hidden() ? model.name : `${model.name}${VARIANT_SUFFIX}`,
       inputModalities: ['text', 'image'],
       ...(model.description === undefined ? {} : { description: model.description }),
     }))
@@ -571,7 +581,7 @@ export class ImageInputVariantAdapter extends LlmAdapter {
     return {
       provider,
       id: model,
-      name: `${info.name}${VARIANT_SUFFIX}`,
+      name: this.hidden() ? info.name : `${info.name}${VARIANT_SUFFIX}`,
       inputModalities: ['text', 'image'],
       ...(info.description === undefined ? {} : { description: info.description }),
       // Capability and call-default metadata rides through unchanged: the
@@ -835,6 +845,16 @@ export function installImageInputVariants(
   getRuntime: () => VisionToolkitRuntime | undefined,
 ): { dispose: () => void; reconcile: () => void } {
   const registrations = new Map<string, () => void>()
+  // The host snapshots adapter provider metadata (including the group display
+  // name) at registration time, so a transparent-routing toggle must rebuild
+  // every wrapper for the new names to reach the model selector.
+  let lastHidden = false
+  // Upstream ids observed missing and the timestamp of the first missing
+  // observation. A wrapper is only released after its upstream stays absent
+  // for the full grace period, so a transient registry gap (adapter
+  // re-registration, HMR reload) cannot drop a wrapper that a live session is
+  // still pointed at, no matter how many sweeps fire in between.
+  const stale = new Map<string, number>()
   let disposed = false
   // Serialize sweeps: a registration itself announces llm/adapters-updated,
   // and two interleaved sweeps must never probe the same route concurrently.
@@ -843,13 +863,29 @@ export function installImageInputVariants(
   // not one per notification (a single registration emits a notification).
   let sweepQueued = false
 
+  const release = (upstream: string): void => {
+    const dispose = registrations.get(upstream)
+    if (dispose === undefined) return
+    registrations.delete(upstream)
+    stale.delete(upstream)
+    try {
+      dispose()
+    } catch (error) {
+      ctx.logger.warn(
+        'dsh-vision-toolkit: image-input variant release failed for "%s": %s',
+        upstream,
+        messageOf(error),
+      )
+    }
+  }
+
   const releaseAll = (): void => {
-    for (const dispose of [...registrations.values()]) dispose()
-    registrations.clear()
+    stale.clear()
+    for (const upstream of [...registrations.keys()]) release(upstream)
   }
 
   const sweep = (): void => {
-    if (sweepQueued) return
+    if (disposed || sweepQueued) return
     sweepQueued = true
     queueMicrotask(() => {
       sweepQueued = false
@@ -861,6 +897,10 @@ export function installImageInputVariants(
     if (disposed) return
     try {
       const variants = getConfig().imageInputVariants
+      if (variants.hidden !== lastHidden) {
+        lastHidden = variants.hidden
+        releaseAll()
+      }
       if (!variants.enabled) {
         releaseAll()
         return
@@ -874,12 +914,33 @@ export function installImageInputVariants(
       } catch {
         return
       }
+      const live = new Set(providers.map(provider => provider.id))
+      // Release restrict-narrowed routes immediately (a configuration change is
+      // authoritative). For routes merely missing from the live registry, keep
+      // the wrapper until the absence outlives the grace period.
+      for (const upstream of [...registrations.keys()]) {
+        if (restrict.size > 0 && !restrict.has(upstream)) {
+          release(upstream)
+          continue
+        }
+        if (live.has(upstream)) {
+          stale.delete(upstream)
+          continue
+        }
+        const missedAt = stale.get(upstream)
+        if (missedAt !== undefined && Date.now() - missedAt >= VARIANT_RELEASE_GRACE_MS) {
+          release(upstream)
+        } else if (missedAt === undefined) {
+          stale.set(upstream, Date.now())
+        }
+      }
       for (const provider of providers) {
         const upstream = provider.id
         if (restrict.size > 0 && !restrict.has(upstream)) continue
         // Our own variant routes declare image input and are never wrapped;
         // probing them would just re-probe their upstream route.
         if (upstream.startsWith(VARIANT_PROVIDER_PREFIX)) continue
+        const variantId = variantProviderId(upstream)
         let models: readonly LlmModelInfo[]
         try {
           models = await llm.listModels(upstream)
@@ -888,18 +949,26 @@ export function installImageInputVariants(
         }
         const eligible = models.some(shouldWrapModel)
         const registered = registrations.has(upstream)
-        if (!eligible && registered) {
-          // The route lost its eligible models: release the stale variant.
-          const dispose = registrations.get(upstream)
-          dispose?.()
-          registrations.delete(upstream)
-          continue
+        if (registered && live.has(variantId)) {
+          // Re-read the live registry after the await: a rebuild inside the
+          // probe window can drop our wrapper without touching our map.
+          const liveNow = new Set(llm.listProviders().map(provider => provider.id))
+          if (liveNow.has(variantId)) {
+            // Healthy handle: only react when the route lost every eligible model.
+            if (!eligible) release(upstream)
+            continue
+          }
+        }
+        if (registered) {
+          // Dead handle from a registry rebuild/reset: drop it and register a
+          // fresh wrapper below.
+          release(upstream)
         }
-        if (!eligible || registered) continue
+        if (!eligible) continue
         if (disposed) return
         try {
           const dispose = llm.registerAdapter(
-            [variantProviderId(upstream)],
+            [variantId],
             new ImageInputVariantAdapter(
               ctx,
               llm,
@@ -907,9 +976,11 @@ export function installImageInputVariants(
               provider.name,
               getRuntime,
               new EvidenceCache(EVIDENCE_CACHE_LIMIT),
+              () => getConfig().imageInputVariants.hidden,
             ),
           )
           registrations.set(upstream, dispose)
+          stale.delete(upstream)
         } catch (error) {
           ctx.logger.warn(
             'dsh-vision-toolkit: image-input variant registration skipped for "%s": %s',
@@ -918,16 +989,6 @@ export function installImageInputVariants(
           )
         }
       }
-      const live = new Set(providers.map(provider => provider.id))
-      for (const [upstream, dispose] of [...registrations]) {
-        // A wrapper is released when its upstream route vanished OR the
-        // current configuration no longer allows that route (restrict
-        // narrowing must not leave stale variants behind).
-        if (!live.has(upstream) || (restrict.size > 0 && !restrict.has(upstream))) {
-          dispose()
-          registrations.delete(upstream)
-        }
-      }
     } catch (error) {
       ctx.logger.warn('dsh-vision-toolkit: image-input variant sweep failed: %s', messageOf(error))
     }
@@ -937,9 +998,14 @@ export function installImageInputVariants(
     ctx.on('llm/adapters-updated', () => { sweep() })
   }
   sweep()
+  // Self-heal safety net: re-verify periodically so a wrapper dropped by an
+  // unobserved cause (registry rebuild without an event we can see) is restored
+  // within one interval.
+  const timer = setInterval(() => { sweep() }, VARIANT_SWEEP_INTERVAL_MS)
   return {
     dispose: () => {
       disposed = true
+      clearInterval(timer)
       releaseAll()
     },
     reconcile: () => { sweep() },

package/src/index.ts

@@ -114,6 +114,7 @@ export async function apply(ctx: Context, config: VisionToolkitConfig = {}): Pro
     artifacts,
     pastedImages,
     createPasteTakeoverResolver(ctx, () => resolveConfig(settings.get())),
+    () => ({ hidden: resolveConfig(settings.get()).imageInputVariants.hidden }),
   )
   disposers.push(variants.dispose)
   disposers.push(settings.watch(async (next) => {

package/src/plugin-update.ts

@@ -822,6 +822,13 @@ export class VisionToolkitPluginUpdateService {
     profile: ProfileInstall,
     pnpmPath: string,
   ): Promise<CommandResult> {
+    // Windows batch shims cannot be spawned directly; route them through cmd.exe.
+    const program = this.platform === 'win32' && /\.(?:cmd|bat)$/i.test(pnpmPath)
+      ? process.env.COMSPEC ?? 'cmd.exe'
+      : pnpmPath
+    const argv = program === pnpmPath
+      ? [pnpmPath, ...args]
+      : [program, '/d', '/s', '/c', pnpmPath, ...args]
     const controller = new AbortController()
     let timedOut = false
     const timeout = setTimeout(() => {
@@ -830,7 +837,7 @@ export class VisionToolkitPluginUpdateService {
     }, timeoutMs)
     try {
       const handle = this.ctx.subprocess.spawn({
-        argv: [pnpmPath, ...args],
+        argv,
         cwd: profile.profileDir,
         stdio: {
           stdin: 'ignore',

package/src/runtime-manager.ts

@@ -39,7 +39,12 @@ async function defaultFactory(ctx: Context, config: ResolvedVisionToolkitConfig)
 }
 
 function fingerprint(config: ResolvedVisionToolkitConfig): string {
-  return JSON.stringify(config)
+  // Transparent routing is a display/policy flag: toggling it must not rebuild
+  // or re-verify the vision runtime, only reconcile the model-selector routes.
+  return JSON.stringify({
+    ...config,
+    imageInputVariants: { ...config.imageInputVariants, hidden: false },
+  })
 }
 
 function messageOf(error: unknown): string {
@@ -73,7 +78,9 @@ export class VisionToolkitRuntimeManager {
   async prepareCandidate(raw: VisionToolkitConfig): Promise<PreparedRuntimeGeneration> {
     const config = resolveConfig(raw)
     const resolvedFingerprint = fingerprint(config)
-    if (this.active?.fingerprint === resolvedFingerprint) return this.active
+    if (this.active?.fingerprint === resolvedFingerprint) {
+      return { ...this.active, config }
+    }
     const runtime = await this.factory(this.ctx, config)
     return { config, fingerprint: resolvedFingerprint, runtime }
   }
@@ -84,6 +91,7 @@ export class VisionToolkitRuntimeManager {
    */
   activateCandidate(candidate: PreparedRuntimeGeneration): void {
     if (this.active?.fingerprint === candidate.fingerprint) {
+      this.active = candidate
       this.lastError = undefined
       return
     }

package/src/runtime.ts

@@ -56,7 +56,9 @@ const VISION_MODEL_TEST_IMAGE = fileURLToPath(new URL('../assets/vision-model-te
 const VISION_MODEL_TEST_PROMPT = 'This is an explicit service readiness test. Reply with one short sentence confirming that you received the image.'
 
 /** Bump when the Pillow compression ladder changes so stale cache entries are ignored. */
-const COMPRESSED_IMAGE_CACHE_VERSION = 'v1'
+const COMPRESSED_IMAGE_CACHE_VERSION = 'v2'
+/** Cache keys carry 64-bit digests so Windows paths stay below MAX_PATH; the full file sha256 is computed on read and compared against this prefix. */
+const COMPRESSED_IMAGE_CACHE_KEY_DIGEST_LENGTH = 16
 const COMPRESSED_IMAGE_CACHE_MAX_ENTRIES = 200
 const COMPRESSED_IMAGE_CACHE_MAX_BYTES = 512 * 1024 * 1024
 const COMPRESSED_IMAGE_CACHE_STALE_PARTIAL_MS = 60 * 60 * 1000
@@ -883,7 +885,7 @@ export class VisionToolkitRuntime {
   private async readCacheCandidate(
     root: string,
     name: string,
-    expectedOutDigest: string,
+    expectedOutDigestPrefix: string,
     maxBytes: number,
     maxPixels: number,
     operation: OperationContext,
@@ -909,7 +911,8 @@ export class VisionToolkitRuntime {
     } catch {
       return undefined
     }
-    if (bytes.length !== info.size || createHash('sha256').update(bytes).digest('hex') !== expectedOutDigest) return undefined
+    const digest = createHash('sha256').update(bytes).digest('hex')
+    if (bytes.length !== info.size || !digest.startsWith(expectedOutDigestPrefix)) return undefined
     let probed: { width: number; height: number; format: string } | undefined
     try {
       probed = await this.adapter.probeImageSize(real, { signal: operation.signal })
@@ -929,7 +932,7 @@ export class VisionToolkitRuntime {
 
   private cacheEntryOutDigest(entry: string, prefix: string): string | undefined {
     const tail = entry.slice(prefix.length + 1)
-    return /^[0-9a-f]{64}-/u.test(tail) ? tail.slice(0, 64) : undefined
+    return /^[0-9a-f]{16}-/u.test(tail) ? tail.slice(0, 16) : undefined
   }
 
   private async pruneCompressedCache(root: string): Promise<void> {
@@ -997,21 +1000,21 @@ export class VisionToolkitRuntime {
     if (bytes.length !== image.bytes) {
       throw new VisionToolkitError('input', `image changed while preparing the vision request: ${image.path}`)
     }
-    const digest = createHash('sha256').update(bytes).digest('hex')
+    const digest = createHash('sha256').update(bytes).digest('hex').slice(0, COMPRESSED_IMAGE_CACHE_KEY_DIGEST_LENGTH)
     const root = await this.compressedImageRoot(policy)
     await this.pruneCompressedCache(root)
     const prefix = `${COMPRESSED_IMAGE_CACHE_VERSION}-${digest}-b${this.config.maxImageBytes}-p${this.config.maxImagePixels}`
     for (const entry of await readdir(root)) {
       if (!entry.startsWith(`${prefix}-`) || entry.startsWith('.')) continue
-      const outDigest = this.cacheEntryOutDigest(entry, prefix)
-      if (outDigest === undefined) {
+      const outDigestPrefix = this.cacheEntryOutDigest(entry, prefix)
+      if (outDigestPrefix === undefined) {
         await rm(join(root, entry), { force: true }).catch(() => {})
         continue
       }
       const cached = await this.readCacheCandidate(
         root,
         entry,
-        outDigest,
+        outDigestPrefix,
         this.config.maxImageBytes,
         this.config.maxImagePixels,
         operation,
@@ -1037,7 +1040,7 @@ export class VisionToolkitRuntime {
     }
     const extension = compressed.format === 'jpeg' ? 'jpg' : compressed.format
     const stagedBytes = await readFile(staged, { signal: operation.signal })
-    const outDigest = createHash('sha256').update(stagedBytes).digest('hex')
+    const outDigest = createHash('sha256').update(stagedBytes).digest('hex').slice(0, COMPRESSED_IMAGE_CACHE_KEY_DIGEST_LENGTH)
     const finalName = `${prefix}-${outDigest}-${compressed.width}x${compressed.height}.${extension}`
     const finalPath = join(root, finalName)
     const existing = await this.readCacheCandidate(

package/src/web.ts

@@ -46,6 +46,9 @@ import { sameOriginPost, sameOriginRequest } from './web-request.ts'
 /** Exact route used by the browser Settings page. */
 export const SETTINGS_ROUTE = '/_dsh/vision-toolkit/settings'
 
+/** Same-origin route used by the browser client to read display-mode flags. */
+export const DISPLAY_CONFIG_ROUTE = '/_dsh/vision-toolkit/display-config'
+
 /** Public Settings snapshot; credential values are deliberately impossible here. */
 export interface VisionToolkitSettingsSnapshot {
   schemaVersion: 1
@@ -504,6 +507,34 @@ export function createPastePolicyHandler(
   }
 }
 
+/**
+ * Same-origin display-config handler: exposes whether transparent routing is
+ * active. The paste integration uses it to choose its notice text; the model
+ * selector hides upstream twins synchronously from DOM display names and does
+ * not depend on this route.
+ * @param getDisplayConfig - resolves the current display-mode flags.
+ * @returns the HTTP handler.
+ */
+export function createDisplayConfigHandler(
+  getDisplayConfig: () => { hidden: boolean },
+): (req: IncomingMessage, res: ServerResponse) => void {
+  return (req, res) => {
+    try {
+      if (req.method !== 'GET') {
+        requestError(res, 405, 'method-not-allowed', 'Use GET')
+        return
+      }
+      if (!sameOriginRequest(req)) {
+        requestError(res, 403, 'origin-rejected', 'The request must originate from this DSH Web application')
+        return
+      }
+      responseJson(res, 200, { ok: true, value: getDisplayConfig() })
+    } catch (error) {
+      requestError(res, 500, 'display-config-failed', publicMessage(error))
+    }
+  }
+}
+
 /**
  * Attach optional Web routes whenever a webServer service is present.
  * @param ctx - plugin context owning route effects.
@@ -511,6 +542,7 @@ export function createPastePolicyHandler(
  * @param artifacts - signed Artifact handler.
  * @param pastedImages - pasted-image workspace handler.
  * @param pastePolicy - paste-policy verdict resolver (sessionId, selection, modelLabel).
+ * @param getDisplayConfig - resolves display-mode flags for the browser client.
  */
 export function installVisionToolkitWeb(
   ctx: Context,
@@ -518,6 +550,7 @@ export function installVisionToolkitWeb(
   artifacts: ArtifactAccessController,
   pastedImages: PastedImageBackend,
   pastePolicy: (sessionId: string, selection?: PasteSelectionQuery, modelLabel?: string) => Promise<PasteVerdict>,
+  getDisplayConfig: () => { hidden: boolean },
 ): void {
   ctx.inject(['webServer'], (webCtx) => {
     webCtx.effect(() => {
@@ -543,7 +576,13 @@ export function installVisionToolkitWeb(
         path: PASTE_POLICY_ROUTE,
         handler: createPastePolicyHandler(pastePolicy),
       })
+      const disposeDisplayConfig = webCtx.webServer.register({
+        kind: 'exact',
+        path: DISPLAY_CONFIG_ROUTE,
+        handler: createDisplayConfigHandler(getDisplayConfig),
+      })
       return () => {
+        disposeDisplayConfig()
         disposePastePolicy()
         disposePasteImages()
         disposeSettings()