dsh-vscode-mode 0.26.0 → 0.27.0

package/src/pendingCompat.ts

@@ -9,11 +9,9 @@ import { pathKeyFor } from './shared/pathKey.js'
 
 /**
  * 进程内"已被待审接管"的路径集合；旧写入口守卫只读它，绝不碰数据库。
- * 按会话登记：待审列表按会话可见，守卫必须同口径，否则会出现"拦得住、看不见"的死锁。
- * 无会话归属的登记落在 workspace 集合（兼容只有工作区+路径的旧用法）。
+ * 按工作区登记，来源会话仅作追溯；任一对话重建或注销都会更新同一份集合。
  */
-const coveredBySession = new Map<string, Set<string>>()
-const coveredWorkspace = new Set<string>()
+const coveredWorkspace = new Map<string, Map<string, string | null>>()
 
 /** 待审条目在面板列表里的 id 前缀，用于把请求路由回待审内核。 */
 export { PENDING_PREFIX } from './shared/pendingReview.js'
@@ -154,16 +152,18 @@ function coverKey(cwd: string, path: string): string {
 }
 
 /**
- * @author ddj 2026年11月3号
- * @description: 取某会话的覆盖集合；首次登记时就地建集合，避免调用方判空。
- * @param sessionId 会话 id
- * @returns 该会话的覆盖键集合
+ * @private
+ * @author ddj 2026年11月04号
+ * @description: 取工作区唯一接管集合；来源对话仅保留为诊断信息。
+ * @param cwd 工作区路径
+ * @returns 路径到登记来源的映射
  */
