dsh-log-gate 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,56 @@
-# Temporary Holding Version
+# dsh-log-gate
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+第三方插件，不是 dsh 官方组件，也与 DeepSeek 无关。它只做一件事：按你的规则，让官方会话日志上传跳过某些会话。备份不是它的工作；文末提到的 UndoHaven 是另一个独立工具。
+
+Third-party plugin. It is not an official dsh component and is not affiliated with DeepSeek. It asks the official session-log uploader to skip sessions you choose. Backup is a different tool.
+
+## 它实际调用的接口
+
+dsh `0.2.2-rc.1` 的 `@deepseek-ai/dsh-session-log-deepseek` 公开了 `ctx.sessionLogDeepSeek.registerExclusion()`。判断函数是同步的，只能看到 `sessionId` 和可选的 `purpose`。返回 `true` 时，这次请求不带 `dsh_session_log`，也不会写下 `delivery-accepted`。
+
+本插件在判断时用 `ctx.sessions.get(sessionId)` 读取该实时会话的 `header.cwd`，再按项目名、目录或 glob 匹配。没有改 dsh，也没有拦 HTTP。
+
+The installed package `@deepseek-ai/dsh-session-log-deepseek` exposes `registerExclusion()`. The predicate sees `sessionId` and an optional `purpose` only. This plugin reads `header.cwd` from the live session and matches project name, directory, or glob. It does not patch dsh and does not hook the network.
+
+## 配置
+
+`mode: all`（默认）拦住每一个实时会话。`mode: listed` 只拦住 `rules` 命中的会话。
+
+```yaml
+- id: log-gate
+  name: dsh-log-gate
+  config:
+    mode: listed
+    rules:
+      - secret-proj
+      - /home/me/work/private
+      - /home/me/clients/**
+```
+
+- 没有斜杠、也没有 `* ? [` 的规则，按 cwd 的最后一段（项目名）匹配。
+- 普通路径匹配该目录及其子目录。
+- 带 glob 的规则用 Node 的 `path.matchesGlob`。
+
+设置页「日志闸门 / Log gate」和 `GET /api/log-gate/status`（仅本机）列出当前实时会话哪些会被拦住。
+
+## 做不到的事
+
+- 判断函数拿不到路径。会话如果不在实时 store 里，`listed` 模式读不到 cwd，**不会**拦住它。`all` 模式只看 session id，仍然拦住。
+- 匹配的是会话创建时的 cwd，不是 agent 后来走进去的每一个目录。
+- 官方上传开关 `session-log-deepseek` 的 `enabled` 在排除规则之前生效。开关关掉时，排除规则不会被问到。本插件不替你改那个开关。
+- 遥测（`session-telemetry-otel`，默认 `FEEDBACK_ONLY`）是另一个开关。这个插件不动它。
+- 拦住不会删日志，也不会写 `delivery-accepted`。之后关掉闸门或删掉规则，下一次官方 API 请求可能把当时没传的后缀补传上去。这是官方实现里的行为，不是额外的补传通道。
+- 不能保证桌面端一定渲染这个设置页。状态同时写在 dsh 日志里。
+
+## 体检
+
+```bash
+dsh-log-gate audit
+dsh-log-gate audit --json
+```
+
+报告列出官方会话日志开关、遥测相关的环境变量和补丁、本机目录大小，以及本地日志里越过最近一次 `delivery-accepted` 的后缀。最后有一句 UndoHaven 的说明和 https://undohaven.com 。
+
+## 验证
+
+`npm test` 里的 `packages/log-gate/test/gate.test.js` 会加载本机安装的 `@deepseek-ai/dsh-session-log-deepseek`，注册本插件的排除规则，并确认命中的会话不会进入 `snapshotEvents`（官方 `prepare` 因此不会带上 `dsh_session_log`）。没有向官方 API 发请求。

