solopup-memory 0.21.0-beta.2 → 0.22.0-beta.3

package/privacy.mjs

@@ -0,0 +1,25 @@
+/** Conservative exposure reduction, not a confidentiality boundary or exhaustive PII detector. */
+import {normalizeText} from './security.mjs'
+const patterns = [
+  ['exact-dob', /生日|出生(?:日期|年月|于|在)?|\bbirth(?:day|date)\b|\bdate\s+of\s+birth\b|\bdob\b|\bborn\b/i],
+  ['personal-profile', /个人档案|性别|男性|女性|\bpersonal\s+profile\b|\bgender\b/i],
+  ['health', /病史|医疗诊断|疾病诊断|医生诊断|诊断(?:为|出)|用药|过敏|怀孕|月经|健康状况|医疗资料|\bmedical\b|\bclinical\s+diagnosis\b|\bdiagnosed\s+with\b|\bmedication\b/i],
+  ['intimate', /亲密关系|性取向|性生活|性行为|伴侣|男朋友|女朋友|前任|恋爱|情人|\bsexual\b|\bintimate\b|\bromantic\b/i],
+  ['personal-contact', /身份证|护照号码|家庭住址|私人电话|银行卡号|\bpassport\s+number\b|\bhome\s+address\b/i],
+  ['marked-private', /\[private(?::[a-z-]+)?\]|保密资料|私密档案|敏感个人/i],
+]
+
+export function memoryPrivacy(value, line = '') {
+  const content = typeof value === 'string' ? value : value && typeof value === 'object'
+    ? [value.summary, value.detail, value.indexLine, JSON.stringify(value.meaning ?? {}),
+      ...(value.evidence ?? []).map(e => e.quote), JSON.stringify(value.fieldLineage ?? {})].filter(Boolean).join('\n') : ''
+  const text = normalizeText(content + '\n' + line)
+  const categories = patterns.filter(([, pattern]) => pattern.test(text)).map(([category]) => category)
+  return {exposure: categories.length ? 'on-demand' : 'automatic', categories}
+}
+export const privateMemory = (value, line = '') => memoryPrivacy(value, line).exposure === 'on-demand'
+export function publicMemoryRecords(records) { return records.filter(record => !privateMemory(record)) }
+export function publicMemoryIndex(lines, records) {
+  return lines.filter(line => !privateMemory(records.find(record => record.indexLine === line || line.endsWith(' ' + record.indexLine)), line))
+}
+export const PRIVATE_MEMORY_NOTICE = '个人资料可能按需保存在本地；未自动提供其内容。仅在用户询问相关资料时使用 memory_search 并明确 includePrivate=true。读取结果仍会进入当前会话及模型请求；这不是加密或文件访问隔离。'

