dsh-plan-completion 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -3,6 +3,37 @@
 All notable changes to this project are documented here.
 Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), versioning: SemVer.
 
+## [0.1.4] - 2026-11-02
+
+### Fixed
+- Suggestion/Markdown cleaning no longer destroys identifiers, file names or globs: `transaction_id`,
+  `payment_test.py`, `C:\work\my_file.js` and `src/**/*.js` keep their underscores/stars. Only paired
+  emphasis markers (`**bold**`, `*italic*`, `_emphasis_`, `~~strike~~`) are stripped; inline code keeps
+  its content with backticks removed.
+- Semantic shortening replaces the raw 40-character cut: prefer the last clause boundary, then a
+  whitespace boundary, then cut before an ASCII token; never leave a truncated identifier/path or a
+  dangling command prefix (`npm`, `npm te`), and drop dangling separators.
+- New `test/text.test.js` covers the identifier/glob/command cases and the old guarantees
+  (single line, ≤40 chars, dangerous suggestions filtered).
+
+### Changed
+- `npm test` now reports **132/132** tests.
+
+## [0.1.3] - 2026-11-02
+
+### Added
+- Plan page「核对进度」button (P0-5): `POST /plan-completion/verify {sessionId}` runs one bounded,
+  authenticated model call that compares the stored plan with recent evidence and returns
+  `{assessment, mismatches[], suggestion}`. It never mutates the plan; results render in the plan
+  panel as an assessment list plus next-step suggestion.
+- New config `maxTokensVerify` (default 600); per-session in-flight guard, 8s abort deadline and
+  parse-error fallbacks; `modelCalls:false` disables this route's model call.
+- Tests: verify prompt/parser edge cases, authenticated route integration, and a client transport
+  test for the new request helper.
+
+### Changed
+- `npm test` now reports **126/126** tests; production routes are `state`/`replan`/`warm`/`verify`.
+
 ## [0.1.2] - 2026-11-02
 
 ### Added

package/README.md

@@ -60,15 +60,23 @@ Client ⇄ Host 唯一通道是本地 HTTP 路由（`ctx.get('webServer').regist
 - `GET /plan-completion/state?sessionId=<id>&reason=<kind>&running=<值>`
 - `POST /plan-completion/warm` `{sessionId}`（旧会话回填：从持久化日志重建计划+建议）
 - `POST /plan-completion/replan` `{sessionId, instruction?}`（生产路由，须通过宿主鉴权）
+- `POST /plan-completion/verify` `{sessionId}`（「核对进度」：一次模型调用返回差异清单，不修改计划）
 - `GET /plan-completion/debug?sessionId=<id>`（仅显式启用调试路由后可用）
 
-> 生产路由：`state`、`replan`、`warm`；所有路由先调用 `connection.requestRejection(req)`。
+> 生产路由：`state`、`replan`、`warm`、`verify`；所有路由先调用 `connection.requestRejection(req)`。
 > 调试路由：`debug`、`diag`、`theme`、`experiment`、`autojob`、`steps`、`reset` —— 仅当 `config.enableDebugRoutes: true` 时注册。
 
 Client 侧用 `fetch(..., {credentials:'same-origin'})`；Electron 的 `dsh-app://app` 页面经主进程转发，响应体可读、自动带 `dsh-auth` cookie。
 
 Client 侧关键 API（实测）：`inputActions.captureInsertion()` 返回 `{start,end,draftRev}`；`insertText(text, span)`；`setDraft(text)`；`useInput(s => s)` 返回 `{draft, attachmentIds, draftRev, phase, occurrences, queue}`。
 
+## 核对进度（v0.1.3）
+
+- 计划面板底部「核对进度」按钮 → `POST /plan-completion/verify {sessionId}`（生产路由，需宿主鉴权）；
+- Host 用**一次**受控模型调用对照「当前计划 + 最近证据」，返回 `{assessment, mismatches[], suggestion}`，**不修改计划**；
+- 面板内展示结论、差异列表与下一步建议；同一会话同时只允许一个核对请求，8s 超时/解析失败返回降级错误，`modelCalls:false` 时禁用模型调用；
+- 输出预算 `maxTokensVerify`（默认 600）；核对结果仅内存展示，不落盘。
+
 ## 计划持久化（v0.1.2）
 
 - 计划 + 最近一条建议按会话持久化到本地文件（`storageDir/plans/<base64url(sessionId)>.json`，原子写）；