package/bin/dsh-log-gate.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { auditHome, renderReport } from '../src/audit.js'
+
+const args = process.argv.slice(2)
+const command = args[0] === 'audit' || !args[0] || args[0] === 'help' ? (args[0] || 'audit') : args[0]
+const flags = {}
+for (let i = 0; i < args.length; i += 1) {
+  const arg = args[i]
+  if (arg === '--json') flags.json = true
+  else if (arg === '--dsh-home') flags.dshHome = args[++i]
+  else if (arg.startsWith('--dsh-home=')) flags.dshHome = arg.slice('--dsh-home='.length)
+}
+
+if (command === 'help' || args.includes('--help')) {
+  console.log('dsh-log-gate audit [--dsh-home PATH] [--json]\nThird-party local report. Not an official dsh command.')
+  process.exit(0)
+}
+
+if (command !== 'audit') {
+  console.error(`Unknown command ${command}. Try: dsh-log-gate audit`)
+  process.exit(1)
+}
+
+const report = await auditHome({ dshHome: flags.dshHome })
+if (flags.json) console.log(JSON.stringify(report, null, 2))
+else console.log(renderReport(report))

package/client.js

@@ -0,0 +1,42 @@
+/* Third-party log gate settings tab. Not an official dsh panel. */
+(function (global) {
+  var loader = global.__ModuleLoader__
+  if (!loader || typeof loader.load !== 'function') return
+  loader.load({
+    id: 'dsh-log-gate',
+    factory: function (require) {
+      var React = require('react')
+      function Tab() {
+        var state = React.useState(null)
+        var status = state[0]
+        var setStatus = state[1]
+        React.useEffect(function () {
+          fetch('/api/log-gate/status').then(function (res) { return res.json() }).then(setStatus).catch(function () { setStatus(null) })
+        }, [])
+        var rows = ((status && status.sessions) || []).map(function (row) {
+          return React.createElement('li', { key: row.id || row.cwd }, (row.blocked ? 'blocked / 已拦住 ' : 'eligible / 会上传 ') + (row.cwd || row.id || ''))
+        })
+        return React.createElement('section', null,
+          React.createElement('h2', null, '日志闸门'),
+          React.createElement('p', null, 'Third-party, not affiliated with DeepSeek. / 第三方插件，与 DeepSeek 无关。'),
+          React.createElement('p', null, status ? status.message : 'Loading / 正在读取'),
+          React.createElement('ul', null, rows.length ? rows : React.createElement('li', null, 'No live sessions / 没有实时会话'))
+        )
+      }
+      return {
+        name: 'dsh-log-gate',
+        inject: ['slots'],
+        apply: function (ctx) {
+          ctx.slots.inject('settings.plugins.tab', function () {
+            return ctx.slots.register({
+              name: 'settings.plugins.tab',
+              id: 'log-gate',
+              order: 70,
+              label: '日志闸门 / Log gate',
+            }, Tab)
+          })
+        },
+      }
+    },
+  })
+})(typeof globalThis !== 'undefined' ? globalThis : this)

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# Third-party session-log gate. Not part of the dsh distribution.
+- id: log-gate
+  name: dsh-log-gate
+  config:
+    mode: all
+    rules: []

package/index.js