package/scripts/demo-source-recall.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+/**
+ * Offline, synthetic mechanics demonstration. Production tool handlers run in a
+ * scripted host, with a scripted validation response, NOT DSH or a real model.
+ * Each phase uses a separate Node process; no old conversation is replayed.
+ * Run without arguments for six output lines, or --json for the full receipt.
+ */
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { basename, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { apply } from '../index.mjs'
+import { scriptedNativeValidationLlm } from '../fixture-host.mjs'
+import { VERSION } from '../version.mjs'
+import { probeEnvironment } from './probe-env.mjs'
+
+const script = fileURLToPath(import.meta.url)
+const quote = '记住：本项目的交付说明统一用中文。'
+const summary = '本项目的交付说明统一用中文'
+const query = '交付说明'
+const sourceSession = 'synthetic-demo-write'
+
+async function phase(name, root) {
+  // The internal phase runner refuses a non-demo home, including a user's home.
+  assert.equal(realpathSync(tmpdir()), join(realpathSync(root), 'tmp'))
+  assert.match(basename(root), /^solopup-readme-demo-/)
+  assert.equal(process.env.DSH_HOME, join(root, 'home'))
+  assert.ok(['write', 'recall', 'other-project'].includes(name))
+  const handlers = [], tools = [], disposers = []
+  const session = { id: name === 'write' ? sourceSession : `synthetic-demo-${name}` }
+  const agent = { session, options: { provider: 'scripted-demo', model: 'scripted-demo' } }
+  let validationCalls = 0
+  const scripted = scriptedNativeValidationLlm()
+  const ctx = {
+    llm: { async prepareCall(config) { validationCalls++; return scripted.prepareCall(config) } },
+    systemPrompt: { context() {} },
+    workingDirectory: { get: () => join(root, name === 'other-project' ? 'project-b' : 'project-a') },
+    tools: { register: tool => tools.push(tool) },
+    on: (event, handler) => handlers.push([event, handler]),
+    effect: fn => { const dispose = fn(); if (typeof dispose === 'function') disposers.push(dispose) },
+  }
+  const emit = (event, ...args) => {
+    for (const [registered, handler] of handlers) if (registered === event) handler(...args)
+  }
+  apply(ctx, { autoCapture: { enabled: false, timeoutMs: 2000 } })
+  try {
+    if (name === 'write') {
+      const message = { id: 'synthetic-owner-message', role: 'user', source: { kind: 'user' }, content: [{ type: 'text', text: quote }] }
+      emit('agent/pre-step', { agent, turn: 1, step: 1, messages: [message] }, () => {})
+      emit('session/event', session, { type: 'user/message', seq: 1, data: message })
+      const args = { type: 'project', scope: 'project', summary, meaning: { kind: 'decision' } }
+      const callId = 'synthetic-demo-write-call'
+      emit('session/event', session, { type: 'tool/call', seq: 2, data: { callId, name: 'memory_write', arguments: JSON.stringify(args), turn: 1, step: 1 } })
+      const result = await tools.find(t => t.name === 'memory_write').execute(args, { agent, callId })
+      assert.equal(result.status, 'recorded')
+      assert.equal(validationCalls, 1)
+      return { sessionId: session.id, ownerMessage: quote, args, result, scriptedValidationCalls: validationCalls }
+    }
+    // No user-message events or old history are provided to these new processes.
+    const search = tools.find(t => t.name === 'memory_search')
+    const args = { query, mode: 'exact' }
+    const current = await search.execute(args, { agent })
+    const history = await search.execute({ ...args, view: 'history' }, { agent })
+    assert.equal(validationCalls, 0)
+    if (name === 'recall') {
+      assert.equal(current.hits.length, 1)
+      assert.equal(current.hits[0].scope, 'project')
+      assert.ok(current.hits[0].text.includes(summary))
+      assert.equal(history.hits.length, 1)
+      assert.equal(history.hits[0].history.sourceSessionId, sourceSession)
+      assert.deepEqual(history.hits[0].history.sourceMessageIds, [`${sourceSession}:1`])
+      assert.ok(history.hits[0].text.includes(quote))
+    } else {
+      assert.equal(current.hits.length, 0)
+      assert.equal(history.hits.length, 0)
+    }
+    return { sessionId: session.id, inheritedMessages: 0, args, current, history, scriptedValidationCalls: validationCalls }
+  } finally {
+    for (const dispose of disposers) dispose()
+  }
+}
+
+if (process.argv[2] === '--phase' && process.argv.length === 5) {
+  console.log(JSON.stringify(await phase(process.argv[3], process.argv[4])))
+} else {
+  assert.ok(process.argv.length === 2 || process.argv.length === 3 && process.argv[2] === '--json', 'usage: node scripts/demo-source-recall.mjs [--json]')
+  const root = realpathSync(mkdtempSync(join(tmpdir(), 'solopup-readme-demo-')))
+  const env = probeEnvironment(root)
+  for (const dir of [env.HOME, env.TMPDIR, join(root, 'project-a'), join(root, 'project-b')]) mkdirSync(dir)
+  for (const project of ['project-a', 'project-b']) writeFileSync(join(root, project, '.dsh-root'), '')
+  try {
+    const phases = {}
+    for (const name of ['write', 'recall', 'other-project']) {
+      const child = spawnSync(process.execPath, [script, '--phase', name, root], { env, encoding: 'utf8', timeout: 30000 })
+      assert.equal(child.status, 0, `demo ${name} failed: ${child.stderr}`)
+      phases[name] = JSON.parse(child.stdout)
+    }
+    const lines = [
+      `synthetic user: ${quote}`,
+      `memory_write: ${phases.write.result.status} (scope=project, meaning=decision)`,
+      `fresh process / memory_search("${query}"): ${phases.recall.current.hits.length} hit (scope=${phases.recall.current.hits[0].scope})`,
+      `current text: ${phases.recall.current.hits[0].text}`,
+      `history source: ${phases.recall.history.hits[0].history.sourceMessageIds.join(', ')}; quote: ${quote}`,
+      `other project / current + history: ${phases['other-project'].current.hits.length} + ${phases['other-project'].history.hits.length} hits`,
+    ]
+    const report = {
+      kind: 'synthetic-scripted-host-mechanics',
+      at: new Date().toISOString(), version: VERSION,
+      scriptSha256: createHash('sha256').update(readFileSync(script)).digest('hex'),
+      environment: { platform: process.platform, arch: process.arch, node: process.version },
+      realDshHost: false, realModel: false, networkRequests: 0,
+      isolatedTemporaryHome: true, separateProcesses: 3,
+      limitations: 'Scripted validator approves this synthetic candidate. This verifies persistence, source return and project filtering only, not model judgment, real DSH schema registration, or natural fresh-chat recall.',
+      lines, phases,
+    }
+    console.log(process.argv[2] === '--json' ? JSON.stringify(report, null, 2) : lines.join('\n'))
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+}

package/scripts/detect.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * 记忆层检测 CLI（L0 不变量层）。只读，不调用模型。
+ *
+ *   node scripts/detect.mjs                 # 检查 ~/.dsh/memory
+ *   node scripts/detect.mjs --root DIR      # 指定记忆根
+ *   node scripts/detect.mjs --json          # 机器可读
+ *   node scripts/detect.mjs --check         # 有 error 则退出码 1（CI 门禁）
+ *   node scripts/detect.mjs --verbose       # 连 info 一起打印
+ */
+
+import { homedir } from 'node:os'
+import { existsSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+import { detectRoot } from '../detect.mjs'
+
+const argv = process.argv.slice(2)
+const flag = (name) => argv.includes(name)
+const option = (name) => {
+  const at = argv.indexOf(name)
+  return at >= 0 ? argv[at + 1] : undefined
+}
+
+const root = resolve(option('--root') ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'memory'))
+if (!existsSync(root)) {
+  console.error(`[detect] 记忆根不存在：${root}`)
+  process.exit(2)
+}
+
+const report = detectRoot(root)
+if (flag('--json')) {
+  process.stdout.write(JSON.stringify(report, null, 2) + '\n')
+} else {
+  const lines = []
+  lines.push(`SoloPup 记忆检测 v${report.version} · ${report.generatedAt}`)
+  lines.push(`根目录：${report.root}`)
+  lines.push(`总计：error ${report.summary.errors} · warning ${report.summary.warnings} · info ${report.summary.infos}`)
+  for (const store of report.stores) {
+    const label = store.scope === 'global' ? 'global' : 'project'
+    const metrics = store.metrics
+    lines.push('')
+    lines.push(`== ${label}：${store.dir}`)
+    if (metrics) {
+      lines.push(
+        `   索引 ${metrics.indexLines}/${metrics.limitLines} 行、${metrics.indexBytes}/${metrics.limitBytes} 字节；` +
+          `有效记录 ${metrics.activeRecords}、待审 ${metrics.pendingRecords}、过期行 ${metrics.expiredIndexLines}；` +
+          `库占用 ${(metrics.storeBytes / 1024).toFixed(1)}K/${metrics.storeLimitBytes / 1024}K`,
+      )
+    }
+    if (store.findings.length === 0) {
+      lines.push('   [ok] 未发现问题（“未发现”不等于“没有问题”，语义质量见 L2）')
+      continue
+    }
+    for (const finding of store.findings) {
+      if (finding.severity === 'info' && !flag('--verbose')) continue
+      const refs = (finding.refs ?? []).map((item) => (item.line === undefined ? item.file : `${item.file}:${item.line}`)).join(' ')
+      lines.push(`   [${finding.severity}] ${finding.id} ${finding.message}${refs ? ` (${refs})` : ''}`)
+      if (finding.fixHint && flag('--verbose')) lines.push(`          修复：${finding.fixHint}`)
+    }
+  }
+  for (const finding of report.crossFindings) {
+    if (finding.severity === 'info' && !flag('--verbose')) continue
+    lines.push(`   [${finding.severity}] ${finding.id} ${finding.message}`)
+  }
+  process.stdout.write(lines.join('\n') + '\n')
+}
+
+if (flag('--check') && report.summary.errors > 0) process.exit(1)

package/scripts/dream.mjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * 做梦 P0：只读的 op 计划生成器（影子报告）。
+ *
+ * 它读 L0 检测 findings 与 L3 遥测，把“该整理什么”写成可审计的 op 列表，
+ * **不写任何文件、不调用模型、不 apply**。真正的应用在 P1 之后，必须人工确认。
+ *
+ *   node scripts/dream.mjs                # 人类可读
+ *   node scripts/dream.mjs --json         # 机器可读
+ *   node scripts/dream.mjs --check        # 有 high 风险 op 时退出码 1
+ */
+
+import { createHash } from 'node:crypto'
+import { homedir } from 'node:os'
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+import { detectRoot, detectStore } from '../detect.mjs'
+import { pruneStore } from '../index.mjs'
+import { collect as collectTelemetry } from './telemetry.mjs'
+
+const KIND_BY_FINDING = {
+  'I3-record-missing-from-index': { kind: 'align-projection', risk: 'auto', why: '账本有效记录没有投影到索引' },
+  'I3-detail-topic-missing': { kind: 'align-projection', risk: 'auto', why: '记录正文文件缺失' },
+  'I3-detail-mismatch': { kind: 'align-projection', risk: 'auto', why: '正文与账本不一致' },
+  'I2-missing-topic-file': { kind: 'repair-reference', risk: 'auto', why: '索引指向不存在的主题文件' },
+  'I2-missing-anchor': { kind: 'repair-reference', risk: 'auto', why: '索引锚点在主题文件里找不到' },
+  'I5-withdrawal-residue': { kind: 'republish-withdrawal', risk: 'auto', why: '撤回没有传播到索引' },
+  'I6-duplicate-line': { kind: 'merge-duplicate', risk: 'human', why: '完全重复的索引行' },
+  'I6-near-duplicate': { kind: 'merge-duplicate', risk: 'human', why: '相似度 ≥0.9 的近重复' },
+  'I7-conflict': { kind: 'arbitrate-conflict', risk: 'human', why: '同一属性并存多个取值' },
+  'I8-budget-lines': { kind: 'compact-index', risk: 'auto', why: '索引行数超限' },
+  'I8-budget-bytes': { kind: 'compact-index', risk: 'auto', why: '索引字节超限' },
+  'I8-budget-store': { kind: 'compact-index', risk: 'auto', why: '库占用超限' },
+  'I10-version-mention': { kind: 'review-stale', risk: 'human', why: '记忆提到与当前版本不同的版本号' },
+  'I14-truncated-paragraph': { kind: 'repair-topic-truncation', risk: 'human', why: '主题段落像被截断' },
+  'I15-heading-without-index': { kind: 'link-heading', risk: 'auto', why: '标题没有索引指向' },
+}
+
+function opId(store, kind, evidence) {
+  return createHash('sha256').update(`${store}|${kind}|${evidence.join(',')}`).digest('hex').slice(0, 12)
+}
+
+export function planDream(root) {
+  const detection = detectRoot(root)
+  const telemetry = collectTelemetry(root)
+  const ops = []
+  for (const store of detection.stores) {
+    const storeName = store.dir === root ? 'global' : store.dir
+    for (const finding of store.findings) {
+      const mapping = KIND_BY_FINDING[finding.id]
+      if (mapping === undefined) continue
+      const evidence = [`${store.scope}:${finding.id}`, ...(finding.refs ?? []).map((ref) => `${ref.file}${ref.line === undefined ? '' : ':' + ref.line}`)]
+      ops.push({
+        opId: opId(storeName, mapping.kind, evidence),
+        kind: mapping.kind,
+        risk: mapping.risk,
+        store: storeName,
+        why: mapping.why,
+        evidence,
+      })
+    }
+  }
+  for (const finding of detection.crossFindings) {
+    if (finding.id !== 'X2-duplicate-store') continue
+    ops.push({
+      opId: opId('root', 'dedupe-store', [finding.message]),
+      kind: 'dedupe-store',
+      risk: 'human',
+      store: 'root',
+      why: '内容完全相同的库（遗留副本）',
+      evidence: [finding.id, finding.message],
+    })
+  }
+  for (const warning of telemetry.warnings) {
+    if (!['T1-low-capture-success', 'T2-zero-output', 'T3-short-sessions'].includes(warning.id)) continue
+    ops.push({
+      opId: opId('root', 'inspect-capture', [warning.id]),
+      kind: 'inspect-capture',
+      risk: 'human',
+      store: 'root',
+      why: warning.message,
+      evidence: [warning.id],
+    })
+  }
+  const summary = {
+    total: ops.length,
+    auto: ops.filter((op) => op.risk === 'auto').length,
+    human: ops.filter((op) => op.risk === 'human').length,
+    byKind: Object.fromEntries([...new Set(ops.map((op) => op.kind))].sort().map((kind) => [kind, ops.filter((op) => op.kind === kind).length])),
+  }
+  return {
+    kind: 'dream-plan',
+    phase: 'P0-shadow',
+    readOnly: true,
+    applySupported: false,
+    modelCalls: 0,
+    generatedAt: new Date().toISOString(),
+    root,
+    summary,
+    ops,
+    detectionSummary: detection.summary,
+    telemetrySummary: { capture: telemetry.capture, output: telemetry.output, warnings: telemetry.warnings.length },
+  }
+}
+
+/** P1 只自动执行确定性与可回滚的整理；其余 op 明确留给人工。 */
+const AUTO_KINDS = new Set(['compact-index'])
+
+export function planHash(plan) {
+  return createHash('sha256')
+    .update(JSON.stringify({ root: plan.root, ops: plan.ops.map((op) => ({ opId: op.opId, kind: op.kind, store: op.store, evidence: op.evidence })) }))
+    .digest('hex')
+}
+
+function storeDir(root, store) {
+  return store === 'global' ? root : store
+}
+
+function backupStore(root, dir, stamp) {
+  const target = join(root, '.dream', 'backups', stamp, dir === root ? 'global' : dir.slice(dir.lastIndexOf('/') + 1))
+  mkdirSync(target, { recursive: true })
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isFile() || entry.name.startsWith('.')) continue
+    copyFileSync(join(dir, entry.name), join(target, entry.name))
+  }
+  return target
+}
+
+export function applyDream(plan, reviewed) {
+  if (reviewed !== planHash(plan)) throw new Error('dream-review-hash-mismatch')
+  const applyOps = plan.ops.filter((op) => AUTO_KINDS.has(op.kind))
+  const skipped = plan.ops.filter((op) => !AUTO_KINDS.has(op.kind)).map((op) => ({ opId: op.opId, kind: op.kind, reason: 'needs-human' }))
+  if (applyOps.length === 0) return { applied: 0, skipped, results: [], backup: null }
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-')
+  const dirs = [...new Set(applyOps.map((op) => storeDir(plan.root, op.store)))]
+  const before = dirs.map((dir) => detectStore(dir, { scope: dir === plan.root ? 'global' : 'project' }))
+  const backup = {}
+  for (const dir of dirs) backup[dir] = backupStore(plan.root, dir, stamp)
+  const results = []
+  for (const dir of dirs) {
+    const result = pruneStore(dir, { apply: true })
+    results.push({ dir, before: result.before, after: result.after, removed: result.removed, archived: result.archived })
+  }
+  const verification = dirs.map((dir, index) => {
+    const after = detectStore(dir, { scope: dir === plan.root ? 'global' : 'project' })
+    return { dir, errorsBefore: before[index].summary.errors, errorsAfter: after.summary.errors, ok: after.summary.errors <= before[index].summary.errors }
+  })
+  const applied = results.reduce((sum, row) => sum + (row.removed.expired + row.removed.duplicate + row.removed.overCap > 0 ? 1 : 0), 0)
+  return { applied: results.length, skipped, results, backup, verification }
+}
+
+if (process.argv[1] !== undefined && import.meta.url === `file://${process.argv[1]}`) {
+  const argv = process.argv.slice(2)
+  const option = (name) => {
+    const at = argv.indexOf(name)
+    return at >= 0 ? argv[at + 1] : undefined
+  }
+  const root = resolve(option('--root') ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'memory'))
+  if (!existsSync(root)) {
+    console.error(`[dream] 记忆根不存在：${root}`)
+    process.exit(2)
+  }
+  const plan = planDream(root)
+  if (argv.includes('--apply')) {
+    const reviewed = option('--reviewed')
+    if (reviewed === undefined) {
+      console.error('[dream] --apply 需要 --reviewed <planHash>；先看 `--json` 输出的完整计划')
+      process.exit(2)
+    }
+    let result
+    try {
+      result = applyDream(plan, reviewed)
+    } catch (error) {
+      console.error(`[dream] 应用失败：${error.message}`)
+      process.exit(2)
+    }
+    if (argv.includes('--json')) process.stdout.write(JSON.stringify({ planHash: planHash(plan), ...result }, null, 2) + '\n')
+    else {
+      const lines = [
+        `做梦 P1 应用 · ${new Date().toISOString()}`,
+        `planHash：${planHash(plan)}`,
+        `执行 ${result.applied} 个自动 op；跳过 ${result.skipped.length} 个（需人工）。`,
+      ]
+      for (const row of result.results) lines.push(`  ${row.dir}：${row.before.lines} → ${row.after.lines} 行，remove expired ${row.removed.expired} / duplicate ${row.removed.duplicate} / overCap ${row.removed.overCap}`)
+      for (const row of result.verification ?? []) lines.push(`  验证 ${row.dir}：error ${row.errorsBefore} → ${row.errorsAfter} ${row.ok ? 'OK' : '恶化，请用备份回滚'}`)
+      if (result.backup !== null) lines.push(`  备份：${Object.values(result.backup).join('、')}`)
+      process.stdout.write(lines.join('\n') + '\n')
+    }
+    process.exit((result.verification ?? []).every((row) => row.ok) ? 0 : 1)
+  }
+  if (argv.includes('--json')) process.stdout.write(JSON.stringify(plan, null, 2) + '\n')
+  else {
+    const lines = [
+      `做梦 P0（影子报告，只读）· ${plan.generatedAt}`,
+      `根目录：${plan.root}`,
+      `op 总数 ${plan.summary.total}（自动可执行候选 ${plan.summary.auto}、需人工确认 ${plan.summary.human}）`,
+      `分类：${Object.entries(plan.summary.byKind).map(([kind, count]) => `${kind} ${count}`).join('、') || '无'}`,
+      '边界：不写文件、不调用模型；apply 未实现。',
+    ]
+    for (const op of plan.ops) lines.push(`  [${op.risk}] ${op.kind} · ${op.why}${op.evidence.length ? `（${op.evidence.slice(0, 3).join('；')}）` : ''}`)
+    process.stdout.write(lines.join('\n') + '\n')
+  }
+  if (argv.includes('--check') && plan.summary.human > 0) process.exit(1)
+}

