dsh-plan-completion 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project are documented here.
 Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), versioning: SemVer.
 
+## [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`，原子写）；
@@ -100,8 +108,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 +119,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,10 @@
 # GitHub 发布评估 · 会话计划补全插件（2026-11-02）
 
-> 历史文档：以下保留 v0.1.0 的交付/评估/计划记录。**v0.1.1 已发布**（鉴权、状态一致性、隐私边界修复），详见 [security.md](security.md) 与 [CHANGELOG](../CHANGELOG.md)；旧记录中的“无鉴权”、原始诊断字段与独立评审不代表当前实现。
+> 历史文档：以下保留 v0.1.0 的交付/评估/计划记录。**当前最新为 v0.1.2**（本地计划持久化 + 鉴权/状态一致性/隐私边界修复），详见 [security.md](security.md) 与 [CHANGELOG](../CHANGELOG.md)；旧记录中的“无鉴权”、原始诊断字段与独立评审不代表当前实现。
 >
 > 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/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.3",
   "private": false,
   "type": "module",
   "description": "Implicit session plans with Tab-completable next-message suggestions for DeepSeek Harness",