@@ -77,6 +85,12 @@ Client 侧关键 API（实测）：`inputActions.captureInsertion()` 返回 `{st
 - 默认目录 `~/.dsh/plan-completion-data`；可用 `storageDir` 改到别处，`persistPlans: false` 退回纯内存；
 - 注意：存储为本地明文 JSON（含计划/建议文本，可能来自会话）；不加密、不自动清理，不适合多用户共享机器。
 
+## 建议文本安全（v0.1.4）
+
+- 去 Markdown 只剥离**成对**的行内标记；`transaction_id`、`payment_test.py`、`C:\a_b\file.js`、`src/**/*.js` 等标识符/路径/glob 原样保留；
+- 超过 40 字时按分句/空白/ASCII token 边界语义化缩短，不再把 `npm test` 截成 `npm`/`npm te`，也不会切断标识符或路径；
+- 危险命令过滤（rm -rf、format、Drop DB 等）不变；单行、≤40 字、可直接发送的约束不变。
+
 ## 模型路由与隐私
 
 - 仅使用宿主 `agentDefaultModel.currentSelection()` 当前默认的 provider/model，不自动改投其他已配置供应商；无可用路由时使用启发式。该默认值不一定是历史会话原先使用的模型。
@@ -100,8 +114,7 @@ Client 侧关键 API（实测）：`inputActions.captureInsertion()` 返回 `{st
         modelCalls: true         # false：本插件仅用启发式，不向模型发送内容
         persistPlans: true       # false：计划只存内存
         storageDir: '~/.dsh/plan-completion-data'
-        enableDebugRoutes: false   # 本地调试时才打开
-        # debugDir: '<本地日志目录>'  # 可选；发布版留空
+        enableDebugRoutes: false   # 本地调试时才打开        # debugDir: '<本地日志目录>'  # 可选；发布版留空
 ```
 
 | 配置项 | 默认 | 作用 | 依据 |
@@ -112,6 +125,7 @@ Client 侧关键 API（实测）：`inputActions.captureInsertion()` 返回 `{st
 | `warmBackfill` | true | 打开「插件从未观察过的旧会话」时，从持久化会话日志回填一次计划+建议 | P0-1；真机老会话回填 2.2s |
 | `persistPlans` | true | 是否把计划+最近建议持久化到本地文件（DSH 重启恢复） | v0.1.2 |
 | `storageDir` | `~/.dsh/plan-completion-data` | 计划文件目录；`~` 会展开为 home；也可用 `DSH_PLAN_COMPLETION_STORE_DIR` | v0.1.2 |
+| `maxTokensVerify` | 600 | 「核对进度」单次模型调用的输出预算 | v0.1.3 |
 | `enableDebugRoutes` | false | 是否注册 `debug/diag/theme/experiment/autojob/steps/reset` 调试路由；仍须鉴权 | 发布版最小攻击面 |
 | `modelCalls` | true | false 时关闭本插件全部模型调用，使用启发式 | 隐私控制 |
 | `debugDir` | 空 | 调试日志/实验结果的落盘目录（也可用 `DSH_PLAN_COMPLETION_DEBUG_DIR`）；空则不写文件 | 可移植性 |

package/client.js

@@ -80,6 +80,7 @@ window.__ModuleLoader__.load({
         'popover.fill': '填入草稿',
         'popover.sync': '同步给 Agent',
         'popover.close': '关闭',
+        'popover.verify': '核对进度',
         'popover.empty': '暂无计划',
         'popover.updated': '更新于 {time}',
         'popover.stale': '计划可能已过期，将在下一回合重建',
@@ -97,7 +98,14 @@ window.__ModuleLoader__.load({
         'sync.todo': '待办：{value}。',
         'sync.reason': '最近更新：{value}。',
         'sync.next': '下一步建议：{value}。',
-        'sync.fallback': '请先确认当前进度，再继续推进。'
+        'sync.fallback': '请先确认当前进度，再继续推进。',
+        'verify.loading': '正在对照计划与实际进度…',
+        'verify.assessment': '核对结论',
+        'verify.mismatch': '差异',
+        'verify.clean': '未发现明显差异。',
+        'verify.next': '建议：{value}',
+        'verify.failed': '核对失败：{value}',
+        'verify.no-session': '当前还没有可用会话'
       },
       en: {
         'entry.aria': 'Open the session plan panel',
@@ -115,6 +123,7 @@ window.__ModuleLoader__.load({
         'popover.fill': 'Fill draft',
         'popover.sync': 'Sync to Agent',
         'popover.close': 'Close',
+        'popover.verify': 'Verify progress',
         'popover.empty': 'No plan yet',
         'popover.updated': 'Updated {time}',
         'popover.stale': 'The plan may be stale and will be rebuilt next turn',
@@ -132,7 +141,14 @@ window.__ModuleLoader__.load({
         'sync.todo': 'Pending: {value}.',
         'sync.reason': 'Latest update: {value}.',
         'sync.next': 'Next suggestion: {value}.',
-        'sync.fallback': 'Please confirm the current progress before continuing.'
+        'sync.fallback': 'Please confirm the current progress before continuing.',
+        'verify.loading': 'Comparing the plan against the latest evidence…',
+        'verify.assessment': 'Assessment',
+        'verify.mismatch': 'Mismatch',
+        'verify.clean': 'No obvious mismatches found.',
+        'verify.next': 'Next: {value}',
+        'verify.failed': 'Verification failed: {value}',
+        'verify.no-session': 'No session available yet'
       }
     };
 
@@ -301,6 +317,14 @@ window.__ModuleLoader__.load({
       '.dpc-pop-foot .dpc-updated{flex:1 1 auto;min-width:0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}',
       '.dpc-actions{padding-top:0;gap:8px;flex:none}',
       '.dpc-btn{border-radius:999px;padding:5px 12px;font-size:12px;line-height:18px}',
+      '.dpc-verify-card{gap:6px}',
+      '.dpc-verify-loading{font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary)}',
+      '.dpc-verify-error{font-size:12px;line-height:18px;color:var(--dsw-alias-state-error-primary, var(--dsw-alias-label-secondary));word-break:break-word}',
+      '.dpc-verify-assessment{font-size:13px;line-height:20px;color:var(--dsw-alias-label-primary);white-space:pre-wrap;word-break:break-word}',
+      '.dpc-verify-list{margin:0;padding-left:16px;display:flex;flex-direction:column;gap:4px}',
+      '.dpc-verify-item{font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary);word-break:break-word}',
+      '.dpc-verify-clean{font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}',
+      '.dpc-verify-next{font-size:12px;line-height:18px;color:var(--dsw-alias-label-primary);word-break:break-word}',
       '.dpc-empty{padding:14px;font-size:13px}'
     ].join('\n');
 
@@ -729,6 +753,40 @@ window.__ModuleLoader__.load({
         });
     }
 
+    /**
+     * P0-5「核对进度」：让 Host 用一次受控模型调用对照计划与实际证据。
+     * 返回 Host 的 JSON（{ok, assessment, mismatches, suggestion}）或 null。
+     */
+    function requestVerify(sessionId) {
+      if (typeof sessionId !== 'string' || sessionId === '') return Promise.resolve(null);
+      let request = null;
+      try {
+        request = fetch('/plan-completion/verify', {
+          method: 'POST',
+          credentials: 'same-origin',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ sessionId: sessionId })
+        });
+      } catch (error) {
+        return Promise.resolve(null);
+      }
+      return Promise.resolve(request)
+        .then(function readResponse(response) {
+          if (!response || response.ok !== true) return null;
+          return Promise.resolve(response.json()).then(
+            function parsed(json) {
+              return json && typeof json === 'object' ? json : null;
+            },
+            function badJson() {
+              return null;
+            }
+          );
+        })
+        .catch(function networkError() {
+          return null;
+        });
+    }
+
     /**
      * P0 boundary: read the current plan state. Keep this signature stable —
      * swapping the transport (HTTP route / projection / wire view) only changes
@@ -1620,7 +1678,7 @@ window.__ModuleLoader__.load({
       );
     }
 
-    function renderPopoverContent(plan, inputActions, t) {
+    function renderPopoverContent(plan, inputActions, t, verify, onVerify) {
       const children = [];
       if (!plan) {
         children.push(
@@ -1732,6 +1790,50 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // P0-5「核对进度」结果：显示在计划正文里，不改动计划本身。
+      if (verify && (verify.loading || verify.error || verify.result)) {
+        const verifyChildren = [
+          h('div', { key: 'label', className: 'dpc-label' }, t('verify.assessment'))
+        ];
+        if (verify.loading) {
+          verifyChildren.push(h('div', { key: 'loading', className: 'dpc-verify-loading' }, t('verify.loading')));
+        } else if (verify.error) {
+          verifyChildren.push(
+            h('div', { key: 'error', className: 'dpc-verify-error' }, t('verify.failed', { value: verify.error }))
+          );
+        } else if (verify.result) {
+          const result = verify.result;
+          if (result.assessment) {
+            verifyChildren.push(h('div', { key: 'assessment', className: 'dpc-verify-assessment' }, result.assessment));
+          }
+          const mismatches = Array.isArray(result.mismatches) ? result.mismatches : [];
+          if (mismatches.length) {
+            verifyChildren.push(
+              h(
+                'ul',
+                { key: 'mismatches', className: 'dpc-verify-list' },
+                mismatches.map(function renderMismatch(item, index) {
+                  const prefix = item && item.stepId ? '[' + item.stepId + '] ' : '';
+                  return h(
+                    'li',
+                    { key: 'mismatch-' + index, className: 'dpc-verify-item' },
+                    prefix + String(item && item.issue ? item.issue : '')
+                  );
+                })
+              )
+            );
+          } else {
+            verifyChildren.push(h('div', { key: 'clean', className: 'dpc-verify-clean' }, t('verify.clean')));
+          }
+          if (result.suggestion) {
+            verifyChildren.push(
+              h('div', { key: 'next', className: 'dpc-verify-next' }, t('verify.next', { value: result.suggestion }))
+            );
+          }
+        }
+        children.push(h('div', { key: 'verify', className: 'dpc-section dpc-verify-card' }, verifyChildren));
+      }
+
       if (plan.updatedAt) {
         children.push(
           h('div', { key: 'updated', className: 'dpc-updated' }, t('popover.updated', { time: formatTime(plan.updatedAt) }))
@@ -1774,6 +1876,20 @@ window.__ModuleLoader__.load({
             },
             t('popover.sync')
           ),
+          h(
+            'button',
+            {
+              type: 'button',
+              className: 'dpc-btn',
+              disabled: !!(verify && verify.loading),
+              onMouseDown: preventDefault,
+              onClick: function onClickVerify(event) {
+                stopPropagation(event);
+                if (typeof onVerify === 'function') onVerify();
+              }
+            },
+            t('popover.verify')
+          ),
           h(
             'button',
             {
@@ -1815,6 +1931,32 @@ window.__ModuleLoader__.load({
       const rootRef = React.useRef(null);
       const open = state.overlayOpen === true;
       const [heroPos, setHeroPos] = React.useState(null);
+      const [verify, setVerify] = React.useState(null);
+
+      // Ephemeral P0-5 verification result: clear it when the active session changes.
+      React.useEffect(function resetVerify() {
+        setVerify(null);
+      }, [state.sessionId]);
+
+      const onVerify = React.useCallback(function requestVerifyAction() {
+        const sessionId = state.sessionId;
+        if (typeof sessionId !== 'string' || sessionId === '') {
+          setVerify({ loading: false, result: null, error: 'no-session' });
+          return;
+        }
+        setVerify({ loading: true, result: null, error: null });
+        requestVerify(sessionId).then(function applyResult(result) {
+          if (!result) {
+            setVerify({ loading: false, result: null, error: 'request-failed' });
+            return;
+          }
+          if (result.ok !== true) {
+            setVerify({ loading: false, result: null, error: String(result.error || 'failed') });
+            return;
+          }
+          setVerify({ loading: false, result: result, error: null });
+        });
+      }, [state.sessionId]);
 
       // P0-2 hero fallback: when no session-bound dock is mounted (new conversation / hero,
       // or a cleared conversation), float a small «▤ 计划» entry above the composer so the
@@ -1908,7 +2050,7 @@ window.__ModuleLoader__.load({
             'data-plan-completion': 'popover',
             style: position
           },
-          renderPopoverContent(state.plan, state.inputActions, t)
+          renderPopoverContent(state.plan, state.inputActions, t, verify, onVerify)
         )
       );
     }

package/docs/phase-2-plan.md

@@ -12,7 +12,7 @@
 
 ### P0（必须，决定可用性与发布）
 
-> 更新（v0.1.2）：P0-1（挂载回填）、P0-2（Hero 常驻）、P0-3（计划持久化）、P0-4（路由鉴权）已交付；以下保留原始规划记录，未完成项为 P0-5 / P0-6。
+> 更新（v0.1.3）：P0-1（挂载回填）、P0-2（Hero 常驻）、P0-3（计划持久化）、P0-4（路由鉴权）、P0-5（核对进度）已交付；以下保留原始规划记录，未完成项为 P0-6。
 
 | # | 事项 | 现状问题 | 方案 | 验收标准 | 预估 |
 |---|---|---|---|---|---|
@@ -20,7 +20,7 @@
 | P0-2 | ✅ **真·常驻（hero / 新会话也有入口）** | `conversation.input.dock` 在无 Session 的 hero 页不渲染；删除全部消息后栏位消失 | 在 `shell.overlay` 增加一个随 composer 定位的轻量 `▤ 计划` 入口（hero 时显示；已有 dock 时隐藏避免重复）；无计划时保留虚线提示胶囊（一期已做） | 新会话 hero、删除全部消息、旧会话、正常会话四种状态都有入口且不重叠 | ✅ 已交付（v0.1.1） |
 | P0-3 | ✅ **计划持久化** | 进程内存，DSH 重启丢失 | 本地文件持久化（`storageDir`，按 sessionId 原子写）+ 启动/打开会话时 hydrate + 版本号 `gen.rev` 保留 | 重启 DSH 后同一会话仍显示原计划与版本；schema 变更可迁移 | ✅ 已交付（v0.1.2，文件存储方案） |
 | P0-4 | ✅ **路由鉴权** | `/plan-completion/*` 调试路由无鉴权（本机回环） | 使用 `connection.requestRejection` 校验来源、或改用 `connection.fetch` 同源校验；调试路由默认仅本机、可配置关闭 | 非本机/非 DSH 页面的请求被拒；客户端不受影响 | ✅ 已交付（v0.1.1） |
-| P0-5 | **「核对进度」按钮** | 计划页只能看状态，无法对照实际进度 | 计划页底部加「核对进度」→ POST `/plan-completion/verify` → 一次模型调用生成「计划 vs 实际差异 + 建议修正」→ 展示在计划页（可折叠、可采纳） | 点击后 ≤5s 返回差异清单；采纳后生成 patch；失败有降级文案 | 1d |
+| P0-5 | ✅ **「核对进度」按钮** | 计划页只能看状态，无法对照实际进度 | 计划页底部加「核对进度」→ POST `/plan-completion/verify` → 一次模型调用生成「计划 vs 实际差异 + 建议修正」→ 展示在计划页（可折叠、可采纳） | 点击后 ≤5s 返回差异清单；采纳后生成 patch；失败有降级文案 | ✅ 已交付（v0.1.3） |
 | P0-6 | **发布工程化** | 无 git 仓库 / LICENSE / CI / 包元数据、README 含本地绝对路径 | 见 `发布评估-GitHub.md` 的 P0 清单 | 全部 P0 项 PASS，`node --test` 绿，仓库可公开 | 1d |
 
 ### P1（体验增强）

package/docs/publish-assessment.md

@@ -1,8 +1,12 @@
 # GitHub 发布评估 · 会话计划补全插件（2026-11-02）
 
-> 历史文档：以下保留 v0.1.0 的交付/评估/计划记录。**v0.1.1 已发布**（鉴权、状态一致性、隐私边界修复），详见 [security.md](security.md) 与 [CHANGELOG](../CHANGELOG.md)；旧记录中的“无鉴权”、原始诊断字段与独立评审不代表当前实现。
+> 历史文档：以下保留 v0.1.0 的交付/评估/计划记录。**当前最新为 v0.1.3**（核对进度 + 本地计划持久化 + 鉴权/状态一致性/隐私边界修复），详见 [security.md](security.md) 与 [CHANGELOG](../CHANGELOG.md)；旧记录中的“无鉴权”、原始诊断字段与独立评审不代表当前实现。
+>
+> v0.1.3 发布记录（2026-11-02）：tag `v0.1.3` + [Release](https://github.com/Xumi0920/dsh-plan-completion/releases/tag/v0.1.3)；GitHub Actions [run 41368609382](https://github.com/Xumi0920/dsh-plan-completion/actions/runs/41368609382)（Ubuntu/Windows × Node20/22 四 job 全绿，126/126 tests）；npm `dsh-plan-completion@0.1.3`（31 files，shasum `11adee0fe9acff199a180be511ca8bc600afdf6f`）；canary 验证 `/plan-completion/verify` 未认证 401、客户端鉴权请求正常。
 >
 > v0.1.1 发布记录（2026-11-02）：tag `v0.1.1` + [Release](https://github.com/Xumi0920/dsh-plan-completion/releases/tag/v0.1.1)；GitHub Actions [run 41366651557](https://github.com/Xumi0920/dsh-plan-completion/actions/runs/41366651557)（Ubuntu/Windows × Node20/22 四 job 全绿）；npm `dsh-plan-completion@0.1.1`（31 files，shasum `18989b0f50b72d5c8c332f3fdee7f43ccb5fd91a`）。
+>
+> v0.1.2 发布记录（2026-11-02）：tag `v0.1.2` + [Release](https://github.com/Xumi0920/dsh-plan-completion/releases/tag/v0.1.2)；GitHub Actions [run 41367719292](https://github.com/Xumi0920/dsh-plan-completion/actions/runs/41367719292)（Ubuntu/Windows × Node20/22 四 job 全绿，120/120 tests）；npm `dsh-plan-completion@0.1.2`（31 files，shasum `e9d5d61ae2cb35f043e2eb7d05a38786d2699626`）；真机持久化 canary 通过（6 个会话计划落盘、会话文件 `gen5.rev0` 可读回、subagent 真实回合自动写入）。
 
 > **2026-11-02 晚更新：P0 清单已全部完成，状态从「不满足全 PASS」→「可按 GitHub 源码仓库发布」。**
 >

package/host/config.js

@@ -69,6 +69,8 @@ export const DEFAULTS = Object.freeze({
   // 真机实测（Lead index.js，2026-11）：rewrite 700 会被截断 → 至少 1200；patch 建议至少 800。
   maxTokensPatch: 800,
   maxTokensRewrite: 1200,
+  /** 「核对进度」一次调用的输出预算（差异清单 JSON，不需要完整步骤表）。 */
+  maxTokensVerify: 600,
   temperaturePatch: 0.2,
   temperatureRewrite: 0.3,
 });

package/host/prompt.js

@@ -384,3 +384,87 @@ export function parseModelOutput(text) {
     return fail('internal', `模型输出解析异常：${errMsg(err)}`);
   }
 }
+
+/* ──────────────────────────────────────────────────────────────
+ * 「核对进度」：对照计划与实际证据，输出差异清单（不修改计划）
+ * ────────────────────────────────────────────────────────────── */
+
+export const VERIFY_SCHEMA = [
+  '{"ok":true,',
+  '"assessment":"<一句话总体判断>",',
+  '"mismatches":[{"stepId":"s2","issue":"<计划状态与证据不一致之处，≤80字>"}],',
+  '"suggestion":"<下一步建议，≤40字，可直接发送>"}',
+].join('');
+
+/**
+ * 构造「核对进度」prompt：不要求 op/steps，只输出 assessment + mismatches + suggestion。
+ * @param {object} evidence 与生成计划相同的证据结构
+ */
+export function buildVerifyPrompt(evidence = {}) {
+  const task = [
+    '【任务：核对计划进度】',
+    '对照下面的计划与最近会话证据，找出计划状态与实际进展不一致的地方：',
+    '- 步骤实际已完成/已开始，但计划仍为 todo/doing；',
+    '- 计划标记 done，但证据中没有完成依据；',
+    '- 步骤被跳过、顺序明显变化，或计划目标与当前工作方向不一致。',
+    '不要修改计划，也不要输出 op/steps/changes 字段。',
+    '没有明显差异时 mismatches 返回空数组，并给出收尾/推进建议。',
+    '严格只输出一个 JSON 对象，schema 如下（字段值用中文）：',
+    VERIFY_SCHEMA,
+  ].join('\n')
+  return {
+    system: `${SYSTEM_PROMPT}\n\n【本次任务】只核对进度并输出差异清单；本次输出 schema 不同于计划更新，不要输出 op 字段。`,
+    messages: buildMessages(evidence, task),
+    maxTokens: DEFAULTS.maxTokensVerify,
+    temperature: 0,
+    op: 'verify',
+  }
+}
+
+/**
+ * 解析「核对进度」输出；永不抛异常。
+ * @param {unknown} text
+ * @returns {{ok:true, output:{assessment:string, mismatches:Array<{stepId:string, issue:string}>, suggestion:string, verifiedAt:number}}|{ok:false, code:string, error:string}}
+ */
+export function parseVerifyOutput(text) {
+  try {
+    if (typeof text !== 'string') return fail('not-string', '模型输出不是字符串')
+    const cleaned = text.replace(/^\uFEFF/, '').trim()
+    if (!cleaned) return fail('empty', '模型输出为空')
+
+    let parsed = null
+    for (const candidate of jsonCandidates(cleaned)) {
+      try {
+        parsed = JSON.parse(candidate)
+        break
+      } catch {
+        /* try next candidate */
+      }
+    }
+    if (!isObj(parsed)) return fail('no-json', '未找到合法 JSON 对象')
+
+    const assessment = isStr(parsed.assessment) ? clampChars(oneLine(parsed.assessment), 200) : ''
+    if (!assessment) return fail('missing-assessment', 'assessment 必填且非空')
+
+    const mismatches = []
+    if (Array.isArray(parsed.mismatches)) {
+      for (const item of parsed.mismatches.slice(0, 6)) {
+        if (!isObj(item)) continue
+        const issue = isStr(item.issue) ? clampChars(oneLine(item.issue), 120) : ''
+        if (!issue) continue
+        const stepId = isStr(item.stepId) ? clampChars(oneLine(item.stepId), 64) : ''
+        mismatches.push({ stepId, issue })
+      }
+    }
+
+    let suggestion = ''
+    if (parsed.suggestion !== undefined) {
+      const sanitized = sanitizeSuggestion(parsed.suggestion, DEFAULTS.suggestionMaxChars)
+      if (sanitized.ok) suggestion = sanitized.text
+    }
+
+    return { ok: true, output: { assessment, mismatches, suggestion, verifiedAt: Date.now() } }
+  } catch (err) {
+    return fail('internal', `核对解析异常：${errMsg(err)}`)
+  }
+}

package/host/text.js

@@ -49,12 +49,17 @@ export function oneLine(value) {
 }
 
 const MD_LINE_PREFIX = /^\s{0,3}(?:#{1,6}\s+|>\s*|[-*+]\s+|\d+[.)]\s+)/;
-const MD_INLINE = /(\*\*|__|\*|_|`)/g;
 const MD_LINK = /\[([^\]]*)\]\([^)]*\)/g;
 const WRAPPING_QUOTES = /^["'“”‘’「」『』]+|["'“”‘’「」『』]+$/g;
+const CLAUSE_BOUNDARY = /[，。；！？、,;!?]/;
+const ASCII_TOKEN_CHAR = /[A-Za-z0-9_./\\-]/;
 
 /**
  * 去掉常见 Markdown 痕迹，得到适合直接发送的纯文本。
+ *
+ * 只剥离「成对」的行内标记：`transaction_id`、`C:\a_b\file.js`、`src/**\/*.js`
+ * 这类标识符/路径/glob 里的 `_`、`*` 不再被误删；
+ * 反引号只去掉包裹符号，代码内容原样保留。
  * @param {unknown} value
  * @returns {string}
  */
@@ -66,18 +71,89 @@ export function stripMarkdown(value) {
     .map((line) => line.replace(MD_LINE_PREFIX, ''))
     .join(' ');
   text = text.replace(MD_LINK, '$1');
-  text = text.replace(MD_INLINE, '');
+  // Protect glob/star patterns (src/**/*.js, *.py, **/) before emphasis stripping.
+  const stars = [];
+  text = text.replace(/\*\*\/|\*\/|\*\.[A-Za-z0-9_-]+/g, (match) => {
+    stars.push(match);
+    return `\u0000${stars.length - 1}\u0000`;
+  });
+  // Inline code: drop the backtick delimiters, keep the code text (underscores intact).
+  text = text.replace(/`([^`\n]+)`/g, '$1').replace(/`/g, '');
+  // Paired emphasis markers only. Never strip a lone _/* that belongs to an identifier,
+  // file name or glob (e.g. transaction_id, foo_bar, *.js).
+  text = text
+    .replace(/\*\*([^*\n]+)\*\*/g, '$1')
+    .replace(/__([^_\n]+)__/g, '$1')
+    .replace(/~~([^~\n]+)~~/g, '$1')
+    .replace(/\*([^*\n]+)\*/g, '$1')
+    .replace(/(^|[^\p{L}\p{N}_])_([^_\n]+)_(?=[^\p{L}\p{N}_]|$)/gu, '$1$2');
+  text = text.replace(/\u0000(\d+)\u0000/g, (_match, index) => stars[Number(index)] ?? '');
   return oneLine(text).replace(WRAPPING_QUOTES, '').trim();
 }
 
 /**
- * 建议文本规范化：单行 + 去 Markdown + 截断到 max 字。
+ * 语义化截短：不把标识符/路径/命令从中间切断。
+ *
+ * 依次尝试：句子/分句边界（，。；！？、,;!?）→ 空白边界 → 回退到 ASCII token 起点。
+ * 实在没有边界时才硬截断，保证返回长度 ≤ max。
+ * @param {unknown} value
+ * @param {number} [max]
+ * @returns {string}
+ */
+export function shortenSuggestion(value, max = DEFAULTS.suggestionMaxChars) {
+  const text = oneLine(value);
+  const limit = Number.isFinite(max) ? Math.floor(max) : 0;
+  if (limit <= 0) return '';
+  const chars = Array.from(text);
+  if (chars.length <= limit) return text;
+
+  const prefix = chars.slice(0, limit).join('');
+  const minUseful = Math.max(1, Math.floor(limit * 0.4));
+
+  // 1) Prefer the last clause boundary so the returned text stays a complete clause.
+  for (let i = prefix.length - 1; i >= minUseful; i -= 1) {
+    if (!CLAUSE_BOUNDARY.test(chars[i])) continue;
+    // Keep sentence-ending punctuation; drop separators such as ，、；: so the
+    // returned suggestion still reads like a message the user can send directly.
+    const keep = /[。！？!?]/.test(chars[i]) ? 1 : 0;
+    const head = chars.slice(0, i + keep).join('').trim();
+    if (head) return head;
+  }
+  // 2) Whitespace boundary: never leaves a partially copied word after it.
+  for (let i = prefix.length - 1; i >= minUseful; i -= 1) {
+    if (/\s/.test(chars[i])) {
+      let head = chars.slice(0, i).join('').trim();
+      // If the cut leaves a lone ASCII command prefix ("…再重跑 npm") and the next
+      // character is another ASCII token, drop that dangling token too.
+      const next = chars[i + 1] ?? '';
+      const tail = head.match(/(?:^|\s)([A-Za-z0-9_./\\-]+)$/);
+      if (tail && ASCII_TOKEN_CHAR.test(next)) {
+        head = head.slice(0, head.length - tail[1].length).trim().replace(/[\s，。；、,;:：-]+$/, '');
+      }
+      if (head) return head;
+    }
+  }
+  // 3) Do not split an ASCII identifier/path/command token: cut before the token.
+  let cut = limit;
+  while (cut > 0 && ASCII_TOKEN_CHAR.test(chars[cut - 1] ?? '') && ASCII_TOKEN_CHAR.test(chars[cut] ?? '')) {
+    cut -= 1;
+  }
+  if (cut > 0) {
+    const head = chars.slice(0, cut).join('').trim().replace(/[\s，。；、,;:：-]+$/, '');
+    if (head) return head;
+  }
+  // 4) Single oversized token: hard clamp (still ≤ limit).
+  return prefix;
+}
+
+/**
+ * 建议文本规范化：单行 + 去 Markdown + 语义化截断到 max 字。
  * @param {unknown} value
  * @param {number} [max]
  * @returns {string}
  */
 export function clampSuggestion(value, max = DEFAULTS.suggestionMaxChars) {
-  return clampChars(stripMarkdown(value), max);
+  return shortenSuggestion(stripMarkdown(value), max);
 }
 
 /**

package/index.js

@@ -18,7 +18,7 @@ import { DEFAULTS } from './host/config.js'
 import { requestRejection, safeDebugRecord, safeDiagnostics } from './host/security.js'
 import { join } from 'node:path'
 import { normalizePlan, patchPlan, rewritePlan, statusFor, applyUserEdit } from './host/plan.js'
-import { buildPatchPrompt, buildRewritePrompt, buildRepairPrompt, parseModelOutput } from './host/prompt.js'
+import { buildPatchPrompt, buildRewritePrompt, buildRepairPrompt, parseModelOutput, buildVerifyPrompt, parseVerifyOutput } from './host/prompt.js'
 import { heuristicSuggestion, fallbackPlan } from './host/heuristics.js'
 import { collectFromEvents } from './host/evidence.js'
 import { createMemoryStore, createFileStore } from './host/store.js'
@@ -254,6 +254,7 @@ export function apply(ctx, config = {}) {
     modelCalls: rawConfig.modelCalls !== false,
     persistPlans: rawConfig.persistPlans !== false,
     storageDir: expandStorageDir(rawConfig.storageDir, process.env.DSH_PLAN_COMPLETION_STORE_DIR),
+    maxTokensVerify: readInt(rawConfig.maxTokensVerify, DEFAULTS.maxTokensVerify, 200, 2000),
     enableDebugRoutes: rawConfig.enableDebugRoutes === true,
     debugDir: typeof rawConfig.debugDir === 'string' && rawConfig.debugDir.trim() !== ''
       ? rawConfig.debugDir.trim()
@@ -297,6 +298,7 @@ export function apply(ctx, config = {}) {
   const sessions = shared.sessions // sessionId -> Session
   const warmAttempts = shared.warmAttempts // sessionId -> { at, seq }
   const inflight = new Map() // sessionId -> AbortController
+  const verifyInflight = new Set() // sessionId -> 正在核对（同一会话同时只允许一个）
   const gate = createGate(DEFAULTS.globalConcurrency)
   // Persistence: a file-backed plan store when a directory is configured; otherwise memory.
   // The store keeps the last plan + suggestion per session so a restart can restore the UI.
@@ -964,6 +966,95 @@ export function apply(ctx, config = {}) {
             jsonResponse(res, 200, outcome)
             return
           }
+          if (pathname === `${ROUTE_PREFIX}verify` && method === 'POST') {
+            const body = (await readJsonBody(req)) ?? {}
+            const sessionId = String(body.sessionId ?? '')
+            if (!sessionId) {
+              jsonResponse(res, 200, { ok: false, error: 'no-session-id' })
+              return
+            }
+            await hydrateSession(sessionId)
+            const plan = states.get(sessionId)?.plan ?? null
+            if (!plan) {
+              jsonResponse(res, 200, { ok: false, error: 'no-plan' })
+              return
+            }
+            if (!settings.modelCalls) {
+              jsonResponse(res, 200, { ok: false, error: 'model-disabled' })
+              return
+            }
+            if (verifyInflight.has(sessionId)) {
+              jsonResponse(res, 200, { ok: false, error: 'in-progress' })
+              return
+            }
+            const route = await pickModel(services)
+            if (!route) {
+              jsonResponse(res, 200, { ok: false, error: 'no-model-route' })
+              return
+            }
+            const session = sessions.get(sessionId) ?? null
+            let events = []
+            try {
+              if (session) {
+                events = Array.from(session.snapshotEvents(Math.max(0, Number(session.seq ?? 0) - 300)) ?? [])
+              }
+            } catch {
+              events = []
+            }
+            const evidence = (() => {
+              try {
+                const collected = collectFromEvents({
+                  events,
+                  plan,
+                  turn: Number(plan.watermark?.turn ?? 0),
+                  sessionId,
+                })
+                if (collected && collected.ok !== false) return collected
+              } catch {
+                /* fall through to the plan-only payload */
+              }
+              return { plan, turn: Number(plan.watermark?.turn ?? 0), lastAssistantText: '', lastUserMessages: [] }
+            })()
+            verifyInflight.add(sessionId)
+            const controller = new AbortController()
+            const timer = setTimeout(() => controller.abort(new Error('verify-deadline')), 8000)
+            const startedAt = Date.now()
+            try {
+              const prompt = buildVerifyPrompt(evidence)
+              prompt.maxTokens = settings.maxTokensVerify
+              const response = await callModel(services, route, prompt, controller.signal)
+              const text = String(response?.text ?? '')
+              if (!text) {
+                jsonResponse(res, 200, { ok: false, error: 'empty-model-output' })
+                return
+              }
+              const parsed = parseVerifyOutput(text)
+              if (!parsed.ok) {
+                debugLog({ phase: 'verify-parse-failed', sessionId, code: parsed.code })
+                jsonResponse(res, 200, { ok: false, error: 'parse-failed', code: parsed.code })
+                return
+              }
+              debugLog({
+                phase: 'verify-done',
+                sessionId,
+                elapsed: Date.now() - startedAt,
+                mismatches: parsed.output.mismatches.length,
+              })
+              jsonResponse(res, 200, {
+                ok: true,
+                ...parsed.output,
+                usage: response?.usage ?? null,
+                elapsedMs: Date.now() - startedAt,
+              })
+            } catch (error) {
+              debugLog({ phase: 'verify-error', sessionId, error: String(error) })
+              jsonResponse(res, 200, { ok: false, error: 'model-error' })
+            } finally {
+              clearTimeout(timer)
+              verifyInflight.delete(sessionId)
+            }
+            return
+          }
           if (pathname === `${ROUTE_PREFIX}state` && method === 'GET') {
             const sessionId = url?.searchParams?.get('sessionId') ?? ''
             await hydrateSession(sessionId)
@@ -1275,6 +1366,7 @@ export function apply(ctx, config = {}) {
       `${ROUTE_PREFIX}state`,
       `${ROUTE_PREFIX}replan`,
       `${ROUTE_PREFIX}warm`,
+      `${ROUTE_PREFIX}verify`,
     ]
     if (settings.enableDebugRoutes) {
       paths.push(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plan-completion",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
   "type": "module",
   "description": "Implicit session plans with Tab-completable next-message suggestions for DeepSeek Harness",