@furongjun1999/dsh-memory 0.4.6 → 0.4.7

package/docs/experiments/deja-vu-negcond/analyze.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""对比实验 A 三场景下每组的 rank / score，判定 state 是否动了排序。"""
+import os
+import sys
+import json
+
+sys.stdout.reconfigure(encoding='utf-8')
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+data = json.load(open(os.path.join(HERE, 'result_A.json'), encoding='utf-8'))
+det = data['detail']
+keys = list(det.keys())
+
+print('每行: 组 | (correct_rank, correct_score) | (bait_rank, bait_score) | total')
+print()
+hdr = '%-5s' % 'gid'
+for k in keys:
+    tag = k.split()[0]
+    hdr += ' | %-30s' % tag
+print(hdr)
+
+rank_changed = 0
+score_changed = 0
+for i in range(len(det[keys[0]])):
+    line = '%-5s' % det[keys[0]][i][0]
+    cells = []
+    for k in keys:
+        row = det[k][i]
+        cells.append('c=%s/%.3f b=%s/%.3f t=%s' % (row[1], row[3], row[2], row[4], row[5]))
+    print(line + ' | ' + ' | '.join('%-30s' % c for c in cells))
+
+print()
+# 量化：S_AR 相对 S_AA 的变化（bait 的 state 从 accepted→rejected）
+print('--- 变化统计 ---')
+for pair in ((0, 1), (0, 2)):
+    a, b = keys[pair[0]], keys[pair[1]]
+    dr = ds = 0
+    for i in range(len(det[a])):
+        if det[a][i][1] != det[b][i][1] or det[a][i][2] != det[b][i][2]:
+            dr += 1
+        if abs(det[a][i][3] - det[b][i][3]) > 1e-6 or abs(det[a][i][4] - det[b][i][4]) > 1e-6:
+            ds += 1
+    print('%s -> %s : rank 变化组数=%d/20, score 变化组数=%d/20' % (a, b, dr, ds))

package/docs/experiments/deja-vu-negcond/corpus.py

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+"""实验共用：20 组对抗语料 + 隔离环境 + 两种注入方式（notes / claude 会话）。"""
+import os
+import json
+import subprocess
+
+DEJA = r'd:\Program Files\2_ai\dsh-memory\.tmp-negcond\deja.exe'
+TOPK = 10
+TS = '2026-09-01T10:00:00Z'
+
+GROUPS = [
+    dict(gid='g01', core='连接池大小',
+         correct='生产环境 MySQL 的连接池大小设为 32，因为单实例要扛 800 QPS',
+         bait='本地开发用 SQLite，连接池大小设为 1，因为文件锁不支持并发写',
+         query='生产环境 MySQL 的连接池大小设多少'),
+    dict(gid='g02', core='超时时间',
+         correct='gRPC 服务端的超时时间设为 5 秒，因为上游重试窗口只有 8 秒',
+         bait='HTTP 网关的超时时间设为 30 秒，因为浏览器要等大文件上传完',
+         query='gRPC 服务端的超时时间该设多少'),
+    dict(gid='g03', core='缓存失效',
+         correct='Redis 集群的缓存失效时间设为 60 秒，因为跨节点一致性只能容忍这个窗口',
+         bait='本地内存的缓存失效时间设为永不失效，因为单进程不需要跨节点同步',
+         query='Redis 集群的缓存失效时间设多久'),
+    dict(gid='g04', core='重试次数',
+         correct='支付回调的重试次数是 3 次，因为对方幂等键只保留 5 分钟',
+         bait='通知推送的重试次数是 5 次，因为用户可能几小时后才打开手机',
+         query='支付回调的重试次数是多少'),
+    dict(gid='g05', core='分页大小',
+         correct='日志查询的分页大小设为 200，因为运维要一次看完整条请求链',
+         bait='用户列表的分页大小设为 20，因为移动端首屏渲染不能卡',
+         query='日志查询的分页大小设多少'),
+    dict(gid='g06', core='加密算法',
+         correct='传输层用 AES-256-GCM 加密，因为要硬件加速且有完整性校验',
+         bait='静态存储用 ChaCha20 加密，因为移动设备上没有 AES 指令集',
+         query='传输层该用哪个加密算法'),
+    dict(gid='g07', core='索引类型',
+         correct='时间序列表用 BRIN 索引，因为数据按时间顺序写入且量极大',
+         bait='用户表用 B-tree 索引，因为要支持等值与范围混合查询',
+         query='时间序列表该建什么索引'),
+    dict(gid='g08', core='限流阈值',
+         correct='登录接口的限流阈值是每分钟 5 次，因为要挡撞库',
+         bait='数据导出的限流阈值是每小时 2 次，因为导出会打满数据库',
+         query='登录接口的限流阈值设多少'),
+    dict(gid='g09', core='日志级别',
+         correct='生产环境的日志级别是 WARN，因为 INFO 会把磁盘写满',
+         bait='开发环境的日志级别是 DEBUG，因为要看清每一步调用',
+         query='生产环境的日志级别设成什么'),
+    dict(gid='g10', core='并发数',
+         correct='图片上传的并发数是 4，因为带宽是瓶颈而不是 CPU',
+         bait='报表生成的并发数是 1，因为要独占数据库连接池',
+         query='图片上传的并发数设多少'),
+    dict(gid='g11', core='心跳间隔',
+         correct='长连接的心跳间隔是 30 秒，因为 NAT 网关 60 秒会回收会话',
+         bait='集群选举的心跳间隔是 3 秒，因为要快速发现主节点失联',
+         query='长连接的心跳间隔设多久'),
+    dict(gid='g12', core='批量大小',
+         correct='消息消费的批量大小是 500，因为一次拉太多会超过处理超时',
+         bait='数据库写入的批量大小是 1000，因为事务日志要凑够一页才刷盘',
+         query='消息消费的批量大小设多少'),
+    dict(gid='g13', core='会话过期',
+         correct='管理后台的会话过期是 15 分钟，因为要满足等保要求',
+         bait='移动端的会话过期是 30 天，因为不能让用户反复登录',
+         query='管理后台的会话过期设多久'),
+    dict(gid='g14', core='压缩级别',
+         correct='归档冷数据的压缩级别是 9，因为只解压一次但要存十年',
+         bait='实时日志的压缩级别是 1，因为压缩耗时不能拖慢写盘',
+         query='归档冷数据的压缩级别设多少'),
+    dict(gid='g15', core='采样率',
+         correct='链路追踪的采样率是 100%，因为是按需开启且要定位长尾',
+         bait='指标采集的采样率是 10%，因为全量上报会打爆监控后端',
+         query='链路追踪的采样率设多少'),
+    dict(gid='g16', core='副本数',
+         correct='核心库的副本数是 3，因为要容忍一个可用区整体挂掉',
+         bait='分析库的副本数是 1，因为离线跑批不需要高可用',
+         query='核心库的副本数设几个'),
+    dict(gid='g17', core='文件分片',
+         correct='视频上传的文件分片是 8MB，因为弱网下小分片重传成本低',
+         bait='固件升级的文件分片是 1MB，因为设备端内存只有 64KB',
+         query='视频上传的文件分片设多大'),
+    dict(gid='g18', core='队列优先级',
+         correct='退款消息的队列优先级是高，因为涉及用户资金',
+         bait='对账消息的队列优先级是低，因为可以延后到凌晨跑',
+         query='退款消息的队列优先级设成什么'),
+    dict(gid='g19', core='字符集',
+         correct='用户昵称的字符集用 utf8mb4，因为要支持 emoji',
+         bait='内部编码的字符集用 latin1，因为只存 ASCII 且要省空间',
+         query='用户昵称的字符集用哪个'),
+    dict(gid='g20', core='备份频率',
+         correct='交易库的备份频率是每小时一次，因为最多只能丢一小时数据',
+         bait='配置库的备份频率是每天一次，因为改动很少且可手工恢复',
+         query='交易库的备份频率设多久'),
+]
+
+
+def make_env(root):
+    env = dict(os.environ)
+    env.update({
+        'PYTHONUTF8': '1',
+        'HOME': root, 'USERPROFILE': root,
+        'DEJA_INDEX_DIR': os.path.join(root, 'idx'),
+        'DEJA_NOTES_FILE': os.path.join(root, 'notes.jsonl'),
+        'XDG_CONFIG_HOME': os.path.join(root, 'config'),
+        'XDG_DATA_HOME': os.path.join(root, 'data'),
+        'DEJA_CLAUDE_ROOT': os.path.join(root, 'claude'),
+    })
+    return env
+
+
+def new_root(prefix):
+    import tempfile
+    root = tempfile.mkdtemp(prefix=prefix)
+    for d in ('claude', 'idx', 'config', 'data'):
+        os.makedirs(os.path.join(root, d), exist_ok=True)
+    return root
+
+
+def write_notes(root, rows):
+    path = os.path.join(root, 'notes.jsonl')
+    with open(path, 'w', encoding='utf-8') as fh:
+        for row in rows:
+            fh.write(json.dumps(row, ensure_ascii=False) + '\n')
+    return path
+
+
+def write_claude_session(root, project, sid, text, ts=TS):
+    """写一条伪造的 Claude Code 会话 jsonl（格式取自竞品 scripts/semanticgap）。"""
+    d = os.path.join(root, 'claude', project)
+    os.makedirs(d, exist_ok=True)
+    rec = {
+        'type': 'user',
+        'sessionId': sid,
+        'cwd': '/tmp/' + project,
+        'timestamp': ts,
+        'message': {'role': 'user', 'content': text},
+    }
+    path = os.path.join(d, sid + '.jsonl')
+    with open(path, 'w', encoding='utf-8') as fh:
+        fh.write(json.dumps(rec, ensure_ascii=False) + '\n')
+    return path
+
+
+def search(root, query, limit=TOPK):
+    p = subprocess.run([DEJA, 'search', query, '--json', '--limit', str(limit)],
+                       capture_output=True, text=True, encoding='utf-8',
+                       errors='replace', env=make_env(root), cwd=root, timeout=300)
+    if p.returncode != 0:
+        return None, p.stderr[:400]
+    try:
+        return json.loads(p.stdout), ''
+    except Exception as exc:  # noqa
+        return None, 'JSON parse: %s | %s' % (exc, p.stdout[:300])
+
+
+def ranks(data, correct_id, bait_id):
+    hits = data.get('hits', [])
+    ids = [h['session']['id'] for h in hits]
+    sc = {h['session']['id']: h.get('score', 0.0) for h in hits}
+    cr = ids.index(correct_id) + 1 if correct_id in ids else -1
+    br = ids.index(bait_id) + 1 if bait_id in ids else -1
+    return cr, br, round(sc.get(correct_id, 0.0), 4), round(sc.get(bait_id, 0.0), 4), \
+        len(ids), [i[-14:] for i in ids]

package/docs/experiments/deja-vu-negcond/expA.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+"""实验 A：负条件拒绝率（标尺 §2.3 判别测试）
+
+问题：当一条记忆的「适用条件」与查询条件不符，它是否被拒绝？
+      更严的追问：当它被**显式手工否决**（state=rejected）时，是否被拒绝？
+
+手段：隔离库 + 手写 notes.jsonl（含 state）+ deja search --json。
+      每条记忆自带的 state 正是标尺 J 维「四态」的载体。
+
+三个库（对照）：
+  S_AA  correct=accepted, bait=accepted   —— 基线：无条件信息，纯相似度
+  S_AR  correct=accepted, bait=rejected   —— 显式否决的诱饵是否仍被召回
+  S_RA  correct=rejected, bait=accepted   —— 显式否决的正确项是否仍被召回
+"""
+import os
+import sys
+import json
+import subprocess
+import tempfile
+
+sys.stdout.reconfigure(encoding='utf-8')
+
+DEJA = r'd:\Program Files\2_ai\dsh-memory\.tmp-negcond\deja.exe'
+TOPK = 10
+
+# 20 组对抗对：correct 与 bait 共享核心名词短语，适用条件互斥。
+# query 明确指定 correct 一侧的条件。
+GROUPS = [
+    dict(gid='g01', core='连接池大小',
+         correct='生产环境 MySQL 的连接池大小设为 32，因为单实例要扛 800 QPS',
+         bait='本地开发用 SQLite，连接池大小设为 1，因为文件锁不支持并发写',
+         query='生产环境 MySQL 的连接池大小设多少'),
+    dict(gid='g02', core='超时时间',
+         correct='gRPC 服务端的超时时间设为 5 秒，因为上游重试窗口只有 8 秒',
+         bait='HTTP 网关的超时时间设为 30 秒，因为浏览器要等大文件上传完',
+         query='gRPC 服务端的超时时间该设多少'),
+    dict(gid='g03', core='缓存失效',
+         correct='Redis 集群的缓存失效时间设为 60 秒，因为跨节点一致性只能容忍这个窗口',
+         bait='本地内存的缓存失效时间设为永不失效，因为单进程不需要跨节点同步',
+         query='Redis 集群的缓存失效时间设多久'),
+    dict(gid='g04', core='重试次数',
+         correct='支付回调的重试次数是 3 次，因为对方幂等键只保留 5 分钟',
+         bait='通知推送的重试次数是 5 次，因为用户可能几小时后才打开手机',
+         query='支付回调的重试次数是多少'),
+    dict(gid='g05', core='分页大小',
+         correct='日志查询的分页大小设为 200，因为运维要一次看完整条请求链',
+         bait='用户列表的分页大小设为 20，因为移动端首屏渲染不能卡',
+         query='日志查询的分页大小设多少'),
+    dict(gid='g06', core='加密算法',
+         correct='传输层用 AES-256-GCM 加密，因为要硬件加速且有完整性校验',
+         bait='静态存储用 ChaCha20 加密，因为移动设备上没有 AES 指令集',
+         query='传输层该用哪个加密算法'),
+    dict(gid='g07', core='索引类型',
+         correct='时间序列表用 BRIN 索引，因为数据按时间顺序写入且量极大',
+         bait='用户表用 B-tree 索引，因为要支持等值与范围混合查询',
+         query='时间序列表该建什么索引'),
+    dict(gid='g08', core='限流阈值',
+         correct='登录接口的限流阈值是每分钟 5 次，因为要挡撞库',
+         bait='数据导出的限流阈值是每小时 2 次，因为导出会打满数据库',
+         query='登录接口的限流阈值设多少'),
+    dict(gid='g09', core='日志级别',
+         correct='生产环境的日志级别是 WARN，因为 INFO 会把磁盘写满',
+         bait='开发环境的日志级别是 DEBUG，因为要看清每一步调用',
+         query='生产环境的日志级别设成什么'),
+    dict(gid='g10', core='并发数',
+         correct='图片上传的并发数是 4，因为带宽是瓶颈而不是 CPU',
+         bait='报表生成的并发数是 1，因为要独占数据库连接池',
+         query='图片上传的并发数设多少'),
+    dict(gid='g11', core='心跳间隔',
+         correct='长连接的心跳间隔是 30 秒，因为 NAT 网关 60 秒会回收会话',
+         bait='集群选举的心跳间隔是 3 秒，因为要快速发现主节点失联',
+         query='长连接的心跳间隔设多久'),
+    dict(gid='g12', core='批量大小',
+         correct='消息消费的批量大小是 500，因为一次拉太多会超过处理超时',
+         bait='数据库写入的批量大小是 1000，因为事务日志要凑够一页才刷盘',
+         query='消息消费的批量大小设多少'),
+    dict(gid='g13', core='会话过期',
+         correct='管理后台的会话过期是 15 分钟，因为要满足等保要求',
+         bait='移动端的会话过期是 30 天，因为不能让用户反复登录',
+         query='管理后台的会话过期设多久'),
+    dict(gid='g14', core='压缩级别',
+         correct='归档冷数据的压缩级别是 9，因为只解压一次但要存十年',
+         bait='实时日志的压缩级别是 1，因为压缩耗时不能拖慢写盘',
+         query='归档冷数据的压缩级别设多少'),
+    dict(gid='g15', core='采样率',
+         correct='链路追踪的采样率是 100%，因为是按需开启且要定位长尾',
+         bait='指标采集的采样率是 10%，因为全量上报会打爆监控后端',
+         query='链路追踪的采样率设多少'),
+    dict(gid='g16', core='副本数',
+         correct='核心库的副本数是 3，因为要容忍一个可用区整体挂掉',
+         bait='分析库的副本数是 1，因为离线跑批不需要高可用',
+         query='核心库的副本数设几个'),
+    dict(gid='g17', core='文件分片',
+         correct='视频上传的文件分片是 8MB，因为弱网下小分片重传成本低',
+         bait='固件升级的文件分片是 1MB，因为设备端内存只有 64KB',
+         query='视频上传的文件分片设多大'),
+    dict(gid='g18', core='队列优先级',
+         correct='退款消息的队列优先级是高，因为涉及用户资金',
+         bait='对账消息的队列优先级是低，因为可以延后到凌晨跑',
+         query='退款消息的队列优先级设成什么'),
+    dict(gid='g19', core='字符集',
+         correct='用户昵称的字符集用 utf8mb4，因为要支持 emoji',
+         bait='内部编码的字符集用 latin1，因为只存 ASCII 且要省空间',
+         query='用户昵称的字符集用哪个'),
+    dict(gid='g20', core='备份频率',
+         correct='交易库的备份频率是每小时一次，因为最多只能丢一小时数据',
+         bait='配置库的备份频率是每天一次，因为改动很少且可手工恢复',
+         query='交易库的备份频率设多久'),
+]
+
+TS = '2026-09-01T10:00:00Z'
+
+
+def make_env(root):
+    env = dict(os.environ)
+    env.update({
+        'PYTHONUTF8': '1',
+        'HOME': root, 'USERPROFILE': root,
+        'DEJA_INDEX_DIR': os.path.join(root, 'idx'),
+        'DEJA_NOTES_FILE': os.path.join(root, 'notes.jsonl'),
+        'XDG_CONFIG_HOME': os.path.join(root, 'config'),
+        'XDG_DATA_HOME': os.path.join(root, 'data'),
+        'DEJA_CLAUDE_ROOT': os.path.join(root, 'claude'),
+    })
+    return env
+
+
+def build_store(state_correct, state_bait):
+    root = tempfile.mkdtemp(prefix='negcond-A-')
+    for d in ('claude', 'idx', 'config', 'data'):
+        os.makedirs(os.path.join(root, d), exist_ok=True)
+    notes = os.path.join(root, 'notes.jsonl')
+    with open(notes, 'w', encoding='utf-8') as fh:
+        for g in GROUPS:
+            for side, text, state in (('c', g['correct'], state_correct),
+                                      ('b', g['bait'], state_bait)):
+                row = {
+                    'ts': TS,
+                    'project': g['gid'],
+                    'text': text,
+                    'kind': 'promoted',
+                    'session': 'claude:%s-%s' % (g['gid'], side),
+                    'state': state,
+                    'title': g['core'],
+                }
+                fh.write(json.dumps(row, ensure_ascii=False) + '\n')
+    return root, notes
+
+
+def search(root, query):
+    p = subprocess.run([DEJA, 'search', query, '--json', '--limit', str(TOPK)],
+                       capture_output=True, text=True, encoding='utf-8',
+                       errors='replace', env=make_env(root), cwd=root, timeout=300)
+    if p.returncode != 0:
+        return None, p.stderr[:400]
+    try:
+        return json.loads(p.stdout), ''
+    except Exception as exc:  # noqa
+        return None, 'JSON parse: %s | %s' % (exc, p.stdout[:300])
+
+
+def evaluate(label, state_correct, state_bait, results):
+    bait_in, bait_first, correct_in, both_scores = 0, 0, 0, []
+    detail = []
+    for g in GROUPS:
+        root, _ = build_store(state_correct, state_bait) if False else (None, None)
+    # placeholder replaced below
+    return None
+
+
+def run_scenario(label, state_correct, state_bait):
+    root, notes = build_store(state_correct, state_bait)
+    rows = []
+    bait_in = bait_first = correct_in = correct_missing = 0
+    score_diffs = []
+    for g in GROUPS:
+        data, err = search(root, g['query'])
+        cid = 'deja-note-claude-%s-c' % g['gid']
+        bid = 'deja-note-claude-%s-b' % g['gid']
+        if data is None:
+            rows.append((g['gid'], 'ERR', err, '', ''))
+            continue
+        ids = [h['session']['id'] for h in data.get('hits', [])]
+        sc = {h['session']['id']: h.get('score', 0.0) for h in data.get('hits', [])}
+        cr = ids.index(cid) + 1 if cid in ids else -1
+        br = ids.index(bid) + 1 if bid in ids else -1
+        if br > 0:
+            bait_in += 1
+        if cr > 0:
+            correct_in += 1
+        else:
+            correct_missing += 1
+        if br > 0 and (cr < 0 or br < cr):
+            bait_first += 1
+        if cr > 0 and br > 0:
+            score_diffs.append(round(sc[bid] - sc[cid], 4))
+        rows.append((g['gid'], cr, br, round(sc.get(cid, 0), 4), round(sc.get(bid, 0), 4),
+                     data.get('total', 0)))
+    n = len(GROUPS)
+    summary = {
+        'scenario': label,
+        'state_correct': state_correct,
+        'state_bait': state_bait,
+        'n': n,
+        'bait_in_top%d' % TOPK: bait_in,
+        'bait_recall_rate': round(bait_in / n, 4),
+        'correct_in_top%d' % TOPK: correct_in,
+        'correct_missing': correct_missing,
+        'bait_ranked_above_correct': bait_first,
+        'bait_wins_rate': round(bait_first / n, 4),
+        'neg_condition_reject_rate': round((n - bait_in) / n, 4),
+    }
+    return summary, rows
+
+
+def main():
+    out = {}
+    detail = {}
+    for label, sc, sb in (('S_AA accepted/accepted', 'accepted', 'accepted'),
+                          ('S_AR accepted/rejected', 'accepted', 'rejected'),
+                          ('S_RA rejected/accepted', 'rejected', 'accepted')):
+        summary, rows = run_scenario(label, sc, sb)
+        out[label] = summary
+        detail[label] = rows
+        print('=== %s ===' % label)
+        print(json.dumps(summary, ensure_ascii=False, indent=2))
+        print()
+
+    with open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'result_A.json'),
+              'w', encoding='utf-8') as fh:
+        json.dump({'summary': out, 'detail': detail}, fh, ensure_ascii=False, indent=2)
+    print('written result_A.json')
+    print()
+    print('%-26s %8s %8s %8s %10s' % ('scenario', 'bait_in', 'corr_in', 'bait#1', 'reject%'))
+    for label, s in out.items():
+        print('%-26s %8d %8d %8d %9.1f%%' % (
+            label, s['bait_in_top%d' % TOPK], s['correct_in_top%d' % TOPK],
+            s['bait_ranked_above_correct'], 100 * s['neg_condition_reject_rate']))
+
+
+main()

package/docs/experiments/deja-vu-negcond/expB.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+"""实验 B：干净版负条件拒绝测试 + 「字段 vs 文本」归因对照
+
+每组**独立库**（只有 2 条记忆），消除跨组干扰。
+
+三个条件：
+  K_A  note,  correct=accepted, bait=accepted  文本: "[accepted] C" / "[accepted] B"
+  K_B  note,  correct=accepted, bait=rejected  文本: "[accepted] C" / "[rejected] B"
+  K_C  claude 会话（无 state 渲染机制），文本与 K_B **逐字相同**: "[accepted] C" / "[rejected] B"
+
+K_A vs K_B : 把诱饵显式手工否决后，召回/排名/分数是否变化？ → 测「显式否决是否被尊重」
+K_B vs K_C : 文本完全相同，唯一差别是 K_B 的 note 带 state 字段（→ SessionMeta.Lifecycle）
+             → 隔离出「是文本效应还是字段效应」
+"""
+import os
+import sys
+import json
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+sys.stdout.reconfigure(encoding='utf-8')
+
+from corpus import GROUPS, new_root, write_notes, write_claude_session, search, TS, TOPK
+
+
+def note_row(g, side, text, state):
+    return {'ts': TS, 'project': 'solo', 'text': text, 'kind': 'promoted',
+            'session': 'claude:%s-%s' % (g['gid'], side), 'state': state,
+            'title': g['core']}
+
+
+def find_ids(data, g):
+    """不依赖 id 命名规则，用各组独有词定位 correct / bait。"""
+    cid = bid = None
+    for h in data.get('hits', []):
+        snip = ' '.join(h.get('snippets', []))
+        if g['correct'][:6] in snip or g['correct'][:6] in h['session'].get('title', ''):
+            cid = h['session']['id']
+        if g['bait'][:6] in snip or g['bait'][:6] in h['session'].get('title', ''):
+            bid = h['session']['id']
+    return cid, bid
+
+
+def probe():
+    """阶段0：确认 claude 注入路径可用，并暴露 id 形式。"""
+    g = GROUPS[0]
+    root = new_root('negcond-Bprobe-')
+    write_claude_session(root, 'solo', g['gid'] + '-c', g['correct'])
+    write_claude_session(root, 'solo', g['gid'] + '-b', g['bait'])
+    data, err = search(root, g['query'])
+    print('=== PROBE (claude path) ===')
+    if data is None:
+        print('FAILED:', err)
+        return None
+    print('total=%s hits=%d' % (data.get('total'), len(data.get('hits', []))))
+    for h in data.get('hits', []):
+        print('  id=%s score=%s tier=%s | %s' % (
+            h['session']['id'], h.get('score'), h.get('tier'),
+            (h.get('snippets') or [''])[0][:70]))
+    print()
+    return data
+
+
+def run_case(g, kind):
+    root = new_root('negcond-B-')
+    if kind in ('A', 'B'):
+        sb = 'accepted' if kind == 'A' else 'rejected'
+        write_notes(root, [note_row(g, 'c', g['correct'], 'accepted'),
+                           note_row(g, 'b', g['bait'], sb)])
+    else:  # C: claude, 文本与 K_B 逐字相同
+        write_claude_session(root, 'solo', g['gid'] + '-c', '[accepted] ' + g['correct'])
+        write_claude_session(root, 'solo', g['gid'] + '-b', '[rejected] ' + g['bait'])
+    data, err = search(root, g['query'])
+    if data is None:
+        return dict(err=err, cr=-1, br=-1, cs=0.0, bs=0.0, total=0, ids=[])
+    cid, bid = find_ids(data, g)
+    ids = [h['session']['id'] for h in data.get('hits', [])]
+    sc = {h['session']['id']: h.get('score', 0.0) for h in data.get('hits', [])}
+    cr = ids.index(cid) + 1 if cid in ids else -1
+    br = ids.index(bid) + 1 if bid in ids else -1
+    return dict(err='', cr=cr, br=br,
+                cs=round(sc.get(cid, 0.0), 6), bs=round(sc.get(bid, 0.0), 6),
+                total=len(ids), ids=ids)
+
+
+def main():
+    if probe() is None:
+        print('claude 注入路径不可用，实验终止')
+        return
+
+    scenarios = ['A', 'B', 'C']
+    res = {k: [] for k in scenarios}
+    for g in GROUPS:
+        for k in scenarios:
+            res[k].append((g['gid'], run_case(g, k)))
+
+    print('%-5s | %-26s | %-26s | %-26s' % ('gid', 'K_A note acc/acc',
+                                             'K_B note acc/rej', 'K_C claude 同文本'))
+    for i in range(len(GROUPS)):
+        cells = []
+        for k in scenarios:
+            r = res[k][i][1]
+            cells.append('c=%s b=%s cs=%.3f bs=%.3f' % (r['cr'], r['br'], r['cs'], r['bs']))
+        print('%-5s | %-26s | %-26s | %-26s' % (GROUPS[i]['gid'], cells[0], cells[1], cells[2]))
+
+    print()
+    print('%-28s %10s %10s %10s %10s' % ('scenario', 'bait_recall', 'bait>corr', 'reject%', 'score≠A'))
+    base = {res['A'][i][0]: res['A'][i][1] for i in range(len(GROUPS))}
+    summary = {}
+    for k in scenarios:
+        n = len(GROUPS)
+        bin_ = sum(1 for _, r in res[k] if r['br'] > 0)
+        bfirst = sum(1 for _, r in res[k] if r['br'] > 0 and (r['cr'] < 0 or r['br'] < r['cr']))
+        sdiff = sum(1 for gid, r in res[k]
+                    if abs(r['bs'] - base[gid]['bs']) > 1e-9 or abs(r['cs'] - base[gid]['cs']) > 1e-9)
+        summary[k] = dict(kind=k, n=n, bait_in=bin_, bait_recall=round(bin_ / n, 4),
+                          bait_first=bfirst, bait_first_rate=round(bfirst / n, 4),
+                          reject_rate=round((n - bin_) / n, 4), score_diff_from_A=sdiff)
+        print('%-28s %9.0f%% %9.0f%% %9.1f%% %9d/20' % (
+            k, 100 * bin_ / n, 100 * bfirst / n, 100 * (n - bin_) / n, sdiff))
+
+    here = os.path.dirname(os.path.abspath(__file__))
+    with open(os.path.join(here, 'result_B.json'), 'w', encoding='utf-8') as fh:
+        json.dump({'summary': summary,
+                   'detail': {k: [dict(gid=gid, **r) for gid, r in res[k]] for k in scenarios}},
+                  fh, ensure_ascii=False, indent=2)
+    print()
+    print('written result_B.json')
+
+
+main()

package/docs/experiments/deja-vu-negcond/final.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""最后一环证据：total>=2 的组里，bait 的 [rejected] 是否被渲染展示、是否影响排序。"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+sys.stdout.reconfigure(encoding='utf-8')
+
+from corpus import GROUPS, new_root, write_notes, search, TS
+
+
+def rows(g, state_b):
+    return [
+        {'ts': TS, 'project': 'solo', 'text': g['correct'], 'kind': 'promoted',
+         'session': 'claude:%s-c' % g['gid'], 'state': 'accepted', 'title': g['core']},
+        {'ts': TS, 'project': 'solo', 'text': g['bait'], 'kind': 'promoted',
+         'session': 'claude:%s-b' % g['gid'], 'state': state_b, 'title': g['core']},
+    ]
+
+
+for gid in ('g02', 'g06', 'g11'):
+    g = GROUPS[int(gid[1:]) - 1]
+    print('=== %s (共存两条均进榜) ===' % gid)
+    for st in ('accepted', 'rejected'):
+        root = new_root('fin-')
+        write_notes(root, rows(g, st))
+        d, _ = search(root, g['query'])
+        order = [h['session']['id'] for h in d['hits']]
+        sc = {h['session']['id']: h['score'] for h in d['hits']}
+        bait_hit = [h for h in d['hits'] if h['session']['id'].endswith('-b')]
+        bt = bait_hit[0]['session'].get('title') if bait_hit else None
+        bs = bait_hit[0]['snippets'][0][:40] if bait_hit else None
+        print('  bait.state=%-8s order=%s scores=%s' % (st, order, sc))
+        print('      bait.title=%r' % bt)
+        print('      bait.snip =%r' % bs)
+    print()