dsh-vscode-mode 0.14.5 → 0.14.7

package/src/dap/manager.ts

@@ -22,7 +22,7 @@ import { childEnv } from '../childEnv.js'
 import { stopTree } from '../processTree.js'
 import { join } from 'node:path'
 import { createFrameParser, encodeMessage } from '../lsp/jsonrpc.js'
-import { sourceBaseOf, sourceKeyOf, sourcePathOf, normalizeSourcePath } from './sourcePath.js'
+import { sourceBaseOf, sourceKeyOf, sourcePathOf, normalizeSourcePath, rankSourceCandidates } from './sourcePath.js'
 import { bpAcksOfResponse, DAP_ACTIONS, needsConfigurationDone, requestOfConfig, threadIdOfStopped, type DapAction, type DapBreakpointInput, type DapBreakpointAck, type DapDebugConfig, type DapEventView, type DapFrameView, type DapPhase, type DapPollResult, type DapScopeView, type DapStateView, type DapVariableView } from '../shared/dap.js'
 import { dapRequest, eventBody, initializeArgs, isDapEvent, isDapResponse, responseBody, type DapEvent, type DapMessage, type DapRequest } from './protocol.js'
 import type { DapAdapterSpec } from './provider.js'
@@ -458,18 +458,50 @@ export class DapSession {
     return '会话在初始化完成前终止（attach/连接目标失败）' + dotrushLog
   }
 
-  /** findFileReq 反向应答：按完整 chunkname 排序工作区候选并缓存首命中。 */
+  /**
+   * 按当前语言过滤并排序源码候选，供反向应答与栈帧解析共用。
+   * @private
+   * @author ddj 2026年10月09号
+   * @param chunk 适配器上报的源码标识
+   * @returns 语言合法、按路径相关度排序的候选
+   */
+  private async sourceCandidates(chunk: string): Promise<string[]> {
+    const files = await this.deps.findFiles(this.workspacePath, chunk)
+    const exts = this.frameExts()
+    const allowed = exts.length ? files.filter((file) => hasSourceExtension(file, exts)) : files
+    return rankSourceCandidates(chunk, allowed, this.workspacePath)
+  }
+
+  /**
+   * 更新源码标识及 basename 缓存；无合法候选时删除旧映射。
+   * @private
+   * @author ddj 2026年10月09号
+   * @param chunk 适配器上报的源码标识
+   * @param file 合法候选首项，空值表示未解析
+   * @description 副作用：更新当前会话源码缓存
+   */
+  private cacheSource(chunk: string, file: string): void {
+    for (const key of [sourceKeyOf(chunk), sourceKeyOf(sourceBaseOf(chunk))]) {
+      if (!key) continue
+      if (file) this.sourceFiles.set(key, file)
+      else this.sourceFiles.delete(key)
+    }
+  }
+
+  /**
+   * findFileReq 反向应答：只返回当前语言合法源码并缓存首命中。
+   * @private
+   * @author ddj 2026年10月09号
+   * @param body 反向请求参数
+   * @description 副作用：更新源码缓存并发送 findFileRsp
+   */
   private async respondFindFile(body: Record<string, unknown>): Promise<void> {
     const seq = typeof body.seq === 'number' ? body.seq : -1
     const chunk = String(body.file ?? '')
-    const files = await this.deps.findFiles(this.workspacePath, chunk)
+    const files = await this.sourceCandidates(chunk)
     log.debug('[dap-trace] findFileReq seq=' + seq + ' chunk=' + chunk + ' candidates=' + files.length + ' first=' + (files[0] ?? ''))
     this.deps.trace?.(this.workspacePath, '[DEBUG findFileReq] seq=' + seq + ' chunk=' + chunk + ' candidates=' + files.length + ' first=' + (files[0] ?? ''))
-    const first = files[0]
-    if (first) {
-      this.sourceFiles.set(sourceKeyOf(chunk), first)
-      this.sourceFiles.set(sourceKeyOf(sourceBaseOf(chunk)), first)
-    }
+    this.cacheSource(chunk, files[0] ?? '')
     this.send({ seq: this.msgSeq++, type: 'request', command: 'findFileRsp', arguments: { seq, files } })
   }
 
