dsh-vscode-mode 0.21.4 → 0.22.0

package/src/pendingRpc.ts

@@ -0,0 +1,128 @@
+/** 待审投影 RPC：Keep/Revert 走累计基线，旧官方审查入口不再承接写操作。 @author ddj 2026年10月29号 */
+import type { RpcHandlerMap } from './shared/rpc.js'
+import type { PendingRequest } from './shared/pendingReview.js'
+import { resolveScope, sessionOf } from './registry.js'
+import type { Registry } from './registry.js'
+import { bucketOf } from './registry.js'
+import { readText } from './pending/capture.js'
+import { pendingRawId, 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 type { ShellLike } from './pending/vcs.js'
+import type { Ctx } from './store.js'
+import { policyOf } from './store.js'
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 待审投影处理器。读路径允许跨实例冷读，写路径必须本端 live 会话。
+ * @param ctx Host 上下文
+ * @param registry 工作区记录桶缓存
+ * @returns 待审相关处理器表
+ */
+export function pendingHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandlerMap> {
+  /** @private @author ddj 2026年10月29号 @param sessionId 请求作用域 @returns 工作区 */
+  async function workspace(sessionId: string): Promise<string> {
+    const scope = await resolveScope(ctx, sessionId)
+    if ('err' in scope) throw new Error('会话不存在或没有工作区')
+    await bucketOf(registry, ctx, scope.cwd)
+    return scope.cwd
+  }
+
+  /** @private @author ddj 2026年10月29号 @param sessionId 请求作用域 @returns 本端 live 会话的工作区 */
+  async function liveWorkspace(sessionId: string): Promise<string> {
+    const cwd = await workspace(sessionId)
+    if (!sessionOf(ctx, sessionId)) throw new Error('写入要求本端活跃会话')
+    return cwd
+  }
+
+  /**
+   * @private
+   * @author ddj 2026年10月30号
+   * @description: 面板列表里的条目 id 带待审前缀（用于和官方条目区分），
+   * 而待审内核按原始身份存取；各处理器统一走 pendingRawId 剥掉前缀。
+   * @param id 请求里的条目 id
+   * @returns 待审内核使用的原始 id
+   */
+  const rawId = pendingRawId
+
+  return {
+    'edrv.pending.list': async (args: PendingRequest) => {
+      const cwd = await workspace(args.sessionId)
+      const page = loadPage(cwd, args.sessionId)
+      // 列表即登记接管关系；旧写入口守卫之后只读内存集合，不再产生数据库读
+      for (const item of page.items) trackPendingCover(cwd, item.path, true)
+      return { ok: true, page }
+    },
+    'edrv.pending.detail': async (args: PendingRequest & { id: string }) => {
+      const cwd = await workspace(args.sessionId)
+      const detail = loadDetail(cwd, rawId(args.id))
+      return detail ? { ok: true, detail } : { ok: false, error: '待审条目不存在' }
+    },
+    'edrv.pending.decide': async (args) => {
+      const cwd = await liveWorkspace(args.sessionId)
+      try {
+        const id = rawId(args.id)
+        const result = await applyDecide(ctx.get('fs'), cwd, { ...args, id }, undefined, policyOf(ctx, sessionOf(ctx, args.sessionId)))
+        if (!result.ok) return { ok: false, error: result.reason }
+        const detail = loadDetail(cwd, id)
+        if (!detail) return { ok: false, error: '待审条目不存在' }
+        return { ok: true, item: detail.item, wrote: result.wrote }
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) }
+      }
+    },
+    'edrv.pending.remove': async (args) => {
+      const cwd = await liveWorkspace(args.sessionId)
+      const id = rawId(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)
+      return { ok: true, removed }
+    },
+    'edrv.pending.history': async (args) => {
+      const cwd = await liveWorkspace(args.sessionId)
+      try {
+        const result = await undoDecide(ctx.get('fs'), cwd, args, undefined, policyOf(ctx, sessionOf(ctx, args.sessionId)))
+        if (!result.ok) return { ok: false, error: result.reason }
+        return { ok: true, item: result.item, wrote: result.wrote }
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) }
+      }
+    },
+    'edrv.pending.import': async (args) => {
+      const cwd = await liveWorkspace(args.sessionId)
+      const raw = ctx.get('shell') as unknown as ShellLike | undefined
+      if (!raw) return { ok: false, error: '当前环境没有 shell 能力，无法读取版本库基线' }
+      // shell 执行器默认按 workspace-write 跑；本机没有可用沙箱后端时会直接拒绝，
+      // 所以按会话策略显式下发（会话已放宽时命令才能跑起来）。
+      const policy = policyOf(ctx, sessionOf(ctx, args.sessionId))
+      const shell: ShellLike = {
+        resolve: (request) => raw.resolve(policy ? { ...request, sandboxPolicy: policy } : request),
+        execute: (spec) => raw.execute(spec),
+      }
+      try {
+        const result = await importFromVcs(shell, cwd, args.sessionId, { includeUntracked: args.includeUntracked, path: args.path })
+        const page = loadPage(cwd, args.sessionId)
+        for (const item of page.items) trackPendingCover(cwd, item.path, true)
+        return { ok: true, imported: result.imported, changes: result.changes }
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) }
+      }
+    },
+    'edrv.pending.refresh': async (args: PendingRequest & { id: string }) => {
+      const cwd = await liveWorkspace(args.sessionId)
+      const id = rawId(args.id)
+      const stored = loadEntries(cwd).find((entry) => entry.entry.id === id)
+      if (!stored) return { ok: false, error: '待审条目不存在' }
+      const session = sessionOf(ctx, args.sessionId)
+      const fs = ctx.get('fs')
+      const target = await fs.resolve(id, { cwd, agent: session })
+      const content = await readText(fs, target).catch(() => undefined)
+      if (content === undefined) return { ok: false, error: '读取失败' }
+      const next = refreshed(stored, content, Date.now())
+      if (next) saveEntry(cwd, next)
+      return { ok: true, item: itemOf(next ?? stored) }
+    },
+  }
+}

