@furongjun1999/dsh-memory 0.4.10 → 0.4.11

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

@@ -1,43 +0,0 @@
-# -*- 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

@@ -1,161 +0,0 @@
-# -*- 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

@@ -1,241 +0,0 @@
-# -*- 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

@@ -1,130 +0,0 @@
-# -*- 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

@@ -1,36 +0,0 @@
-# -*- 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()