dsh-prompt-predict 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ferrisching
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,170 @@
-# Temporary Holding Version
+# dsh-prompt-predict
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<div align="center">
+  <b>Codex 风格的输入框提示词联想</b><br />
+  助手回复结束后，把你的下一句话以灰色 ghost text 直接写进输入框 —— <b>Tab 采纳</b>、<b>Esc 忽略</b>、开始输入自动消失<br /><br />
+  <a href="https://github.com/ferrisching/dsh-prompt-predict/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/ferrisching/dsh-prompt-predict" /></a>
+  <img alt="version 0.1.0" src="https://img.shields.io/badge/version-0.1.0-blue" />
+  <img alt="已验证 DSH 0.2.0-rc.2" src="https://img.shields.io/badge/DSH-0.2.0--rc.2-4d6bfe" />
+  <img alt="零运行时依赖" src="https://img.shields.io/badge/%E4%BE%9D%E8%B5%96-%E9%9B%B6%E8%BF%90%E8%A1%8C%E6%97%B6%E4%BE%9D%E8%B5%96-41ba41" />
+  <img alt="客户端 + Host 双端插件" src="https://img.shields.io/badge/%E5%BD%A2%E6%80%81-Host%20%2B%20%E5%AE%A2%E6%88%B7%E7%AB%AF%E6%8F%92%E4%BB%B6-8250df" />
+  <a href="./LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-yellow.svg" /></a>
+</div>
+
+`dsh-prompt-predict` 是一个 [DeepSeek Harness](https://www.deepseek.com/) 插件：每轮助手回复结束后，它根据当前会话预测你**下一句最可能输入什么**，并以灰色 ghost text 的形式浮在输入框里。整条建议不写进编辑器，只有按下 `Tab` 采纳时才真正插入（可撤销），因此误预测零成本。
+
+## 📑 目录
+
+- [✨ 功能一览](#-功能一览)
+- [🚀 安装](#-安装)
+- [⌨️ 使用](#-使用)
+- [⚙️ 设置](#-设置)
+- [🔌 HTTP 接口](#-http-接口)
+- [🧩 工作原理](#-工作原理)
+- [🛠️ 开发](#-开发)
+- [🔐 安全与成本](#-安全与成本)
+- [⚠️ 已知限制](#-已知限制)
+- [📄 许可](#-许可)
+
+## ✨ 功能一览
+
+- **回复结束即出建议**：在输入框首字符处浮出灰色 ghost text，光标位置、字号、行高都对齐当前编辑器
+- **三种交互**：`Tab` 采纳 · `Esc` 忽略 · 开始输入自动消失；采纳前建议不属于会话内容
+- **轻量上下文**：只取最近若干条 user/assistant 的纯文本，工具结果、附件、系统提示一律不进辅助调用
+- **默认跟随当前会话模型**：不写死任何提供商，联想调用沿用会话自身选用的模型；也可以在设置页固定到某个更便宜的模型
+- **全部可调**：开关、提供商 / 模型、响应超时、上下文规模、思考深度，保存后立即生效，无需重启 DSH
+- **零运行时依赖**：纯 ESM，Host 端与客户端都不引入第三方包
+
+## 🚀 安装
+
+### 从源码安装（推荐）
+
+```bash
+git clone https://github.com/ferrisching/dsh-prompt-predict.git
+cd dsh-prompt-predict
+bash scripts/install.sh
+```
+
+脚本会现场打包本仓库、装进 profile 的 `node_modules`，并把 `dsh-prompt-predict` 接进 `dsh.profile.bundles`。默认目标是 `~/.dsh/profiles/desktop`，装别的 profile：
+
+```bash
+bash scripts/install.sh ~/.dsh/profiles/web
+```
+
+**装完重启 DSH 生效**，然后在 **设置 → 提示词联想** 里能看到开关与各项参数。
+
+### 手动安装
+
+```bash
+cd ~/.dsh/profiles/desktop
+pnpm add /path/to/dsh-prompt-predict
+```
+
+再打开该 profile 的 `package.json`，把 `"dsh-prompt-predict"` 加进 `dsh.profile.bundles` 数组，重启 DSH。
+
+> `pnpm add <仓库目录>` 装的是符号链接，指向你的工作区，适合边改边调；`scripts/install.sh` 装的是打包副本。
+
+### 安装要求
+
+- 已在 **DSH `0.2.0-rc.2`** 上验证（桌面端）
+- `node` / `pnpm`：安装脚本优先使用 `~/.dsh/dsh-runtimes/*/dependencies` 下 DSH 自带的运行时，找不到才回退 `PATH`
+- macOS / Linux；Windows 未验证
+
+## ⌨️ 使用
+
+1. 正常对话，等助手这一轮回复结束，且**输入框为空**
+2. 约 350 ms 后，输入框里浮出一条灰色建议
+3. 想用就按 `Tab`（建议此刻才插入输入框，可撤销）；不想用按 `Esc`，或直接开始打字，建议自动消失
+
+建议只在输入框为空、且当前会话不在运行中时出现；切换会话、中断回复都会清掉旧建议。
+
+## ⚙️ 设置
+
+**设置 → 提示词联想**：
+
+| 设置项 | 说明 | 默认 |
+|---|---|---|
+| 启用联想 | 总开关 | 开 |
+| 提供商 / 模型 | 联想调用使用的模型；选「跟随当前会话模型」则沿用会话自身模型 | 跟随当前会话模型 |
+| 响应超时（高级） | 1–60 秒 | 12 秒 |
+| 上下文规模（高级） | 少 3 条 / 标准 8 条 / 多 12 条 | 标准 8 条 |
+| 思考深度（高级） | 选项**按所选模型动态生成**，模型不支持的档位不会出现 | 关闭（最快最省） |
+
+- 保存后**立即生效**，无需重启 DSH
+- 设置落盘在 `~/.dsh/dsh-prompt-predict/config.json`（权限 600）
+- 优先级：**用户保存的设置 > cordis patch 部署默认 > 内置默认**
+
+## 🔌 HTTP 接口
+
+插件在 DSH 的 Web 服务上注册同源前缀路由 `/dsh-prompt-predict`，设置页与输入框联想都走它。所有接口都经 DSH 浏览器 Cookie 认证（`connection.requestRejection`），非本机浏览器调用会拿到 401/403。
+
+| 方法 | 路径 | 说明 |
+|---|---|---|
+| GET | `/dsh-prompt-predict/status` | 当前会话模型、有效设置、已保存项、部署默认 |
+| GET | `/dsh-prompt-predict/catalog` | 全部 provider 与模型（供下拉选择） |
+| GET | `/dsh-prompt-predict/efforts?provider=&model=` | 该模型真实支持的思考档位 |
+| POST | `/dsh-prompt-predict/settings` | 保存设置；`{ "reset": true }` 恢复默认 |
+| POST | `/dsh-prompt-predict/suggest` | `{ sessionId }` → 一条建议 |
+
+## 🧩 工作原理
+
+**Host 端**（`lib/`）
+
+1. `lib/index.js` 作为插件入口注册同源 HTTP 路由
+2. 收到 `suggest` 后，`lib/predict.mjs` 从会话里裁出最近的 user/assistant 纯文本——按条数上限和字符预算从后往前取
+3. 裁剪结果被**帧化成一条 request-only 的 user 输入**再发给辅助模型：DSH 的 Assistant Message 必须带完整 `stream` / `replayState`，不能拿裁剪片段伪装成助手消息（与 session-title 的做法一致）
+4. 流式收回的文本经归一化（剥掉代码块包装、`建议：` 前缀、成对引号，合并换行）后返回给客户端
+
+模型选择上，`provider` / `model` 为 `auto` 表示跟随会话；此时不向辅助调用写死路由，由 `predictNextPrompt` 继承会话自身选用的模型。
+
+**客户端**（`client/`）
+
+- 注入 `conversation.composer.dock`（输入框旁的生命周期挂载点）与 `settings.section`（设置页分区）两个 slot
+- ghost text 是一层**覆盖层**，不写进 Lexical 编辑器；只有采纳时才通过 `inputActions.insertText` 真正插入
+
+## 🛠️ 开发
+
+```bash
+git clone https://github.com/ferrisching/dsh-prompt-predict.git
+cd dsh-prompt-predict
+node test/predict.mjs      # 31 项：文本裁剪、建议清洗、路由继承、设置校验、接口端到端
+```
+
+```
+.
+├── lib/                 Host 端（纯 ESM，无构建步骤）
+│   ├── index.js         插件入口，注册 HTTP 路由
+│   ├── host-route.mjs   同源接口：状态 / 模型目录 / 思考档位 / 设置 / 建议
+│   ├── predict.mjs      会话裁剪、调用辅助模型、建议归一化
+│   └── config.mjs       用户设置持久化
+├── client/
+│   └── client.js        客户端：输入框 ghost text 覆盖层 + 设置页
+├── test/
+│   └── predict.mjs      31 项用例
+├── scripts/
+│   └── install.sh       一键安装 / 升级
+├── cordis.patch.yml     插件挂载补丁
+└── package.json
+```
+
+测试不依赖 DSH 运行时：用假 ctx 与本地 HTTP server 覆盖路由注册、设置校验、路由继承与端到端调用。
+
+## 🔐 安全与成本
+
+- 每轮助手回复最多产生**一次**小额辅助调用，默认 `maxTokens: 64`
+- 建议**不写入会话日志**；只有按 `Tab` 采纳并发送后才成为正式消息
+- 只发送裁剪后的 user/assistant 纯文本，工具结果、附件、系统提示都不出本机
+- 设置页与联想接口均走 DSH 自身的浏览器 Cookie 认证
+
+## ⚠️ 已知限制
+
+- 仅在 DSH `0.2.0-rc.2` 上验证过，其它版本未测
+- 依赖宿主的 `conversation.composer.dock` 与 `settings.section` 两个 slot 名称，DSH 大版本调整后可能需要适配
+- **尚未发布到 npm 官方源**，因此暂时无法通过 DSH 的「添加插件」向导安装，只能用上面的源码安装方式
+- 联想会消耗所选模型的额度；固定到快速小模型比跟随推理模型更省
+
+## 📄 许可
+
+[MIT](LICENSE) © ferrisching
+
+可以自由使用、修改、分发，包括闭源商业项目；只需保留版权声明与许可证文本。

package/client/client.js

@@ -0,0 +1,410 @@
+window.__ModuleLoader__.load({
+  id: "dsh-prompt-predict",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+    var React = require("react");
+    var h = React.createElement;
+    var useState = React.useState;
+    var useEffect = React.useEffect;
+    var useRef = React.useRef;
+    var useCallback = React.useCallback;
+
+    var name = "dsh-prompt-predict";
+    var inject = ["slots"];
+
+    var EFFORT_LABELS = {
+      off: "关闭", none: "关闭", minimal: "最小", low: "低", medium: "中", high: "高", max: "最大",
+    };
+
+    // ---------- 设置页样式 ----------
+    var SS = {
+      card: { border: "1px solid var(--dsh-border, #e7e8ee)", borderRadius: 14, padding: "20px 22px", maxWidth: 560, background: "var(--dsh-bg, #fff)" },
+      title: { fontSize: 15, fontWeight: 600, color: "#111827", margin: "0 0 4px" },
+      muted: { color: "#6b7280", fontSize: 13, lineHeight: 1.7 },
+      row: { display: "flex", alignItems: "center", gap: 12, margin: "14px 0" },
+      label: { width: 110, fontSize: 13, color: "#374151", flex: "none" },
+      select: { flex: 1, padding: "7px 10px", border: "1px solid #d1d5db", borderRadius: 8, fontSize: 13, background: "#fff", maxWidth: 320 },
+      input: { width: 90, padding: "7px 10px", border: "1px solid #d1d5db", borderRadius: 8, fontSize: 13 },
+      btnPrimary: { padding: "8px 16px", border: 0, borderRadius: 8, background: "#4f6ef7", color: "#fff", cursor: "pointer", fontSize: 13 },
+      btnGhost: { padding: "8px 16px", border: "1px solid #e5e7eb", borderRadius: 8, background: "#fff", color: "#374151", cursor: "pointer", fontSize: 13 },
+      toggleTrack: function (on) { return { width: 38, height: 22, borderRadius: 22, border: 0, cursor: "pointer", padding: 2, background: on ? "#4f6ef7" : "#d1d5db", transition: "background .15s" }; },
+      toggleThumb: function (on) { return { display: "block", width: 18, height: 18, borderRadius: 18, background: "#fff", transform: on ? "translateX(16px)" : "translateX(0)", transition: "transform .15s" }; },
+      err: { color: "#dc2626", fontSize: 12, marginTop: 8 },
+      ok: { color: "#047857", fontSize: 12, marginTop: 8 },
+      divider: { borderTop: "1px solid #ececf1", margin: "16px 0" },
+      advBtn: { background: "none", border: 0, color: "#4f6ef7", fontSize: 13, cursor: "pointer", padding: 0 },
+    };
+    function dim(style, busy) { return busy ? Object.assign({}, style, { opacity: .55, cursor: "not-allowed" }) : style; }
+
+    function api(path, body) {
+      var controller = new AbortController();
+      var timer = setTimeout(function () { controller.abort(); }, 15000);
+      var opts = body === undefined ? {} : {
+        method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body),
+      };
+      return fetch("./dsh-prompt-predict/" + path, Object.assign({}, opts, { signal: controller.signal }))
+        .then(function (r) { return r.json(); })
+        .finally(function () { clearTimeout(timer); });
+    }
+
+    function notifySettings(effective) {
+      window.dispatchEvent(new CustomEvent("dsh-prompt-predict:settings", { detail: effective }));
+    }
+
+    function findEditor(sessionId) {
+      var scoped = sessionId ? document.querySelector('[data-conversation-session="' + sessionId + '"] [data-composer-input="true"]') : null;
+      return scoped || document.querySelector('[data-composer-input="true"]');
+    }
+
+    // 行内 ghost text 覆盖层：不写进 Lexical，只有 Tab/点击采纳时才 insertText。
+    function GhostOverlay(props) {
+      var suggestion = props.suggestion;
+      var sessionId = props.sessionId;
+      var onAccept = props.onAccept;
+      var _p = useState(null), pos = _p[0], setPos = _p[1];
+
+      var measure = useCallback(function () {
+        var ed = findEditor(sessionId);
+        if (!ed) { setPos(null); return; }
+        var r = ed.getBoundingClientRect();
+        var cs = getComputedStyle(ed);
+        setPos({
+          left: r.left + parseFloat(cs.paddingLeft || "0"),
+          top: r.top + parseFloat(cs.paddingTop || "0"),
+          fontFamily: cs.fontFamily,
+          fontSize: cs.fontSize,
+          lineHeight: cs.lineHeight,
+          fontWeight: cs.fontWeight,
+        });
+      }, [sessionId]);
+
+      useEffect(function () {
+        measure();
+        var ed = findEditor(sessionId);
+        var ro = null;
+        if (typeof ResizeObserver !== "undefined" && ed) { ro = new ResizeObserver(measure); ro.observe(ed); }
+        window.addEventListener("resize", measure, true);
+        window.addEventListener("scroll", measure, true);
+        return function () {
+          if (ro) ro.disconnect();
+          window.removeEventListener("resize", measure, true);
+          window.removeEventListener("scroll", measure, true);
+        };
+      }, [measure, suggestion]);
+
+      useEffect(function () {
+        var ed = findEditor(sessionId);
+        var ph = ed && ed.parentElement ? ed.parentElement.querySelector('[class*="placeholder"]') : null;
+        if (ph) ph.style.visibility = "hidden";
+        return function () { if (ph) ph.style.visibility = ""; };
+      }, [sessionId, suggestion]);
+
+      if (!pos) return null;
+      return h("div", {
+        role: "status",
+        "aria-live": "polite",
+        "data-prompt-predict-ghost": "true",
+        style: {
+          position: "fixed", left: pos.left, top: pos.top, zIndex: 60,
+          display: "flex", alignItems: "baseline", gap: 8, pointerEvents: "none",
+          fontFamily: pos.fontFamily, fontSize: pos.fontSize, lineHeight: pos.lineHeight, fontWeight: pos.fontWeight,
+          maxWidth: "min(70vw, 72ch)",
+        },
+      },
+        h("span", {
+          style: { color: "#9aa3b2", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", maxWidth: "60ch" },
+        }, suggestion),
+        h("button", {
+          type: "button", onClick: onAccept,
+          title: "Tab 采纳 · Esc 忽略",
+          style: {
+            pointerEvents: "auto", flex: "none", padding: "0 7px", height: 19, borderRadius: 5,
+            border: "1px solid var(--dsw-alias-border-l1, #d1d5db)", background: "var(--dsw-alias-bg-secondary, #f8fafc)",
+            color: "#9aa3b2", fontSize: 10, fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace", cursor: "pointer",
+          },
+        }, "Tab"),
+        h("span", { style: { color: "#b0b7c3", fontSize: 10, whiteSpace: "nowrap" } }, "Esc 忽略"));
+    }
+
+    // ================= 建议（composer dock 仅提供生命周期；显示覆盖到输入框内） =================
+    function PredictionDock(props) {
+      var sessionId = props.sessionId;
+      var useSession = props.useSession;
+      var useInput = props.useInput;
+      var inputActions = props.inputActions;
+      var running = useSession(function (value) { return Boolean(value && value.running); });
+      var blank = useSession(function (value) { return Boolean(value && value.blank); });
+      var removed = useSession(function (value) { return Boolean(value && value.removed); });
+      var draft = useInput(function (value) { return String(value && value.draft || ""); });
+      var _s = useState(""), suggestion = _s[0], setSuggestion = _s[1];
+      var _en = useState(true), enabled = _en[0], setEnabled = _en[1];
+      var armed = useRef(true);
+      var abortRef = useRef(null);
+      var sessionRef = useRef(sessionId);
+      var dismissedByDraft = useRef(false);
+      if (draft.trim() !== "") dismissedByDraft.current = true;
+      var visibleSuggestion = dismissedByDraft.current ? "" : suggestion;
+
+      // 首次读取启用状态；设置页保存后通过事件让当前会话立即生效。
+      useEffect(function () {
+        api("status").then(function (j) { setEnabled(!(j && j.effective && j.effective.enabled === false)); }).catch(function () { });
+      }, [sessionId]);
+      useEffect(function () {
+        var changed = function (event) {
+          var on = event.detail?.enabled !== false;
+          setEnabled(on);
+          if (!on) {
+            setSuggestion("");
+            if (abortRef.current) abortRef.current.abort();
+          }
+        };
+        window.addEventListener("dsh-prompt-predict:settings", changed);
+        return function () { window.removeEventListener("dsh-prompt-predict:settings", changed); };
+      }, []);
+
+      useEffect(function () {
+        sessionRef.current = sessionId;
+        armed.current = true;
+        dismissedByDraft.current = false;
+        setSuggestion("");
+        if (abortRef.current) abortRef.current.abort();
+      }, [sessionId]);
+
+      useEffect(function () {
+        if (!enabled) return;
+        if (running) {
+          armed.current = true;
+          dismissedByDraft.current = false;
+          setSuggestion("");
+          if (abortRef.current) abortRef.current.abort();
+          return;
+        }
+        if (!sessionId || blank || removed || !armed.current) return;
+        if (draft.trim() !== "") return;
+        armed.current = false;
+        var controller = new AbortController();
+        abortRef.current = controller;
+        var timer = setTimeout(function () {
+          api("suggest", { sessionId: sessionId })
+            .then(function (result) {
+              if (controller.signal.aborted || sessionRef.current !== sessionId) return;
+              if (result && result.ok && typeof result.suggestion === "string") setSuggestion(result.suggestion.trim());
+            })
+            .catch(function () { /* 预测失败静默，不打断正常输入 */ });
+        }, 350);
+        return function () {
+          clearTimeout(timer);
+          controller.abort();
+          if (abortRef.current === controller) abortRef.current = null;
+        };
+      }, [sessionId, running, blank, removed, draft, enabled]);
+
+      var accept = useCallback(function () {
+        if (!visibleSuggestion || !inputActions || draft.trim() !== "") return false;
+        try {
+          var span = inputActions.captureInsertion();
+          if (!inputActions.insertText(visibleSuggestion, span)) return false;
+          setSuggestion("");
+          return true;
+        } catch { return false; }
+      }, [visibleSuggestion, inputActions, draft]);
+
+      useEffect(function () {
+        if (!visibleSuggestion) return;
+        var onKey = function (event) {
+          if (event.isComposing) return;
+          if (event.key === "Escape") { event.preventDefault(); setSuggestion(""); return; }
+          if (event.key !== "Tab" || event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return;
+          if (!accept()) return;
+          event.preventDefault();
+          event.stopPropagation();
+        };
+        window.addEventListener("keydown", onKey, true);
+        return function () { window.removeEventListener("keydown", onKey, true); };
+      }, [visibleSuggestion, accept]);
+
+      // 建议直接以灰色 ghost text 覆盖在 Lexical 输入框首字符处。
+      if (!enabled || draft.trim() !== "" || !visibleSuggestion) return null;
+      return h(GhostOverlay, { suggestion: visibleSuggestion, sessionId: sessionId, onAccept: accept });
+    }
+
+    // ================= 设置页 =================
+    function SettingsSection() {
+      var _st = useState(null), st = _st[0], setSt = _st[1];
+      var _cat = useState(null), cat = _cat[0], setCat = _cat[1];
+      var _pv = useState(""), provider = _pv[0], setProvider = _pv[1];
+      var _md = useState(""), model = _md[0], setModel = _md[1];
+      var _to = useState(12), timeoutSec = _to[0], setTimeoutSec = _to[1];
+      var _ctx = useState(8), ctxSize = _ctx[0], setCtxSize = _ctx[1];
+      var _ef = useState("off"), effort = _ef[0], setEffort = _ef[1];
+      var _eo = useState([]), effortOptions = _eo[0], setEffortOptions = _eo[1];
+      var _busy = useState(false), busy = _busy[0], setBusy = _busy[1];
+      var _msg = useState(null), msg = _msg[0], setMsg = _msg[1];
+      var _adv = useState(false), adv = _adv[0], setAdv = _adv[1];
+      var _dirty = useState(false), dirty = _dirty[0], setDirty = _dirty[1];
+
+      function loadAll() {
+        api("status").then(function (j) {
+          if (!j || !j.ok) return;
+          setSt(j);
+          var eff = j.effective || {};
+          setProvider(eff.provider || "");
+          setModel(eff.model || "");
+          setTimeoutSec(Math.round((eff.timeoutMs || 12000) / 1000));
+          setCtxSize(eff.maxMessages || 8);
+          setEffort(eff.reasoningEffort || "off");
+          setDirty(false);
+        }).catch(function () { });
+        api("catalog").then(function (j) { if (j && j.ok) setCat(j.groups || []); }).catch(function () { });
+      }
+      useEffect(function () { loadAll(); }, []);
+
+      // 思考档位跟随所选模型动态生成（模型不支持的档位不出现，避免保存被拒）；
+      // 选「跟随当前会话模型」时，按当前会话实际使用的模型取档位。
+      useEffect(function () {
+        var p = provider, m = model;
+        if (p === "auto" || m === "auto") {
+          var cur = (st && st.current) || {};
+          p = cur.provider; m = cur.model;
+        }
+        if (!p || !m) { setEffortOptions([]); return; }
+        api("efforts?provider=" + encodeURIComponent(p) + "&model=" + encodeURIComponent(m))
+          .then(function (j) { setEffortOptions(j && j.ok && Array.isArray(j.efforts) ? j.efforts : []); })
+          .catch(function () { setEffortOptions([]); });
+      }, [provider, model, st]);
+
+      function providerGroups() { return (cat || []).filter(function (g) { return g.models && g.models.length; }); }
+      function modelsOf(p) {
+        var g = (cat || []).find(function (x) { return x.id === p; });
+        return g ? g.models : [];
+      }
+
+      function save() {
+        setBusy(true); setMsg(null);
+        api("settings", {
+          provider: provider, model: model,
+          timeoutMs: timeoutSec * 1000,
+          maxMessages: ctxSize,
+          reasoningEffort: effort,
+        }).then(function (j) {
+          if (j && j.ok) { notifySettings(j.effective); setMsg({ ok: true, text: "已保存，立即生效" }); setDirty(false); loadAll(); }
+          else setMsg({ ok: false, text: (j && j.reason) || "保存失败" });
+        }).catch(function (e) { setMsg({ ok: false, text: String(e) }); })
+          .finally(function () { setBusy(false); });
+      }
+      function toggleEnabled(on) {
+        setBusy(true); setMsg(null);
+        api("settings", { enabled: on }).then(function (j) {
+          if (j && j.ok) { notifySettings(j.effective); setSt(Object.assign({}, st, { effective: j.effective })); loadAll(); setMsg({ ok: true, text: on ? "已开启联想" : "已关闭联想" }); }
+          else setMsg({ ok: false, text: (j && j.reason) || "操作失败" });
+        }).catch(function (e) { setMsg({ ok: false, text: String(e) }); })
+          .finally(function () { setBusy(false); });
+      }
+      function resetDefaults() {
+        setBusy(true); setMsg(null);
+        api("settings", { reset: true }).then(function (j) {
+          if (j && j.ok) { notifySettings(j.effective); setMsg({ ok: true, text: "已恢复默认" }); loadAll(); }
+        }).finally(function () { setBusy(false); });
+      }
+
+      if (!st) return h("div", { style: SS.card }, h("p", { style: SS.muted }, "加载中…"));
+      var eff = st.effective || {};
+      var enabled = eff.enabled !== false;
+
+      return h("div", { style: SS.card },
+        h("p", { style: SS.title }, "提示词联想"),
+        h("p", { style: SS.muted }, "助手回复结束后，在输入框里直接给出灰色建议（Tab 采纳、Esc 忽略、开始输入自动消失）。"),
+
+        h("div", { style: SS.row },
+          h("span", { style: SS.label }, "启用联想"),
+          h("button", { type: "button", style: SS.toggleTrack(enabled), onClick: function () { toggleEnabled(!enabled); }, disabled: busy, "aria-pressed": enabled },
+            h("span", { style: SS.toggleThumb(enabled) })),
+          h("span", { style: SS.muted }, enabled ? "已开启" : "已关闭")),
+
+        h("div", { style: SS.divider }),
+
+        h("div", { style: SS.row },
+          h("span", { style: SS.label }, "提供商"),
+          h("select", {
+            style: SS.select, value: provider, disabled: !enabled || busy,
+            onChange: function (e) {
+              var p = e.target.value;
+              setProvider(p);
+              if (p === "auto") { setModel("auto"); }
+              else { var ms = modelsOf(p); setModel(ms.length ? ms[0].id : ""); }
+              setEffort("auto"); setDirty(true);
+            },
+          },
+            h("option", { value: "auto" }, "跟随当前会话模型"),
+            providerGroups().map(function (g) {
+              return h("option", { key: g.id, value: g.id }, g.name + "（" + g.id + "）");
+            }))),
+        h("div", { style: SS.row },
+          h("span", { style: SS.label }, "模型"),
+          h("select", {
+            style: SS.select, value: model, disabled: !enabled || busy || provider === "auto",
+            onChange: function (e) { setModel(e.target.value); setEffort("auto"); setDirty(true); },
+          },
+            provider === "auto"
+              ? h("option", { value: "auto" }, "跟随当前会话模型")
+              : modelsOf(provider).map(function (m) {
+                  return h("option", { key: m.id, value: m.id }, m.name + "（" + m.id + "）");
+                }))),
+        h("p", { style: SS.muted }, "默认跟随当前会话模型；也可固定到某个模型——选快模型更省额度。"),
+
+        h("p", null, h("button", { style: SS.advBtn, onClick: function () { setAdv(!adv); } }, (adv ? "▾" : "▸") + " 高级")),
+        adv ? h("div", null,
+          h("div", { style: SS.row },
+            h("span", { style: SS.label }, "响应超时"),
+            h("input", { style: SS.input, type: "number", min: 1, max: 60, value: timeoutSec, disabled: !enabled || busy, onChange: function (e) { setTimeoutSec(Number(e.target.value)); setDirty(true); } }),
+            h("span", { style: SS.muted }, "秒（1–60）")),
+          h("div", { style: SS.row },
+            h("span", { style: SS.label }, "上下文规模"),
+            h("select", { style: SS.select, value: ctxSize, disabled: !enabled || busy, onChange: function (e) { setCtxSize(Number(e.target.value)); setDirty(true); } },
+              h("option", { value: 3 }, "少：最近 3 条消息"),
+              h("option", { value: 8 }, "标准：最近 8 条（默认）"),
+              h("option", { value: 12 }, "多：最近 12 条")),
+            h("span", { style: SS.muted }, "越多越准但越慢")),
+          h("div", { style: SS.row },
+            h("span", { style: SS.label }, "思考深度"),
+            h("select", { style: SS.select, value: effort, disabled: !enabled || busy, onChange: function (e) { setEffort(e.target.value); setDirty(true); } },
+              h("option", { value: "auto" }, effortOptions.length === 0 ? "跟随模型默认（该模型未公布可调档位）" : "跟随模型默认"),
+              (function () {
+                var ids = effortOptions.slice();
+                if (effort && effort !== "auto" && ids.indexOf(effort) === -1) ids.push(effort); // 保留当前已保存值，避免下拉显示错位
+                return ids.map(function (id) {
+                  return h("option", { key: id, value: id }, (EFFORT_LABELS[id] || id) + (id === "off" ? "（最快最省）" : ""));
+                });
+              })()),
+            h("span", { style: SS.muted }, "联想宜浅；过深会把 token 烧在推理上")) ) : null,
+
+        h("div", { style: { display: "flex", gap: 10, marginTop: 16 } },
+          h("button", { style: dim(SS.btnPrimary, busy || !dirty), onClick: save, disabled: busy || !dirty }, busy ? "保存中…" : "保存"),
+          h("button", { style: dim(SS.btnGhost, busy), onClick: resetDefaults, disabled: busy }, "恢复默认")),
+        msg ? h("p", { style: msg.ok ? SS.ok : SS.err }, msg.text) : null);
+    }
+
+    function apply(ctx) {
+      ctx.slots.inject("conversation.composer.dock", function () {
+        return ctx.slots.register({
+          name: "conversation.composer.dock",
+          id: "prompt-prediction",
+          order: 10,
+        }, PredictionDock);
+      });
+      ctx.slots.inject("settings.section", function () {
+        return ctx.slots.register({
+          name: "settings.section",
+          id: "prompt-predict",
+          order: 2,
+          label: function () { return "提示词联想"; },
+          inject: function () { return {}; },
+        }, SettingsSection);
+      });
+    }
+
+    module.exports = { name: name, inject: inject, apply: apply };
+    return module.exports;
+  },
+});

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-prompt-predict
+      name: dsh-prompt-predict

package/lib/config.mjs

@@ -0,0 +1,28 @@
+// 用户设置持久化（~/.dsh/dsh-prompt-predict/config.json，600）。
+// 只存用户覆盖的字段；未覆盖的走 cordis patch 部署默认 → 内置默认。
+import { readFileSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+
+export function configFilePath() {
+  return join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'dsh-prompt-predict', 'config.json');
+}
+
+export function readSettings() {
+  try {
+    const raw = JSON.parse(readFileSync(configFilePath(), 'utf8'));
+    return raw && typeof raw === 'object' ? raw : {};
+  } catch { return {}; }
+}
+
+export function writeSettings(patch) {
+  const next = { ...readSettings(), ...patch };
+  for (const key of Object.keys(next)) if (next[key] === undefined || next[key] === null) delete next[key];
+  mkdirSync(dirname(configFilePath()), { recursive: true, mode: 0o700 });
+  writeFileSync(configFilePath(), JSON.stringify(next, null, 2), { mode: 0o600 });
+  return next;
+}
+
+export function clearSettings() {
+  try { rmSync(configFilePath()); } catch { /* 不存在 */ }
+}

package/lib/host-route.mjs

@@ -0,0 +1,264 @@
+// 同源 HTTP 接口：提示词预测 + 设置页（启用开关、模型选择、高级参数）。
+import { predictNextPrompt } from './predict.mjs';
+import { readSettings, writeSettings, clearSettings } from './config.mjs';
+
+const MAX_BODY = 16 * 1024;
+
+function readJson(req) {
+  return new Promise((resolve) => {
+    let raw = '';
+    let tooBig = false;
+    req.on('data', (chunk) => {
+      if (tooBig) return;
+      raw += chunk;
+      if (raw.length > MAX_BODY) { tooBig = true; raw = ''; }
+    });
+    req.on('end', () => {
+      if (tooBig) return resolve(null);
+      try { resolve(raw ? JSON.parse(raw) : {}); } catch { resolve(null); }
+    });
+    req.on('error', () => resolve(null));
+  });
+}
+
+function sendJson(res, status, value) {
+  if (res.writableEnded) return;
+  const body = JSON.stringify(value);
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(body),
+    'cache-control': 'no-store',
+  });
+  res.end(body);
+}
+
+export function registerPredictRoute(ctx, cordisConfig = {}) {
+  const webServer = ctx?.webServer;
+  const connection = ctx?.connection;
+  if (!webServer || typeof webServer.register !== 'function') return null;
+
+  // provider/model 为 'auto' 表示「跟随当前会话模型」：不向辅助调用写死路由，
+  // 由 predictNextPrompt 继承会话自身选用的模型。
+  const AUTO = 'auto';
+  const isAuto = (value) => !value || value === AUTO;
+  const routeOf = (provider, model) => (isAuto(provider) || isAuto(model) ? undefined : { provider, model });
+
+  // 内置默认（可被 cordis patch 部署默认覆盖，再被用户保存的设置覆盖）
+  const builtinDefaults = {
+    enabled: true,
+    provider: AUTO,
+    model: AUTO,
+    timeoutMs: 12000,
+    maxTokens: 64,
+    maxMessages: 8,
+    maxChars: 6000,
+    reasoningEffort: 'off',
+  };
+  const deployDefaults = { ...builtinDefaults, ...cordisConfig };
+
+  const currentSelection = () => {
+    try { return ctx.agentDefaultModel.currentSelection() ?? {}; } catch { return {}; }
+  };
+
+  /** 有效设置 = 部署默认 + 用户保存的覆盖（每次请求时读取，改设置立即生效）。 */
+  const effective = () => ({ ...deployDefaults, ...readSettings() });
+
+
+  async function catalogGroups() {
+    const providers = ctx.llm.listProviders();
+    return Promise.all(providers.map(async (provider) => {
+      try {
+        const models = await ctx.llm.listModels(provider.id);
+        return { id: provider.id, name: provider.name, models: models.map((m) => ({ id: m.id, name: m.name })) };
+      } catch (error) {
+        return { id: provider.id, name: provider.name, models: [], error: String(error?.message ?? error) };
+      }
+    }));
+  }
+
+  async function validateRoute(provider, model) {
+    try {
+      const models = await ctx.llm.listModels(provider);
+      if (!models.some((m) => m.id === model)) return `provider "${provider}" 没有模型 "${model}"`;
+      return null;
+    } catch (error) {
+      return `provider "${provider}" 不可用：${String(error?.message ?? error)}`;
+    }
+  }
+
+  async function validateEffort(provider, model, effort) {
+    if (!['off', 'low', 'high', 'max'].includes(effort)) return '不支持的思考深度';
+    const controller = new AbortController();
+    let timer;
+    try {
+      const info = await Promise.race([
+        ctx.llm.resolveModelInfo(provider, model, controller.signal),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => { controller.abort(); reject(new Error('模型能力查询超时')); }, 3500);
+        }),
+      ]);
+      const efforts = info?.reasoning?.efforts?.map((e) => e.id) ?? [];
+      if (efforts.length === 0) return `模型 "${model}" 未公布可调思考深度，请选「跟随模型默认」`;
+      if (!efforts.includes(effort)) return `模型 "${model}" 不支持思考深度 "${effort}"（可选：${efforts.join('、')}）`;
+      return null;
+    } catch {
+      return '暂时无法确认模型支持的思考深度，请选「跟随模型默认」后保存';
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  const route = {
+    kind: 'prefix',
+    path: '/dsh-prompt-predict',
+    handler: async (req, res) => {
+      let rejection;
+      if (typeof connection?.requestRejection === 'function') {
+        try { rejection = connection.requestRejection(req); } catch { rejection = 403; }
+      } else {
+        rejection = 403;
+      }
+      if (rejection !== undefined) {
+        sendJson(res, rejection, { ok: false, reason: rejection === 401 ? 'unauthorized' : 'forbidden' });
+        return;
+      }
+
+      const path = new URL(req.url ?? '/', 'http://x').pathname;
+
+      if (path === '/dsh-prompt-predict/status' && req.method === 'GET') {
+        const current = currentSelection();
+        sendJson(res, 200, {
+          ok: true,
+          current: { provider: current.provider ?? null, model: current.model ?? null },
+          effective: effective(),
+          saved: readSettings(),
+          defaults: deployDefaults,
+        });
+        return;
+      }
+
+      if (path === '/dsh-prompt-predict/catalog' && req.method === 'GET') {
+        sendJson(res, 200, { ok: true, groups: await catalogGroups() });
+        return;
+      }
+
+      // 某个 provider/model 实际支持的思考档位（设置页据此动态生成下拉，避免出现无效选项）
+      if (path === '/dsh-prompt-predict/efforts' && req.method === 'GET') {
+        const url = new URL(req.url ?? '/', 'http://x');
+        const provider = url.searchParams.get('provider') ?? '';
+        const model = url.searchParams.get('model') ?? '';
+        if (!provider || !model) { sendJson(res, 400, { ok: false, reason: '缺少 provider 或 model' }); return; }
+        const controller = new AbortController();
+        let timer;
+        try {
+          const info = await Promise.race([
+            ctx.llm.resolveModelInfo(provider, model, controller.signal),
+            new Promise((_, reject) => { timer = setTimeout(() => { controller.abort(); reject(new Error('timeout')); }, 3500); }),
+          ]);
+          const efforts = info?.reasoning?.efforts?.map((e) => e.id) ?? [];
+          sendJson(res, 200, { ok: true, efforts, default: info?.reasoning?.defaultEffort ?? null });
+        } catch {
+          sendJson(res, 200, { ok: false, reason: '暂时无法获取该模型支持的思考深度' });
+        } finally {
+          clearTimeout(timer);
+        }
+        return;
+      }
+
+      if (path === '/dsh-prompt-predict/settings' && req.method === 'POST') {
+        const body = await readJson(req);
+        if (!body) { sendJson(res, 400, { ok: false, reason: '请求体不是合法 JSON' }); return; }
+        if (body.reset === true) {
+          clearSettings();
+          sendJson(res, 200, { ok: true, effective: effective(), saved: {} });
+          return;
+        }
+        const patch = {};
+        if (typeof body.enabled === 'boolean') patch.enabled = body.enabled;
+        if (typeof body.provider === 'string' && typeof body.model === 'string' && body.provider && body.model) {
+          if (isAuto(body.provider) || isAuto(body.model)) {
+            patch.provider = AUTO;
+            patch.model = AUTO;
+          } else {
+            const problem = await validateRoute(body.provider, body.model);
+            if (problem) { sendJson(res, 200, { ok: false, reason: problem }); return; }
+            patch.provider = body.provider;
+            patch.model = body.model;
+          }
+        }
+        if (body.timeoutMs !== undefined) {
+          const v = Number(body.timeoutMs);
+          if (!Number.isSafeInteger(v) || v < 1000 || v > 60000) { sendJson(res, 200, { ok: false, reason: '超时需在 1–60 秒之间' }); return; }
+          patch.timeoutMs = v;
+        }
+        if (body.maxMessages !== undefined) {
+          const v = Number(body.maxMessages);
+          if (!Number.isSafeInteger(v) || v < 2 || v > 20) { sendJson(res, 200, { ok: false, reason: '上下文条数需在 2–20 之间' }); return; }
+          patch.maxMessages = v;
+        }
+        if (body.reasoningEffort !== undefined) {
+          const v = String(body.reasoningEffort);
+          if (v === 'auto') { patch.reasoningEffort = 'auto'; }
+          else {
+            const next = { ...effective(), ...patch };
+            // 跟随当前会话模型时模型不固定，无法按具体模型校验档位，直接按用户选择保存。
+            const pinned = routeOf(next.provider, next.model);
+            const problem = pinned ? await validateEffort(pinned.provider, pinned.model, v) : null;
+            if (problem) { sendJson(res, 200, { ok: false, reason: problem }); return; }
+            patch.reasoningEffort = v;
+          }
+        }
+        writeSettings(patch);
+        sendJson(res, 200, { ok: true, effective: effective(), saved: readSettings() });
+        return;
+      }
+
+      if (path !== '/dsh-prompt-predict/suggest' || req.method !== 'POST') {
+        sendJson(res, 404, { ok: false, reason: 'not found' });
+        return;
+      }
+
+      const eff = effective();
+      if (eff.enabled === false) {
+        sendJson(res, 200, { ok: false, disabled: true, reason: '提示词联想已关闭' });
+        return;
+      }
+
+      const body = await readJson(req);
+      if (!body || typeof body.sessionId !== 'string' || body.sessionId.trim() === '') {
+        sendJson(res, 400, { ok: false, reason: '缺少 sessionId' });
+        return;
+      }
+      const session = ctx.sessions.get(body.sessionId);
+      if (!session) {
+        sendJson(res, 404, { ok: false, reason: 'Session 不存在' });
+        return;
+      }
+
+      const abort = new AbortController();
+      const timeout = setTimeout(() => abort.abort('prediction timeout'), Number(eff.timeoutMs) || 12000);
+      const onClose = () => { if (!res.writableEnded) abort.abort('client disconnected'); };
+      res.on('close', onClose);
+      try {
+        const result = await predictNextPrompt(ctx, session, {
+          signal: abort.signal,
+          maxTokens: Number(eff.maxTokens) || 64,
+          maxMessages: Number(eff.maxMessages) || 8,
+          maxChars: Number(eff.maxChars) || 6000,
+          route: (typeof body.provider === 'string' && typeof body.model === 'string' && body.provider && body.model)
+            ? routeOf(body.provider, body.model)
+            : routeOf(eff.provider, eff.model),
+          reasoningEffort: typeof body.reasoningEffort === 'string' ? body.reasoningEffort
+            : (eff.reasoningEffort && eff.reasoningEffort !== 'auto' ? eff.reasoningEffort : undefined),
+        });
+        sendJson(res, 200, { ok: true, suggestion: result.suggestion, provider: result.route.provider, model: result.route.model });
+      } catch (error) {
+        if (!res.writableEnded) sendJson(res, 200, { ok: false, reason: String(error?.message ?? error) });
+      } finally {
+        clearTimeout(timeout);
+        res.off('close', onClose);
+      }
+    },
+  };
+  return webServer.register(route);
+}

package/lib/index.js

@@ -0,0 +1,16 @@
+// dsh-prompt-predict Host 插件入口。
+import { registerPredictRoute } from './host-route.mjs';
+
+const name = 'dsh-prompt-predict';
+const inject = ['sessions', 'llm', 'agentDefaultModel', 'connection', 'webServer'];
+
+export function apply(ctx, config = {}) {
+  // cordis patch 的 config 作为部署默认；用户保存的设置（文件）在每次请求时再覆盖。
+  // 内置兜底（provider/model/超时等）由 host-route 负责。
+  const dispose = registerPredictRoute(ctx, config);
+  ctx?.effect?.(() => () => {
+    try { dispose?.(); } catch { /* 忽略 */ }
+  }, 'dsh-prompt-predict: unregister HTTP route');
+}
+
+export { name, inject };

package/lib/predict.mjs

@@ -0,0 +1,130 @@
+// 提示词预测核心：会话裁剪 → 调当前会话模型 → 归一化为一条可直接发送的建议。
+import { randomUUID } from 'node:crypto';
+
+const DEFAULT_SYSTEM = `你是输入框预测器。根据当前对话，预测用户下一条最可能发给助手的消息。
+规则：
+1. 只输出一条可直接发送的消息，不要解释、不要加引号、不要加“建议：”等前缀。
+2. 使用用户近期主要语言；中文通常 8–50 个字，其他语言保持同等简洁。
+3. 建议必须具体、自然、能推进当前任务；优先延续助手刚完成或刚提出的下一步。
+4. 不要复述助手最后一句，不要编造用户未表达的目标，不要输出 Markdown 代码块。`;
+
+/** 从消息 content 里只抽取普通文本。 */
+export function messageText(message) {
+  if (!message || !Array.isArray(message.content)) return '';
+  return message.content
+    .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text.trim())
+    .filter(Boolean)
+    .join('\n')
+    .trim();
+}
+
+/**
+ * 裁出最近的用户/助手文本消息，按总字符预算从后往前保留。
+ * 工具、系统、developer、图片和文件块不进入辅助模型请求。
+ */
+export function recentMessages(messages, { maxMessages = 8, maxChars = 6000, perMessageChars = 1600 } = {}) {
+  const candidates = [];
+  for (const message of Array.isArray(messages) ? messages : []) {
+    if (message?.role !== 'user' && message?.role !== 'assistant') continue;
+    const text = messageText(message);
+    if (!text) continue;
+    candidates.push({ role: message.role, text: text.slice(-perMessageChars) });
+  }
+  const kept = [];
+  let used = 0;
+  for (let i = candidates.length - 1; i >= 0 && kept.length < maxMessages; i -= 1) {
+    const item = candidates[i];
+    const cost = item.text.length + 32;
+    if (kept.length > 0 && used + cost > maxChars) break;
+    kept.unshift(item);
+    used += cost;
+  }
+  return kept;
+}
+
+/** 清掉模型常见包装，只留下单行建议。 */
+export function normalizeSuggestion(input, maxChars = 180) {
+  let text = String(input ?? '').trim();
+  text = text.replace(/^```[a-z0-9_-]*\s*/i, '').replace(/\s*```$/i, '').trim();
+  text = text.replace(/^(?:建议|预测|下一条(?:消息|提示词)|用户(?:可能会说)?)[：:]\s*/i, '');
+  text = text.replace(/^["'“‘]+|["'”’]+$/g, '').trim();
+  text = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).join(' ');
+  text = text.replace(/\s+/g, ' ').trim();
+  if (text.length > maxChars) text = text.slice(0, maxChars).trim();
+  return text;
+}
+
+function selectionFor(ctx, session) {
+  try {
+    const header = session?.requestHeader?.();
+    const config = header?.config;
+    if (typeof config?.provider === 'string' && typeof config?.model === 'string') {
+      return { provider: config.provider, model: config.model };
+    }
+  } catch { /* 回退到全局默认 */ }
+  return ctx.agentDefaultModel.currentSelection();
+}
+
+/** 生成一条建议。 */
+export async function predictNextPrompt(ctx, session, {
+  signal,
+  maxTokens = 64,
+  maxMessages = 8,
+  maxChars = 6000,
+  system = DEFAULT_SYSTEM,
+  route: routeOverride,
+  reasoningEffort,
+} = {}) {
+  const history = recentMessages(session?.deriveMessages?.() ?? [], { maxMessages, maxChars });
+  if (history.length === 0) throw new Error('没有可用于预测的会话文本');
+  const route = routeOverride ?? selectionFor(ctx, session);
+  if (typeof route?.provider !== 'string' || typeof route?.model !== 'string') {
+    throw new Error('无法确定联想所用模型，请在「设置 → 提示词联想」里显式选择提供商与模型');
+  }
+  const framedHistory = history.map((item) => {
+    const label = item.role === 'user' ? '用户' : '助手';
+    return `[${label}]\n${item.text}`;
+  }).join('\n\n');
+  // 不能把裁剪后的 assistant 文本伪装成 canonical Assistant Message：DSH 的 Assistant Message
+  // 必须带完整 stream/replayState。像 session-title 一样帧化成一条 request-only user input。
+  const messages = [{
+    id: randomUUID(),
+    role: 'user',
+    source: { kind: 'dsh-prompt-predict' },
+    content: [{
+      type: 'text',
+      text: `以下是当前会话最近内容：\n\n${framedHistory}\n\n请预测我下一条最可能输入的消息。只输出预测内容。`,
+    }],
+  }];
+  let output = '';
+  let reasoning = '';
+  let finish;
+  const options = {
+    provider: route.provider,
+    model: route.model,
+    messages,
+    system,
+    maxTokens,
+    sessionId: session.id,
+    purpose: 'prompt-prediction',
+    signal,
+  };
+  // 思考深度：仅在显式设置时传入；联想默认应保持最浅以保证速度/成本。
+  if (reasoningEffort) options.reasoningEffort = reasoningEffort;
+  for await (const chunk of ctx.llm.stream(options)) {
+    if (chunk?.type === 'text-delta' && typeof chunk.text === 'string') output += chunk.text;
+    if (chunk?.type === 'reasoning-delta' && typeof chunk.text === 'string') reasoning += chunk.text;
+    if (chunk?.type === 'finish') finish = chunk.reason;
+  }
+  if (finish?.kind === 'error' || finish?.kind === 'aborted') {
+    const failure = finish.failure;
+    throw new Error(failure?.message ?? failure?.code ?? `模型调用${finish.kind}`);
+  }
+  const suggestion = normalizeSuggestion(output);
+  if (!suggestion) {
+    const detail = reasoning.trim() ? `（模型只返回 reasoning：${normalizeSuggestion(reasoning, 80)}）` : '';
+    throw new Error(`模型未生成有效建议${detail}`);
+  }
+  return { suggestion, route, historySize: history.length };
+}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "dsh-prompt-predict",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Codex-style composer predictions for DeepSeek Harness: suggest the user's next prompt after each reply and accept it with Tab.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": "./client/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "client",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node test/predict.mjs",
+    "pack": "pnpm pack"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ferrisching/dsh-prompt-predict.git"
+  },
+  "homepage": "https://github.com/ferrisching/dsh-prompt-predict#readme",
+  "bugs": {
+    "url": "https://github.com/ferrisching/dsh-prompt-predict/issues"
+  },
+  "author": "ferrisching",
+  "license": "MIT",
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "prompt-prediction",
+    "composer",
+    "ghost-text"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  }
+}