package/src/reviewDb.ts

@@ -207,6 +207,9 @@ export function reviewPage(cwd: string, cursor = 0, history = false, path?: stri
 
 /** @public @author ddj 2026年10月26号 @param cwd Migrated workspace. @param path Legacy write target. @returns Whether any official version owns the file, including decided history. */
 export function hasOfficial(cwd: string, path: string): boolean {
+  // 防御：解析结果若被误当成路径传进来（不透明对象），按「无官方记录」处理，
+  // 否则 SQLite 会把对象当命名参数绑定，抛出与真实原因无关的错误。
+  if (typeof path !== 'string') return false
   const db = dbFor(cwd)
   // A read guard must not acquire a migration write lock on legacy-only databases.
   if (!db.prepare("SELECT 1 FROM sqlite_master WHERE name='review_files' AND type='table'").get()) return false

package/src/reviewRpc.ts

@@ -1,7 +1,10 @@
 /** Session-scoped official review RPC. @author ddj 2026年10月26号 */
 import type { RpcHandlerMap } from './shared/rpc.js'
+import type { PendingPage } from './shared/pendingReview.js'
 import { decideReview, reviewDetail, reviewPage } from './reviewDb.js'
 import { undoReview } from './reviewUndo.js'
+import { applyDecide, 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 type { Ctx } from './store.js'
@@ -31,19 +34,67 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
     await bucketOf(registry, ctx, scope.cwd)
     return scope.cwd
   }
+
+  /**
+   * @private
+   * @author ddj 2026年10月30号
+   * @description: 读取待审页；待审库尚未建立或迁移失败时按空页处理。
+   * 待审投影是增量能力，不能因为它让官方列表整体不可用。
+   * @param cwd 工作区
+   * @param sessionId 请求会话
+   * @returns 待审页（失败为空页）
+   */
+  function pendingPageOf(cwd: string, sessionId: string): PendingPage {
+    try { return loadPage(cwd, sessionId) }
+    catch { return { items: [], pending: 0, nextCursor: null, gaps: [] } }
+  }
+
   return {
     'edrv.review.list': async (args) => {
       const cwd = await workspace(args.sessionId)
-      return { ok: true, page: reviewPage(cwd, args.cursor, args.history, args.path) }
+      const official = reviewPage(cwd, args.cursor, args.history, args.path)
+      const pending = pendingPageOf(cwd, args.sessionId)
+      // 历史快照只属于官方通道；待审条目没有轮次历史，混进去会造出假的「轮次 0」。
+      if (args.history) return { ok: true, page: official }
+      if (args.path !== undefined) {
+        // 单文件台账（差异栏「详情」展开处）必须并上该路径的待审条目，
+        // 否则待审详情（块判定 + 批注 + 让 AI 应答）在这条入口上永远点不到。
+        const key = args.path
+        const own = pending.items.filter((item) => pendingSamePath(item.path, key)).map((item) => pendingItemOf(item, cwd))
+        // 待审接管后同路径的官方轮次行只是旧口径残影：留着会让人点进只读详情，以为没有判定入口。
+        const history = own.length ? official.items.filter((item) => !pendingSamePath(item.path, key)) : official.items
+        return { ok: true, page: { ...official, items: [...own, ...history] } }
+      }
+      // 待审投影就位后由它承接被覆盖路径，官方旧行让位，同一路径只保留一个权威
+      return { ok: true, page: mergedPage(official, pending, cwd) }
     },
     'edrv.review.detail': async (args) => {
       const cwd = await workspace(args.sessionId)
+      if (args.id.startsWith(PENDING_PREFIX)) {
+        const detail = loadDetail(cwd, args.id.slice(PENDING_PREFIX.length))
+        if (!detail) return { ok: false, error: '待审条目不存在' }
+        return { ok: true, detail: pendingDetailOf(detail, new Date(detail.item.updatedAt).toISOString(), cwd) }
+      }
       const detail = reviewDetail(cwd, args.id)
       return detail ? { ok: true, detail } : { ok: false, error: '官方审查记录不存在' }
     },
     'edrv.review.decide': async (args) => {
       // 写类操作要求 live 会话：避免两端并发写同一工作区审查库，回滚也依赖本端会话内容
       const cwd = await liveWorkspace(args.sessionId)
+      if (args.id.startsWith(PENDING_PREFIX)) {
+        // 待审条目走累计基线：Keep 零写盘，Revert 写回并读回校验
+        const result = await applyDecide(ctx.get('fs'), cwd, {
+          sessionId: args.sessionId,
+          id: args.id.slice(PENDING_PREFIX.length),
+          revision: args.revision,
+          operationId: args.operationId,
+          decision: args.decision,
+          scope: args.scope === 'hunk' ? 'block' : 'file',
+          ...(args.blockId === undefined ? {} : { blockId: args.blockId }),
+        })
+        if (!result.ok) return { ok: false, error: result.reason }
+        return { ok: true, revision: result.flags.revision }
+      }
       try {
         const result = args.decision === 'rejected'
           ? await undoReview(ctx, sessionOf(ctx, args.sessionId), cwd, args)

package/src/rpc.ts

@@ -60,7 +60,9 @@ import type { FileVersions } from './fileVersions.js'
 import { settingsDocPath } from './settingsDocPath.js'
 import { createTextPages } from './textPages.js'
 import { reviewHandlers } from './reviewRpc.js'
-import { fileAbsent, missingReview, missingDecide } from './missingReview.js'
+import { pendingHandlers } from './pendingRpc.js'
+import { fileAbsent, missingReview, missingDecide, missingPath } from './missingReview.js'
+import { pendingCovers } from './pendingCompat.js'
 
 /** Process-local cursor signer; reads must stay on the Host filesystem capability. */
 const readTextPage = createTextPages()
@@ -103,6 +105,19 @@ function recView(record: DiffRecord, ws: RemoteWs | null = null): RecordView {
   }
 }
 
+/**
+ * 旧写入口守卫：路径已由待审累计基线接管时一律拒绝，避免两套权威同时写同一文件。
+ * @author ddj 2026年10月29号
+ * @param cwd 工作区
+ * @param path 请求涉及的路径（可为空表示无法定位）
+ * @returns 拒绝原因，未接管时为 null
+ */
+function legacyBlocked(cwd: string, path: string | undefined): string | null {
+  if (!path) return null
+  if (!pendingCovers(cwd, path)) return null
+  return '该文件已由待审累计基线接管，请使用面板 Keep/Revert（edrv.review.decide）'
+}
+
 /** 会话/工作区公共前置：返回 {session,cwd} 或错误文案。 */
 async function requireSession(ctx: Ctx, sessionId: string | undefined): Promise<
   { session: Session; cwd: string } | { err: string }
@@ -600,6 +615,7 @@ export function buildHandlers(
     // edrv.dap.* 由 createDapRpc 提供（调试会话单例），这里并入。
     ...((dapHandlers ?? {}) as RpcHandlerMap),
     ...(reviewHandlers(ctx, registry) as RpcHandlerMap),
+    ...(pendingHandlers(ctx, registry) as RpcHandlerMap),
     'edrv.list': async (args) => {
       // #region debug log
       const start = performance.now()
@@ -688,6 +704,8 @@ export function buildHandlers(
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const bucket = await bucketOf(registry, ctx, sc.cwd)
+      const blocked = legacyBlocked(sc.cwd, bucket.get(args.callId)?.path)
+      if (blocked) return { ok: false, error: blocked }
       const results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, [{ callId: args.callId, scope: args.scope, hunkIndex: args.hunkIndex, decision: 'accepted' }])
       const item = results[0]
       if (!item?.ok) return { ok: false, error: item?.error ?? '操作失败' }
@@ -697,6 +715,8 @@ export function buildHandlers(
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const bucket = await bucketOf(registry, ctx, sc.cwd)
+      const blocked = legacyBlocked(sc.cwd, bucket.get(args.callId)?.path)
+      if (blocked) return { ok: false, error: blocked }
       const results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, [{ callId: args.callId, scope: args.scope, hunkIndex: args.hunkIndex, decision: 'rejected' }])
       const item = results[0]
       if (!item?.ok) return { ok: false, error: item?.error ?? '操作失败' }
@@ -705,6 +725,8 @@ export function buildHandlers(
     'edrv.missingReview': async (args) => {
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
+      const blocked = legacyBlocked(sc.cwd, args.path)
+      if (blocked) return { ok: false, error: blocked }
       try {
         const bucket = await bucketOf(registry, ctx, sc.cwd)
         if (!await fileAbsent(ctx, sc.cwd, args.path)) return { ok: true, review: null }
@@ -714,6 +736,8 @@ export function buildHandlers(
     'edrv.missingDecide': async (args) => {
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
+      const blocked = legacyBlocked(sc.cwd, missingPath(args.token))
+      if (blocked) return { ok: false, error: blocked }
       try {
         const bucket = await bucketOf(registry, ctx, sc.cwd)
         return { ok: true, callIds: await missingDecide(ctx, sc.session, sc.cwd, bucket, args.token, args.operationId, args.undo === true) }
@@ -723,7 +747,10 @@ export function buildHandlers(
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const bucket = await bucketOf(registry, ctx, sc.cwd)
-      const results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, Array.isArray(args.items) ? args.items : [])
+      const items = Array.isArray(args.items) ? args.items : []
+      const blocked = items.map((item) => legacyBlocked(sc.cwd, bucket.get(item.callId)?.path)).find((reason) => reason !== null)
+      if (blocked) return { ok: false, error: blocked }
+      const results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, items)
       return { ok: true, results }
     },
     /** @author ddj 2026年10月22号 @param args Read-only request. @returns Bounded official range read, or unsupported on older providers; never bypasses Host IO. */

package/src/shared/pendingReview.ts

@@ -0,0 +1,105 @@
+/**
+ * dsh-vscode-mode 待审投影（pending review）的共享契约：按文件累计的净差异视图。
+ * 官方快照表是不可变事实来源，本类型只是可由事实重建的投影，任何决定都不等于磁盘版本。
+ * @author ddj 2026年10月29号
+ */
+import type { OfficialDiff } from './review.js'
+import type { ReviewBlockState } from './reviewRegions.js'
+
+/** 基线形态：`file` 写回内容，`none` 说明基线没有该路径（Revert 语义是删除文件）。 */
+export type PendingEarlier = 'file' | 'none'
+
+/** 会话血缘，用于子代理/派生会话归属到同一待审视图。 */
+export interface PendingLineage {
+  parentSessionId?: string
+  origin?: string
+  delegationDepth?: number
+  cwd?: string
+}
+
+/** 待审条目的展示投影。 */
+export interface PendingItem {
+  /** 稳定身份键（后端 + 目标键），客户端按它发送动作。 */
+  id: string
+  /** 展示路径。 */
+  path: string
+  earlierVersion: PendingEarlier
+  added: number
+  deleted: number
+  /** oldText 与 newText 严格相等：已解决但仍留在列表。 */
+  settled: boolean
+  /** 读者还没看过的最新变化。 */
+  unseen: boolean
+  /** 文件已不存在（Revert 可恢复）。 */
+  missing: boolean
+  /** 当前文件内容已被外部改动替换过。 */
+  diverged: boolean
+  /** 文本超出存储/展示上限，差异与决定能力受限。 */
+  oversized: boolean
+  revision: number
+  updatedAt: number
+  sessionId: string
+  sessionIds: string[]
+  lineage?: PendingLineage
+}
+
+/** 一页待审条目。 */
+export interface PendingPage {
+  items: PendingItem[]
+  pending: number
+  nextCursor: number | null
+  /** 采集/重建过程中的缺口说明，绝不静默吞掉。 */
+  gaps: string[]
+}
+
+/** 单条待审详情。 */
+export interface PendingDetail {
+  item: PendingItem
+  diff: OfficialDiff
+  blocks: ReviewBlockState[]
+  capability: { keep: boolean; revert: boolean; reason: string }
+}
+
+/** 全部请求都带会话作用域，工作区由 host 解析，永不采信客户端 cwd。 */
+export interface PendingRequest {
+  sessionId: string
+}
+
+/** 决定粒度。 */
+export interface PendingScope {
+  scope: 'file' | 'block' | 'range' | 'all'
+  blockId?: string
+  startLine?: number
+  endLine?: number
+}
+
+/** Keep/Revert 请求；operationId 提供幂等，revision 提供并发校验。 */
+export interface PendingDecide extends PendingRequest, PendingScope {
+  id: string
+  revision: number
+  operationId: string
+  decision: 'accepted' | 'rejected'
+}
+
+/** 从列表移除已解决条目（不触碰磁盘）。 */
+export interface PendingRemove extends PendingRequest {
+  id: string
+  revision: number
+  operationId: string
+}
+
+/** 撤销/重做一次决定。 */
+export interface PendingHistoryMove extends PendingRequest {
+  direction: 'undo' | 'redo'
+  operationId: string
+}
+
+/** 从版本控制导入本地改动。 */
+export interface PendingImport extends PendingRequest {
+  includeUntracked?: boolean
+  /** 只刷新一个文件，便于大仓单文件重扫。 */
+  path?: string
+}
+
+/** 待审条目在面板列表里的 id 前缀；客户端与 Host 共用这一份口径。 */
+export const PENDING_PREFIX = 'pending:'

package/src/shared/rpc.ts

@@ -26,6 +26,10 @@ import { appUrl } from './appUrl.js'
 import type { LoggerLevel } from './logger.js'
 import type { SvnViewRequest, SvnViewPayload } from './svnExplorer.js'
 import type { DecideReview, ReviewDetail, ReviewPage, ReviewRequest } from './review.js'
+import type {
+  PendingDecide, PendingDetail, PendingHistoryMove, PendingImport,
+  PendingItem, PendingPage, PendingRemove, PendingRequest,
+} from './pendingReview.js'
 
 /** webServer 精确路由。 */
 export const RPC_PATH = '/edrv/rpc'
@@ -372,6 +376,13 @@ export interface RpcRequestMap {
   'edrv.review.list': ReviewRequest & { cursor?: number; history?: boolean; path?: string }
   'edrv.review.detail': ReviewRequest & { id: string }
   'edrv.review.decide': DecideReview
+  'edrv.pending.list': PendingRequest
+  'edrv.pending.detail': PendingRequest & { id: string }
+  'edrv.pending.decide': PendingDecide
+  'edrv.pending.remove': PendingRemove
+  'edrv.pending.refresh': PendingRequest & { id: string }
+  'edrv.pending.history': PendingHistoryMove
+  'edrv.pending.import': PendingImport
   'edrv.list': { sessionId?: string; callIds?: string[]; skipStale?: boolean }
   'edrv.accept': { sessionId?: string; callId: string; scope?: RpcScope; hunkIndex?: number }
   'edrv.reject': { sessionId?: string; callId: string; scope?: RpcScope; hunkIndex?: number }
@@ -546,6 +557,13 @@ export interface RpcOkMap {
   'edrv.review.list': { page: ReviewPage }
   'edrv.review.detail': { detail: ReviewDetail }
   'edrv.review.decide': { revision: number }
+  'edrv.pending.list': { page: PendingPage }
+  'edrv.pending.detail': { detail: PendingDetail }
+  'edrv.pending.decide': { item: PendingItem; wrote: boolean }
+  'edrv.pending.remove': { removed: boolean }
+  'edrv.pending.refresh': { item: PendingItem }
+  'edrv.pending.history': { item: PendingItem; wrote: boolean }
+  'edrv.pending.import': { imported: number; changes: number }
   'edrv.list': { records: RecordView[] }
   'edrv.accept': { record: RecordView }
   'edrv.reject': { record: RecordView }

package/src/store.ts

@@ -78,6 +78,25 @@ export async function resolveTargetIn(ctx: Ctx, cwd: string, path: string): Prom
   return fs.resolve(path, cwd ? { cwd } : {})
 }
 
+/**
+ * 把解析结果还原成宿主路径字符串。
+ * 官方 provider 的 resolve 返回不透明 FsTarget，而多数调用点按字符串使用；
+ * 直接把对象当路径传下去会落进 SQL 绑定或 path.resolve，报出与真实原因无关的错误。
+ * @author ddj 2026年10月30号
+ * @param ctx DSH 上下文
+ * @param target resolve 的返回值：宿主路径字符串或 FsTarget
+ * @returns 宿主路径字符串；无法还原时返回空串
+ */
+export function targetPathOf(ctx: Ctx, target: unknown): string {
+  if (typeof target === 'string') return target
+  const fs = ctx.get('fs')
+  if (typeof fs?.processPath !== 'function') return ''
+  try {
+    const resolved = fs.processPath(target as never)
+    return typeof resolved === 'string' && resolved !== '[object Object]' ? resolved : ''
+  } catch { return '' }
+}
+
 /** 读取工作区主 sidecar 文本（缺失/失败 → null）。 */
 async function readSidecarText(ctx: Ctx, cwd: string | null): Promise<string | null> {
   const fs = ctx.get('fs')