@@ -0,0 +1,111 @@
+import Schema from '@deepseek-ai/schemastery'
+import { decideBlock } from './src/match.js'
+
+export const name = 'log-gate'
+export const inject = ['sessionLogDeepSeek', 'sessions']
+
+export const Config = Schema.object({
+  mode: Schema.union(['all', 'listed']).default('all').volatile(),
+  rules: Schema.array(Schema.string()).default([]).volatile(),
+})
+
+function read(value, fallback) {
+  if (value && typeof value === 'object' && typeof value.get === 'function') {
+    const got = value.get()
+    return got === undefined || got === null ? fallback : got
+  }
+  return value === undefined || value === null ? fallback : value
+}
+
+export function currentRules(config = {}) {
+  return {
+    mode: read(config.mode, 'all') === 'listed' ? 'listed' : 'all',
+    rules: [...read(config.rules, [])],
+  }
+}
+
+export function classifyLive(sessions, config) {
+  const rules = currentRules(config)
+  return [...sessions].map((session) => {
+    const cwd = session?.header?.cwd || null
+    const decision = decideBlock({ ...rules, cwd })
+    return {
+      id: session?.id || null,
+      cwd,
+      blocked: decision.blocked,
+      reason: decision.reason,
+    }
+  })
+}
+
+export function statusMessage(rows, config) {
+  const rules = currentRules(config)
+  const blocked = rows.filter((row) => row.blocked).length
+  const open = rows.length - blocked
+  if (rules.mode === 'all') {
+    return `dsh-log-gate: session-log upload is blocked for every live session (${blocked} blocked, ${open} still eligible). Telemetry is a separate switch. / 日志闸门：当前实时会话的官方会话日志上传都已拦住（拦住 ${blocked}，仍会上传 ${open}）。遥测是另一个开关。`
+  }
+  return `dsh-log-gate: listed rules, ${blocked} live session(s) blocked, ${open} still eligible. Unknown cwd is not blocked. / 日志闸门：按列出的规则，拦住 ${blocked} 个实时会话，${open} 个仍会上传。读不到 cwd 时不拦。`
+}
+
+function log(ctx, message) {
+  if (typeof ctx?.logger?.info === 'function') ctx.logger.info(message)
+}
+
+function send(res, status, body) {
+  const payload = Buffer.from(JSON.stringify(body))
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+    'content-length': payload.length,
+  })
+  res.end(payload)
+}
+
+export function mount(webServer, ctx, config) {
+  return webServer.register({
+    kind: 'prefix',
+    path: '/api/log-gate',
+    async handler(req, res) {
+      const address = req.socket?.remoteAddress || ''
+      if (address !== '127.0.0.1' && address !== '::1' && address !== '::ffff:127.0.0.1') {
+        send(res, 403, { error: 'loopback' })
+        return
+      }
+      const url = new URL(req.url || '/', 'http://127.0.0.1')
+      if (req.method === 'GET' && (url.pathname === '/api/log-gate/status' || url.pathname === '/status')) {
+        const live = typeof ctx.sessions?.list === 'function' ? ctx.sessions.list() : []
+        const rows = classifyLive(live, config)
+        send(res, 200, { ...currentRules(config), sessions: rows, message: statusMessage(rows, config) })
+        return
+      }
+      send(res, 404, { error: 'not_found' })
+    },
+  })
+}
+
+export function apply(ctx, config = {}) {
+  const exclude = (request) => {
+    const session = ctx.sessions?.get?.(request.sessionId)
+    return decideBlock({ ...currentRules(config), cwd: session?.header?.cwd }).blocked
+  }
+  const stop = ctx.sessionLogDeepSeek.registerExclusion(exclude)
+  const rows = classifyLive(typeof ctx.sessions?.list === 'function' ? ctx.sessions.list() : [], config)
+  log(ctx, statusMessage(rows, config))
+  let unmount = () => {}
+  const attach = (host) => {
+    if (host?.webServer?.register) unmount = mount(host.webServer, host, config) || (() => {})
+  }
+  if (ctx.webServer?.register) attach(ctx)
+  else if (typeof ctx.inject === 'function') {
+    try {
+      ctx.inject(['webServer'], (child) => { attach(child) })
+    } catch {
+      /* settings UI is optional */
+    }
+  }
+  return () => {
+    unmount()
+    return stop?.()
+  }
+}

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "dsh-log-gate",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Unofficial third-party gate for dsh session-log upload. Not affiliated with DeepSeek.",
+  "engines": {
+    "node": ">=24.9.0",
+    "dsh": ">=0.2.1-rc.5 <0.3.0"
+  },
+  "bin": {
+    "dsh-log-gate": "./bin/dsh-log-gate.js"
+  },
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "3.19.0"
+  },
+  "license": "MIT"
+}

package/src/audit.js