package/scripts/probe-history.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/** Real DSH CLI/Loader, Session and Projection API check. Synthetic input, no model calls. */
+import { spawn } from 'node:child_process'
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, realpathSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { probeEnvironment } from './probe-env.mjs'
+
+const CLI = process.env.DSH_CLI ?? '/Applications/DeepSeek Harness.app/Contents/Resources/runtime/cli/bin/dsh'
+if (!existsSync(CLI)) { console.error('[FAIL] DSH_CLI must identify an installed official host'); process.exit(2) }
+const source = dirname(dirname(fileURLToPath(import.meta.url)))
+const root = realpathSync(mkdtempSync(join(tmpdir(), 'dsh-history-probe-')))
+const env = probeEnvironment(root), profile = join(env.HOME, 'profiles', 'probe')
+mkdirSync(profile, { recursive: true }); mkdirSync(env.TMPDIR)
+const reportFile = join(root, 'result.json'), driver = join(root, 'driver.mjs')
+writeFileSync(driver, `
+import assert from 'node:assert/strict'
+import { readFileSync, writeFileSync } from 'node:fs'
+import * as memory from ${JSON.stringify(pathToFileURL(join(source, 'index.mjs')).href)}
+import { memoryContextProjection, reconcileMemoryContext } from ${JSON.stringify(pathToFileURL(join(source, 'context-history.mjs')).href)}
+export const name = 'solopup-history-probe'
+export const inject = ['sessions', 'sessionProjections', 'systemPrompt', 'workingDirectory', 'tools']
+export async function apply(ctx) {
+  try {
+    const owner = await ctx.plugin(memory, { autoCapture: { enabled: false } })
+    if (typeof owner?.await === 'function') await owner.await()
+    const stamp = JSON.parse(readFileSync(${JSON.stringify(join(env.HOME, 'memory', '.loaded.json'))}, 'utf8'))
+    assert.equal(stamp.memoryHistory.available, true)
+    assert.equal(stamp.tools.length, 6)
+    const key = 'solopup:synthetic-projection-probe'
+    const definition = { ...memoryContextProjection(), key }
+    const register = async () => {
+      const value = await ctx.sessionProjections.register(definition)
+      return typeof value?.stateOf === 'function' ? { ...value, retained: true } : { stateOf: session => ctx.sessionProjections.stateOf(session, key), dispose: value, retained: false }
+    }
+    const handle = await register()
+    const session = ctx.sessions.create('solopup-synthetic-history')
+    const ordinary = { id: 'ordinary', role: 'user', source: { kind: 'user' }, content: [{ type: 'text', text: 'ordinary synthetic quotation remains' }] }
+    session.append('user/message', ordinary, { surfaceOp: 'append' })
+    const sections = [{ name: 'memory:index', text: 'obsolete synthetic memory' }, { name: 'other:context', text: 'keep other provider' }]
+    const old = { id: 'old-context', role: 'user', source: { kind: 'runtime-context', form: 'snapshot', sections }, content: [{ type: 'text', text: 'Current runtime context. This snapshot supersedes earlier runtime-context snapshots.\\n\\n' + sections.map(s => s.text).join('\\n\\n') }] }
+    const event = session.append('user/message', old, { surfaceOp: 'append' })
+    assert.deepEqual(handle.stateOf(session).nodes, [{ id: 'old-context', seq: event.seq }])
+    assert.equal(reconcileMemoryContext(session, handle.stateOf(session), 'current synthetic memory').replaced, 1)
+    assert.deepEqual(session.deriveMessages()[0], ordinary)
+    assert.doesNotMatch(JSON.stringify(session.deriveMessages()), /obsolete synthetic memory/)
+    assert.match(JSON.stringify(session.deriveMessages()), /keep other provider/)
+    assert.deepEqual(handle.stateOf(session).nodes, [])
+    await handle.dispose()
+    // A registration acquired after events exist must reconstruct from the real Session.
+    const replay = await register()
+    assert.deepEqual(replay.stateOf(session).nodes, [])
+    const replayed = ctx.sessions.create('solopup-synthetic-replay', { seed: [{ ...event, seq: 0 }] })
+    assert.equal(replay.stateOf(replayed).nodes.length, 1)
+    await replay.dispose()
+    if (replay.retained) assert.equal(replay.stateOf(replayed).nodes.length, 1, 'retained readers remain usable after owner disposal')
+    await assert.rejects(async () => await ctx.sessionProjections.register({ ...definition, stateVersion: -1 }), /non-negative/)
+    await owner.dispose()
+    writeFileSync(${JSON.stringify(reportFile)}, JSON.stringify({ passed: true, realDshHost: true, realModel: false, cleanHome: true, syntheticInput: true, tools: stamp.tools.length, projectionApi: handle.retained ? 'retained-handle' : 'legacy-registry', historyAvailable: stamp.memoryHistory.available, liveState: true, rewritePreservesOrdinaryAndOtherProvider: true, coldReplay: true, registrationRejected: true, ownerDisposed: true }) + '\\n')
+  } catch (error) {
+    writeFileSync(${JSON.stringify(reportFile)}, JSON.stringify({ passed: false, error: error.stack }) + '\\n')
+  }
+}
+`)
+writeFileSync(join(profile, 'package.json'), JSON.stringify({ name: 'solopup-history-probe', private: true, dependencies: {}, dsh: { profile: { bundles: ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-web-app'] } } }))
+writeFileSync(join(profile, 'cordis.yml'), '[]\n')
+writeFileSync(join(profile, 'cordis.patch.yml'), `- insert:\n    - id: history-probe\n      name: ${JSON.stringify(pathToFileURL(driver).href)}\n`)
+let output = '', child
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+try {
+  child = spawn(CLI, ['--profile', 'probe', '--port', '0', '--no-open'], { env, stdio: ['ignore', 'pipe', 'pipe'] })
+  child.stdout.on('data', chunk => { output += chunk }); child.stderr.on('data', chunk => { output += chunk })
+  let childError
+  child.once('error', error => { childError = error.code })
+  const deadline = Date.now() + 40000
+  while (!existsSync(reportFile) && !childError && child.exitCode === null && Date.now() < deadline) await sleep(100)
+  if (!existsSync(reportFile)) throw Error(`history-probe-host-failed:${childError ?? child.exitCode ?? 'timeout'}\n${output.slice(-6000)}`)
+  const report = JSON.parse(readFileSync(reportFile, 'utf8'))
+  if (!report.passed) throw Error(report.error + '\n' + output.slice(-6000))
+  console.log('[PASS] Real DSH history registration, live state, rewrite, cold replay, rejection and disposal')
+  console.log(JSON.stringify(report))
+} catch (error) {
+  console.error('[FAIL] ' + error.message); process.exitCode = 1
+} finally {
+  if (child && child.exitCode === null && child.signalCode === null) {
+    const stopped = new Promise(resolve => child.once('exit', resolve))
+    child.kill('SIGTERM'); await Promise.race([stopped, sleep(1500)])
+    if (child.exitCode === null && child.signalCode === null) { child.kill('SIGKILL'); await Promise.race([stopped, sleep(1500)]) }
+  }
+  rmSync(root, { recursive: true, force: true })
+}

package/scripts/probe-load.mjs

@@ -84,5 +84,5 @@ if (missing.length > 0) {
   console.error(`[FAIL] 少注册了工具：${missing.join('、')}`)
   process.exit(1)
 }
-if (stamp.sourceControl?.state !== 'managed' || stamp.degraded?.length) { console.error('[FAIL] 工具存在但来源控制未就绪'); process.exit(1) }
+if (stamp.sourceControl?.state !== 'managed' || stamp.degraded?.length || stamp.memoryHistory?.available !== true) { console.error('[FAIL] 工具存在但来源控制未就绪'); process.exit(1) }
 console.log(`[PASS] 隔离实例加载成功：v${stamp.version}，${stamp.tools.length} 个工具，pid ${stamp.pid}`)

package/scripts/probe-package.mjs

@@ -49,6 +49,10 @@ try {
   report.lockContention = testOutput.split('\n').filter((line) => /accepted=40; lock-busy retries=/.test(line))
   if (!Number.isInteger(report.packagedTests) || report.packagedTests < 1) throw new Error('package-probe-test-count-missing')
 
+  const historyOutput = run(process.execPath, ['scripts/probe-history.mjs'], unpacked, { env: { ...cleanEnv, DSH_CLI: CLI } })
+  report.historyContract = JSON.parse(historyOutput.trim().split('\n').at(-1))
+  if (!report.historyContract.passed) throw new Error('package-probe-history-contract-failed')
+
   // Entire profile is authored here; no copy of the user's desktop configuration.
   const home = join(root, 'home'); const profile = join(home, 'profiles', 'clean')
   mkdirSync(profile, { recursive: true })
@@ -71,8 +75,8 @@ try {
   }
   if (!stamp) throw new Error(`package-probe-host-load-failed:${hostError ?? host.exitCode ?? 'timeout'}`)
   const expected = ['memory_write', 'memory_forget', 'memory_links', 'memory_search', 'memory_prune', 'memory_status']
-  if (stamp.version !== pkg.version || expected.some((tool) => !stamp.tools.includes(tool)) || stamp.degraded.length || stamp.sourceControl?.state !== 'managed') throw new Error('package-probe-host-registration-failed')
-  report.hostLoad = { version: stamp.version, node: stamp.node, tools: stamp.tools, cleanHome: true, profileCopied: false, sourceControl: stamp.sourceControl,
+  if (stamp.version !== pkg.version || expected.some((tool) => !stamp.tools.includes(tool)) || stamp.degraded.length || stamp.sourceControl?.state !== 'managed' || stamp.memoryHistory?.available !== true) throw new Error('package-probe-host-registration-failed')
+  report.hostLoad = { version: stamp.version, node: stamp.node, tools: stamp.tools, cleanHome: true, profileCopied: false, sourceControl: stamp.sourceControl, memoryHistory: stamp.memoryHistory,
     environmentAllowlist: Object.keys(cleanEnv).sort(), parentEnvironmentInherited: false }
   const retained = join(home, 'memory', 'MEMORY.md')
   const syntheticMemory = '- [user] 合成验收偏好只用于打包检查 — user.md\n'