-function sessionCovers(sessionId: string): Set<string> {
-  const existing = coveredBySession.get(sessionId)
+function workspaceCovers(cwd: string): Map<string, string | null> {
+  const workspaceKey = pathKey(cwd)
+  const existing = coveredWorkspace.get(workspaceKey)
   if (existing) return existing
-  const created = new Set<string>()
-  coveredBySession.set(sessionId, created)
+  const created = new Map<string, string | null>()
+  coveredWorkspace.set(workspaceKey, created)
   return created
 }
 
@@ -178,25 +178,25 @@ function sessionCovers(sessionId: string): Set<string> {
  */
 export function trackPendingCover(cwd: string, path: string, covered: boolean, sessionId?: string): void {
   const key = coverKey(cwd, path)
-  const target = sessionId ? sessionCovers(sessionId) : coveredWorkspace
-  if (covered) target.add(key)
+  const target = workspaceCovers(cwd)
+  if (covered) target.set(key, sessionId ?? null)
   else target.delete(key)
 }
 
 /**
  * @author ddj 2026年11月3号
- * @description: 用一次列表结果整体重建某会话的接管集合：条目被移除或结案后自动失效，不再残留登记。
+ * @description: 用完整列表重建工作区接管集合，清除任何对话留下的过期登记。
  * @param cwd 工作区
  * @param sessionId 会话 id
  * @param paths 本会话当前可见的待审条目路径
  * @returns 无
  */
 export function setPendingCovers(cwd: string, sessionId: string, paths: readonly string[]): void {
-  const next = new Set<string>()
+  const next = new Map<string, string | null>()
   for (const path of paths) {
-    if (path) next.add(coverKey(cwd, path))
+    if (path) next.set(coverKey(cwd, path), sessionId)
   }
-  coveredBySession.set(sessionId, next)
+  coveredWorkspace.set(pathKey(cwd), next)
 }
 
 /**
@@ -208,16 +208,13 @@ export function setPendingCovers(cwd: string, sessionId: string, paths: readonly
  */
 export function pendingCoverOwner(cwd: string, path: string): string | null {
   const key = coverKey(cwd, path)
-  for (const [sessionId, set] of coveredBySession) {
-    if (set.has(key)) return sessionId
-  }
-  return null
+  return coveredWorkspace.get(pathKey(cwd))?.get(key) ?? null
 }
 
 /**
  * @author ddj 2026年10月29号
  * @description: 判断某路径是否已由待审投影接管；仅读进程内集合，不产生任何 IO。
- * 给 sessionId 时按该会话的可见范围判定（列表看不到的接管不拦旧入口），缺省按全工作区并集判定。
+ * 所有对话按同一工作区集合判定，兼容参数不影响可见范围。
  * @param cwd 工作区
  * @param path 请求路径
  * @param sessionId 会话 id；缺省按并集判定
@@ -225,12 +222,7 @@ export function pendingCoverOwner(cwd: string, path: string): string | null {
  */
 export function pendingCovers(cwd: string, path: string, sessionId?: string): boolean {
   const key = coverKey(cwd, path)
-  if (coveredWorkspace.has(key)) return true
-  if (sessionId) return coveredBySession.get(sessionId)?.has(key) === true
-  for (const set of coveredBySession.values()) {
-    if (set.has(key)) return true
-  }
-  return false
+  return coveredWorkspace.get(pathKey(cwd))?.has(key) === true
 }
 
 /**

package/src/pendingRpc.ts

@@ -8,7 +8,6 @@ import { readText } from './pending/capture.js'
 import { pendingRawId, setPendingCovers, trackPendingCover } from './pendingCompat.js'
 import { loadEntries, saveEntry } from './pending/persist.js'
 import { applyDecide, importFromVcs, itemOf, loadDetail, loadPage, refreshed, removeEntry, undoDecide } from './pending/store.js'
-import { addedFiles } from './reviewDb.js'
 import type { ShellLike } from './pending/vcs.js'
 import type { Ctx } from './store.js'
 import { policyOf } from './store.js'
@@ -83,16 +82,16 @@ function readHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
   return {
     'edrv.pending.list': async (args: PendingRequest) => {
       const cwd = await kit.read(args.sessionId)
-      // 与官方入口同口径：本会话新建的文件基线置空，列表里的增删行数才等于整文件行数
-      const page = loadPage(cwd, args.sessionId, addedFiles(cwd, args.sessionId))
-      // 列表即登记接管关系：整集重建本会话的登记，条目被移出列表后自动失效
+      // 与统一审查入口共用来源基线，不按查看者对话切分。
+      const page = loadPage(cwd, args.sessionId)
+      // 完整工作区列表重建唯一接管集合，清除所有来源的过期登记。
       setPendingCovers(cwd, args.sessionId, page.items.map((item) => item.path))
       return { ok: true, page }
     },
     'edrv.pending.detail': async (args: PendingRequest & { id: string }) => {
       const cwd = await kit.read(args.sessionId)
       const rawId = pendingRawId(args.id)
-      const detail = loadDetail(cwd, rawId, addedFiles(cwd, args.sessionId).has(rawId))
+      const detail = loadDetail(cwd, rawId)
       return detail ? { ok: true, detail } : { ok: false, error: '待审条目不存在' }
     },
   }
@@ -124,7 +123,7 @@ function decideHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
       const id = pendingRawId(args.id)
       const path = loadEntries(cwd).find((stored) => stored.entry.id === id)?.entry.path
       const removed = removeEntry(cwd, id, args.revision)
-      // 移除后该路径不再由待审投影接管，旧入口守卫随之放行（仅注销本会话的登记）
+      // 移除后注销工作区唯一登记，其他对话不留过期副本。
       if (removed && path) trackPendingCover(cwd, path, false, args.sessionId)
       return { ok: true, removed }
     },

package/src/reviewCapture.ts

@@ -3,7 +3,8 @@ import { rawReviewFile, evidenceBlocks } from './reviewEvidence.js'
 import type { RawReviewFile } from './reviewEvidence.js'
 import type { ReviewSnapshot } from './shared/review.js'
 import { reviewDb } from './reviewDb.js'
-import { resolveTarget } from './store.js'
+import { cwdOfSession } from './store.js'
+import { toolTargets } from './toolTargets.js'
 import type { Ctx } from './store.js'
 import { log } from './log.js'
 
@@ -18,12 +19,19 @@ export function installEvidence(ctx: Ctx): EvidenceCapture {
   const chains = new Map<string, Map<string, ByteChain>>()
   const staged = new Map<string, Map<string, ByteChain>>()
   let stopped = false
+  const disposed = new Set<string>()
   ctx.on('tools/execute', aroundTool)
   ctx.on('session/event', onEvent)
   ctx.on('session/disposed', onDisposed)
 
   /** @private @author ddj 2026年10月27号 @param session Disposed owner. Drops optional in-memory evidence, never persisted official facts. */
-  function onDisposed(session: { id: string }): void { chains.delete(session.id) }
+  function onDisposed(session: { id: string }): void {
+    disposed.add(session.id)
+    chains.delete(session.id)
+    for (const key of staged.keys()) {
+      if ((JSON.parse(key) as unknown[])[0] === session.id) staged.delete(key)
+    }
+  }
 
   /** @private @author ddj 2026年10月27号 @returns Current bounded capture footprint, excluding transient filesystem reads. */
   function footprint(): number {
@@ -39,34 +47,67 @@ export function installEvidence(ctx: Ctx): EvidenceCapture {
   /** @private @author ddj 2026年10月27号 @param exec Allowed tool dispatch. @param next Original dispatch. @returns Original result unchanged, regardless of capture failure. */
   async function aroundTool(exec: any, next: () => Promise<any>): Promise<any> {
     const session = exec.agent?.session
-    const path = exec.arguments?.file_path
-    if (stopped || !session?.id || !['edit', 'write'].includes(exec.name) || typeof path !== 'string') return next()
-    let fs: any
-    let chain: ByteChain | undefined
-    let target: any
+    if (stopped || !session?.id) return next()
+    const captures: Array<{ fs: any; target: any; chain: ByteChain }> = []
     try {
-      if ((chains.size >= 16 && !chains.has(session.id)) || footprint() >= 32 * 1024 * 1024) return next()
-      fs = ctx.get('fs')
-      target = await resolveTarget(ctx, session, path)
-      const identity = fs.processPath(target)
-      const before = await readRaw(fs, target, exec.signal)
-      let files = chains.get(session.id)
-      if (!files) { files = new Map(); chains.set(session.id, files) }
-      if (files.size >= 64 && !files.has(identity)) return next()
-      chain = files.get(identity)
-      if (!chain) { chain = { before, after: before, busy: false, invalid: false }; files.set(identity, chain) }
-      if (chain.busy || chain.after.hash !== before.hash) chain.invalid = true
-      chain.busy = true
-    } catch { /* No trustworthy read means no undo evidence, not a failed user tool. */ }
+      const cwd = cwdOfSession(ctx, session)
+      const fs = ctx.get('fs')
+      const paths = await toolTargets(exec)
+      for (const path of paths) {
+        try {
+          const capture = await prepareRaw(fs, session.id, cwd ?? undefined, path, exec.signal)
+          if (capture) captures.push(capture)
+        } catch { /* A failed target never prevents independent targets. */ }
+      }
+    } catch { /* Optional parser absence must not fail the original tool. */ }
     try { return await next() }
     finally {
-      if (chain) {
-        try { chain.after = await readRaw(fs, target, exec.signal) } catch { chain.invalid = true }
-        chain.busy = false
+      for (const capture of captures) {
+        try {
+          const after = await readRaw(capture.fs, capture.target, exec.signal)
+          if (!stopped && !disposed.has(session.id)) {
+            capture.chain.after = after
+            if (footprint() > 32 * 1024 * 1024) {
+              capture.chain.invalid = true
+              capture.chain.before = rawReviewFile(null); capture.chain.after = rawReviewFile(null)
+            }
+          }
+        } catch { capture.chain.invalid = true }
+        capture.chain.busy = false
       }
     }
   }
 
+  /** @private @author ddj 2026年11月04号 @param sessionId Frozen owner. @param cwd Frozen workspace. @param path Patch target. @param signal Tool cancellation. @returns Reserved raw capture or no evidence. */
+  async function prepareRaw(fs: any, sessionId: string, cwd: string | undefined, path: string, signal?: AbortSignal) {
+    if (stopped || disposed.has(sessionId) || !cwd || (chains.size >= 16 && !chains.has(sessionId)) || footprint() >= 32 * 1024 * 1024) return null
+    const target = await fs.resolve(path, { cwd })
+    if (stopped || disposed.has(sessionId)) return null
+    const identity = fs.processPath(target)
+    let files = chains.get(sessionId)
+    if (!files) { files = new Map(); chains.set(sessionId, files) }
+    if (files.size >= 64 && !files.has(identity)) return null
+    let chain = files.get(identity)
+    if (chain?.busy) { chain.invalid = true; return null }
+    const empty = rawReviewFile(null)
+    if (!chain) {
+      chain = { before: empty, after: empty, busy: true, invalid: false }
+      files.set(identity, chain)
+      try { chain.before = await readRaw(fs, target, signal); chain.after = chain.before }
+      catch (error) { chain.invalid = true; chain.busy = false; throw error }
+    } else {
+      chain.busy = true
+      try {
+        const before = await readRaw(fs, target, signal)
+        if (chain.after.hash !== before.hash) chain.invalid = true
+      } catch (error) { chain.invalid = true; chain.busy = false; throw error }
+    }
+    if (stopped || disposed.has(sessionId) || footprint() > 32 * 1024 * 1024) {
+      chain.invalid = true; chain.busy = false; files.delete(identity); return null
+    }
+    return { fs, target, chain }
+  }
+
   /** @private @author ddj 2026年10月27号 @param session Source session. @param event Published official turn. Freezes the chain before the next turn can mutate it. */
   function onEvent(session: any, event: any): void {
     if (stopped || event.type !== 'workspace/changes') return

package/src/reviewEvidence.ts

@@ -16,7 +16,7 @@ export function rawReviewFile(bytes: Uint8Array | null): RawReviewFile {
 }
 
 /** @private @author ddj 2026年10月27号 @param file Persisted raw image. @returns UTF-8 storage text preserving BOM and terminators. @throws Binary, invalid encoding or corrupt hash. */
-function rawText(file: RawReviewFile): string {
+export function rawText(file: RawReviewFile): string {
   const bytes = Buffer.from(file.bytes, 'base64')
   if (bytes.length > 8 * 1024 * 1024 || bytes.includes(0)) throw new Error('回滚证据不是受支持的 UTF-8 文本')
   if (rawReviewFile(file.present ? bytes : null).hash !== file.hash) throw new Error('回滚证据哈希不匹配')

package/src/reviewRpc.ts

@@ -3,13 +3,13 @@ import { createHash } from 'node:crypto'
 import type { RpcHandlerMap } from './shared/rpc.js'
 import type { KeepAllItem, KeepAllResult, ReviewDetail, ReviewItem, ReviewPage } from './shared/review.js'
 import type { PendingPage } from './shared/pendingReview.js'
-import { addedFiles, decideReview, keepOfficialAll, reviewDetail, reviewPage } from './reviewDb.js'
+import { decideReview, keepOfficialAll, reviewDetail, reviewPage } from './reviewDb.js'
 import { undoReview } from './reviewUndo.js'
 import { applyDecide, keepAll, loadDetail, loadPage } from './pending/store.js'
 import { PENDING_PREFIX, mergedPage, pendingDetailOf, pendingItemOf, pendingSamePath } from './pendingCompat.js'
 import { bucketOf, resolveScope, sessionOf } from './registry.js'
 import type { Registry } from './registry.js'
-import { resolveTargetIn } from './store.js'
+import { policyOf, resolveTargetIn } from './store.js'
 import type { Ctx } from './store.js'
 import { log } from './log.js'
 
@@ -154,9 +154,8 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
    */
   function pendingPageOf(cwd: string, sessionId: string): PendingPage {
     try {
-      // 本会话新建的文件由官方首个块判为整文件新增，待审基线必须跟着置空：
-      // 否则同一次新建会同时存在「官方说全加 516 行」与「待审说改 8 处」两套相反口径。
-      const page = loadPage(cwd, sessionId, addedFiles(cwd, sessionId))
+      // 基线由累计条目来源及决定历史统一解析，不依赖当前查看者对话。
+      const page = loadPage(cwd, sessionId)
       // 已结算（老文本与新文本一致）的投影没有净变化可审：留着会顶掉同路径的官方待审记录，
       // 让差异栏选中一条 Keep 不可用的条目，表现为「按钮亮着却点不动」。
       return page.items.some((item) => item.settled === true)
@@ -279,7 +278,7 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
       if (args.id.startsWith(PENDING_PREFIX)) {
         const entryId = args.id.slice(PENDING_PREFIX.length)
         // 详情侧与列表侧必须同一口径：整文件新增的文件用空基线渲染，差异块才是全绿一整块
-        const detail = loadDetail(cwd, entryId, addedFiles(cwd, args.sessionId).has(entryId))
+        const detail = loadDetail(cwd, entryId)
         if (!detail) return { ok: false, error: '待审条目不存在' }
 
         const mapped = pendingDetailOf(detail, new Date(detail.item.updatedAt).toISOString(), cwd)
@@ -314,7 +313,7 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
             decision: args.decision,
             scope: args.scope === 'hunk' ? 'block' : 'file',
             ...(args.blockId === undefined ? {} : { blockId: args.blockId }),
-          })
+          }, undefined, policyOf(ctx, sessionOf(ctx, args.sessionId)))
           if (!result.ok) return { ok: false, error: result.reason }
           return { ok: true, revision: result.flags.revision }
         }

package/src/toolTargets.ts

@@ -0,0 +1,63 @@
+/** Optional Host patch target extraction; results never substitute raw preimages. @author ddj 2026年11月04号 */
+import { loadHostModule } from './hostImport.js'
+
+export interface ToolCall {
+  name?: string
+  id?: string
+  arguments?: { file_path?: unknown; path?: unknown; input?: unknown }
+}
+interface PatchTarget { path: string; moveTo?: string }
+
+/** @public @author ddj 2026年11月04号 @param result Untrusted tool envelope. @returns Diagnostic-only status; never writable preimages. */
+export function patchDiagnostics(result: unknown): string[] {
+  const envelope = result as { value?: unknown } | null
+  const payload = (envelope?.value ?? result) as { phase?: unknown; operations?: unknown } | null
+  if (payload?.phase !== 'commit' || !Array.isArray(payload.operations)) return ['apply_patch result unavailable or malformed']
+  const diagnostics: string[] = []
+  for (const operation of payload.operations) {
+    if (!operation || typeof operation.path !== 'string' || !['add', 'update', 'delete', 'move'].includes(operation.kind)
+      || !['completed', 'failed', 'unknown', 'skipped'].includes(operation.status)) {
+      diagnostics.push('apply_patch operation malformed'); continue
+    }
+    if (operation.status !== 'completed') diagnostics.push(operation.path + ': ' + operation.status)
+    if (operation.changes !== undefined && (!Array.isArray(operation.changes) || operation.changes.some((change: any) =>
+      !change || typeof change.path !== 'string' || !(change.before === null || typeof change.before === 'string') || !(change.after === null || typeof change.after === 'string')))) {
+      diagnostics.push(operation.path + ': changes malformed')
+    }
+  }
+  return diagnostics
+}
+export type PatchParser = (input: string) => PatchTarget[]
+let parserLoad: Promise<PatchParser | null> | undefined
+
+/** @public @author ddj 2026年11月04号 @returns Optional official parser; missing capabilities remain retryable. */
+export async function patchParser(): Promise<PatchParser | null> {
+  if (!parserLoad) {
+    parserLoad = loadHostModule('@deepseek-ai/dsh-fs-patch').then((module) => {
+      const parser = (module as { parsePatch?: PatchParser }).parsePatch
+      return typeof parser === 'function' ? parser : null
+    }).catch(() => null)
+  }
+  const parser = await parserLoad
+  if (!parser) parserLoad = undefined
+  return parser
+}
+
+/** @public @author ddj 2026年11月04号 @param call Tool identity and arguments. @param parser Optional injectable official parser. @returns Unique unresolved source/destination paths. @throws Unsupported parser or malformed patch. */
+export async function toolTargets(call: ToolCall, parser?: PatchParser | null): Promise<string[]> {
+  if (['edit', 'write', 'str_replace_editor'].includes(String(call.name))) {
+    const path = call.arguments?.file_path ?? call.arguments?.path
+    return typeof path === 'string' && path ? [path] : []
+  }
+  if (call.name !== 'apply_patch') return []
+  if (typeof call.arguments?.input !== 'string') throw new Error('apply_patch input unavailable')
+  const parse = parser === undefined ? await patchParser() : parser
+  if (!parse) throw new Error('Host patch parser unavailable')
+  const paths = new Set<string>()
+  for (const operation of parse(call.arguments.input)) {
+    if (typeof operation.path !== 'string' || !operation.path) throw new Error('Invalid patch target')
+    paths.add(operation.path)
+    if (operation.moveTo) paths.add(operation.moveTo)
+  }
+  return [...paths]
+}