@@ -0,0 +1,302 @@
+import { readdir, readFile, stat } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { zstdDecompressSync } from 'node:zlib'
+import { decideBlock } from './match.js'
+
+const SESSION_LOG = /^session(?:\.v\d+)?\.jsonl(?:\.zstd)?$/
+const READ_LIMIT = 32 * 1024 * 1024
+
+export function resolveDshHome(env = process.env, flag) {
+  if (flag) return resolve(flag)
+  if (env.DSH_HOME) return resolve(env.DSH_HOME)
+  return join(homedir(), '.dsh')
+}
+
+/** Pull plugin config blocks out of a cordis patch list. Tolerates comments and nested config. */
+export function readPatchPlugins(text) {
+  const plugins = []
+  let current = null
+  let inConfig = false
+  let inRules = false
+  for (const raw of String(text || '').split(/\r?\n/)) {
+    const line = raw.replace(/\t/g, '  ')
+    if (/^\s*#/.test(line) || !line.trim()) continue
+    const id = line.match(/^- id:\s*['"]?([A-Za-z0-9_-]+)['"]?\s*$/)
+    if (id) {
+      current = { id: id[1], config: {}, disabled: false }
+      plugins.push(current)
+      inConfig = false
+      inRules = false
+      continue
+    }
+    if (!current) continue
+    if (/^\s+disabled:\s*true\s*$/.test(line)) current.disabled = true
+    if (/^\s+config:\s*$/.test(line)) {
+      inConfig = true
+      inRules = false
+      continue
+    }
+    if (!inConfig) continue
+    if (/^\S/.test(line) || /^- /.test(line)) {
+      inConfig = false
+      inRules = false
+      continue
+    }
+    const enabled = line.match(/^\s+enabled:\s*(true|false)\s*$/)
+    if (enabled) current.config.enabled = enabled[1] === 'true'
+    const mode = line.match(/^\s+mode:\s*['"]?([A-Za-z0-9_-]+)['"]?\s*$/)
+    if (mode && !mode[1].startsWith('!!')) current.config.mode = mode[1]
+    if (/^\s+rules:\s*$/.test(line)) {
+      current.config.rules = []
+      inRules = true
+      continue
+    }
+    const rule = line.match(/^\s+-\s+['"]?(.+?)['"]?\s*$/)
+    if (inRules && rule) current.config.rules.push(rule[1])
+    else if (!/^\s+- /.test(line)) inRules = false
+  }
+  return plugins
+}
+
+function lastPlugin(plugins, id) {
+  return [...plugins].reverse().find((row) => row.id === id) || null
+}
+
+async function readMaybe(path) {
+  try {
+    return await readFile(path, 'utf8')
+  } catch (error) {
+    if (error.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+async function dirSize(root, state = { bytes: 0, files: 0, capped: false }) {
+  let entries = []
+  try {
+    entries = await readdir(root, { withFileTypes: true })
+  } catch (error) {
+    if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return state
+    throw error
+  }
+  for (const entry of entries) {
+    if (state.files > 20000) {
+      state.capped = true
+      return state
+    }
+    const path = join(root, entry.name)
+    if (entry.isSymbolicLink()) continue
+    if (entry.isDirectory()) await dirSize(path, state)
+    else if (entry.isFile()) {
+      const info = await stat(path)
+      state.bytes += info.size
+      state.files += 1
+    }
+  }
+  return state
+}
+
+async function walkLogs(sessionsRoot) {
+  const found = []
+  async function walk(dir) {
+    let entries = []
+    try {
+      entries = await readdir(dir, { withFileTypes: true })
+    } catch (error) {
+      if (error.code === 'ENOENT') return
+      throw error
+    }
+    for (const entry of entries) {
+      const path = join(dir, entry.name)
+      if (entry.isDirectory()) await walk(path)
+      else if (entry.isFile() && SESSION_LOG.test(entry.name)) found.push(path)
+    }
+  }
+  await walk(sessionsRoot)
+  return found
+}
+
+function parseLog(bytes) {
+  let text
+  if (bytes.length >= 4 && bytes[0] === 0x28 && bytes[1] === 0xb5 && bytes[2] === 0x2f && bytes[3] === 0xfd) {
+    text = zstdDecompressSync(bytes).toString('utf8')
+  } else {
+    text = bytes.toString('utf8')
+  }
+  let header = null
+  let maxSeq = -1
+  let accepted = -1
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue
+    let row
+    try {
+      row = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (row.type === 'session' && header === null) header = row
+    if (typeof row.seq === 'number') maxSeq = Math.max(maxSeq, row.seq)
+    if (row.type === 'session-log-deepseek/delivery-accepted') {
+      const through = Number(row.data?.throughSeq)
+      if (Number.isFinite(through)) accepted = Math.max(accepted, through)
+    }
+  }
+  return { header, maxSeq, accepted, pending: maxSeq > accepted }
+}
+
+export async function inspectSessions(sessionsRoot) {
+  const files = await walkLogs(sessionsRoot)
+  const sessions = []
+  for (const file of files) {
+    const info = await stat(file)
+    if (info.size > READ_LIMIT) {
+      sessions.push({ file, unreadable: true, reason: 'too-large', bytes: info.size })
+      continue
+    }
+    try {
+      const parsed = parseLog(await readFile(file))
+      sessions.push({
+        file,
+        id: parsed.header?.id || null,
+        cwd: parsed.header?.cwd || null,
+        maxSeq: parsed.maxSeq,
+        acceptedThrough: parsed.accepted,
+        pending: parsed.pending,
+        bytes: info.size,
+      })
+    } catch {
+      sessions.push({ file, unreadable: true, reason: 'unreadable', bytes: info.size })
+    }
+  }
+  return sessions
+}
+
+function telemetryReport(env, plugins) {
+  const row = lastPlugin(plugins, 'session-telemetry-otel')
+  const disabledEnv = env.DSH_TELEMETRY_DISABLED
+  const envSet = disabledEnv != null && disabledEnv !== ''
+  const patchMode = row?.disabled ? 'disabled-row' : (row?.config?.mode || null)
+  return {
+    separateFromSessionLog: true,
+    defaultMode: 'FEEDBACK_ONLY',
+    patchMode,
+    envMode: env.DSH_TELEMETRY_MODE || null,
+    disabledEnv: envSet,
+    note: envSet
+      ? 'A non-empty DSH_TELEMETRY_DISABLED makes the launcher append a disabled row for session-telemetry-otel. Any value, including 0 or false, counts.'
+      : 'Session telemetry is a different switch from official session-log upload. The stock default is FEEDBACK_ONLY: a prefix leaves only after explicit feedback.',
+  }
+}
+
+function uploadSwitch(plugins) {
+  const row = lastPlugin(plugins, 'session-log-deepseek')
+  if (row?.disabled) return { enabled: false, source: 'row-disabled' }
+  if (typeof row?.config?.enabled === 'boolean') return { enabled: row.config.enabled, source: 'patch' }
+  return { enabled: true, source: 'default' }
+}
+
+function gateConfig(plugins) {
+  const row = lastPlugin(plugins, 'log-gate')
+  if (!row || row.disabled) return { installed: false, mode: null, rules: [] }
+  return {
+    installed: true,
+    mode: row.config.mode === 'listed' ? 'listed' : 'all',
+    rules: Array.isArray(row.config.rules) ? row.config.rules : [],
+  }
+}
+
+export async function auditHome(opts = {}) {
+  const env = opts.env || process.env
+  const dshHome = resolveDshHome(env, opts.dshHome)
+  const agentsHome = opts.agentsHome || (env.DSH_AGENTS_HOME ? resolve(env.DSH_AGENTS_HOME) : join(homedir(), '.agents'))
+  const profileRoot = join(dshHome, 'profiles')
+  let profileNames = []
+  try {
+    profileNames = (await readdir(profileRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name)
+  } catch {
+    profileNames = []
+  }
+  const layers = []
+  for (const name of profileNames) {
+    const text = await readMaybe(join(profileRoot, name, 'cordis.patch.yml'))
+    if (text != null) layers.push({ name: `profiles/${name}`, plugins: readPatchPlugins(text) })
+  }
+  const homeText = await readMaybe(join(dshHome, 'cordis.patch.yml'))
+  if (homeText != null) layers.push({ name: 'home', plugins: readPatchPlugins(homeText) })
+  const merged = layers.flatMap((layer) => layer.plugins)
+  const upload = uploadSwitch(merged)
+  const gate = gateConfig(merged)
+  const telemetry = telemetryReport(env, merged)
+  const sessionsRoot = join(dshHome, 'sessions')
+  const sessions = await inspectSessions(sessionsRoot)
+  const classified = sessions.map((session) => {
+    if (session.unreadable) return { ...session, blocked: null }
+    const decision = decideBlock({ mode: gate.installed ? gate.mode : 'off', rules: gate.rules, cwd: session.cwd })
+    const blocked = gate.installed ? decision.blocked : false
+    let catchUp = 'none'
+    if (session.pending && !upload.enabled) catchUp = 'held-by-official-switch'
+    else if (session.pending && blocked) catchUp = 'held-by-gate'
+    else if (session.pending) catchUp = 'would-upload'
+    return { ...session, blocked, reason: decision.reason, catchUp }
+  })
+  const [homeSize, sessionSize, agentsSize, anon] = await Promise.all([
+    dirSize(dshHome),
+    dirSize(sessionsRoot),
+    dirSize(agentsHome),
+    stat(join(dshHome, '.anonymous-user-id')).then((info) => ({ exists: true, bytes: info.size })).catch(() => ({ exists: false, bytes: 0 })),
+  ])
+  return {
+    dshHome,
+    agentsHome,
+    layers: layers.map((layer) => layer.name),
+    upload,
+    telemetry,
+    gate,
+    sizes: {
+      dshHome: homeSize,
+      sessions: sessionSize,
+      agents: agentsSize,
+      anonymousUserId: anon,
+    },
+    sessions: classified,
+  }
+}
+
+export function renderReport(report) {
+  const lines = []
+  lines.push('dsh-log-gate audit / 本机数据去向体检')
+  lines.push(`DSH_HOME  ${report.dshHome}`)
+  lines.push(`agents    ${report.agentsHome}`)
+  lines.push('')
+  lines.push(`Official session-log upload: ${report.upload.enabled ? 'on' : 'off'} (${report.upload.source})`)
+  lines.push(`官方会话日志上传：${report.upload.enabled ? '开' : '关'}（${report.upload.source}）`)
+  lines.push(`Telemetry mode on disk: ${report.telemetry.patchMode || 'not set'}; env DSH_TELEMETRY_MODE=${report.telemetry.envMode || 'unset'}; DSH_TELEMETRY_DISABLED=${report.telemetry.disabledEnv ? 'set' : 'unset'}`)
+  lines.push(report.telemetry.note)
+  lines.push('')
+  if (!report.gate.installed) {
+    lines.push('dsh-log-gate is not enabled in the profile or home patch, so it is not omitting uploads.')
+    lines.push('配置里没有启用 dsh-log-gate，因此它现在不会拦截上传。')
+  } else {
+    lines.push(`dsh-log-gate mode: ${report.gate.mode}; rules: ${report.gate.rules.length ? report.gate.rules.join(', ') : '(none)'}`)
+  }
+  lines.push('')
+  lines.push(`Size  home ${report.sizes.dshHome.bytes} B, sessions ${report.sizes.sessions.bytes} B, agents ${report.sizes.agents.bytes} B`)
+  lines.push(`Anonymous id file: ${report.sizes.anonymousUserId.exists ? `present, ${report.sizes.anonymousUserId.bytes} B` : 'absent'}`)
+  lines.push('')
+  const pending = report.sessions.filter((session) => session.catchUp && session.catchUp !== 'none')
+  if (pending.length === 0) {
+    lines.push('No stored session showed an unsent suffix past the last delivery-accepted mark.')
+    lines.push('没有发现越过最近一次 delivery-accepted 的未发送后缀。')
+  } else {
+    lines.push('Unsent suffixes stay in the local log. A blocked request does not write delivery-accepted, so opening the gate later can upload that suffix on a later official API request.')
+    lines.push('未发送的后缀仍在本地日志里。被拦住的请求不会写下 delivery-accepted，所以以后打开闸门时，下一次官方 API 请求可能补传这段。')
+    for (const session of pending.slice(0, 20)) {
+      lines.push(`- ${session.id || session.file}  cwd=${session.cwd || '?'}  ${session.catchUp}  seq ${session.acceptedThrough} -> ${session.maxSeq}`)
+    }
+  }
+  lines.push('')
+  lines.push('UndoHaven can keep an encrypted snapshot of this home on the machine, and only copy it off the machine if you ask. https://undohaven.com')
+  lines.push('如果想给这份家目录留一份默认只在本机的加密快照，可以用 UndoHaven。https://undohaven.com')
+  return lines.join('\n')
+}

package/src/match.js

@@ -0,0 +1,44 @@
+import { basename, matchesGlob, resolve, sep } from 'node:path'
+
+/** True when a rule uses glob metacharacters. */
+export function hasGlob(rule) {
+  return /[*?[\]]/.test(rule)
+}
+
+/**
+ * Match a session cwd against one rule.
+ * A rule with no slash and no glob is a project name (the cwd basename).
+ * A path matches that directory and anything inside it.
+ * A glob is tested against the cwd and against a `/**` suffix.
+ */
+export function ruleMatches(cwd, rule) {
+  const raw = String(rule || '').trim()
+  if (!raw) return false
+  if (raw === '*' || raw === '**') return true
+  const glob = hasGlob(raw)
+  if (!raw.includes('/') && !raw.includes('\\') && !glob) return basename(cwd) === raw
+  const abs = resolve(cwd)
+  if (!glob) {
+    const target = resolve(raw)
+    const prefix = target.endsWith(sep) ? target : `${target}${sep}`
+    if (abs === target || abs.startsWith(prefix)) return true
+  }
+  if (matchesGlob(abs, raw)) return true
+  if (!raw.endsWith('/**') && matchesGlob(abs, `${raw.replace(/\/$/, '')}/**`)) return true
+  return false
+}
+
+/**
+ * Decide whether one session's log upload should be omitted.
+ * `all` blocks every session id, even when cwd is unknown.
+ * `listed` blocks only matching rules. An unknown cwd is not blocked:
+ * the official exclusion callback does not include a path.
+ */
+export function decideBlock({ mode, rules, cwd }) {
+  if (mode !== 'listed') return { blocked: true, reason: 'all' }
+  if (!cwd) return { blocked: false, reason: 'cwd-unknown' }
+  for (const rule of rules || []) {
+    if (ruleMatches(cwd, rule)) return { blocked: true, reason: String(rule) }
+  }
+  return { blocked: false, reason: 'no-match' }
+}

package/test/gate.test.js

@@ -0,0 +1,119 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+import { pathToFileURL } from 'node:url'
+import { zstdCompressSync } from 'node:zlib'
+import { auditHome, readPatchPlugins, renderReport } from '../src/audit.js'
+import { decideBlock, ruleMatches } from '../src/match.js'
+import { Config, apply, classifyLive, currentRules } from '../index.js'
+
+const DSH = process.env.UNDOHAVEN_DSH_PREFIX || '/tmp/hhy-dsh'
+
+test('rules match project names, directories, and globs', () => {
+  assert.equal(ruleMatches('/home/me/secret-proj', 'secret-proj'), true)
+  assert.equal(ruleMatches('/home/me/secret-proj', 'other'), false)
+  assert.equal(ruleMatches('/home/me/work/private/app', '/home/me/work/private'), true)
+  assert.equal(ruleMatches('/home/me/clients/acme', '/home/me/clients/**'), true)
+  assert.equal(decideBlock({ mode: 'all', rules: [], cwd: null }).blocked, true)
+  assert.equal(decideBlock({ mode: 'listed', rules: ['secret-proj'], cwd: null }).blocked, false)
+  assert.equal(decideBlock({ mode: 'listed', rules: ['secret-proj'], cwd: '/x/secret-proj' }).reason, 'secret-proj')
+})
+
+test('settings schema defaults to blocking every session', () => {
+  const value = Config['~standard'].validate({}).value
+  assert.equal(currentRules(value).mode, 'all')
+  assert.deepEqual(currentRules(value).rules, [])
+})
+
+test('patch reader sees the official switches and this gate', () => {
+  const plugins = readPatchPlugins(`
+- id: session-log-deepseek
+  config:
+    enabled: false
+- id: session-telemetry-otel
+  config:
+    mode: DISABLED
+- id: log-gate
+  config:
+    mode: listed
+    rules:
+      - secret-proj
+`)
+  assert.equal(plugins.find((row) => row.id === 'session-log-deepseek').config.enabled, false)
+  assert.equal(plugins.find((row) => row.id === 'session-telemetry-otel').config.mode, 'DISABLED')
+  assert.deepEqual(plugins.find((row) => row.id === 'log-gate').config.rules, ['secret-proj'])
+})
+
+test('audit report names switches, catch-up, and UndoHaven', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'log-gate-'))
+  const dsh = join(root, 'dsh')
+  const sessionDir = join(dsh, 'sessions', 'proj', 's1')
+  await mkdir(sessionDir, { recursive: true })
+  await mkdir(join(dsh, 'profiles', 'default'), { recursive: true })
+  await writeFile(join(dsh, 'profiles', 'default', 'cordis.patch.yml'), `
+- id: session-log-deepseek
+  config:
+    enabled: true
+- id: log-gate
+  config:
+    mode: listed
+    rules:
+      - secret-proj
+`)
+  const lines = [
+    JSON.stringify({ type: 'session', version: 4, id: 's1', cwd: '/work/secret-proj', createdAt: 1, isSeeded: false, delegationDepth: 0 }),
+    JSON.stringify({ type: 'user/message', seq: 0, time: 1, data: {} }),
+    JSON.stringify({ type: 'session-log-deepseek/delivery-accepted', seq: 1, time: 2, data: { sessionId: 's1', throughSeq: 0 } }),
+    JSON.stringify({ type: 'user/message', seq: 2, time: 3, data: {} }),
+  ].join('\n')
+  await writeFile(join(sessionDir, 'session.v4.jsonl.zstd'), zstdCompressSync(Buffer.from(lines)))
+  const report = await auditHome({ dshHome: dsh, agentsHome: join(root, 'agents'), env: {} })
+  assert.equal(report.upload.enabled, true)
+  assert.equal(report.gate.mode, 'listed')
+  assert.equal(report.sessions[0].catchUp, 'held-by-gate')
+  const text = renderReport(report)
+  assert.match(text, /https:\/\/undohaven\.com/)
+  assert.match(text, /delivery-accepted/)
+  assert.match(text, /FEEDBACK_ONLY|Telemetry/)
+  await rm(root, { recursive: true, force: true })
+})
+
+test('real session-log service omits a blocked session before reading events', async () => {
+  const moduleUrl = pathToFileURL(join(DSH, 'node_modules/@deepseek-ai/dsh-session-log-deepseek/lib/index.js'))
+  let SessionLogDeepSeekService
+  try {
+    ;({ SessionLogDeepSeekService } = await import(moduleUrl))
+  } catch (error) {
+    assert.fail(`real dsh session-log package is required at ${moduleUrl.pathname}: ${error.message}`)
+  }
+  const sessions = new Map()
+  let prepare
+  const ctx = {
+    reflect: { provide(name, self) { ctx[name] = self; return self } },
+    deepseekLlmApiExtensions: { register(_field, handler) { prepare = handler.prepare; return () => {} } },
+    sessions: {
+      get(id) { return sessions.get(id) },
+      list() { return [...sessions.values()] },
+    },
+    effect(fn) { return fn() },
+    logger: { warn() {}, info() {} },
+  }
+  new SessionLogDeepSeekService(ctx, { enabled: { get() { return true } }, maxBytes: 8 * 1024 * 1024 })
+  const reads = []
+  const session = (id, cwd) => ({
+    id,
+    header: { cwd, version: 4 },
+    snapshotEvents() { reads.push(id); return [] },
+  })
+  sessions.set('secret', session('secret', '/work/secret-proj'))
+  sessions.set('open', session('open', '/work/public'))
+  apply(ctx, { mode: 'listed', rules: ['secret-proj'] })
+  assert.equal(prepare({ sessionId: 'secret' }), undefined)
+  assert.equal(prepare({ sessionId: 'open' }), undefined)
+  assert.deepEqual(reads, ['open'])
+  const rows = classifyLive(ctx.sessions.list(), { mode: 'listed', rules: ['secret-proj'] })
+  assert.equal(rows.find((row) => row.id === 'secret').blocked, true)
+  assert.equal(rows.find((row) => row.id === 'open').blocked, false)
+})