dsh-manage-session 0.3.3 → 0.5.1

package/src/host/health/attribution.ts

@@ -1,118 +1,118 @@
-/**
- * 归属：把投影 key 指回产出它的插件包。
- *
- * 做法是静态扫描 profile 的 `node_modules`：`<pkg>/lib/index.js` 里
- * `sessionProjections.register({ key: 'xxx' })`（或其定义工厂）会命中
- * `key:\s*['"](\w+)['"]` 正则；据此建立 `投影 key → 包名` 索引。
- * `@deepseek-ai/*` 视为内置（core）；扫不到时如实返回 `unknown`，禁止臆测。
- */
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-import type { GateAttribution } from './gates.ts'
-
-/** 一条归属记录。 */
-export interface ProjectionOwner {
-  key: string
-  /** 包名；内置包以 `@deepseek-ai/` 前缀判定。 */
-  package: string
-  /** 'core' 表示内置包，'plugin' 表示第三方插件。 */
-  kind: 'core' | 'plugin'
-  /** 命中文件（相对 node_modules）。 */
-  entry: string
-}
-
-/** 默认扫描根：profile 的 node_modules。 */
-export function defaultProfileNodeModules(dshHome?: string): string {
-  return join(dshHome ?? join(homedir(), '.dsh'), 'profiles', 'web', 'node_modules')
-}
-
-/** 收集候选包目录（含 @scope/pkg 一层）。 */
-function candidatePackages(root: string): { name: string; dir: string }[] {
-  const out: { name: string; dir: string }[] = []
-  if (!existsSync(root)) return out
-  for (const entry of readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
-    if (entry.name.startsWith('.')) continue
-    const dir = join(root, entry.name)
-    if (entry.name.startsWith('@')) {
-      let scoped: string[] = []
-      try {
-        scoped = readdirSync(dir)
-      } catch { continue }
-      for (const child of scoped) {
-        out.push({ name: `${entry.name}/${child}`, dir: join(dir, child) })
-      }
-      continue
-    }
-    out.push({ name: entry.name, dir })
-  }
-  return out
-}
-
-/** 单个入口文件的最大扫描字节数（超大 bundle 直接跳过，避免无谓内存与耗时）。 */
-const MAX_SCAN_BYTES = 12 << 20
-
-/** 扫描若干候选入口文件里出现的投影 key。 */
-function keysInFile(file: string): string[] {
-  if (!existsSync(file)) return []
-  let text: string
-  try {
-    if (statSync(file).size > MAX_SCAN_BYTES) return []
-    text = readFileSync(file, 'utf8')
-  } catch {
-    return []
-  }
-  const keys = new Set<string>()
-  const pattern = /key:\s*['"]([A-Za-z_$][\w$]*)['"]/g
-  let match: RegExpExecArray | null
-  while ((match = pattern.exec(text)) !== null) {
-    const key = match[1]
-    if (key !== undefined && key !== '') keys.add(key)
-  }
-  return [...keys]
-}
-
-/**
- * 建立投影 key → 包 的索引。
- * @param nodeModulesRoot - profile 的 node_modules 根。
- * @returns 归属记录（同一 key 多包命中时保留首个并排序稳定）。
- */
-export function buildProjectionOwnerIndex(nodeModulesRoot: string): ProjectionOwner[] {
-  const records: ProjectionOwner[] = []
-  const seen = new Set<string>()
-  for (const pack of candidatePackages(nodeModulesRoot)) {
-    const lib = join(pack.dir, 'lib')
-    let entries: string[] = []
-    try {
-      if (!statSync(lib).isDirectory()) continue
-      entries = readdirSync(lib).filter(name => name.endsWith('.js'))
-    } catch {
-      continue
-    }
-    for (const name of entries) {
-      const file = join(lib, name)
-      for (const key of keysInFile(file)) {
-        if (seen.has(key)) continue
-        seen.add(key)
-        records.push({
-          key,
-          package: pack.name,
-          kind: pack.name.startsWith('@deepseek-ai/') ? 'core' : 'plugin',
-          entry: `${pack.name}/lib/${name}`,
-        })
-      }
-    }
-  }
-  return records.sort((left, right) => left.key.localeCompare(right.key))
-}
-
-/** 索引查询器。 */
-export function createAttributor(index: readonly ProjectionOwner[]): (projection: string) => GateAttribution | undefined {
-  const byKey = new Map(index.map(record => [record.key, record]))
-  return (projection: string) => {
-    const owner = byKey.get(projection)
-    if (owner === undefined) return { projection, package: 'unknown' }
-    return { projection, package: owner.package }
-  }
-}
+/**
+ * 归属：把投影 key 指回产出它的插件包。
+ *
+ * 做法是静态扫描 profile 的 `node_modules`：`<pkg>/lib/index.js` 里
+ * `sessionProjections.register({ key: 'xxx' })`（或其定义工厂）会命中
+ * `key:\s*['"](\w+)['"]` 正则；据此建立 `投影 key → 包名` 索引。
+ * `@deepseek-ai/*` 视为内置（core）；扫不到时如实返回 `unknown`，禁止臆测。
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import type { GateAttribution } from './gates.ts'
+
+/** 一条归属记录。 */
+export interface ProjectionOwner {
+  key: string
+  /** 包名；内置包以 `@deepseek-ai/` 前缀判定。 */
+  package: string
+  /** 'core' 表示内置包，'plugin' 表示第三方插件。 */
+  kind: 'core' | 'plugin'
+  /** 命中文件（相对 node_modules）。 */
+  entry: string
+}
+
+/** 默认扫描根：profile 的 node_modules。 */
+export function defaultProfileNodeModules(dshHome?: string): string {
+  return join(dshHome ?? join(homedir(), '.dsh'), 'profiles', 'web', 'node_modules')
+}
+
+/** 收集候选包目录（含 @scope/pkg 一层）。 */
+function candidatePackages(root: string): { name: string; dir: string }[] {
+  const out: { name: string; dir: string }[] = []
+  if (!existsSync(root)) return out
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
+    if (entry.name.startsWith('.')) continue
+    const dir = join(root, entry.name)
+    if (entry.name.startsWith('@')) {
+      let scoped: string[] = []
+      try {
+        scoped = readdirSync(dir)
+      } catch { continue }
+      for (const child of scoped) {
+        out.push({ name: `${entry.name}/${child}`, dir: join(dir, child) })
+      }
+      continue
+    }
+    out.push({ name: entry.name, dir })
+  }
+  return out
+}
+
+/** 单个入口文件的最大扫描字节数（超大 bundle 直接跳过，避免无谓内存与耗时）。 */
+const MAX_SCAN_BYTES = 12 << 20
+
+/** 扫描若干候选入口文件里出现的投影 key。 */
+function keysInFile(file: string): string[] {
+  if (!existsSync(file)) return []
+  let text: string
+  try {
+    if (statSync(file).size > MAX_SCAN_BYTES) return []
+    text = readFileSync(file, 'utf8')
+  } catch {
+    return []
+  }
+  const keys = new Set<string>()
+  const pattern = /key:\s*['"]([A-Za-z_$][\w$]*)['"]/g
+  let match: RegExpExecArray | null
+  while ((match = pattern.exec(text)) !== null) {
+    const key = match[1]
+    if (key !== undefined && key !== '') keys.add(key)
+  }
+  return [...keys]
+}
+
+/**
+ * 建立投影 key → 包 的索引。
+ * @param nodeModulesRoot - profile 的 node_modules 根。
+ * @returns 归属记录（同一 key 多包命中时保留首个并排序稳定）。
+ */
+export function buildProjectionOwnerIndex(nodeModulesRoot: string): ProjectionOwner[] {
+  const records: ProjectionOwner[] = []
+  const seen = new Set<string>()
+  for (const pack of candidatePackages(nodeModulesRoot)) {
+    const lib = join(pack.dir, 'lib')
+    let entries: string[] = []
+    try {
+      if (!statSync(lib).isDirectory()) continue
+      entries = readdirSync(lib).filter(name => name.endsWith('.js'))
+    } catch {
+      continue
+    }
+    for (const name of entries) {
+      const file = join(lib, name)
+      for (const key of keysInFile(file)) {
+        if (seen.has(key)) continue
+        seen.add(key)
+        records.push({
+          key,
+          package: pack.name,
+          kind: pack.name.startsWith('@deepseek-ai/') ? 'core' : 'plugin',
+          entry: `${pack.name}/lib/${name}`,
+        })
+      }
+    }
+  }
+  return records.sort((left, right) => left.key.localeCompare(right.key))
+}
+
+/** 索引查询器。 */
+export function createAttributor(index: readonly ProjectionOwner[]): (projection: string) => GateAttribution | undefined {
+  const byKey = new Map(index.map(record => [record.key, record]))
+  return (projection: string) => {
+    const owner = byKey.get(projection)
+    if (owner === undefined) return { projection, package: 'unknown' }
+    return { projection, package: owner.package }
+  }
+}

package/src/host/health/gates.ts

@@ -16,6 +16,7 @@ import {
   type SessionPriority,
 } from './generation.ts'
 import { firstLosslessViolation, type LosslessViolation } from './lossless.ts'
+import { gateSourceKind, readSourceKindFacts } from './source-kind.ts'
 
 /**
  * gate 严重级。
@@ -45,7 +46,7 @@ export interface GateAttribution {
 
 /** 一个 gate 的结果。 */
 export interface GateResult {
-  id: 'generation' | 'log-integrity' | 'projection-cache' | 'lossless-json' | 'cold-read'
+  id: 'generation' | 'log-integrity' | 'projection-cache' | 'lossless-json' | 'cold-read' | 'source-kind'
   level: GateLevel
   evidence: string
   attribution?: GateAttribution
@@ -402,6 +403,8 @@ export function buildSessionReport(context: GateContext): SessionHealthReport {
     gates.push(gateProjectionCache(readProjectionCache(context.sessionId, tail.lastSeq, context.dshHome)))
     gates.push(gateLosslessJson(context.projectionState, context.attribute))
     gates.push(gateColdRead(tail))
+    // 署名格式门：v4 线要求 producer-owned source kind（详见 source-kind.ts 的版本依赖表）。
+    gates.push(gateSourceKind(readSourceKindFacts(log)))
   }
   // 总判聚合：fail > warn > ok。`skipped` 有意不参与——它是「本门无从判定」的
   // 中性档，既非通过也非异常，抬升总判会把冷态会话全变成「注意」（实测噪声源）。

package/src/host/health/lossless.ts

@@ -1,128 +1,128 @@
-/**
- * 无损 JSON 判定 —— 本次事故的核心 gate 判据。
- *
- * 判定口径与宿主 `@deepseek-ai/dsh-util-values` 的 `isJsonValue` 一致：
- * 普通（或 null）原型的对象、可枚举的字符串键、有限数（含拒绝 -0）、非稀疏数组、
- * 无环；undefined / NaN / ±Infinity / 函数 / Symbol / BigInt 一律视为不可无损序列化。
- *
- * 通过宿主 `assertJsonArgs` / 投影缓存写入的数据都会先过这道口径，所以投影**状态**
- * 一旦含上述值，`api-session/added` 推送与检查点写入都会失败（症状错位的根因）。
- */
-
-/** 首个违规点位。 */
-export interface LosslessViolation {
-  /** 到违规值的属性路径，例如 `.activeStep.lastSettled.actualTokens`。 */
-  path: string
-  /** 违规原因的可读描述。 */
-  reason:
-    | 'undefined'
-    | 'NaN'
-    | 'Infinity'
-    | '-Infinity'
-    | '-0'
-    | 'function'
-    | 'symbol'
-    | 'bigint'
-    | 'sparse-array-hole'
-    | 'non-plain-prototype'
-    | 'non-enumerable-or-symbol-key'
-    | 'cycle'
-  /** 违规处的实际类型（便于人工核对）。 */
-  actual: string
-}
-
-/** 单个值是否可无损 JSON 序列化。 */
-export function isLossless(value: unknown): boolean {
-  return firstLosslessViolation(value) === undefined
-}
-
-/** 判定一个普通对象是否「普通原型」（Object.prototype 或 null）。 */
-function isPlainObjectPrototype(value: object): boolean {
-  const prototype = Object.getPrototypeOf(value) as object | null
-  return prototype === null || prototype === Object.prototype
-}
-
-/**
- * 找出第一个破坏无损 JSON 的值；全部合规时返回 undefined。
- * @param value - 待判定的值（通常是投影状态）。
- * @param limit - 最多访问的节点数（防御超大对象）。
- * @returns 首个违规点位或 undefined。
- */
-export function firstLosslessViolation(value: unknown, limit = 200_000): LosslessViolation | undefined {
-  const ancestors = new Set<object>()
-  const stack: { node: unknown; path: string; leave?: boolean }[] = [{ node: value, path: '' }]
-  let visited = 0
-  while (stack.length > 0) {
-    const task = stack.pop()
-    if (task === undefined) break
-    if (task.leave === true) {
-      ancestors.delete(task.node as object)
-      continue
-    }
-    if (visited >= limit) return { path: task.path, reason: 'cycle', actual: `node-limit(${limit})` }
-    visited += 1
-    const node = task.node
-    if (node === undefined) return { path: task.path, reason: 'undefined', actual: 'undefined' }
-    if (node === null) continue
-    switch (typeof node) {
-      case 'boolean':
-      case 'string':
-        continue
-      case 'number':
-        if (Number.isNaN(node)) return { path: task.path, reason: 'NaN', actual: 'NaN' }
-        if (node === Infinity) return { path: task.path, reason: 'Infinity', actual: 'Infinity' }
-        if (node === -Infinity) return { path: task.path, reason: '-Infinity', actual: '-Infinity' }
-        if (Object.is(node, -0)) return { path: task.path, reason: '-0', actual: '-0' }
-        continue
-      case 'function':
-        return { path: task.path, reason: 'function', actual: 'function' }
-      case 'symbol':
-        return { path: task.path, reason: 'symbol', actual: 'symbol' }
-      case 'bigint':
-        return { path: task.path, reason: 'bigint', actual: 'bigint' }
-      default:
-        break
-    }
-    const object = node as object
-    if (ancestors.has(object)) return { path: task.path, reason: 'cycle', actual: 'object-cycle' }
-    if (Array.isArray(object)) {
-      if (!isPlainArray(object)) return { path: task.path, reason: 'non-plain-prototype', actual: 'array-subclass' }
-      // 先按升序找出最低位的洞（报告口径确定），再倒序入栈以获得左→右的访问顺序。
-      for (let index = 0; index < object.length; index += 1) {
-        if (!Object.prototype.hasOwnProperty.call(object, index)) {
-          return { path: `${task.path}[${index}]`, reason: 'sparse-array-hole', actual: 'hole' }
-        }
-      }
-      ancestors.add(object)
-      stack.push({ node: object, path: task.path, leave: true })
-      for (let index = object.length - 1; index >= 0; index -= 1) {
-        stack.push({ node: object[index], path: `${task.path}[${index}]` })
-      }
-      continue
-    }
-    if (!isPlainObjectPrototype(object)) {
-      const name = (object as { constructor?: { name?: string } }).constructor?.name ?? 'unknown'
-      return { path: task.path, reason: 'non-plain-prototype', actual: name }
-    }
-    const keys = Reflect.ownKeys(object)
-    for (const key of keys) {
-      if (typeof key !== 'string' || !Object.prototype.propertyIsEnumerable.call(object, key)) {
-        return { path: `${task.path}.${String(key)}`, reason: 'non-enumerable-or-symbol-key', actual: typeof key }
-      }
-    }
-    ancestors.add(object)
-    stack.push({ node: object, path: task.path, leave: true })
-    for (let index = keys.length - 1; index >= 0; index -= 1) {
-      const key = keys[index]
-      if (key === undefined || typeof key !== 'string') continue
-      stack.push({ node: (object as Record<string, unknown>)[key], path: `${task.path}.${key}` })
-    }
-  }
-  return undefined
-}
-
-/** 数组是否为普通数组（排除子类）。 */
-function isPlainArray(value: readonly unknown[]): boolean {
-  const prototype = Object.getPrototypeOf(value) as object | null
-  return prototype === null || prototype === Array.prototype
-}
+/**
+ * 无损 JSON 判定 —— 本次事故的核心 gate 判据。
+ *
+ * 判定口径与宿主 `@deepseek-ai/dsh-util-values` 的 `isJsonValue` 一致：
+ * 普通（或 null）原型的对象、可枚举的字符串键、有限数（含拒绝 -0）、非稀疏数组、
+ * 无环；undefined / NaN / ±Infinity / 函数 / Symbol / BigInt 一律视为不可无损序列化。
+ *
+ * 通过宿主 `assertJsonArgs` / 投影缓存写入的数据都会先过这道口径，所以投影**状态**
+ * 一旦含上述值，`api-session/added` 推送与检查点写入都会失败（症状错位的根因）。
+ */
+
+/** 首个违规点位。 */
+export interface LosslessViolation {
+  /** 到违规值的属性路径，例如 `.activeStep.lastSettled.actualTokens`。 */
+  path: string
+  /** 违规原因的可读描述。 */
+  reason:
+    | 'undefined'
+    | 'NaN'
+    | 'Infinity'
+    | '-Infinity'
+    | '-0'
+    | 'function'
+    | 'symbol'
+    | 'bigint'
+    | 'sparse-array-hole'
+    | 'non-plain-prototype'
+    | 'non-enumerable-or-symbol-key'
+    | 'cycle'
+  /** 违规处的实际类型（便于人工核对）。 */
+  actual: string
+}
+
+/** 单个值是否可无损 JSON 序列化。 */
+export function isLossless(value: unknown): boolean {
+  return firstLosslessViolation(value) === undefined
+}
+
+/** 判定一个普通对象是否「普通原型」（Object.prototype 或 null）。 */
+function isPlainObjectPrototype(value: object): boolean {
+  const prototype = Object.getPrototypeOf(value) as object | null
+  return prototype === null || prototype === Object.prototype
+}
+
+/**
+ * 找出第一个破坏无损 JSON 的值；全部合规时返回 undefined。
+ * @param value - 待判定的值（通常是投影状态）。
+ * @param limit - 最多访问的节点数（防御超大对象）。
+ * @returns 首个违规点位或 undefined。
+ */
+export function firstLosslessViolation(value: unknown, limit = 200_000): LosslessViolation | undefined {
+  const ancestors = new Set<object>()
+  const stack: { node: unknown; path: string; leave?: boolean }[] = [{ node: value, path: '' }]
+  let visited = 0
+  while (stack.length > 0) {
+    const task = stack.pop()
+    if (task === undefined) break
+    if (task.leave === true) {
+      ancestors.delete(task.node as object)
+      continue
+    }
+    if (visited >= limit) return { path: task.path, reason: 'cycle', actual: `node-limit(${limit})` }
+    visited += 1
+    const node = task.node
+    if (node === undefined) return { path: task.path, reason: 'undefined', actual: 'undefined' }
+    if (node === null) continue
+    switch (typeof node) {
+      case 'boolean':
+      case 'string':
+        continue
+      case 'number':
+        if (Number.isNaN(node)) return { path: task.path, reason: 'NaN', actual: 'NaN' }
+        if (node === Infinity) return { path: task.path, reason: 'Infinity', actual: 'Infinity' }
+        if (node === -Infinity) return { path: task.path, reason: '-Infinity', actual: '-Infinity' }
+        if (Object.is(node, -0)) return { path: task.path, reason: '-0', actual: '-0' }
+        continue
+      case 'function':
+        return { path: task.path, reason: 'function', actual: 'function' }
+      case 'symbol':
+        return { path: task.path, reason: 'symbol', actual: 'symbol' }
+      case 'bigint':
+        return { path: task.path, reason: 'bigint', actual: 'bigint' }
+      default:
+        break
+    }
+    const object = node as object
+    if (ancestors.has(object)) return { path: task.path, reason: 'cycle', actual: 'object-cycle' }
+    if (Array.isArray(object)) {
+      if (!isPlainArray(object)) return { path: task.path, reason: 'non-plain-prototype', actual: 'array-subclass' }
+      // 先按升序找出最低位的洞（报告口径确定），再倒序入栈以获得左→右的访问顺序。
+      for (let index = 0; index < object.length; index += 1) {
+        if (!Object.prototype.hasOwnProperty.call(object, index)) {
+          return { path: `${task.path}[${index}]`, reason: 'sparse-array-hole', actual: 'hole' }
+        }
+      }
+      ancestors.add(object)
+      stack.push({ node: object, path: task.path, leave: true })
+      for (let index = object.length - 1; index >= 0; index -= 1) {
+        stack.push({ node: object[index], path: `${task.path}[${index}]` })
+      }
+      continue
+    }
+    if (!isPlainObjectPrototype(object)) {
+      const name = (object as { constructor?: { name?: string } }).constructor?.name ?? 'unknown'
+      return { path: task.path, reason: 'non-plain-prototype', actual: name }
+    }
+    const keys = Reflect.ownKeys(object)
+    for (const key of keys) {
+      if (typeof key !== 'string' || !Object.prototype.propertyIsEnumerable.call(object, key)) {
+        return { path: `${task.path}.${String(key)}`, reason: 'non-enumerable-or-symbol-key', actual: typeof key }
+      }
+    }
+    ancestors.add(object)
+    stack.push({ node: object, path: task.path, leave: true })
+    for (let index = keys.length - 1; index >= 0; index -= 1) {
+      const key = keys[index]
+      if (key === undefined || typeof key !== 'string') continue
+      stack.push({ node: (object as Record<string, unknown>)[key], path: `${task.path}.${key}` })
+    }
+  }
+  return undefined
+}
+
+/** 数组是否为普通数组（排除子类）。 */
+function isPlainArray(value: readonly unknown[]): boolean {
+  const prototype = Object.getPrototypeOf(value) as object | null
+  return prototype === null || prototype === Array.prototype
+}