@anionex/dsh-vision-toolkit 0.1.7 → 0.1.8

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write dsh-vision-dark-theme/README.md
-README.md: ab7ac8d402f6da738a0d70cad3170c3dc0d970cb
-README.zh.md: 6d6da22d56babde78acffa0b7865b941476f0134
+README.md: 73215f08bb8e697ddc9c49cc4e1a5491a0f4c735
+README.zh.md: 8a8979e5b3ea6e03e58b51dea8ce49b0d1e218ea

package/README.md

@@ -2,6 +2,7 @@
 
 # DSH Vision Toolkit
 
+[![Top at dshfind](https://img.shields.io/badge/top%20at-dshfind-FFD700?style=flat-square)](https://dshfind.com/)
 [![X (Twitter)](https://img.shields.io/badge/-@anion__ex-000000?style=flat-square&logo=x&logoColor=white)](https://x.com/anion_ex)
 [![Release v0.1.7](https://img.shields.io/badge/release-v0.1.7-5B4CF0?style=flat-square)](https://github.com/Anionex/dsh-vision-toolkit/releases/tag/v0.1.7)
 [![Verified: 168 tests](https://img.shields.io/badge/verified-168%20tests-2EA44F?style=flat-square)](tests)
@@ -145,6 +146,14 @@ Runtime readiness is profile-wide, but the ten visual execution schemas are Agen
 
 Health checks, connection testing, and plugin/upstream version inspection are administrative Web Settings operations. `vision_toolkit_health` and `vision_toolkit_version` are not model tools and never enter an Agent's schema, including after visual-tool activation.
 
+## Image-input variants for text-only models
+
+Text-only model routes get sibling model-selector entries named `<model> (Vision Toolkit)` under a matching provider group. A variant declares image input, so pasted images keep the native attachment flow — composer thumbnail, durable session image, and history rendering — and the plugin rewrites every image block into a Vision Toolkit description only on the wire to the model, before the request reaches the upstream route. The session log is untouched; replay and the UI keep the real image.
+
+A variant is registered automatically for every model the host positively declares text-only (for example the DeepSeek chat family). Paste handling is automatic: when the current model is confirmed text-only and its variant exists, the browser integration switches the session to the variant by itself (a short notice names the new model) and the paste then keeps the native flow; no manual model change is needed. The host's verdict uses the exact model route the browser read from the live model catalog, with the selector label as fallback; unconfirmed or image-capable routes always keep the native flow, and a text-only model without a variant (for example when variants are disabled) keeps the paste-to-path takeover, which copies the image into the session workspace and inserts its path as text.
+
+Description conversion needs the configured vision provider and its credential; when the runtime is not ready or a read fails, the wire block degrades to an explanatory note instead of failing the turn. Disable variants with `imageInputVariants.enabled: false`, restrict the wrapped routes with `imageInputVariants.providers`, or keep the paste-to-path behavior for text-only models with `imageInputVariants.autoSwitch: false`.
+
 ## Requirements
 
 - DeepSeek Harness with a Web or Headless profile and `pnpm` available to `dsh plugin`.
@@ -233,6 +242,10 @@ The bundle defaults to the managed runtime. A profile patch can override the pro
     runtime:
       mode: managed
     allowedDirs: []
+    imageInputVariants:
+      enabled: true
+      providers: []
+      autoSwitch: true
 ```
 
 ### Configuration fields
@@ -254,6 +267,9 @@ The bundle defaults to the managed runtime. A profile patch can override the pro
 | `runtime.agentVisionToolkitPath` | unset | Required in `external` mode; exported exact snapshot or clean pinned Git checkout |
 | `runtime.python` | unset | Optional Python 3.11+ bootstrap/interpreter override |
 | `allowedDirs` | `[]` | Additional realpath-resolved input roots; the session workspace is always allowed |
+| `imageInputVariants.enabled` | `true` | Register image-input variant entries for text-only model routes in the model selector |
+| `imageInputVariants.providers` | `[]` | Restrict wrapped upstream routes by provider id; empty wraps every eligible route |
+| `imageInputVariants.autoSwitch` | `true` | Automatically switch a text-only session to its image-input variant on paste, so the image keeps the native flow; `false` keeps the paste-to-path takeover for text-only models |
 
 ### Credentials
 
@@ -341,7 +357,7 @@ The committed evidence records an initial `6.04%` difference across six non-zero
 
 | Symptom | Resolution |
 |---|---|
-| `Model "..." does not support image input. (attachment-error)` | The image used DSH's native model-attachment channel, so a text-only model rejected the turn before the Skill or Vision Toolkit could run. Use DSH Paste Input's attachment button, paste, or drop flow so the file is copied into the session workspace and represented by a path, then invoke `/vision-tools`. Restart the Web profile and reload the page after installing or upgrading either browser plugin. |
+| `Model "..." does not support image input. (attachment-error)` | The image used DSH's native model-attachment channel, so a text-only model rejected the turn before the Skill or Vision Toolkit could run. With image-input variants enabled this is rare: pasting normally auto-switches the session to the `<model> (Vision Toolkit)` variant. If variants are disabled or auto-switch is off, use DSH Paste Input's attachment button, paste, or drop flow so the file is copied into the session workspace and represented by a path, then invoke `/vision-tools`. Restart the Web profile and reload the page after installing or upgrading either browser plugin. |
 | Credential reported missing | Paste the key into Web Settings **API key**, keep the advanced **Credential name** aligned with `provider.credential`, save, then rerun health. Headless deployments can provision the same reference in `$DSH_HOME/.credentials.yaml`. Local-only tools do not need it. |
 | Runtime preparation fails | Read the Settings runtime error, verify Python 3.11+, package-cache/network access, disk permissions, and the exact external pin. Save only after correcting the candidate; the active generation remains intact. |
 | Chrome is not found | Install Chrome, Chromium, or Edge or configure an environment where one is discoverable. Only `vision_html_screenshot` is unavailable. |

package/README.zh.md

@@ -2,6 +2,7 @@
 
 # DSH Vision Toolkit
 
+[![推荐 at dshfind](https://img.shields.io/badge/%E6%8E%A8%E8%8D%90-dshfind-FFD700?style=flat-square)](https://dshfind.com/)
 [![X (Twitter)](https://img.shields.io/badge/-@anion__ex-000000?style=flat-square&logo=x&logoColor=white)](https://x.com/anion_ex)
 [![Release v0.1.7](https://img.shields.io/badge/release-v0.1.7-5B4CF0?style=flat-square)](https://github.com/Anionex/dsh-vision-toolkit/releases/tag/v0.1.7)
 [![Verified: 168 tests](https://img.shields.io/badge/verified-168%20tests-2EA44F?style=flat-square)](tests)
@@ -145,6 +146,14 @@ flowchart LR
 
 健康检查、连接测试以及插件/上游版本检查属于 Web Settings 管理操作。`vision_toolkit_health` 和 `vision_toolkit_version` 不是模型工具，即使视觉执行工具已经激活，也永远不会进入 Agent schema。
 
+## 纯文本模型的图片输入变体
+
+纯文本模型路由会获得同名的兄弟模型条目：`<模型名> (Vision Toolkit)`，挂在对应的提供方分组下。变体声明支持图片输入，因此粘贴的图片走原生附件流程——输入框缩略图、会话持久化图片与历史渲染全部保留——插件只在发往模型的请求链路上把每个图片块改写成 Vision Toolkit 描述文本，再转交上游路由。会话日志不被改动；回放与 UI 看到的始终是真实图片。
+
+插件会自动为宿主明确声明为纯文本的每个模型注册变体（例如 DeepSeek 对话家族）。粘贴处理是全自动的：当当前模型被确认为纯文本、且它的变体已注册时，浏览器端集成会自动把会话切换到变体（会有一条简短提示说明新模型名），随后粘贴走原生流程，无需手动切换模型。宿主依据浏览器从实时模型目录读到的精确模型路由来裁决，模型选择器标签作为兜底；无法确认或支持图片的路由一律保持原生流程，而"纯文本但没有变体"的模型（例如变体被关闭时）继续走"粘贴转路径"：图片被复制进会话工作区，输入框里插入的是它的路径文本。
+
+描述转换需要已配置的视觉提供方及其 Credential；当运行时未就绪或读取失败时，请求链路上的图片块降级为说明文本，而不是让整轮失败。用 `imageInputVariants.enabled: false` 关闭变体，用 `imageInputVariants.providers` 限制被包装的路由，或用 `imageInputVariants.autoSwitch: false` 让纯文本模型继续走"粘贴转路径"。
+
 ## 运行要求
 
 - 启用 Web 或 Headless Profile 的 DeepSeek Harness，并确保 `dsh plugin` 可以使用 `pnpm`。
@@ -233,6 +242,10 @@ Bundle 默认使用 managed 运行时。Profile patch 可以覆盖提供方与
     runtime:
       mode: managed
     allowedDirs: []
+    imageInputVariants:
+      enabled: true
+      providers: []
+      autoSwitch: true
 ```
 
 ### 配置字段
@@ -254,6 +267,9 @@ Bundle 默认使用 managed 运行时。Profile patch 可以覆盖提供方与
 | `runtime.agentVisionToolkitPath` | 未设置 | `external` 模式必填；必须是精确导出快照或固定 commit 的干净 Git checkout |
 | `runtime.python` | 未设置 | 可选的 Python 3.11+ 引导程序/解释器覆盖值 |
 | `allowedDirs` | `[]` | 额外的 realpath 解析输入根目录；会话工作区始终允许 |
+| `imageInputVariants.enabled` | `true` | 为纯文本模型路由在模型选择器中注册图片输入变体条目 |
+| `imageInputVariants.providers` | `[]` | 按提供方 id 限制被包装的上游路由；为空时包装所有符合条件的路由 |
+| `imageInputVariants.autoSwitch` | `true` | 粘贴时自动把纯文本会话切换到其图片输入变体，让图片保持原生流程；`false` 时纯文本模型继续走"粘贴转路径" |
 
 ### Credential
 
@@ -341,7 +357,7 @@ npm run example:ui-restoration:write
 
 | 症状 | 解决方法 |
 |---|---|
-| `Model "..." does not support image input. (attachment-error)` | 图片走了 DSH 的模型原生附件通道，纯文本模型会在 Skill 或 Vision Toolkit 运行前拒绝该轮。请使用 DSH Paste Input 的附件按钮、粘贴或拖放流程，让文件先复制到会话工作区并以路径形式进入消息，再调用 `/vision-tools`。安装或升级任一浏览器插件后，需要重启 Web Profile 并刷新页面。 |
+| `Model "..." does not support image input. (attachment-error)` | 图片走了 DSH 的模型原生附件通道，纯文本模型会在 Skill 或 Vision Toolkit 运行前拒绝该轮。启用图片输入变体时这很少发生：粘贴会自动把会话切换到 `<模型名> (Vision Toolkit)` 变体。若变体被关闭或自动切换被禁用，请使用 DSH Paste Input 的附件按钮、粘贴或拖放流程，让文件先复制到会话工作区并以路径形式进入消息，再调用 `/vision-tools`。安装或升级任一浏览器插件后，需要重启 Web Profile 并刷新页面。 |
 | Credential 显示缺失 | 在 Web 设置页的 **API 密钥** 中粘贴密钥，确认高级设置中的 **凭据名称** 与 `provider.credential` 一致，保存后重新运行健康检查。Headless 部署可以在 `$DSH_HOME/.credentials.yaml` 中预置同名引用。本地工具不需要它。 |
 | 运行时准备失败 | 查看 Settings 中的运行时错误，检查 Python 3.11+、软件包缓存/网络、磁盘权限和精确 external 固定版本。修正候选后再保存；当前 generation 不受影响。 |
 | 找不到 Chrome | 安装 Chrome、Chromium 或 Edge，或让其中一个可被运行环境发现。只有 `vision_html_screenshot` 不可用。 |

package/lib/client.js

@@ -895,7 +895,7 @@ function apply(ctx) {
 __modules["./paste-images.js"] = function(module, exports, require, __load_) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PasteImageController = exports.PASTE_IMAGES_ROUTE = void 0;
+exports.PasteImageController = exports.PASTE_POLICY_ROUTE = exports.PASTE_IMAGES_ROUTE = void 0;
 exports.PasteImageDock = PasteImageDock;
 exports.installPasteImages = installPasteImages;
 const jsx_runtime_1 = require("react/jsx-runtime");
@@ -903,9 +903,12 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const SOURCE = 'vision-toolkit-pasted-image';
 exports.PASTE_IMAGES_ROUTE = '/_dsh/vision-toolkit/paste-images';
+exports.PASTE_POLICY_ROUTE = '/_dsh/vision-toolkit/paste-policy';
 const MAX_IMAGES = 20;
 const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
 const MAX_BATCH_BYTES = 80 * 1024 * 1024;
+/** A confirmed paste verdict older than this is unknown again, even while a refresh is in flight. */
+const VERDICT_MAX_AGE_MS = 15000;
 const CORDIS_ORIGINAL = Symbol.for('cordis.original');
 function registryIdentity(registry) {
     let current = registry;
@@ -944,6 +947,25 @@ function imageFiles(data) {
     const candidates = itemFiles.length > 0 ? itemFiles : Array.from(data.files);
     return candidates.filter(file => file.type.toLowerCase().startsWith('image/'));
 }
+/**
+ * The selector label the model picker currently shows, or '' when none is
+ * readable. Matches the host ModelSelect trigger aria-labels ("Select model,
+ * current …" / "选择模型，当前 …"); any other label wording falls back to the
+ * session-header verdict, which is stale until the next request.
+ */
+function currentModelLabel() {
+    const buttons = document.querySelectorAll('button[aria-label]');
+    for (const button of buttons) {
+        const label = button.getAttribute('aria-label') ?? '';
+        if (/select model|current model|选择模型/iu.test(label))
+            return label;
+    }
+    return '';
+}
+/** Verdict cache key: the model label is part of the answer, so a switch invalidates it. */
+function verdictKey(sessionId, modelLabel) {
+    return `${sessionId}|${modelLabel}`;
+}
 function validateImages(files) {
     if (files.length > MAX_IMAGES)
         throw new Error(`Paste at most ${MAX_IMAGES} images at a time`);
@@ -975,6 +997,9 @@ class PasteImageController {
     records = new Map();
     listeners = new Set();
     revision = 0;
+    verdicts = new Map();
+    /** Guards the synthetic replay paste from re-entering capture interception. */
+    replaying = false;
     constructor(ctx) {
         this.ctx = ctx;
     }
@@ -1074,30 +1099,246 @@ class PasteImageController {
             throw error;
         }
     }
-    handlePaste(event) {
-        const files = imageFiles(event.clipboardData);
-        if (files.length === 0)
+    /**
+     * The host's verdict for one Session and selector label, when fresh. The
+     * last CONFIRMED answer is authoritative while a background refresh is in
+     * flight (the paste acts on what the host last said; the refresh only
+     * covers the next paste). A label that changed since the confirmation
+     * answers undefined, so the native attachment flow stays the default.
+     * @param sessionId - the live Session the paste belongs to.
+     * @param modelLabel - the model-selector label currently shown.
+     * @returns the fresh confirmed verdict, or undefined when unconfirmed.
+     */
+    verdictFor(sessionId, modelLabel) {
+        const entry = this.verdicts.get(verdictKey(sessionId, modelLabel));
+        if (entry === undefined || entry.at === 0)
+            return undefined;
+        if (Date.now() - entry.at > VERDICT_MAX_AGE_MS)
+            return undefined;
+        return { takeOver: entry.takeOver, ...(entry.autoSwitch === undefined ? {} : { autoSwitch: entry.autoSwitch }) };
+    }
+    /**
+     * The exact model route the live model catalog reports for one Session.
+     * Unreadable routes answer undefined, so the verdict falls back to the
+     * selector label alone.
+     * @param sessionId - the live Session id.
+     * @returns the current provider/model selection, when readable.
+     */
+    async readSelection(sessionId) {
+        const connection = this.ctx.get('connection');
+        if (connection === undefined)
+            return undefined;
+        try {
+            const { result } = await connection.api.sessions.models({ sessionId });
+            if (!result.ok)
+                return undefined;
+            const current = result.value.current;
+            if (current === undefined || current === null || current.provider === '' || current.model === '')
+                return undefined;
+            return {
+                provider: current.provider,
+                model: current.model,
+                ...(current.reasoningEffort === undefined ? {} : { reasoningEffort: current.reasoningEffort }),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Ask the host what to do with a paste for the current model, and cache the
+     * answer per Session and selector label. A model switch changes the label,
+     * which changes the cache key, so a stale verdict never outlives the model
+     * it described. The exact selection rides along when the live model catalog
+     * is readable, so the host can answer with an auto-switch route; a 404
+     * simply leaves the verdict unconfirmed; the next focus or paste retries.
+     * @param sessionId - the live Session to ask about.
+     * @param modelLabel - the model-selector label currently shown.
+     */
+    refreshVerdict(sessionId, modelLabel) {
+        const key = verdictKey(sessionId, modelLabel);
+        const cached = this.verdicts.get(key);
+        // Dedupe only on an in-flight request, never on freshness: the host's
+        // model route can change under an unchanged Session id.
+        if (cached?.pending)
+            return;
+        const entry = {
+            pending: true,
+            takeOver: cached ? cached.takeOver : false,
+            at: cached ? cached.at : 0,
+            ...(cached?.autoSwitch === undefined ? {} : { autoSwitch: cached.autoSwitch }),
+        };
+        this.verdicts.set(key, entry);
+        void (async () => {
+            const selection = await this.readSelection(sessionId);
+            const query = new URLSearchParams({ sessionId });
+            if (modelLabel !== '')
+                query.set('model', modelLabel);
+            if (selection !== undefined) {
+                query.set('provider', selection.provider);
+                query.set('modelId', selection.model);
+                if (selection.reasoningEffort !== undefined)
+                    query.set('reasoningEffort', selection.reasoningEffort);
+            }
+            let request;
+            try {
+                request = fetch(`${exports.PASTE_POLICY_ROUTE}?${query.toString()}`);
+            }
+            catch {
+                // No fetch surface (test runtime, pre-fetch bootstrap): leave the
+                // verdict unconfirmed rather than letting the paste listener die.
+                entry.pending = false;
+                return;
+            }
+            request
+                .then((response) => {
+                if (response.status === 404) {
+                    // Route not mounted yet (plugin load race, hot reload): forget every
+                    // verdict and retry on the next focus or paste instead of standing
+                    // down for the page lifetime.
+                    this.verdicts.clear();
+                    return null;
+                }
+                if (!response.ok)
+                    throw new Error(`paste policy ${response.status}`);
+                return response.json();
+            })
+                .then((body) => {
+                entry.pending = false;
+                if (body !== null) {
+                    entry.takeOver = body.value.takeOver === true;
+                    if (body.value.autoSwitch !== undefined)
+                        entry.autoSwitch = body.value.autoSwitch;
+                    else
+                        delete entry.autoSwitch;
+                    entry.at = Date.now();
+                }
+            })
+                .catch(() => {
+                entry.pending = false;
+            });
+        })();
+    }
+    /**
+     * Switch one Session to the route the host validated, through the same
+     * model-directory seat the selector uses when present (so the shared UI
+     * state moves with the session), falling back to the raw RPC.
+     * @param sessionId - the live Session id.
+     * @param route - the validated variant route.
+     */
+    async switchModel(sessionId, route) {
+        const directories = this.ctx.get('modelDirectories');
+        if (directories !== undefined) {
+            // The label is a display hint; the seat only needs the exact route.
+            await directories.directoryFor(sessionId).select({
+                provider: route.provider,
+                model: route.model,
+                ...(route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort }),
+            });
+            return;
+        }
+        const connection = this.ctx.get('connection');
+        if (connection === undefined)
+            throw new Error('No model switch channel is available in this Web application');
+        const { result } = await connection.api.sessions.selectModel({
+            sessionId,
+            provider: route.provider,
+            model: route.model,
+            ...(route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort }),
+        });
+        if (!result.ok)
+            throw new Error(`${result.error?.code ?? 'select-model-failed'}: ${result.error?.message ?? 'unknown error'}`);
+    }
+    /**
+     * Replay a swallowed paste as a synthetic clipboard event so the composer's
+     * own intake (limits, thumbnails, keyboard) runs with the captured files.
+     * @returns false when the environment cannot construct a clipboard payload.
+     */
+    replayPaste(target, files, text) {
+        let data;
+        try {
+            data = new DataTransfer();
+            for (const file of files)
+                data.items.add(file);
+            if (text !== '')
+                data.setData('text/plain', text);
+        }
+        catch {
             return false;
-        const target = event.target;
-        if (!(target instanceof HTMLTextAreaElement) || target.closest('[data-composer-card]') === null)
+        }
+        let event;
+        try {
+            event = new ClipboardEvent('paste', {
+                clipboardData: data,
+                bubbles: true,
+                cancelable: true,
+            });
+        }
+        catch {
             return false;
-        event.preventDefault();
-        event.stopPropagation();
-        event.stopImmediatePropagation();
-        const sessionId = this.ctx.sessions.list.getSnapshot().current;
-        if (sessionId === undefined)
-            return true;
+        }
+        if (event.clipboardData === null || event.clipboardData.files.length === 0)
+            return false;
+        this.replaying = true;
+        try {
+            target.dispatchEvent(event);
+        }
+        finally {
+            this.replaying = false;
+        }
+        return true;
+    }
+    /**
+     * Auto-switch flow: switch the Session to the image-input variant, announce
+     * it, then replay the paste into the composer's native intake. A failed
+     * switch, or an environment that cannot replay clipboard bytes, degrades to
+     * the path takeover with the same files.
+     * @param sessionId - the live Session id.
+     * @param target - the composer textarea the paste landed on.
+     * @param files - the captured image files.
+     * @param text - same-paste text, replayed alongside the files.
+     * @param route - the validated variant route to switch to.
+     */
+    async autoSwitchPaste(sessionId, target, files, text, route) {
+        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`);
+        }
+        catch (error) {
+            input.notify('error', `Model switch failed; images will be sent as workspace paths: ${message(error)}`);
+            this.takeoverPaste(sessionId, target, files, text);
+            return;
+        }
+        // Replaying lets the composer's own intake run (thumbnail, limits,
+        // keyboard); if the environment cannot replay clipboard bytes, the
+        // images still land as workspace paths.
+        const before = input.state.getSnapshot().imageIds.length;
+        const replayed = this.replayPaste(target, files, text);
+        const after = input.state.getSnapshot().imageIds.length;
+        if (!replayed || after <= before) {
+            this.takeoverPaste(sessionId, target, files, text);
+        }
+    }
+    /**
+     * Path-takeover flow: insert the same-paste text and every image as a text
+     * reference that serializes to the image's workspace path on send.
+     * @param sessionId - the live Session id.
+     * @param target - the composer textarea the paste landed on.
+     * @param files - the captured image files.
+     * @param text - same-paste text.
+     */
+    takeoverPaste(sessionId, target, files, text) {
         const input = this.inputFor(sessionId);
         const snapshot = input.state.getSnapshot();
         if (snapshot.phase !== 'plain')
-            return true;
+            return;
         const start = Math.max(0, Math.min(target.selectionStart ?? snapshot.draft.length, snapshot.draft.length));
         const end = Math.max(start, Math.min(target.selectionEnd ?? start, snapshot.draft.length));
-        const text = (event.clipboardData?.getData('text/plain') ?? '').replaceAll('\uFFFC', '');
         try {
             let cursor = this.insertText(input, text, start, end);
             validateImages(files);
-            cursor = this.insertRecords(String(sessionId), input, files, cursor);
+            cursor = this.insertRecords(sessionId, input, files, cursor);
             requestAnimationFrame(() => {
                 target.focus({ preventScroll: true });
                 target.setSelectionRange(cursor, cursor);
@@ -1106,6 +1347,45 @@ class PasteImageController {
         catch (error) {
             input.notify('error', message(error));
         }
+    }
+    handlePaste(event) {
+        if (this.replaying)
+            return false;
+        const files = imageFiles(event.clipboardData);
+        if (files.length === 0)
+            return false;
+        const target = event.target;
+        if (!(target instanceof HTMLTextAreaElement) || target.closest('[data-composer-card]') === null)
+            return false;
+        const sessionId = this.ctx.sessions.list.getSnapshot().current;
+        if (sessionId === undefined)
+            return false;
+        const modelLabel = currentModelLabel();
+        this.refreshVerdict(sessionId, modelLabel);
+        // Only a fresh host verdict acts; the native attachment flow stays the
+        // default while the host is unconfirmed.
+        const verdict = this.verdictFor(sessionId, modelLabel);
+        if (verdict === undefined)
+            return false;
+        // An image-capable model (the variant routes included) keeps its native
+        // paste: no switch, no takeover.
+        if (verdict.takeOver === false && verdict.autoSwitch === undefined)
+            return false;
+        event.preventDefault();
+        event.stopPropagation();
+        event.stopImmediatePropagation();
+        const input = this.inputFor(sessionId);
+        if (input.state.getSnapshot().phase !== 'plain')
+            return true;
+        const text = (event.clipboardData?.getData('text/plain') ?? '').replaceAll('\uFFFC', '');
+        if (verdict.autoSwitch !== undefined) {
+            // The text-only model has an image-input variant: switch first, then
+            // let the paste flow natively so the thumbnail and durable session
+            // image are preserved.
+            void this.autoSwitchPaste(sessionId, target, files, text, verdict.autoSwitch);
+            return true;
+        }
+        this.takeoverPaste(sessionId, target, files, text);
         return true;
     }
     remove(sessionId, occurrence) {
@@ -1252,8 +1532,18 @@ function installPasteImages(ctx) {
     });
     ctx.effect(() => {
         const listener = (event) => { controller.handlePaste(event); };
+        // A focus-time prefetch has the verdict ready before the first paste can land.
+        const onFocusIn = () => {
+            const sessionId = ctx.sessions.list.getSnapshot().current;
+            if (sessionId !== undefined)
+                controller.refreshVerdict(String(sessionId), currentModelLabel());
+        };
         document.addEventListener('paste', listener, true);
-        return () => { document.removeEventListener('paste', listener, true); };
+        document.addEventListener('focusin', onFocusIn, true);
+        return () => {
+            document.removeEventListener('paste', listener, true);
+            document.removeEventListener('focusin', onFocusIn, true);
+        };
     }, 'dsh-vision-toolkit: clipboard image capture');
     ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({
         name: 'conversation.input.dock',