@@ -583,27 +615,43 @@ export class DapSession {
     if (phase === 'idle') { this.events = []; this.config = null; this.pid = undefined; this.error = undefined }
   }
 
-  /** 适配器上报路径 → 帧视图（file 始终保留可打开的规范路径）。 */
+  /**
+   * 适配器源码标识转帧视图；完整合法路径优先，错误语言缓存须重新解析。
+   * @private
+   * @author ddj 2026年10月09号
+   * @param item 适配器栈帧
+   * @param index 栈帧下标（EmmyLua frameId）
+   * @returns 保留原始行号、只含合法源码路径的帧视图
+   * @description 副作用：按需查找源码并更新会话缓存
+   */
   private async frameViewOf(item: unknown, index: number): Promise<DapFrameView> {
     const raw = item as Record<string, unknown>
     const source = (raw.source ?? {}) as Record<string, unknown>
     const sourcePath = typeof source.path === 'string' ? source.path : ''
     const sourceName = typeof source.name === 'string' ? source.name : ''
+    const exts = this.frameExts()
     const cached = this.sourceFiles.get(sourceKeyOf(sourcePath)) ?? this.sourceFiles.get(sourceKeyOf(sourceName))
-    let selected = cached || sourcePath || sourceName
-    const needsLookup = !selected || !hasSourceExtension(selected, this.frameExts())
+    const validPath = sourcePath && !isBareChunk(sourcePath)
+      && (exts.length ? hasSourceExtension(sourcePath, exts) : sourceBaseOf(sourcePath).includes('.'))
+    const validCache = cached && (!exts.length || hasSourceExtension(cached, exts))
+    let selected = validPath ? sourcePath : validCache ? cached : sourcePath || sourceName
+    const needsLookup = !validPath && !validCache
+    if (cached && !validCache) {
+      this.cacheSource(sourcePath, '')
+      this.cacheSource(sourceName, '')
+    }
     log.debug('[dap-trace] frame rawPath=' + sourcePath + ' name=' + sourceName + ' cached=' + (cached ?? '') + ' needsLookup=' + needsLookup + ' selected=' + selected)
     this.deps.trace?.(this.workspacePath, '[DEBUG frame] rawPath=' + sourcePath + ' name=' + sourceName + ' cached=' + (cached ?? '') + ' needsLookup=' + needsLookup + ' selected=' + selected)
-    if (!cached && needsLookup) {
-      const candidates = await this.deps.findFiles(this.workspacePath, sourceName || sourcePath)
+    if (needsLookup) {
+      const candidates = await this.sourceCandidates(sourceName || sourcePath)
       log.debug('[dap-trace] frameLookup source=' + (sourceName || sourcePath) + ' candidates=' + candidates.length + ' first=' + (candidates[0] ?? ''))
       this.deps.trace?.(this.workspacePath, '[DEBUG frameLookup] source=' + (sourceName || sourcePath) + ' candidates=' + candidates.length + ' first=' + (candidates[0] ?? ''))
       if (candidates[0]) {
         selected = candidates[0]
-        this.sourceFiles.set(sourceKeyOf(sourceName || sourcePath), candidates[0])
-      } else if (isBareChunk(sourceName || sourcePath)) {
-        // 反查失败 + 裸 chunkname：无可打开路径。置空而非回退原串，
-        // 避免客户端按工作区根拼出必然不存在的路径、打开注定失败的页签。
+        this.cacheSource(sourceName || sourcePath, candidates[0])
+      } else if (exts.length || isBareChunk(sourceName || sourcePath)) {
+        // 反查失败且当前语言已知或只有裸 chunk：不回退到错误语言文件，
+        // 也不让客户端按工作区根拼出不存在的 chunk 路径。
         selected = ''
       }
     }

package/src/model.ts

@@ -4,7 +4,7 @@
  * 作者 ddj 2026-08-20
  */
 import type { Decision, DiffRecord, Hunk, RecordSummary } from './shared/types.js'
-import { applyLocations, fingerprint, isNoopHunk, locateHunks, preciseHunk } from './shared/diff.js'
+import { applyLocations, fingerprint, isNoopHunk, locateHunks, normalizeForCompare, normalizeHunk, preciseHunk } from './shared/diff.js'
 
 /** 工作区记录桶上限（超过后按 at 最旧剔除）。 */
 export const MAX_RECORDS = 200
@@ -157,6 +157,117 @@ export function reconstructOriginal(records: DiffRecord[], content: string): { c
   }
 }
 
+// #region 过程抵消
+
+/**
+ * @public
+ * @author ddj 2026年10月10号
+ * 判断记录是否完全未决策；缺少逐块状态时沿用 pending 的 call 状态。
+ * @param record 审查记录
+ * @returns 未归档、未覆盖且没有用户决策时为 true
+ */
+export function fullyPending(record: DiffRecord): boolean {
+  return !record.archived && !record.superseded && record.decisions.call === 'pending'
+    && record.decisions.perHunk.every((value) => value === 'pending')
+}
+
+/**
+ * @public
+ * @author ddj 2026年10月10号
+ * 比较整组 hunk 是否逐块精确逆反；不把新建或纯 no-op 当作抵消。
+ * @param prior 先前修改的差异块
+ * @param later 后续修改的差异块
+ * @returns 文本归一化后整组逆反且包含真实修改时为 true
+ */
+export function hunksInverse(prior: Hunk[], later: Hunk[]): boolean {
+  if (!prior.length || prior.length !== later.length) return false
+  let changed = false
+  for (let idx = 0; idx < prior.length; idx++) {
+    const a = normalizeHunk(prior[idx])
+    const b = normalizeHunk(later[idx])
+    if (a.oldText !== b.newText || a.newText !== b.oldText) return false
+    if (!isNoopHunk(a)) changed = true
+  }
+  return changed
+}
+
+/**
+ * @private
+ * @author ddj 2026年10月10号
+ * 同路径优先按捕获批次排序；旧记录仅使用有效时间，不拿 callId 伪造先后证据。
+ * @param a 第一条记录
+ * @param b 第二条记录
+ * @returns 负数表示 a 更早，零表示先后无法区分
+ */
+function recordOrder(a: DiffRecord, b: DiffRecord): number {
+  if (a.path !== b.path) return a.path.localeCompare(b.path)
+  if (Number.isInteger(a.batch) && Number.isInteger(b.batch)
+    && a.batch > 0 && b.batch > 0 && a.batch !== b.batch) return a.batch - b.batch
+  const delta = Date.parse(a.at) - Date.parse(b.at)
+  return Number.isFinite(delta) ? delta : 0
+}
+
+/**
+ * @private
+ * @author ddj 2026年10月10号
+ * 确认完整文件快照往返，防止相同文本在不同位置的反向修改被误隐藏。
+ * @param prior 先前记录
+ * @param later 后续记录
+ * @returns 两端快照互换且文件存在性未变化时为 true；缺少证据时保留审查
+ */
+function snapshotsRestore(prior: DiffRecord, later: DiffRecord): boolean {
+  if (prior.create || later.create) return false
+  if (typeof prior.before !== 'string' || typeof prior.after !== 'string'
+    || typeof later.before !== 'string' || typeof later.after !== 'string') return false
+  return normalizeForCompare(prior.before) === normalizeForCompare(later.after)
+    && normalizeForCompare(prior.after) === normalizeForCompare(later.before)
+}
+
+/**
+ * @public
+ * @author ddj 2026年10月10号
+ * 查找最近一条未决的整记录逆反；必须有文件快照证明原内容确实恢复。
+ * @param records 工作区记录（不修改输入）
+ * @param record 新记录
+ * @returns 可安全配对的先前记录，证据不足或部分撤销时为 null
+ */
+export function findInversePrior(records: DiffRecord[], record: DiffRecord): DiffRecord | null {
+  if (!fullyPending(record)) return null
+  let found: DiffRecord | null = null
+  for (const prior of records) {
+    if (prior.callId === record.callId || prior.path !== record.path || !fullyPending(prior)) continue
+    if (recordOrder(prior, record) >= 0 || !hunksInverse(prior.hunks, record.hunks)) continue
+    if (!snapshotsRestore(prior, record)) continue
+    if (!found || recordOrder(found, prior) < 0) found = prior
+  }
+  return found
+}
+
+/**
+ * @public
+ * @author ddj 2026年10月10号
+ * 按捕获顺序贪心配对历史抵消记录，每条最多使用一次；桶上限为 200。
+ * @param records 工作区记录（不修改输入或记录状态）
+ * @returns 可以整对归档的记录对
+ */
+export function findCanceledPairs(records: DiffRecord[]): Array<[DiffRecord, DiffRecord]> {
+  const available: DiffRecord[] = []
+  const pairs: Array<[DiffRecord, DiffRecord]> = []
+  const ordered = [...records].sort(recordOrder)
+  for (const record of ordered) {
+    const prior = findInversePrior(available, record)
+    if (!prior) {
+      if (fullyPending(record)) available.push(record)
+      continue
+    }
+    pairs.push([prior, record])
+    available.splice(available.indexOf(prior), 1)
+  }
+  return pairs
+}
+
+// #endregion
+
 /** 文件当前最大批次号（无记录为 0）。 */
 export function fileMaxBatch(records: Map<string, DiffRecord>, path: string): number {
   let m = 0

package/src/rpc.ts

@@ -13,6 +13,7 @@ import {
   READ_CAP,
   appendArchiveEntries,
   archiveRecords,
+  archiveCanceled,
   autoArchiveStale,
   policyOf,
   resolveTarget,
@@ -613,6 +614,7 @@ export function buildHandlers(
           const staleStart = performance.now()
           // #endregion
           await autoArchiveStale(ctx, sc.session, sc.cwd, bucket)
+          await archiveCanceled(ctx, sc.session, sc.cwd, bucket)
           // #region debug log
           staleMs = performance.now() - staleStart
           // #endregion

package/src/shared/rpc.ts

@@ -24,6 +24,7 @@ import type { DapAction, DapAdapterInfo, DapBreakpointAck, DapBreakpointInput, D
 import { DAP_ACTIONS } from './dap.js'
 import { appUrl } from './appUrl.js'
 import type { LoggerLevel } from './logger.js'
+import type { SvnViewRequest, SvnViewPayload } from './svnExplorer.js'
 
 /** webServer 精确路由。 */
 export const RPC_PATH = '/edrv/rpc'
@@ -464,6 +465,8 @@ export interface RpcRequestMap {
   'snippets.entries': { sessionId?: string }
   'svn.status': { sessionId?: string; force?: boolean }
   'svn.changes': { sessionId?: string; force?: boolean }
+  'svn.explorerStatus': { sessionId?: string; force?: boolean }
+  'svn.explorerView': SvnViewRequest
   'svn.diffBase': { sessionId?: string; path: string }
   'svn.revert': { sessionId?: string; paths: string[] }
   'svn.add': { sessionId?: string; paths: string[] }
@@ -624,6 +627,8 @@ export interface RpcOkMap {
   'snippets.entries': { entries: SnippetEntry[] }
   'svn.status': SvnStatusPayload
   'svn.changes': { wcRoot: string; entries: SvnChangeEntry[]; truncated: boolean }
+  'svn.explorerStatus': { entries: SvnChangeEntry[]; truncated: boolean; prefix: string }
+  'svn.explorerView': SvnViewPayload
   'svn.diffBase': { base: string | null; working: string; reason?: string; error?: string; binary?: boolean; encodingHint?: boolean }
   'svn.revert': { count: number; summary: string; output: string }
   'svn.add': { count: number; summary: string; output: string }
@@ -642,7 +647,7 @@ export interface RpcOkMap {
   'svn.tortoise': { launched: string }
   'svn.patchText': { text: string; truncated: boolean; binary: boolean }
   'svn.diffSum': { entries: SvnSumEntry[]; truncated: boolean }
-  'svn.remoteStatus': { outdated: SvnRemoteOutdatedEntry[]; againstRev: number | null }
+  'svn.remoteStatus': { outdated: SvnRemoteOutdatedEntry[]; againstRev: number | null; truncated: boolean }
   'svn.conflictArtifacts': { artifacts: SvnConflictArtifact[] }
   'svn.diffLocalPair': SvnDiffRevResult
   'svn.fileSizes': { sizes: Array<{ path: string; size: number | null }> }

package/src/shared/svn.ts

@@ -413,6 +413,61 @@ export function svnBadgeTitle(entry: SvnChangeEntry): string {
   return letter + ' ' + SVN_STATUS_LABEL[entry.status]
 }
 
+/** 文件夹子树聚合状态（资源管理器目录徽标数据源）。 */
+export interface SvnFolderAgg {
+  /** 子树内最强子项状态（决胜见 SVN_FOLDER_STATUS_RANK）。 */
+  status: SvnItemStatus
+  /** 子树内变更条目总数（含更深层目录下的）。 */
+  count: number
+}
+
+/**
+ * 文件夹聚合决胜优先级（强→弱）：冲突/障碍/缺失等 danger 态先于常规修改，
+ * 未版本控制最弱；未列出的状态（normal/external/ignored）不参与聚合。
+ */
+export const SVN_FOLDER_STATUS_RANK: Partial<Record<SvnItemStatus, number>> = {
+  conflicted: 90,
+  obstructed: 80,
+  missing: 70,
+  incomplete: 60,
+  deleted: 50,
+  replaced: 40,
+  modified: 30,
+  added: 20,
+  unversioned: 10,
+}
+
+/**
+ * 变更清单 → 目录路径 → 子树聚合状态表（P2-15 资源管理器文件夹徽标）。
+ * svn status 只报告目录自身状态、子项变更不上卷，受版本控制目录因此缺席清单；
+ * 此处对每条变更沿路径拆出全部祖先目录，累计计数并按 SVN_FOLDER_STATUS_RANK
+ * 取最强状态。目录自身被报告（A/?/属性M 等）时调用方以直接条目优先，本表只兜底。
+ * @author ddj 2026年10月09号
+ * @param entries 变更清单（host `svn.changes` 原始条目，路径 `/` 分隔）
+ * @returns 目录相对路径 → 聚合状态（根路径 '' 不入表；入参为空返回空表）
+ */
+export function svnFolderStatusOf(entries: readonly SvnChangeEntry[]): Record<string, SvnFolderAgg> {
+  const result: Record<string, SvnFolderAgg> = {}
+  for (const entry of entries) {
+    if (!isSvnChange(entry)) continue
+    const parts = String(entry.path ?? '').replace(/\\/g, '/').split('/').filter(Boolean)
+    const rank = SVN_FOLDER_STATUS_RANK[entry.status] ?? 0
+    let dir = ''
+    // 最后一段是条目自身，只向上聚合到祖先目录（目录自身的行走直接条目）
+    for (let i = 0; i < parts.length - 1; i++) {
+      dir = dir ? dir + '/' + parts[i] : parts[i]
+      const prev = result[dir]
+      if (!prev) {
+        result[dir] = { status: entry.status, count: 1 }
+        continue
+      }
+      prev.count += 1
+      if (rank > (SVN_FOLDER_STATUS_RANK[prev.status] ?? 0)) prev.status = entry.status
+    }
+  }
+  return result
+}
+
 // --endregion
 
 // --region P2 动作文案与判定

package/src/shared/svnExplorer.ts

@@ -0,0 +1,97 @@
+/** Explorer-only SVN presentation; change-list/menu semantics stay untouched. @author ddj 2026年10月09号 */
+import type { SvnChangeEntry, SvnItemStatus, SvnRemoteOutdatedEntry } from './svn.js'
+import { SVN_FOLDER_STATUS_RANK, SVN_STATUS_LABEL } from './svn.js'
+
+export type SvnIconKind = 'clean' | 'modified' | 'conflict' | 'added' | 'deleted' | 'unversioned' | 'ignored' | 'external'
+export interface SvnExplorerIndex {
+  entries: Map<string, SvnChangeEntry>
+  folders: Map<string, { status: SvnItemStatus; count: number }>
+  truncated: boolean
+}
+export interface SvnExplorerMark { kind: SvnIconKind; title: string }
+export interface SvnViewRow { path: string; isDir: boolean }
+export type SvnRefreshReason = 'read' | 'paths' | 'full' | 'calibrate'
+export interface SvnViewRequest {
+  sessionId?: string; rows: SvnViewRow[]; reason?: SvnRefreshReason; paths?: string[]
+  clientId?: string; eventId?: string; revision?: number; generation?: number
+}
+export interface SvnViewMark { path: string; kind: SvnIconKind | null; count: number; stale: boolean }
+export interface SvnViewPayload {
+  scopeId: string; prefix: string; revision: number; generation: number; observedGeneration: number
+  confirmedAt: number; complete: boolean; refreshing: boolean; scanMs: number; error: string
+  mismatch: boolean; rows: SvnViewMark[]
+}
+const ICON_KIND: Record<SvnItemStatus, SvnIconKind> = {
+  normal: 'clean', modified: 'modified', replaced: 'modified', added: 'added',
+  deleted: 'deleted', missing: 'deleted', incomplete: 'conflict', obstructed: 'conflict',
+  conflicted: 'conflict', unversioned: 'unversioned', ignored: 'ignored', external: 'external',
+}
+
+/** @public @author ddj 2026年10月09号 @param entry Local status. @returns Effective content/property status. */
+export function localStatusOf(entry: SvnChangeEntry): SvnItemStatus {
+  if (entry.props === 'conflicted') return 'conflicted'
+  if (entry.status === 'normal' && entry.props === 'modified') return 'modified'
+  return entry.status
+}
+
+/** @private @author ddj 2026年10月09号 @param path Relative path. @returns Ancestors, excluding self/root. */
+function parentsOf(path: string): string[] {
+  const result: string[] = []
+  let dir = path
+  while (dir.includes('/')) {
+    dir = dir.slice(0, dir.lastIndexOf('/'))
+    result.push(dir)
+  }
+  return result
+}
+
+/** @public @author ddj 2026年10月09号 @param entries Confirmed verbose statuses. @param truncated Incomplete snapshot. @returns Indexed entries and descendant changes. */
+export function explorerIndexOf(entries: readonly SvnChangeEntry[], truncated = false): SvnExplorerIndex {
+  const index: SvnExplorerIndex = { entries: new Map(), folders: new Map(), truncated }
+  for (const entry of entries) {
+    index.entries.set(entry.path, entry)
+    const status = localStatusOf(entry)
+    if (status === 'normal' || status === 'ignored' || status === 'external') continue
+    for (const dir of parentsOf(entry.path)) {
+      const prev = index.folders.get(dir)
+      if (!prev) { index.folders.set(dir, { status, count: 1 }); continue }
+      prev.count++
+      if ((SVN_FOLDER_STATUS_RANK[status] ?? 0) > (SVN_FOLDER_STATUS_RANK[prev.status] ?? 0)) prev.status = status
+    }
+  }
+  return index
+}
+
+/** @public @author ddj 2026年10月09号 @param index Confirmed snapshot. @param path Row path. @param isDir Directory row. @returns Overlay or null; absent entries never imply clean. */
+export function explorerMarkOf(index: SvnExplorerIndex | null, path: string, isDir: boolean): SvnExplorerMark | null {
+  if (!index) return null
+  let entry = index.entries.get(path)
+  if (!entry) {
+    for (const parent of parentsOf(path)) {
+      const ancestor = index.entries.get(parent)
+      if (ancestor?.status === 'ignored' || ancestor?.status === 'unversioned') { entry = ancestor; break }
+    }
+  }
+  let status = entry ? localStatusOf(entry) : null
+  const agg = isDir ? index.folders.get(path) : null
+  if (agg && (!status || (SVN_FOLDER_STATUS_RANK[agg.status] ?? 0) > (SVN_FOLDER_STATUS_RANK[status] ?? 0))) status = agg.status
+  if (!status) return null
+  if (status === 'normal' && (entry?.versioned !== true || (isDir && index.truncated))) return null
+  const title = status === 'normal' ? '本地正常（已受控，未修改；不表示仓库无更新）' : SVN_STATUS_LABEL[status]
+  return { kind: ICON_KIND[status], title: title + (agg ? '；子项 ' + agg.count + ' 处变更' : '') }
+}
+
+/** @public @author ddj 2026年10月09号 @param entries Remote changes. @returns Exact and ancestor update counts. */
+export function remoteIndexOf(entries: readonly SvnRemoteOutdatedEntry[]): Map<string, number> {
+  const result = new Map<string, number>()
+  for (const entry of entries) {
+    for (const path of [entry.path, ...parentsOf(entry.path)]) result.set(path, (result.get(path) ?? 0) + 1)
+  }
+  return result
+}
+
+/** @public @author ddj 2026年10月09号 @param path WC-relative path. @param prefix Session path under WC. @returns Session-relative path or null outside session. */
+export function explorerPathOf(path: string, prefix: string): string | null {
+  if (!prefix || prefix === '.') return path
+  return path.startsWith(prefix + '/') ? path.slice(prefix.length + 1) : null
+}

package/src/store.ts

@@ -6,7 +6,7 @@
 import type { ArchiveBatch, DiffRecord, SidecarData } from './shared/types.js'
 import type { ReadState } from './shared/diff.js'
 import { fingerprint, isNoopHunk, locateHunks, normalizeForCompare, normalizeHunk, preciseHunk } from './shared/diff.js'
-import { archiveEntryFor, normalizeRecord } from './model.js'
+import { archiveEntryFor, findCanceledPairs, findInversePrior, normalizeRecord } from './model.js'
 import { SIDECAR, SIDECAR_ARCHIVE } from './paths.js'
 import { log } from './log.js'
 import { debugRecord } from './debugLog.js'
@@ -246,6 +246,41 @@ export async function autoArchiveStale(ctx: Ctx, session: Session, cwd: string,
   return stale.length
 }
 
+/**
+ * @public
+ * @author ddj 2026年10月10号
+ * 归档整记录精确抵消对；捕获时仅检查新记录，列表维护时检查整个桶。
+ * @param ctx DSH 上下文
+ * @param session 当前会话
+ * @param cwd 工作区
+ * @param bucket 活跃记录桶
+ * @param record 可选的新捕获记录
+ * @returns 本次归档记录数（不是配对数）
+ * @throws 归档失败时恢复内存标志并透传错误，已保存的捕获记录不受影响
+ */
+export async function archiveCanceled(
+  ctx: Ctx, session: Session, cwd: string, bucket: Map<string, DiffRecord>, record?: DiffRecord,
+): Promise<number> {
+  const records = [...bucket.values()]
+  const prior = record ? findInversePrior(records, record) : null
+  const pairs = record ? (prior ? [[prior, record]] : []) : findCanceledPairs(records)
+  const canceled = pairs.flat()
+  if (!canceled.length) return 0
+  const original = canceled.map((rec) => ({ rec, at: rec.at, superseded: rec.superseded }))
+  const at = new Date().toISOString()
+  for (const rec of canceled) { rec.superseded = true; rec.at = at }
+  try {
+    await archiveRecords(ctx, session, cwd, bucket, canceled, '编辑过程自抵消（新增后还原），自动跳过审查')
+  } catch (error) {
+    for (const item of original) {
+      item.rec.superseded = item.superseded
+      item.rec.at = item.at
+    }
+    throw error
+  }
+  return canceled.length
+}
+
 /** 读取归档 sidecar 文本（缺失/失败 → null）。 */
 export async function readArchiveText(ctx: Ctx, cwd: string | null): Promise<string | null> {
   const fs = ctx.get('fs')