dsh-predict 0.0.0-stage → 1.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dogtiti
+
+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,192 @@
-# Temporary Holding Version
+# dsh-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.
+[![npm](https://img.shields.io/npm/v/dsh-predict?label=npm&color=2f6fed)](https://www.npmjs.com/package/dsh-predict)
+[![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![dsh](https://img.shields.io/badge/DSH-%5E0.2.1--0-2f6fed)](https://github.com/deepseek-ai/deepseek-harness)
+
+基于当前对话预测下一条用户指令，直接呈现在输入框的占位文字中；按 `Tab` 采纳为可编辑草稿。
+
+---
+
+## 效果
+
+会话空闲且输入框为空时，原生提示文字被替换为一条建议：
+
+```diff
+- 发消息或创建任务, / 调用指令, @ 文件或对话
++ 跑一下测试
+```
+
+`Tab` 或点击可填入输入框（光标位于末尾），不会自动发送。
+
+建议由当前会话正在使用的模型生成：
+
+| 上下文 | 建议 |
+| --- | --- |
+| 刚完成一次代码修改 | `跑一下看看效果` |
+| 测试报告显示 3 个失败用例 | `先修掉这三个失败用例` |
+
+---
+
+## 安装
+
+**市场索引**
+
+```
+https://raw.githubusercontent.com/Dogtiti/dsh-predict/main/market-index.json
+```
+
+设置 → 插件 → 启用实验性市场 bundle → Discover → 添加上面的地址 → 安装 `dsh-predict`。
+
+**npm**
+
+```bash
+npm i dsh-predict
+```
+
+在 Plugins 页用「添加」填写包名。
+
+**本地目录**
+
+```bash
+git clone https://github.com/Dogtiti/dsh-predict
+```
+
+Plugins → 添加 → 选择该目录。
+
+---
+
+## 行为
+
+建议仅在以下条件全部满足时请求并显示：
+
+- 该会话已完成至少一轮对话
+- 会话不在运行中
+- 输入框为空、无待发送附件、无已认领的斜杠命令
+- 非一次性子会话（只读输入框）
+
+不接管的情况：
+
+| 条件 | 行为 |
+| --- | --- |
+| 输入框非空 | 不请求、不显示 |
+| 会话运行中 | 不显示 |
+| `/` 或 `@` 菜单弹出 | 不显示 |
+
+---
+
+## 配置
+
+```yaml
+- insert:
+    - id: composer-predict
+      name: 'dsh-predict'
+      config:
+        model: deepseek-chat
+        maxSuggestionChars: 24
+```
+
+| 键 | 默认 | 说明 |
+| --- | --- | --- |
+| `enabled` | `true` | 总开关；关闭后路由返回 503，客户端不再请求 |
+| `provider` / `model` | `''` | 指定模型；留空跟随当前会话 |
+| `maxContextMessages` | `8` | 送入模型的消息条数（取尾部） |
+| `maxMessageChars` | `600` | 单条消息最大字符数（保留头尾） |
+| `maxSuggestionChars` | `32` | 建议的目标长度 |
+| `maxTokens` | `200` | 输出上限 |
+| `timeoutMs` | `20000` | 单次请求超时 |
+| `cacheTtlMs` | `60000` | 相同会话事件序号下的缓存时间 |
+| `diagnostics` | `false` | 将客户端判定写入 `.diagnostics.jsonl`，用于排障 |
+
+---
+
+## 实现
+
+插件为标准的 DSH bundle，包含 Host 与 Client 两部分：
+
+```
+┌──────────────── 浏览器 ────────────────┐        ┌───────────── Host ─────────────┐
+│ conversation.composer.dock             │        │ POST /api/composer.predict     │
+│  · 回合结束时请求（running: true→false） │  HTTP  │  · sessions.get(id)            │
+│  · 重绘 [data-composer-placeholder]     │ ─────► │  · session.deriveMessages()    │
+│  · 自检：内容包含建议且字号 ≥ 8px        │ ◄───── │  · 当前会话 provider/model      │
+│  · Tab → inputActions.setDraft()        │  JSON  │  · 按 seq 缓存 60s             │
+└────────────────────────────────────────┘        └────────────────────────────────┘
+```
+
+宿主占位元素已提供定位（`inset:4px 8px auto 14px`）、字号、行高、省略号与 IME 组合期隐藏，插件只改写其内容：
+
+```css
+[data-composer-placeholder] { color: transparent }
+[data-composer-placeholder]::after {
+  content: "跑一下测试";
+  position: absolute; inset: 0;
+  font: inherit;
+}
+```
+
+不使用 `font-size: 0` 配合变量恢复字号：变量解析失败时字号会退化为 0，文字存在但不可见。`font: inherit` 不依赖变量。
+
+挂载后读取 `getComputedStyle(target, '::after')` 自检，若内容不含建议或字号小于 8px，回退为输入框下方一行并在控制台输出 `[composer-predict]` 警告。
+
+---
+
+## 数据与开销
+
+- 读取本会话日志尾部（用户与助手文本、工具名、工作目录），发送至会话自身配置的模型服务与凭据。
+- 每轮一次独立小请求，默认上限 200 tokens；`enabled: false` 可关闭。
+- 结果不落盘，不写入会话日志。
+
+---
+
+## 开发
+
+```bash
+node --test "test/*.test.mjs"
+```
+
+14 项：提示词拼装、模型路由回退、输出清洗、缓存失效、开关、CSS 转义、门禁条件、兜底渲染。
+
+`test/render-proof/` 将插件实际生成的 CSS 应用于宿主占位结构，用无头 Chrome 渲染并截图，用于核对重绘结果，包含字号变量非法的边界环境。
+
+---
+
+## 兼容性
+
+- DSH `^0.2.1-0`（`engines.dsh`）。
+- 依赖宿主占位元素的 `[data-composer-placeholder]` 标记；缺失时走回退路径，不影响输入框本身。
+
+---
+
+## 相关插件
+
+| 插件 | 说明 |
+| --- | --- |
+| **dsh-predict**（本仓库） | 预测下一条指令并显示为占位文字，`Tab` 采纳 |
+| [dsh-plugin-composer-history](https://github.com/Dogtiti/dsh-plugin-composer-history) | 输入框中按 `↑` / `↓` 回填历史消息 |
+| [dsh-plugin-subagent-bridge](https://github.com/Dogtiti/dsh-plugin-subagent-bridge) | 让 Codex 通过本机 MCP 把 DSH 当 subagent 用（spawn / wait / followup），反向也能把任务派给 Codex |
+| [dsh-plugin-usage-panel](https://github.com/Dogtiti/dsh-plugin-usage-panel) | 在模型选择器旁显示供应商套餐额度余量（目前 GLM Coding Plan），点开是明细浮层 |
+| [dsh-plugin-provider-icons](https://github.com/Dogtiti/dsh-plugin-provider-icons) | 在模型名旁显示供应商品牌 logo（24 个厂商，支持前缀匹配） |
+
+
+## 许可
+
+MIT © [Dogtiti](https://github.com/Dogtiti)
+
+## 诊断
+
+`diagnostics: true` 会把每次预测的决策写进包目录下的 `.diagnostics.jsonl`：
+
+```
+{"event":"predict-request","sessionId":"…","found":true,"transcriptLength":3217}
+{"event":"predict-done","sessionId":"…","suggestion":"跑一下测试","raw":"跑一下测试"}
+{"event":"predict-error","sessionId":"…","message":"…"}
+```
+
+用来回答"为什么输入框没有预测"：`found:false` = 会话没挂载；`transcriptLength` 太小 = 可参考的上下文太少；`suggestion:null` + `raw:"NONE"` = 模型判定无法预测。
+
+## 没有就不显示
+
+提示词不再让模型输出 `NONE` 之类的占位词：**有具体任务就给一条，没有就什么都不输出**。插件侧再把少数模型"把沉默写成文字"的情况（`NONE` / `无` / `什么都不输出` / `空回复`）统一当成"没有建议"，输入框保持原样。
+
+实测同一个真实工作会话：旧提示词返回 `NONE`，新提示词返回「停止重复调用，改为汇总当前验证结果」；只有问候的对话则保持空白。

package/client.js

@@ -0,0 +1,353 @@
+/**
+ * Client half of the composer-prediction bundle.
+ *
+ * Primary surface: the prediction repaints the composer's own placeholder, so the
+ * suggestion appears exactly where the user types. If that repaint cannot be applied
+ * (the shipped placeholder markup moved, or a style policy blocks the injected rule),
+ * the component falls back to a compact row under the composer instead of showing
+ * nothing. Tab fills the prediction in as an ordinary editable draft either way.
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-predict',
+  factory(require) {
+    const React = require('react')
+    const h = React.createElement
+
+    /** Route registered by the Host half, addressed document-relatively. */
+    const ROUTE = 'api/composer.predict'
+
+    /** Diagnostic route; the Host half appends one line per report. */
+    const REPORT = 'api/composer.report'
+
+    /**
+     * The shipped composer placeholder element. Its geometry, typography, IME hiding,
+     * and empty-draft lifetime are the host's; this plugin only repaints its content.
+     */
+    const PLACEHOLDER = '[data-composer-placeholder]'
+
+    /** Inline styles for the fallback row, so it renders even when `<style>` is blocked. */
+    const ROW = {
+      row: {
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'flex-end',
+        gap: '4px',
+        minWidth: '0',
+        padding: '0 2px',
+        fontFamily: 'inherit',
+      },
+      hint: {
+        display: 'inline-flex',
+        alignItems: 'center',
+        minWidth: '0',
+        maxWidth: '100%',
+        padding: '1px 6px',
+        border: 'none',
+        borderRadius: '8px',
+        background: 'transparent',
+        color: 'var(--dsw-alias-label-secondary)',
+        fontSize: '12px',
+        lineHeight: '18px',
+        cursor: 'pointer',
+        textAlign: 'left',
+      },
+      text: {
+        minWidth: '0',
+        overflow: 'hidden',
+        textOverflow: 'ellipsis',
+        whiteSpace: 'nowrap',
+      },
+      dismiss: {
+        flex: 'none',
+        display: 'grid',
+        placeItems: 'center',
+        width: '18px',
+        height: '18px',
+        padding: '0',
+        border: 'none',
+        borderRadius: '999px',
+        background: 'transparent',
+        color: 'var(--dsw-alias-label-secondary)',
+        fontSize: '12px',
+        lineHeight: '1',
+        cursor: 'pointer',
+      },
+    }
+
+    /** Whether a transport or repaint problem was already reported in this page. */
+    let warned = false
+
+    /** Whether an empty prediction was already reported in this page. */
+    let quiet = false
+
+    /**
+     * Escape one string for a double-quoted CSS `content` value.
+     * @param text - plain text.
+     * @returns the escaped value.
+     */
+    function cssString(text) {
+      return text.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/[\r\n\t]/g, ' ')
+    }
+
+    /**
+     * Build the rule set that repaints the composer placeholder.
+     * The host's element already owns the geometry, font, ellipsis, and IME hiding;
+     * this only swaps its text for the prediction.
+     * @param text - predicted instruction.
+     * @returns CSS text.
+     */
+    function ghostCss(text) {
+      return [
+        /* Keep the host's text node (its layout is already right) but make it invisible;
+         * the repaint is an absolute overlay, so it needs no font-size trick and no CSS
+         * variable that may not resolve to a length. */
+        `${PLACEHOLDER}{color:transparent!important;}`,
+        `${PLACEHOLDER}::after{content:"${cssString(text)}";position:absolute;inset:0;color:var(--dsw-alias-label-caption,#9a9a9a);font:inherit;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}`,
+      ].join('')
+    }
+
+    /**
+     * Send one diagnostic snapshot to the Host half. Never throws.
+     * @param payload - plain JSON snapshot.
+     */
+    async function sendReport(payload) {
+      try {
+        await fetch(new URL(REPORT, document.baseURI), {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify(payload),
+          credentials: 'same-origin',
+        })
+      } catch {
+        /* Diagnostics never affect the feature. */
+      }
+    }
+
+    /**
+     * Ask the Host half for this Session's prediction.
+     * @param sessionId - Session to predict for.
+     * @param signal - cancellation.
+     * @returns the instruction, or null when none is available.
+     */
+    async function requestSuggestion(sessionId, signal) {
+      const response = await fetch(new URL(ROUTE, document.baseURI), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ sessionId }),
+        credentials: 'same-origin',
+        signal,
+      })
+      if (!response.ok) {
+        if (warned !== true && response.status !== 404) {
+          warned = true
+          console.warn(`[composer-predict] prediction route answered ${response.status}`)
+        }
+        return null
+      }
+      const data = await response.json()
+      const suggestion = data?.suggestion
+      if (typeof suggestion !== 'string' || suggestion.trim() === '') {
+        if (quiet !== true) {
+          quiet = true
+          console.info('[composer-predict] the host returned no suggestion', data)
+        }
+        return null
+      }
+      return suggestion.trim()
+    }
+
+    /**
+     * Guard the slot's standard props before any hook runs.
+     * @param props - slot standard props.
+     * @returns the painter, or null when this slot lacks the composer hooks.
+     */
+    function PlaceholderPainter(props) {
+      if (typeof props.useInput !== 'function' || typeof props.useSession !== 'function') return null
+      if (props.inputActions === undefined || props.inputActions === null) return null
+      if (typeof props.sessionId !== 'string' || props.sessionId === '') return null
+      return h(PainterBody, props)
+    }
+
+    /**
+     * Own the prediction lifecycle and paint it, in-box when possible.
+     * @param props - slot standard props.
+     * @returns the painted style element, a fallback row, or null.
+     */
+    function PainterBody(props) {
+      const { sessionId, useSession, useInput, inputActions } = props
+      const draft = useInput((snapshot) => snapshot.draft)
+      const attachmentCount = useInput((snapshot) => snapshot.attachmentIds.length)
+      const phase = useInput((snapshot) => snapshot.phase)
+      const running = useSession((snapshot) => snapshot.running)
+      const blank = useSession((snapshot) => snapshot.blank)
+      const removed = useSession((snapshot) => snapshot.removed)
+      const subagentMode = useSession((snapshot) => snapshot.subagent?.address?.mode ?? null)
+
+      const [generation, setGeneration] = React.useState(0)
+      const [entry, setEntry] = React.useState(null)
+      const [surface, setSurface] = React.useState('placeholder')
+      const anchorRef = React.useRef(null)
+      const previousRunning = React.useRef(running === true)
+
+      React.useEffect(() => {
+        const wasRunning = previousRunning.current
+        previousRunning.current = running === true
+        if (wasRunning && running !== true) setGeneration((value) => value + 1)
+      }, [running])
+
+      const idle = running !== true && blank !== true && removed !== true
+      const writable = subagentMode === null || subagentMode === 'continuable'
+      const key = `${sessionId}:${generation}`
+
+      React.useEffect(() => {
+        if (!idle || !writable) return undefined
+        const controller = new AbortController()
+        let live = true
+        setEntry((current) => (current?.key === key ? current : { key, text: null }))
+        requestSuggestion(sessionId, controller.signal)
+          .then((text) => {
+            if (live) setEntry({ key, text })
+          })
+          .catch(() => {
+            if (live) setEntry({ key, text: null })
+          })
+        return () => {
+          live = false
+          controller.abort()
+        }
+      }, [idle, writable, key, sessionId])
+
+      const suggestion = entry?.key === key ? entry.text : null
+      /* The host renders its placeholder under exactly these conditions; matching them
+       * keeps the repaint attached to a real element instead of racing it. */
+      const paints = typeof suggestion === 'string' && suggestion !== '' && draft === '' && attachmentCount === 0 && phase === 'plain' && idle && writable
+
+      /* Verify the repaint after it mounts, and drop to the row when it did not land. */
+      React.useEffect(() => {
+        if (!paints) {
+          setSurface('placeholder')
+          return
+        }
+        if (surface === 'row') return
+        const dock = anchorRef.current?.closest('[data-composer-dock]')
+        const target = dock?.parentElement?.querySelector(PLACEHOLDER)
+        const after = target === null || target === undefined ? null : getComputedStyle(target, '::after')
+        const painted = after === null ? '' : String(after.content ?? '')
+        const sized = after === null ? 0 : Number.parseFloat(after.fontSize)
+        const landed = painted !== '' && painted !== 'none' && painted !== 'normal' && painted.includes(suggestion) && sized >= 8
+        if (landed) return
+        setSurface('row')
+        if (warned !== true) {
+          warned = true
+          console.warn('[composer-predict] the composer placeholder could not be repainted; showing the row instead')
+        }
+      }, [paints, surface, suggestion])
+
+      /* One diagnostic line per distinct decision, so a silent composer is explainable. */
+      const reportRef = React.useRef('')
+      React.useEffect(() => {
+        const signature = `${key}|${suggestion ?? ''}|${paints}|${draft === ''}|${phase}`
+        if (reportRef.current === signature) return
+        reportRef.current = signature
+        const dock = anchorRef.current?.closest('[data-composer-dock]') ?? document.querySelector('[data-composer-dock]')
+        const target = dock?.parentElement?.querySelector(PLACEHOLDER) ?? document.querySelector(PLACEHOLDER)
+        const after = target === null || target === undefined ? '' : String(getComputedStyle(target, '::after').content ?? '')
+        void sendReport({
+          sessionId,
+          generation,
+          surface,
+          paints,
+          hasText: typeof suggestion === 'string' && suggestion !== '',
+          text: typeof suggestion === 'string' ? suggestion.slice(0, 60) : '',
+          draftLength: typeof draft === 'string' ? draft.length : -1,
+          phase,
+          running,
+          blank,
+          removed,
+          subagentMode,
+          placeholderFound: target !== null && target !== undefined,
+          afterContent: after.slice(0, 80),
+          styleInDom: document.querySelector('style[data-dsh-composer-predict]') !== null,
+        })
+      }, [anchorRef, blank, draft, generation, key, paints, phase, removed, sessionId, subagentMode, suggestion, surface])
+
+      const accept = React.useCallback(() => {
+        if (typeof suggestion !== 'string' || suggestion === '') return
+        try {
+          inputActions.setDraft(suggestion)
+        } catch {
+          return
+        }
+      }, [inputActions, suggestion])
+
+      React.useEffect(() => {
+        if (!paints) return undefined
+        const onKeyDown = (event) => {
+          if (event.key !== 'Tab' || event.isComposing) return
+          if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) return
+          if (event.defaultPrevented) return
+          const dock = anchorRef.current?.closest('[data-composer-dock]')
+          if (!dock) return
+          const active = document.activeElement
+          if (!active || active.isContentEditable !== true) return
+          if (!dock.parentElement?.contains(active)) return
+          event.preventDefault()
+          event.stopPropagation()
+          accept()
+        }
+        window.addEventListener('keydown', onKeyDown, true)
+        return () => window.removeEventListener('keydown', onKeyDown, true)
+      }, [accept, paints])
+
+      if (!paints) return null
+
+      if (surface === 'row') {
+        return h(
+          'div',
+          { style: ROW.row, ref: anchorRef },
+          h(
+            'button',
+            {
+              type: 'button',
+              style: ROW.hint,
+              title: `${suggestion} — Tab`,
+              onMouseDown: (event) => event.preventDefault(),
+              onClick: accept,
+            },
+            h('span', { style: ROW.text }, suggestion),
+          ),
+          h(
+            'button',
+            {
+              type: 'button',
+              style: ROW.dismiss,
+              title: '×',
+              'aria-label': '×',
+              onMouseDown: (event) => event.preventDefault(),
+              onClick: () => setEntry({ key, text: null }),
+            },
+            '×',
+          ),
+        )
+      }
+
+      return h('style', { ref: anchorRef, 'data-dsh-composer-predict': true }, ghostCss(suggestion))
+    }
+
+    return {
+      inject: ['slots'],
+      apply(ctx) {
+        ctx.slots.inject('conversation.composer.dock', () =>
+          ctx.slots.register(
+            {
+              name: 'conversation.composer.dock',
+              id: 'composer-predict',
+              order: 0,
+            },
+            PlaceholderPainter,
+          ),
+        )
+      },
+    }
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,7 @@
+- insert:
+    - id: composer-predict
+      name: 'dsh-predict'
+      config:
+        maxContextMessages: 8
+        maxSuggestionChars: 32
+        timeoutMs: 20000

package/icon.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" role="img" aria-label="Composer prediction">
+  <rect x="1" y="1" width="22" height="22" rx="6" fill="#2f6fed"/>
+  <path d="M5.6 7.4 9.3 12l-3.7 4.6" fill="none" stroke="#ffffff" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M10.6 16.6h7.6" fill="none" stroke="#ffffff" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M17.2 5.2l.72 1.86 1.86.72-1.86.72-.72 1.86-.72-1.86-1.86-.72 1.86-.72z" fill="#ffffff" opacity="0.9"/>
+</svg>

package/index.js

@@ -0,0 +1,377 @@
+/**
+ * Host half of the composer-prediction bundle.
+ *
+ * One authenticated Fetch route reads the tail of the Session log and asks the model
+ * that Session already uses for the user's most likely next instruction. The Client
+ * half only renders the answer and turns it into an editable draft.
+ */
+
+import { appendFile } from 'node:fs/promises'
+
+export const name = 'composer-predict'
+
+export const inject = ['connection']
+
+/** Route the browser addresses document-relatively. */
+const ROUTE_PATH = '/api/composer.predict'
+
+/** Client diagnostics route; only answers while the diagnostic log is enabled. */
+const REPORT_PATH = '/api/composer.report'
+
+/** Where the diagnostic log lands, when enabled: next to this module, in the checkout. */
+const REPORT_FILE = new URL('./.diagnostics.jsonl', import.meta.url)
+
+/** Per-Session answer cache size; a Session's `seq` invalidates its own entry. */
+const CACHE_LIMIT = 64
+
+const DEFAULTS = {
+  enabled: true,
+  maxContextMessages: 8,
+  maxMessageChars: 600,
+  maxSuggestionChars: 32,
+  maxTokens: 200,
+  timeoutMs: 20000,
+  cacheTtlMs: 60000,
+  provider: '',
+  model: '',
+  diagnostics: false,
+}
+
+/**
+ * Register the prediction route and the client diagnostic route.
+ * @param ctx - Host context carrying the Web connection.
+ * @param config - row configuration from the bundle patch.
+ */
+export function apply(ctx, config = {}) {
+  const settings = resolveSettings(config)
+  const cache = new Map()
+  ctx.effect(() => {
+    const connection = Reflect.get(ctx, 'connection')
+    const disposers = [
+      connection.fetch.register({
+        path: ROUTE_PATH,
+        methods: ['POST'],
+        requestBody: 'buffered',
+        fetch: (request) => handle(ctx, request, settings, cache),
+      }),
+      connection.fetch.register({
+        path: REPORT_PATH,
+        methods: ['POST'],
+        requestBody: 'buffered',
+        fetch: (request) => report(request, settings),
+      }),
+    ]
+    return () => {
+      for (const dispose of disposers) Promise.resolve(dispose()).catch(() => {})
+    }
+  }, 'composer-predict: routes')
+  if (settings.diagnostics === true) {
+    const line = `${JSON.stringify({ time: new Date().toISOString(), event: 'host-apply', settings })}\n`
+    void appendFile(REPORT_FILE, line, 'utf8').catch(() => {})
+  }
+}
+
+/**
+ * Append one diagnostic line when `diagnostics` is on. Silent otherwise.
+ * @param settings - resolved plugin settings.
+ * @param row - fields to record.
+ */
+function trace(settings, row) {
+  if (settings.diagnostics !== true) return
+  const line = `${JSON.stringify({ time: new Date().toISOString(), ...row })}\n`
+  void appendFile(REPORT_FILE, line, 'utf8').catch(() => {})
+}
+
+/**
+ * Append one client diagnostic line.
+ * @param request - buffered Fetch request carrying the client snapshot.
+ * @param settings - resolved plugin settings.
+ * @returns an empty OK response.
+ */
+async function report(request, settings) {
+  if (settings.diagnostics !== true) return new Response(null, { status: 204 })
+  let body
+  try {
+    body = await request.json()
+  } catch {
+    return json(400, { error: 'invalid-body' })
+  }
+  const line = `${JSON.stringify({ time: new Date().toISOString(), ...body })}\n`
+  try {
+    await appendFile(REPORT_FILE, line, 'utf8')
+  } catch {
+    return json(500, { error: 'write-failed' })
+  }
+  return new Response(null, { status: 204 })
+}
+
+/**
+ * Answer one prediction request.
+ * @param ctx - Host context.
+ * @param request - buffered Fetch request whose body is `{ sessionId }`.
+ * @param settings - resolved plugin settings.
+ * @param cache - per-Session answer cache.
+ * @returns a JSON response; transport failures never surface as 500.
+ */
+async function handle(ctx, request, settings, cache) {
+  if (!settings.enabled) return json(503, { suggestion: null, error: 'disabled' })
+
+  let payload
+  try {
+    payload = await request.json()
+  } catch {
+    return json(400, { suggestion: null, error: 'invalid-body' })
+  }
+
+  const sessionId = typeof payload?.sessionId === 'string' ? payload.sessionId : ''
+  if (sessionId === '') return json(400, { suggestion: null, error: 'missing-session' })
+
+  const session = safe(() => ctx.get('sessions')?.get?.(sessionId))
+  if (!session) {
+    trace(settings, { event: 'predict-request', sessionId, found: false })
+    return json(404, { suggestion: null, error: 'session-not-found' })
+  }
+
+  const seq = Number(session.seq) || 0
+  const cached = cache.get(sessionId)
+  if (cached !== undefined && cached.seq === seq && Date.now() - cached.time < settings.cacheTtlMs) {
+    return json(200, { suggestion: cached.suggestion })
+  }
+
+  const llm = safe(() => ctx.get('llm'))
+  if (!llm) return json(503, { suggestion: null, error: 'llm-unavailable' })
+
+  const route = resolveRoute(ctx, session, settings)
+  if (!route) return json(503, { suggestion: null, error: 'model-unavailable' })
+
+  const transcript = buildTranscript(session, settings)
+  trace(settings, { event: 'predict-request', sessionId, found: true, transcriptLength: transcript.length })
+  if (transcript === '') return json(200, { suggestion: null })
+
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), settings.timeoutMs)
+  const abort = () => controller.abort()
+  request.signal?.addEventListener('abort', abort)
+  try {
+    let text = ''
+    const stream = llm.stream({
+      provider: route.provider,
+      model: route.model,
+      system: systemPrompt(settings),
+      messages: [{ role: 'user', content: [{ type: 'text', text: transcript }] }],
+      maxTokens: settings.maxTokens,
+      signal: controller.signal,
+    })
+    for await (const chunk of stream) {
+      if (chunk?.type === 'text-delta' && typeof chunk.text === 'string') text += chunk.text
+      else if (chunk?.type === 'finish' && chunk.reason?.kind !== 'stop') break
+    }
+    const suggestion = cleanSuggestion(text, settings)
+    trace(settings, { event: 'predict-done', sessionId, suggestion, raw: text.slice(0, 120) })
+    remember(cache, sessionId, { seq, suggestion, time: Date.now() })
+    return json(200, { suggestion })
+  } catch (error) {
+    trace(settings, { event: 'predict-error', sessionId, message: messageOf(error) })
+    return json(200, { suggestion: null, error: messageOf(error) })
+  } finally {
+    clearTimeout(timer)
+    request.signal?.removeEventListener('abort', abort)
+  }
+}
+
+/**
+ * Keep the cache bounded, most recently used last.
+ * @param cache - session cache.
+ * @param key - Session id.
+ * @param entry - cached answer.
+ */
+function remember(cache, key, entry) {
+  cache.delete(key)
+  cache.set(key, entry)
+  while (cache.size > CACHE_LIMIT) {
+    const oldest = cache.keys().next()
+    if (oldest.done === true) break
+    cache.delete(oldest.value)
+  }
+}
+
+/**
+ * Resolve the model route: explicit config, then the Session's frozen request head,
+ * then its last request context, then the process default.
+ * @param ctx - Host context.
+ * @param session - live Session.
+ * @param settings - resolved plugin settings.
+ * @returns a provider/model pair, or undefined when none is configured.
+ */
+function resolveRoute(ctx, session, settings) {
+  if (settings.provider !== '' && settings.model !== '') {
+    return { provider: settings.provider, model: settings.model }
+  }
+  const config = safe(() => session.requestHeader()?.config)
+  if (typeof config?.provider === 'string' && typeof config?.model === 'string') {
+    return { provider: config.provider, model: config.model }
+  }
+  const context = safe(() => session.requestContext())
+  if (typeof context?.provider === 'string' && typeof context?.model === 'string') {
+    return { provider: context.provider, model: context.model }
+  }
+  const selection = safe(() => ctx.get('agentDefaultModel')?.currentSelection?.())
+  if (typeof selection?.provider === 'string' && typeof selection?.model === 'string') {
+    return { provider: selection.provider, model: selection.model }
+  }
+  return undefined
+}
+
+/**
+ * Render the conversation tail as role-labelled lines.
+ * @param session - live Session.
+ * @param settings - resolved plugin settings.
+ * @returns the prompt body, empty when the Session carries no conversation.
+ */
+function buildTranscript(session, settings) {
+  const messages = safe(() => session.deriveMessages()) ?? []
+  const lines = []
+  for (const message of messages) {
+    if (message?.role !== 'user' && message?.role !== 'assistant') continue
+    const blocks = Array.isArray(message.content) ? message.content : []
+    const text = blocks
+      .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+      .map((block) => block.text)
+      .join('\n')
+      .trim()
+    const tools = blocks.filter((block) => block?.type === 'tool-call' && typeof block.name === 'string').map((block) => block.name)
+    if (text === '' && tools.length === 0) continue
+    const label = message.role === 'user' ? '用户' : '助手'
+    const toolNote = tools.length === 0 ? '' : `（调用工具：${[...new Set(tools)].join('、')}）`
+    lines.push(`${label}: ${clip(text, settings.maxMessageChars)}${toolNote}`)
+  }
+  if (lines.length === 0) return ''
+  const tail = lines.slice(-Math.max(1, settings.maxContextMessages))
+  const cwd = safe(() => session.header?.cwd)
+  const where = typeof cwd === 'string' && cwd !== '' ? `工作目录：${cwd}\n\n` : ''
+  return `${where}对话尾部：\n${tail.join('\n')}\n\n请只输出用户的下一条指令；没有就什么都不输出。`
+}
+
+/**
+ * The instruction block for one prediction call.
+ * @param settings - resolved plugin settings.
+ * @returns the system prompt.
+ */
+function systemPrompt(settings) {
+  const limit = settings.maxSuggestionChars
+  return [
+    '你是一个编码智能体的「下一步指令预测器」。',
+    '阅读给出的对话尾部，预测用户此刻最可能直接发送的下一条指令。',
+    '',
+    '规则：',
+    '- 使用对话本身的语言（对话以中文为主就用中文，以英文为主就用英文）。',
+    `- 只输出一条指令：具体、可执行，不超过 ${limit} 个汉字或 ${limit} 个英文单词。`,
+    '- 只输出指令本身：不要引号、不要编号、不要句末句号、不要解释、不要换行。',
+    '- 给出紧接着的下一步：运行或验证、修复报错、补充测试、继续实现、调整样式、打开结果。',
+    '- 不要复述用户上一句，也不要给出与当前任务无关的通用建议。',
+    '- 只要对话里有具体的任务上下文，就给出你认为最可能的一条指令。',
+    '- 对话里没有具体任务（例如只有问候、闲聊、或话题刚结束）时，什么都不要输出，不要编造任务。',
+    '- 不要输出 NONE、无、N/A 之类的占位字样。',
+  ].join('\n')
+}
+
+/**
+ * Narrow the model reply to one editable instruction.
+ * @param text - accumulated model text.
+ * @param settings - resolved plugin settings.
+ * @returns the instruction, or null when the model declined.
+ */
+function cleanSuggestion(text, settings) {
+  if (typeof text !== 'string') return null
+  const line = text
+    .split('\n')
+    .map((part) => part.trim())
+    .find((part) => part !== '')
+  if (line === undefined) return null
+  let value = line
+    .replace(/^[-*•\d.、)）\s]+/u, '')
+    .replace(/^["'“”‘’`「」《》]+|["'“”‘’`「」《》]+$/gu, '')
+    .trim()
+  if (value === '') return null
+  /* A model told to stay silent sometimes writes "nothing" as words instead. */
+  if (/^(none|n\/a|无|没有|无法预测|什么都不输出|不输出|空回复|空)$/iu.test(value)) return null
+  const cap = Math.max(8, settings.maxSuggestionChars * 3)
+  if (value.length > cap) value = value.slice(0, cap)
+  return value
+}
+
+/**
+ * Keep the head and tail of one long message.
+ * @param text - message text.
+ * @param limit - maximum characters.
+ * @returns the clipped text.
+ */
+function clip(text, limit) {
+  if (typeof text !== 'string') return ''
+  if (limit <= 0 || text.length <= limit) return text
+  const head = Math.max(1, Math.floor(limit * 0.7))
+  const tail = Math.max(1, Math.floor(limit * 0.25))
+  return `${text.slice(0, head)} … ${text.slice(-tail)}`
+}
+
+/**
+ * Read a value without letting an unavailable capability break the route.
+ * @param read - thunk returning the value.
+ * @returns the value or undefined.
+ */
+function safe(read) {
+  try {
+    return read()
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Describe an error for the Client, which only logs it.
+ * @param error - thrown value.
+ * @returns a short message.
+ */
+function messageOf(error) {
+  if (error instanceof Error) return error.message
+  return String(error)
+}
+
+/**
+ * Build one JSON response.
+ * @param status - HTTP status.
+ * @param body - JSON-serializable body.
+ * @returns the response.
+ */
+function json(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      'content-type': 'application/json; charset=utf-8',
+      'cache-control': 'no-store',
+    },
+  })
+}
+
+/**
+ * Merge row configuration over the defaults.
+ * @param config - row configuration.
+ * @returns resolved settings.
+ */
+function resolveSettings(config) {
+  const merged = { ...DEFAULTS }
+  for (const [key, value] of Object.entries(config ?? {})) {
+    if (!(key in DEFAULTS)) continue
+    if (typeof DEFAULTS[key] === 'number') {
+      const number = Number(value)
+      if (Number.isFinite(number) && number >= 0) merged[key] = number
+      continue
+    }
+    if (typeof DEFAULTS[key] === 'boolean') {
+      merged[key] = value === true || value === 'true'
+      continue
+    }
+    if (typeof value === 'string') merged[key] = value
+  }
+  return merged
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Composer Prediction",
+    "description": "Predicts the instruction you are most likely to send next from the current conversation and offers it under the composer. Press Tab to turn it into an editable draft."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "下一步指令建议",
+    "description": "根据当前对话预测你最可能发送的下一条指令，显示在输入框下方；按 Tab 即可填入输入框，作为可编辑的草稿。"
+  }
+}

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "dsh-predict",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.2.1",
+  "type": "module",
+  "description": "Predicts your next instruction from the current conversation and shows it as the composer placeholder; press Tab to turn it into an editable draft.",
+  "keywords": [
+    "dsh-plugin",
+    "deepseek",
+    "harness",
+    "composer",
+    "prediction",
+    "autocomplete"
+  ],
+  "author": "Dogtiti",
+  "license": "MIT",
+  "homepage": "https://github.com/Dogtiti/dsh-predict#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Dogtiti/dsh-predict"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg"
+  ],
+  "engines": {
+    "dsh": "^0.2.1-0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  },
+  "bugs": {
+    "url": "https://github.com/Dogtiti/dsh-predict/issues"
+  }
+}