Recognize explicit ICLR workshop decisions with scope guards

.gitea/workflows/check.yml

@@ -53,11 +53,8 @@ jobs:
               subprocess.run([python,'-I','-B','-m','paper_atlas','import','arxiv','--help'],cwd=outside,check=True)
               subprocess.run([python,'-I','-B','-m','paper_atlas','maintain','backfill','--help'],cwd=outside,check=True)
               subprocess.run([python,'-I','-B','-m','paper_atlas','audit','public-openreview','--help'],cwd=outside,check=True)
-              subprocess.run([python,'-I','-B','-m','paper_atlas','audit','histories','--help'],cwd=outside,check=True)
-              subprocess.run([python,'-I','-B','-m','paper_atlas','curate','identifiers','--help'],cwd=outside,check=True)
               subprocess.run([python,'-I','-B','-c','from paper_atlas.postgres.writer import PostgresStore, WriteConnection'],cwd=outside,check=True)
               smoke = "from paper_atlas.db.store import Store; from paper_atlas.config import DEFAULT_REGISTRY; import json; assert {'COLM','MM','MLSys'} <= {v['acronym'] for v in json.loads(DEFAULT_REGISTRY.read_text())['venues']}; s=Store('installed.sqlite'); s.conn.close()"
               subprocess.run([python,'-I','-B','-c',smoke],cwd=outside,check=True)
               subprocess.run([python,'-I','-B','-m','paper_atlas','query','--db','installed.sqlite','--stats'],cwd=outside,check=True)
-              subprocess.run([python,'-I','-B','-m','paper_atlas','audit','histories','--db','installed.sqlite','--examples','0'],cwd=outside,check=True)
           PY

docs/data-sources.md

@@ -93,6 +93,12 @@ paper-atlas audit public-openreview --db /data/paper-index/papers.sqlite \
 
 输出按会议、届次及 main、position、datasets_benchmarks 分文件。workshop 默认进入单独的 held 清单；有明确 workshop 名称时可通过 `--include-workshops` 单列采集，不合并到主会。Retraction、未映射的轨道或负面标签也保留在 `held-records.jsonl`，不强改为 Reject 或 Withdrawn。当前决定表没有独立 retracted 状态，因此撤回发表记录仍需后续专门建模。
 
+`parser_version=2` 还会将明确负面标签但标题缺失、空白或 null 的记录放入 `held-records.jsonl`，保留原始状态、forum ID、固定来源版本和行号；不制造标题或导入不可识别的论文，也不让这一条缺失阻断其他可用记录。held 文件哈希与各原因数量保存在 inventory；非文本标题、错误身份、冲突届次和哈希不符仍使整批失败。旧年 ICLR 镜像的明确 `Withdraw` 标签归为 `withdrawn`，`Workshop`、`Poster Workshop`、`Oral Workshop` 均不作为拒稿。采集文件与导入主库仍是两个独立步骤。
+
+`parser_version=3` 增加五组已核实身份的 ICLR workshop 标签：2024 ME-FoMo / GenAI4DM 的 Withdrawn Submission、2025 AgenticAI 的 Reject / LMRL 的 Withdrawn Submission，以及 2026 LLM Reasoning 的 Withdrawn Submission。仅在 `--include-workshops` 下输出，并分别保存 `workshop_me_fomo`、`workshop_genai4dm`、`workshop_agenticai`、`workshop_lmrl`、`workshop_llm_reasoning`；默认仍暂存。标签必须与原文件会议、年份和原始 workshop track 一致，错年/错会议使采集失败，错轨道单独暂存，未知标签继续待核查，不用宽泛的 Reject/Withdraw 正则猜测。
+
+[OpenReview 官方 ICLR 活动目录](https://openreview.net/venue?id=ICLR.cc) 确认上述独立 workshop 身份；[ME-FoMo 2024](https://sites.google.com/view/me-fomo2024/call-for-papers)、[GenAI4DM 2024](https://sites.google.com/view/genai4dm-iclr2024)、[AgenticAI 2025](https://iclragenticai.github.io/) 和 [LLM Reasoning 2026](https://sites.google.com/view/iclr-2026-llmreasoning) 的活动网站也提供对应投稿入口。输出在 metadata 保存 `workshop_venueid` 和身份目录证据，决定仍只标为固定镜像的公开分类断言，保留原始标签、forum、来源行号与哈希，不声称核验原始决定签名。2026-11-08 核查时部分原站记录页要求浏览器验证；身份目录和主办方入口可读，不代表逐篇原始决定已可访问，也不外推其他 workshop 的公开政策。采集后仍须经过 PostgreSQL 身份/决定冲突预检、串行导入和独立验收。
+
 该来源明确标记为 `curated_public_status_assertion`：保留源 commit、文件哈希、行号、原标签和 forum ID，不声称已核验原始 PC 签名。只保存标题、摘要、公开作者名、关键词、领域、索引与决定来源，不缓存镜像中的个人资料、邮箱、性别、评审内容或 PDF。所有输出清单均为 partial；盘点中的零条记录仅描述这个固定镜像。
 
 入库前审计核验文件哈希、数量、轨道和来源声明，并用真实 forum ID 对比同届同轨道已有投稿。存在不同决定时阻止整批导入，交由来源和时序核查；另一会议的后续录用属于独立投稿历史，不构成该次拒稿的冲突。同一 forum 的镜像不新增投稿事件，但论文实体的跨平台去重仍须在全量结束后核验。审计通过的报告包含带 SHA-256 的导入队列；应在单写入维护锁下及时串行导入，主库变化后重新审计。

docs/usage.md

@@ -2,55 +2,6 @@
 
 先在已确认的远程环境安装项目，使用 `paper-atlas`。从源码运行时，将命令前缀替换为 `python3 -B -m paper_atlas`，其余参数相同。数据目录位于仓库外。
 
-## 按证据补充稳定标识
-
-`paper-atlas curate identifiers --plan /data/review/plan.json --output /data/review/prepared`
-只生成新的 JSONL、manifest、证据副本及 `curation-report.json`，不会连接数据库。
-输出目录必须不存在，父目录必须已存在；任何输入或断言失败，都不发布本批输出。
-原始文件不变，未选中的记录逐字节保留。题名、作者、年份、页码、投稿决定、标签和既有 metadata
-均不重写，仅补充 `identifiers` 并追加 `metadata.identifier_curation` 证据链。
-
-计划格式如下（哈希占位符须替换为真实 SHA256，所有路径按命令当前目录解析）：
-
-```json
-{
-  "format_version": 1,
-  "inputs": [{
-    "file": "/data/review/uai2001.jsonl",
-    "sha256": "<JSONL 文件 SHA256>",
-    "manifest_sha256": "<同名 .manifest.json 文件 SHA256>"
-  }],
-  "assertions": [{
-    "source": "dblp",
-    "external_id": "conf/uai/example",
-    "record_sha256": "<原始物理行字节 SHA256，包含该行原有换行符>",
-    "identifiers": {"arxiv": "1408.1485"},
-    "evidence": [{
-      "file": "/data/review/primary-metadata.json",
-      "sha256": "<证据 JSON 文件 SHA256>",
-      "url": "https://example.org/primary-record",
-      "checked_at": "2026-11-08T08:00:00Z",
-      "note": "说明人工核对的题名、作者、出版版本和稳定标识证据"
-    }]
-  }]
-}
-```
-
-输入 manifest 必须包含 `source/venue/year/track/count/list_url/file_sha256`，且与逐条记录一致。
-断言必须唯一、准确命中一条记录。仅支持无版本后缀的 arXiv 编号与小写规范 DOI；
-已有同类标识不允许覆盖，相同值可以补记证据。证据只接受不超过 16 MiB 的 JSON 元数据文件，
-来源 URL 要求 HTTPS 且不含凭据，核查时间必须带时区；不下载论文 PDF。
-
-`verification_scope=input_and_evidence_integrity_only` 和 `semantic_identity_verified=false`
-明确表示哈希校验不能证明两条记录属于同一作品。请先独立核对版本关系；仅年份、页码或相同题名
-不能作为合并依据。存在来源冲突的行应继续暂缓。新 manifest 保留原来的 partial 状态及摘要缺失数，
-不会把补充编号伪装成来源覆盖或摘要补全。证据副本按 SHA256 保存在输出目录 `evidence/`，
-原计划也保存在 `plan.json`，供之后复查。
-
-文件生成后仍需另做当前 PostgreSQL 身份、投稿和决定冲突预检；导入运行时必须包含
-“稳定标识优先、多个标题候选则整文件回滚”的身份保护，再以 `import records` 独立导入并验收。
-该命令不会自动导入或合并实体，也不代表最终全库去重通过。
-
 ## PostgreSQL 查询
 
 在远程环境安装 `.[postgres]`，通过权限为 `0600` 的 libpq service 文件连接，不把密码放入 URL、命令行或仓库。
@@ -128,10 +79,10 @@ paper-atlas maintain merge --db /data/paper-index/samples/example.sqlite \
 ## 4. 查询与分析前检查
 
 ```sh
-paper-atlas query --pg-service foundry-research --query '"language model"' --limit 20
+paper-atlas query --db /data/paper-index/papers.sqlite --query '"language model"' --limit 20
-paper-atlas query --pg-service foundry-research --tag arxiv:category=cs.AI
+paper-atlas query --db /data/paper-index/papers.sqlite --tag arxiv:category=cs.AI
-paper-atlas query --pg-service foundry-research --venue ICLR --year 2025 --status rejected
+paper-atlas query --db /data/paper-index/papers.sqlite --venue ICLR --year 2025 --status rejected
-paper-atlas query --pg-service foundry-research --paper 123
+paper-atlas query --db /data/paper-index/papers.sqlite --paper 123
 paper-atlas coverage --db /data/paper-index/papers.sqlite --out /data/paper-index/collected/coverage.json
 ```
 
@@ -140,28 +91,10 @@ paper-atlas coverage --db /data/paper-index/papers.sqlite --out /data/paper-inde
 例如，查找在 ICLR 有拒稿记录、但在其他已知投稿中已有录用的论文：
 
 ```sh
-paper-atlas query --pg-service foundry-research \
+paper-atlas query --db /data/paper-index/papers.sqlite \\
   --venue ICLR --status rejected --outcome accepted
 ```
 
 `known_acceptances` 列出目前仍为录用状态的各次投稿及会议、年份、track 和决定证据，`publication_outcome` 汇总为 accepted 或 no_known_acceptance。汇总会检查所有会议和 track，不把某次拒稿覆盖到整篇论文；同一次投稿的后续撤稿也会更新该次状态并保留原决定。no_known_acceptance 只表示现有来源中没有查到录用，不能称为“从未录用”。
 
 `--stats` 中 papers 是当前规则下的论文实体数；source_records 是来源记录数；decisions 是决定观察数。一个投稿可能有多个来源和多条观察，不能相加当作论文数。
-
-已有稳定标识或原来源记录匹配时，该身份优先；同标题、同作者的另一 arXiv 存档或扩展稿不会仅因相似标题被并入。没有身份锚点时，作者佐证的精确标题只有一个候选才可匹配；多个候选会报 `Ambiguous paper identity`，整个采集文件回滚并记录失败运行。应补有证据的标识或先核查版本关系，不删除重复候选或任取第一个。一个新来源明确同时携带两个既有稳定标识时，仍可按既有规则归并并保留投稿、标签和合并日志；未归并的同标题关系继续保留为待核查候选。这些规则不证明全库去重完成。
-
-## 5. 投稿历史关系审计
-
-```sh
-PGSERVICEFILE=/etc/paper-atlas/pg_service.conf paper-atlas audit histories \
-  --pg-service foundry-research --pg-schema research --examples 20 \
-  --out /data/paper-index/collected/history-audit.json
-```
-
-使用一个只读一致性快照，区分论文实体、投稿和决定观察；分别统计同次投稿曾出现负面与录用观察、不同投稿共存负面与当前已知录用、不同会议之间的共存。workshop/main 是不同 track，属于同一会议时不算跨会议；会议别名也不会增加一个会议。当前已知录用使用与 `query --outcome` 相同的“每次投稿最新观察”规则，后续撤稿的该次投稿不再算当前录用，但旧录用决定仍保留。
-
-报告不凭观察时间、届次年份或行顺序断言“拒稿发生在录用之前”。样例保留真实 `decision_date`、`observed_at`、原始标签、证据 URL 和决定来源，供进一步核查；日期缺失仍保持未知。`negative` 统计包含 rejected、desk_rejected 和 withdrawn，其原始状态不互相替换。
-
-总数覆盖快照内全部投稿，样例由 `--examples` 限定为 0–100 篇；每篇最多展示 20 次投稿、每次最多 50 条决定、每条决定最多 100 个来源，并明确标记截断。样例优先保留负面/录用的不同投稿对。四项来源关系检查报告缺失关联和来源论文归属不一致，不自动修复。
-
-这些统计依赖现有论文身份关联，不证明实体合并正确，也不证明原始决定签名、公开拒稿全集、标签类型或最终全库去重已完成。SQLite 独立样本可使用 `--db`；冻结备份不能代表当前 PostgreSQL 的历史情况。

paper_atlas/audits/histories.py

@@ -1,196 +0,0 @@
-"""Audit linked submission histories without inferring event chronology."""
-import argparse
-from collections import Counter
-import json
-from pathlib import Path
-import sqlite3
-
-from paper_atlas.db.backend import database_arguments, open_read_connection
-from paper_atlas.db.submissions import timestamp
-from paper_atlas.querying import LATEST_DECISION
-
-
-ATTEMPTS = '''SELECT s.paper_id,s.id AS submission_id,e.venue_id,v.acronym AS venue,e.year,e.track,
-    count(d.id) AS decision_observations,
-    MAX(CASE WHEN d.status IN ('rejected','desk_rejected','withdrawn') THEN 1 ELSE 0 END)
-        AS historical_negative,
-    MAX(CASE WHEN d.status='accepted' THEN 1 ELSE 0 END) AS historical_acceptance,
-    COALESCE(MAX(CASE WHEN ''' + LATEST_DECISION + ''' THEN d.status END),'unknown')
-        AS latest_observed_status
-    FROM submissions s JOIN editions e ON e.id=s.edition_id JOIN venues v ON v.id=e.venue_id
-    LEFT JOIN decisions d ON d.submission_id=s.id
-    GROUP BY s.paper_id,s.id,e.venue_id,v.acronym,e.year,e.track
-    ORDER BY s.paper_id,e.venue_id,s.id'''
-
-
-def _paper_counts(attempts):
-    negative = sum(row['historical_negative'] for row in attempts)
-    accepted = sum(row['latest_observed_status'] == 'accepted' for row in attempts)
-    overlap = sum(row['historical_negative'] and row['latest_observed_status'] == 'accepted'
-                  for row in attempts)
-    venues = {}
-    for row in attempts:
-        counts = venues.setdefault(row['venue_id'], [0, 0])
-        counts[0] += row['historical_negative']
-        counts[1] += row['latest_observed_status'] == 'accepted'
-    return {
-        'papers_with_submissions': 1,
-        'papers_with_multiple_submissions': int(len(attempts) > 1),
-        'papers_with_historical_negative': int(negative > 0),
-        'papers_with_current_known_acceptance': int(accepted > 0),
-        'papers_with_negative_and_acceptance_in_distinct_attempts': int(negative * accepted > overlap),
-        'papers_with_negative_and_acceptance_in_distinct_venues':
-            int(negative * accepted > sum(n * a for n, a in venues.values())),
-    }
-
-
-def _example(connection, attempts):
-    # Keep a negative/accepted pair visible even when a paper has many attempts.
-    accepted = [row for row in attempts if row['latest_observed_status'] == 'accepted']
-    first = accepted[0] if accepted else None
-    other_venue = next((row for row in accepted if row['venue_id'] != first['venue_id']), None)
-    pair = None
-    for negative in attempts:
-        if negative['historical_negative'] and first:
-            candidate = first if first['venue_id'] != negative['venue_id'] else other_venue
-            if candidate:
-                pair = (negative, candidate)
-                break
-    if pair is None:
-        for negative in attempts:
-            if negative['historical_negative'] and first:
-                candidate = first if first['submission_id'] != negative['submission_id'] else (
-                    accepted[1] if len(accepted) > 1 else None)
-                if candidate:
-                    pair = (negative, candidate)
-                    break
-    selected = {}
-    for row in list(pair or ()) + attempts:
-        if len(selected) < 20:
-            selected.setdefault(row['submission_id'], dict(row))
-    for row in selected.values():
-        row['decisions'] = []
-        for decision in connection.execute('''SELECT id,status,raw_value,evidence_url,
-                decision_date,observed_at FROM decisions WHERE submission_id=?
-                ORDER BY observed_at DESC,COALESCE(decision_date,observed_at) DESC,id DESC LIMIT 50''',
-                (row['submission_id'],)):
-            entry = dict(decision)
-            sources = [dict(source) for source in connection.execute('''
-                SELECT so.name,r.external_id,ds.source_decision_id FROM decision_sources ds
-                JOIN source_records r ON r.id=ds.source_record_id JOIN sources so ON so.id=r.source_id
-                WHERE ds.decision_id=? ORDER BY so.name,r.external_id LIMIT 101''', (entry['id'],))]
-            entry['sources'] = sources[:100]
-            entry['sources_truncated'] = len(sources) > 100
-            row['decisions'].append(entry)
-        row['decisions_truncated'] = row['decision_observations'] > len(row['decisions'])
-    paper_id = attempts[0]['paper_id']
-    return {'paper_id': paper_id,
-            'title': connection.execute('SELECT title FROM papers WHERE id=?', (paper_id,)).fetchone()[0],
-            'counts': _paper_counts(attempts), 'attempt_count': len(attempts),
-            'attempts': list(selected.values()), 'attempts_truncated': len(attempts) > len(selected),
-            'chronology': 'Not inferred from observed_at, edition year, or row order.'}
-
-
-def report(db=None, *, pg_service=None, pg_schema=None, examples=20):
-    if not 0 <= examples <= 100:
-        raise ValueError('Examples must be between 0 and 100')
-    started_at = timestamp()
-    connection = open_read_connection(db, pg_service=pg_service, pg_schema=pg_schema)
-    if not pg_service:
-        connection.row_factory = sqlite3.Row
-    try:
-        if pg_service:
-            identity = connection.execute('SELECT current_database(),current_schema()').fetchone()
-            database, schema = identity[0], identity[1]
-        else:
-            database, schema = str(Path(db).resolve()), None
-        names = ['papers_with_submissions', 'papers_with_multiple_submissions',
-                 'papers_with_historical_negative', 'papers_with_current_known_acceptance',
-                 'papers_with_negative_and_acceptance_in_distinct_attempts',
-                 'papers_with_negative_and_acceptance_in_distinct_venues']
-        totals = Counter({key: 0 for key in names})
-        totals.update(submissions=0, decision_observations=0,
-                      attempts_with_historical_negative=0,
-                      attempts_with_historical_negative_and_acceptance=0)
-        latest = Counter()
-        sample_attempts = []
-
-        def consume(rows):
-            if not rows:
-                return
-            counts = _paper_counts(rows)
-            totals.update(counts)
-            if counts['papers_with_negative_and_acceptance_in_distinct_attempts'] and len(sample_attempts) < examples:
-                sample_attempts.append(rows)
-
-        current = []
-        for raw in connection.execute(ATTEMPTS):
-            row = dict(raw)
-            if current and row['paper_id'] != current[0]['paper_id']:
-                consume(current)
-                current = []
-            current.append(row)
-            totals['submissions'] += 1
-            totals['decision_observations'] += row['decision_observations']
-            totals['attempts_with_historical_negative'] += row['historical_negative']
-            totals['attempts_with_historical_negative_and_acceptance'] += int(
-                row['historical_negative'] and row['historical_acceptance'])
-            latest[row['latest_observed_status']] += 1
-        consume(current)
-        # These are relationship checks, not a substitute for the final entity/FK audit.
-        integrity = {}
-        checks = {
-            'submissions_without_source_links': '''SELECT count(*) FROM submissions s
-                WHERE NOT EXISTS(SELECT 1 FROM submission_sources ss WHERE ss.submission_id=s.id)''',
-            'decisions_without_source_links': '''SELECT count(*) FROM decisions d
-                WHERE NOT EXISTS(SELECT 1 FROM decision_sources ds WHERE ds.decision_id=d.id)''',
-            'submission_source_paper_mismatches': '''SELECT count(*) FROM submission_sources ss
-                JOIN submissions s ON s.id=ss.submission_id JOIN source_records r ON r.id=ss.source_record_id
-                WHERE s.paper_id<>r.paper_id''',
-            'decision_source_paper_mismatches': '''SELECT count(*) FROM decision_sources ds
-                JOIN decisions d ON d.id=ds.decision_id JOIN submissions s ON s.id=d.submission_id
-                JOIN source_records r ON r.id=ds.source_record_id WHERE s.paper_id<>r.paper_id''',
-        }
-        for name, query in checks.items():
-            integrity[name] = connection.execute(query).fetchone()[0]
-        return {'report_started_at': started_at, 'checked_at': timestamp(),
-                'engine': 'postgresql' if pg_service else 'sqlite', 'database': database,
-                'schema': schema, 'pg_service': pg_service,
-                'status': 'observed_history_audit_not_final_dedup', 'counts': dict(totals),
-                'latest_attempt_status_counts': dict(sorted(latest.items())),
-                'evidence_relationship_checks': integrity,
-                'examples': [_example(connection, rows) for rows in sample_attempts],
-                'example_limit': examples,
-                'interpretation': [
-                    'Counts use existing canonical paper links, not independently verified real-world identity.',
-                    'Negative includes rejected, desk_rejected and withdrawn observations; these remain distinct decisions.',
-                    'Known acceptance follows the latest observed decision per attempt, matching query --outcome.',
-                    'Distinct attempts/venues require separate submission/venue IDs; aliases do not create new venues.',
-                    'Coexisting evidence does not prove rejection happened before acceptance. observed_at is collection time.',
-                    'No known acceptance is not proof of never accepted. Source signatures and completeness are not established here.',
-                    'Examples are bounded; counts include all attempts and observations in one read-only snapshot.',
-                    'This does not perform entity merging, final deduplication, or label namespace/type validation.',
-                ]}
-    finally:
-        connection.close()
-
-
-def main(argv=None, *, prog=None):
-    parser = argparse.ArgumentParser(prog=prog)
-    database_arguments(parser)
-    parser.add_argument('--examples', type=int, default=20)
-    parser.add_argument('--out')
-    args = parser.parse_args(argv)
-    result = report(args.db, pg_service=args.pg_service, pg_schema=args.pg_schema, examples=args.examples)
-    text = json.dumps(result, ensure_ascii=False, indent=2)
-    if args.out:
-        path = Path(args.out)
-        stage = path.with_suffix('.part')
-        stage.write_text(text + '\n')
-        stage.replace(path)
-    else:
-        print(text)
-
-
-if __name__ == '__main__':
-    main()

paper_atlas/audits/public_openreview.py

@@ -39,9 +39,7 @@ def audit(db, inventory, out, *, pg_service=None, pg_schema=None):
             if json.loads(path.with_suffix('.manifest.json').read_text()) != manifest:
                 raise ValueError('Collected manifest differs from inventory')
             count = 0
-            # Unicode paragraph/line separators are valid inside JSON strings;
+            for line in path.read_text().splitlines():
-            # split physical byte lines, not Unicode text boundaries.
-            for line in path.read_bytes().splitlines():
                 row = json.loads(line)
                 if any(row[key] != manifest[key] for key in ('source', 'venue', 'year', 'track')):
                     raise ValueError('Record edition differs from inventory')

paper_atlas/cli.py

@@ -6,7 +6,6 @@ from paper_atlas import __version__
 
 
 COMMANDS = {
-    ('curate','identifiers'): ('paper_atlas.curation.identifiers', {}, '按证据补充稳定标识并生成独立待导入文件'),
     ('query',): ('paper_atlas.querying', {}, '查询论文、标签和投稿历史'),
     ('coverage',): ('paper_atlas.audits.coverage', {}, '查看全部候选会议的覆盖情况'),
     ('download',): ('paper_atlas.io.snapshots', {}, '下载并校验固定版本快照'),
@@ -36,7 +35,6 @@ COMMANDS = {
     ('audit','arxiv'): ('paper_atlas.audits.arxiv', {}, '核验 arXiv 原始编号、重复行与 ZIP 完整性'),
     ('audit','arxiv-tags'): ('paper_atlas.audits.arxiv_tags', {}, '逐记录核验 arXiv 类别及出处完整性'),
     ('audit','public-openreview'): ('paper_atlas.audits.public_openreview', {}, '核对公开负面决定与已有投稿历史'),
-    ('audit','histories'): ('paper_atlas.audits.histories', {}, '只读核对跨会议投稿历史及决定来源关系'),
 }
 
 
@@ -49,7 +47,7 @@ def main(argv=None):
             leaf=commands.add_parser(route[0],help=help_text,add_help=False)
         else:
             if route[0] not in groups:
-                group=commands.add_parser(route[0],help={'collect':'采集来源元数据','catalogue':'盘点历史目录','import':'导入数据库','maintain':'维护数据库','audit':'核验数据','curate':'按证据整理元数据'}[route[0]])
+                group=commands.add_parser(route[0],help={'collect':'采集来源元数据','catalogue':'盘点历史目录','import':'导入数据库','maintain':'维护数据库','audit':'核验数据'}[route[0]])
                 groups[route[0]]=group.add_subparsers(dest='operation',required=True)
             leaf=groups[route[0]].add_parser(route[1],help=help_text,add_help=False)
         leaf.set_defaults(handler=(route,module,kwargs))

paper_atlas/collectors/public_openreview.py

@@ -27,11 +27,25 @@ RAW_ROOT = 'https://raw.githubusercontent.com/papercopilot/openreview/' + REVISI
 TREE_URL = 'https://api.github.com/repos/papercopilot/openreview/git/trees/' + REVISION + '?recursive=1'
 NEGATIVE = {'reject': 'rejected', 'rejected': 'rejected',
             'desk reject': 'desk_rejected', 'desk rejected': 'desk_rejected',
-            'withdrawn': 'withdrawn', 'withdrawal': 'withdrawn'}
+            'withdraw': 'withdrawn', 'withdrawn': 'withdrawn', 'withdrawal': 'withdrawn'}
 TRACKS = {'main': 'main', 'Position': 'position',
           'Datasets & Benchmarks': 'datasets_benchmarks'}
 WORKSHOP_REJECT_LABELS = {"aim-fm workshop @ neurips'24 reject",
                           'coginterp @ neurips 2025 reject'}
+# Exact curated labels, tied to the year and raw workshop track. The official
+# venue directory establishes workshop identity, not an original decision signature.
+ICLR_WORKSHOP_LABELS = {
+    'iclr 2024 workshop mefomo withdrawn submission':
+        (2024, 'workshop_me_fomo', 'withdrawn', 'ME-FoMo'),
+    'iclr 2024 workshop genai4dm withdrawn submission':
+        (2024, 'workshop_genai4dm', 'withdrawn', 'GenAI4DM'),
+    'iclr 2025 workshop agenticai reject':
+        (2025, 'workshop_agenticai', 'rejected', 'AgenticAI'),
+    'iclr 2025 workshop lmrl withdrawn submission':
+        (2025, 'workshop_lmrl', 'withdrawn', 'LMRL'),
+    'iclr 2026 workshop llm reasoning withdrawn submission':
+        (2026, 'workshop_llm_reasoning', 'withdrawn', 'LLM_Reasoning'),
+}
 
 
 def download(url, limit):
@@ -63,6 +77,20 @@ def normalize(row, family, year, provenance, include_workshops=False):
     """Return a normalized assertion or a reason requiring separate review."""
     raw_status = row.get('status', '')
     status = negative_status(raw_status)
+    workshop = ICLR_WORKSHOP_LABELS.get(' '.join(raw_status.casefold().split()))
+    workshop_metadata = {}
+    if workshop:
+        expected_year, expected_track, status, group_name = workshop
+        if family != 'iclr' or year != expected_year:
+            raise ValueError('Workshop status label conflicts with source conference year')
+        if row.get('track') != expected_track:
+            return None, 'conflicting_workshop_track'
+        if not include_workshops:
+            return None, 'separate_workshop'
+        workshop_metadata = {
+            'workshop_venueid': f'ICLR.cc/{year}/Workshop/{group_name}',
+            'workshop_identity_evidence_url': 'https://openreview.net/venue?id=ICLR.cc',
+        }
     if status is None:
         if re.search(r'\bretract\w*\b', raw_status, re.I):
             return None, 'retracted'
@@ -90,7 +118,9 @@ def normalize(row, family, year, provenance, include_workshops=False):
         return None, 'unmapped_venue'
     title = row.get('title')
     abstract = row.get('abstract')
-    if not isinstance(title, str) or not title.strip():
+    if title is None or (isinstance(title, str) and not title.strip()):
+        return None, 'missing_title'
+    if not isinstance(title, str):
         raise ValueError('Public submission lacks a title')
     if abstract is not None and not isinstance(abstract, str):
         raise ValueError('Abstract must be text or null')
@@ -116,7 +146,8 @@ def normalize(row, family, year, provenance, include_workshops=False):
             'venue': venue, 'year': year, 'track': normalized_track,
             'status': status, 'raw_decision': raw_status, 'evidence_url': evidence,
             'observed_at': AS_OF, 'tags': tags,
-            'metadata': {**provenance, 'raw_track': track, 'raw_status': raw_status,
+            'metadata': {**provenance, **workshop_metadata,
+                         'raw_track': track, 'raw_status': raw_status,
                          'evidence_kind': 'curated_public_status_assertion',
                          'original_decision_signature_verified': False,
                          'source_snapshot_upper_bound': AS_OF}}, None
@@ -215,7 +246,7 @@ def _collect_files(out, selected, include_workshops, fetcher):
             name = f'public-openreview-{family}-{year}-{track}.jsonl'
             path = stage / name
             path.write_text(''.join(json.dumps(row, ensure_ascii=False) + '\n' for row in records))
-            manifest = {'source': SOURCE, 'parser_version': 1, 'venue': records[0]['venue'],
+            manifest = {'source': SOURCE, 'parser_version': 3, 'venue': records[0]['venue'],
                         'year': year, 'track': track, 'count': len(records), 'status': 'partial',
                         'file': str(out / name), 'file_sha256': hashlib.sha256(path.read_bytes()).hexdigest(),
                         'list_url': REPOSITORY + '/tree/' + REVISION, 'source_revision': REVISION,

paper_atlas/curation/__init__.py

@@ -1 +0,0 @@
-"""Offline, evidence-bound preparation of metadata for separate ingestion."""

paper_atlas/curation/identifiers.py

@@ -1,212 +0,0 @@
-"""Add reviewed stable identifiers without rewriting bibliographic source fields.
-
-Hashes establish file integrity, not the truth of an identity assertion. Identity
-review and a fresh database preflight remain separate requirements.
-"""
-import argparse
-from datetime import datetime
-import hashlib
-import json
-from pathlib import Path
-import re
-import tempfile
-from urllib.parse import urlsplit
-
-
-SCOPE = 'input_and_evidence_integrity_only'
-MAX_METADATA_BYTES = 16 * 1024 * 1024
-
-
-def digest(data):
-    return hashlib.sha256(data).hexdigest()
-
-
-def object_keys(value, required, optional=()):
-    if not isinstance(value, dict) or not set(required) <= value.keys() or value.keys() - set(required) - set(optional):
-        raise ValueError('Missing or unsupported plan fields')
-
-
-def json_bytes(value):
-    return (json.dumps(value, ensure_ascii=False, separators=(',', ':'), allow_nan=False) + '\n').encode('utf-8')
-
-
-def decode(raw):
-    def unique(pairs):
-        result = {}
-        for key, value in pairs:
-            if key in result:
-                raise ValueError('Duplicate JSON key: ' + key)
-            result[key] = value
-        return result
-    return json.loads(raw, object_pairs_hook=unique,
-                      parse_constant=lambda value: (_ for _ in ()).throw(ValueError('Non-finite JSON value')))
-
-
-def metadata(path, expected=None):
-    with Path(path).open('rb') as stream:
-        raw = stream.read(MAX_METADATA_BYTES + 1)
-    if len(raw) > MAX_METADATA_BYTES:
-        raise ValueError('Metadata exceeds size limit')
-    if expected is not None:
-        check_hash(raw, expected)
-    return raw, decode(raw)
-
-
-def check_hash(raw, expected):
-    if not isinstance(expected, str) or not re.fullmatch('[0-9a-f]{64}', expected) or digest(raw) != expected:
-        raise ValueError('SHA256 mismatch')
-
-
-def identifier(scheme, value):
-    if not isinstance(value, str) or any(char.isspace() or ord(char) < 32 or ord(char) == 127 for char in value):
-        raise ValueError('Invalid identifier')
-    if scheme == 'arxiv':
-        pattern = r'(?:\d{2}(?:0[1-9]|1[0-2])\.\d{4,5}|[a-zA-Z][a-zA-Z.-]*/\d{2}(?:0[1-9]|1[0-2])\d{3})'
-        valid = re.fullmatch(pattern, value)
-    elif scheme == 'doi':
-        valid = re.fullmatch(r'10\.\d{4,9}/\S+', value) and value == value.lower()
-    else:
-        valid = False
-    if not valid:
-        raise ValueError('Unsupported or noncanonical identifier: ' + scheme)
-
-
-def prepare(plan_path, output):
-    plan_raw, plan = metadata(plan_path)
-    object_keys(plan, ('format_version', 'inputs', 'assertions'))
-    if type(plan['format_version']) is not int or plan['format_version'] != 1:
-        raise ValueError('Unsupported format version')
-    if not isinstance(plan['inputs'], list) or not plan['inputs'] or not isinstance(plan['assertions'], list) or not plan['assertions']:
-        raise ValueError('Inputs and assertions must be nonempty lists')
-    output = Path(output).absolute()
-    if output.exists():
-        raise ValueError('Output directory must not already exist')
-    if not output.parent.is_dir():
-        raise ValueError('Output parent directory must exist')
-    assertions = {}
-    evidence_files = {}
-    checked_evidence = {}
-    for assertion in plan['assertions']:
-        object_keys(assertion, ('source', 'external_id', 'record_sha256', 'identifiers', 'evidence'))
-        if any(not isinstance(assertion[key], str) or not assertion[key] for key in ('source', 'external_id')):
-            raise ValueError('Invalid source identity')
-        key = (assertion['source'], assertion['external_id'])
-        if key in assertions:
-            raise ValueError('Duplicate identity assertion')
-        ids = assertion['identifiers']
-        if not isinstance(ids, dict) or not ids:
-            raise ValueError('Identifiers must be a nonempty object')
-        for scheme, value in ids.items():
-            identifier(scheme, value)
-        if not isinstance(assertion['evidence'], list) or not assertion['evidence']:
-            raise ValueError('Evidence is required')
-        references = []
-        for evidence in assertion['evidence']:
-            object_keys(evidence, ('file', 'sha256', 'url', 'checked_at', 'note'))
-            if not all(isinstance(value, str) and value for value in evidence.values()):
-                raise ValueError('Invalid evidence fields')
-            url = urlsplit(evidence['url'])
-            if url.scheme != 'https' or not url.hostname or url.username or url.password:
-                raise ValueError('Evidence requires an HTTPS URL without credentials')
-            if datetime.fromisoformat(evidence['checked_at'].replace('Z', '+00:00')).utcoffset() is None:
-                raise ValueError('Evidence timestamp requires a timezone')
-            evidence_key = (str(Path(evidence['file']).absolute()), evidence['sha256'])
-            if evidence_key not in checked_evidence:
-                checked_evidence[evidence_key] = metadata(evidence['file'], evidence['sha256'])[0]
-            raw = checked_evidence[evidence_key]
-            evidence_files[evidence['sha256']] = raw
-            references.append({**evidence, 'file': 'evidence/' + evidence['sha256'] + '.json'})
-        assertions[key] = (assertion, references)
-    seen = set()
-    applied = set()
-    names = set()
-    report = {'format_version': 1, 'plan_sha256': digest(plan_raw),
-              'verification_scope': SCOPE, 'semantic_identity_verified': False,
-              'database_written': False, 'files': [], 'assertions_applied': 0, 'identifiers_added': 0}
-    with tempfile.TemporaryDirectory(prefix='.identifier-curation-', dir=output.parent) as temporary:
-        staging = Path(temporary) / 'prepared'
-        staging.mkdir()
-        (staging / 'evidence').mkdir()
-        (staging / 'plan.json').write_bytes(plan_raw)
-        for sha, raw in evidence_files.items():
-            (staging / 'evidence' / (sha + '.json')).write_bytes(raw)
-        for entry in plan['inputs']:
-            object_keys(entry, ('file', 'sha256', 'manifest_sha256'))
-            path = Path(entry['file'])
-            if path.suffix != '.jsonl' or path.name in names:
-                raise ValueError('Inputs require distinct JSONL basenames')
-            names.add(path.name)
-            _, manifest = metadata(path.with_suffix('.manifest.json'), entry['manifest_sha256'])
-            if not isinstance(manifest, dict) or not {'source','venue','year','track','count','list_url','file_sha256'} <= manifest.keys():
-                raise ValueError('Complete source manifest required')
-            if manifest['file_sha256'] != entry['sha256']:
-                raise ValueError('Manifest and plan hashes differ')
-            before = hashlib.sha256()
-            after = hashlib.sha256()
-            count = 0
-            with path.open('rb') as source, (staging / path.name).open('wb') as target:
-                for raw in source:
-                    before.update(raw)
-                    row = decode(raw)
-                    if any(row[field] != manifest[field] for field in ('source', 'venue', 'year', 'track')):
-                        raise ValueError('Record differs from source manifest')
-                    key = (row['source'], row['external_id'])
-                    if key in seen:
-                        raise ValueError('Duplicate source identity in input batch')
-                    seen.add(key)
-                    if key in assertions:
-                        assertion, references = assertions[key]
-                        check_hash(raw, assertion['record_sha256'])
-                        existing = row.get('identifiers', {})
-                        if existing is None:
-                            existing = {}
-                        if not isinstance(existing, dict):
-                            raise ValueError('Invalid existing identifiers')
-                        for scheme, value in assertion['identifiers'].items():
-                            if scheme in existing and existing[scheme] != value:
-                                raise ValueError('Existing identifier conflict')
-                        details = row.setdefault('metadata', {})
-                        if not isinstance(details, dict):
-                            raise ValueError('Invalid record metadata')
-                        history = details.setdefault('identifier_curation', [])
-                        if not isinstance(history, list):
-                            raise ValueError('Invalid curation history')
-                        history.append({'plan_sha256': digest(plan_raw), 'input_file_sha256': entry['sha256'],
-                                        'record_sha256': digest(raw), 'previous_identifiers': dict(existing),
-                                        'identifiers_asserted': assertion['identifiers'], 'evidence': references,
-                                        'verification_scope': SCOPE})
-                        report['identifiers_added'] += len(assertion['identifiers'].keys() - existing.keys())
-                        row['identifiers'] = {**existing, **assertion['identifiers']}
-                        raw = json_bytes(row)
-                        applied.add(key)
-                    target.write(raw)
-                    after.update(raw)
-                    count += 1
-            if before.hexdigest() != entry['sha256'] or not re.fullmatch('[0-9a-f]{64}', entry['sha256']):
-                raise ValueError('Input SHA256 mismatch')
-            if not count or type(manifest['count']) is not int or count != manifest['count']:
-                raise ValueError('Manifest count mismatch')
-            provenance = {'plan_sha256': digest(plan_raw), 'input_file_sha256': before.hexdigest(),
-                          'input_manifest_sha256': entry['manifest_sha256'], 'verification_scope': SCOPE}
-            prepared = {**manifest, 'file': str(output / path.name), 'file_sha256': after.hexdigest(),
-                        'identifier_curation': provenance}
-            (staging / path.with_suffix('.manifest.json').name).write_bytes(json_bytes(prepared))
-            report['files'].append({'file': str(output / path.name), 'count': count,
-                                    'input_sha256': before.hexdigest(), 'sha256': after.hexdigest()})
-        if applied != assertions.keys():
-            raise ValueError('Assertion target absent from input batch')
-        report['assertions_applied'] = len(applied)
-        (staging / 'curation-report.json').write_bytes(json_bytes(report))
-        # All files are on the same filesystem. No database or input mutation.
-        if output.exists():
-            raise ValueError('Output directory appeared during preparation')
-        staging.rename(output)
-    return report
-
-
-def main(argv=None, *, prog=None):
-    parser = argparse.ArgumentParser(prog=prog, description=__doc__)
-    parser.add_argument('--plan', required=True, type=Path)
-    parser.add_argument('--output', required=True, type=Path)
-    args = parser.parse_args(argv)
-    print(json.dumps(prepare(args.plan, args.output), ensure_ascii=False))

paper_atlas/db/store.py

@@ -95,19 +95,13 @@ class Store:
             matches.add(old[0])
         key = normalized(title)
         title_matches = c.execute('SELECT id,authors_json,abstract FROM papers WHERE title_key=?',(key,)).fetchall()
-        # An existing identifier/source record anchors the entity. Title
+        authors_set = author_keys(authors)
-        # similarity must not pull in another deposit or an extended version.
+        for paper,old_authors,old_abstract in title_matches:
-        if not matches:
+            overlap = authors_set & author_keys(json.loads(old_authors))
-            title_only_matches = set()
+            # Cross-platform title matching needs independent author corroboration.
-            authors_set = author_keys(authors)
+            same_source = c.execute('SELECT 1 FROM source_records WHERE paper_id=? AND source_id=? LIMIT 1',(paper,source_id)).fetchone()
-            for paper,old_authors,old_abstract in title_matches:
+            if not same_source and len(key)>=25 and (len(overlap)>=2 or (overlap and abstract and abstract.strip()==(old_abstract or '').strip())):
-                overlap = authors_set & author_keys(json.loads(old_authors))
+                matches.add(paper)
-                same_source = c.execute('SELECT 1 FROM source_records WHERE paper_id=? AND source_id=? LIMIT 1',(paper,source_id)).fetchone()
-                if not same_source and len(key)>=25 and (len(overlap)>=2 or (overlap and abstract and abstract.strip()==(old_abstract or '').strip())):
-                    title_only_matches.add(paper)
-            if len(title_only_matches)>1:
-                raise ValueError('Ambiguous paper identity: multiple author-corroborated title matches; provide verified identifiers')
-            matches = title_only_matches
         if matches:
             paper = min(matches)
             for other in sorted(matches-{paper}):

tests/test_histories.py

@@ -1,114 +0,0 @@
-from pathlib import Path
-import tempfile
-import unittest
-
-from paper_atlas.audits.histories import report
-from paper_atlas.db.store import Store
-
-
-def add_history_fixture(store):
-    def event(work, forum, venue, year, track, status, observed):
-        paper, record = store.record('history_fixture', work + '/' + forum,
-            'https://example.org/' + forum, work + ' title\x00 preserved', 'Abstract', ['Jane Doe'],
-            {'arxiv': work})
-        store.decision(paper, record, venue, year, track, forum,
-            'https://example.org/' + forum + '/' + str(status), status, status or '',
-            identities=[('openreview', forum)], observed_at=observed)
-        return paper
-
-    # The negative observation was collected later: observation order is not chronology.
-    event('2501.00001', 'HistoryA01', 'ICLR', 2024, 'main', 'rejected', '2026-02-01T00:00:00Z')
-    event('2501.00001', 'HistoryA02', 'ICML', 2025, 'main', 'accepted', '2026-01-01T00:00:00Z')
-    event('2501.00002', 'HistoryB01', 'ICLR', 2024, 'main', 'rejected', '2026-01-01T00:00:00Z')
-    event('2501.00002', 'HistoryB01', 'ICLR', 2024, 'main', 'accepted', '2026-02-01T00:00:00Z')
-    event('2501.00003', 'HistoryC01', 'ICLR', 2024, 'main', 'desk_rejected', '2026-01-01T00:00:00Z')
-    event('2501.00003', 'HistoryC02', 'ICLR', 2024, 'workshop_example', 'accepted', '2026-02-01T00:00:00Z')
-    event('2501.00004', 'HistoryD01', 'ICML', 2025, 'main', 'accepted', '2026-01-01T00:00:00Z')
-    event('2501.00004', 'HistoryD01', 'ICML', 2025, 'main', 'withdrawn', '2026-02-01T00:00:00Z')
-    event('2501.00004', 'HistoryD02', 'ICLR', 2024, 'main', 'rejected', '2026-01-01T00:00:00Z')
-    event('2501.00005', 'HistoryE01', 'COLM', 2026, 'main', None, '2026-01-01T00:00:00Z')
-    store.conn.commit()
-
-
-class HistoryTests(unittest.TestCase):
-    def setUp(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.tmp.cleanup)
-        self.db = Path(self.tmp.name) / 'sample.sqlite'
-        self.store = Store(self.db)
-        self.addCleanup(self.store.conn.close)
-
-    def test_distinct_attempts_venues_and_latest_acceptances_are_not_observation_counts(self):
-        add_history_fixture(self.store)
-        result = report(self.db)
-        self.assertEqual(result['counts'], {
-            'papers_with_submissions': 5, 'papers_with_multiple_submissions': 3,
-            'papers_with_historical_negative': 4, 'papers_with_current_known_acceptance': 3,
-            'papers_with_negative_and_acceptance_in_distinct_attempts': 2,
-            'papers_with_negative_and_acceptance_in_distinct_venues': 1,
-            'submissions': 8, 'decision_observations': 9,
-            'attempts_with_historical_negative': 5,
-            'attempts_with_historical_negative_and_acceptance': 2,
-        })
-        self.assertEqual(result['latest_attempt_status_counts'],
-                         {'accepted': 3, 'desk_rejected': 1, 'rejected': 2, 'unknown': 1, 'withdrawn': 1})
-        self.assertEqual(len(result['examples']), 2)
-        first = result['examples'][0]
-        self.assertIn('\x00', first['title'])
-        self.assertEqual({r['venue'] for r in first['attempts']}, {'ICLR', 'ICML'})
-        self.assertTrue(all(r['decisions'][0]['sources'] for r in first['attempts']))
-        self.assertTrue(all(r['decisions'][0]['decision_date'] is None for r in first['attempts']))
-        self.assertIn('Not inferred', first['chronology'])
-        self.assertEqual(result['status'], 'observed_history_audit_not_final_dedup')
-        self.assertTrue(all(v == 0 for v in result['evidence_relationship_checks'].values()))
-
-    def test_missing_and_mislinked_source_evidence_is_reported_without_repair(self):
-        add_history_fixture(self.store)
-        self.store.conn.execute('DELETE FROM decision_sources WHERE decision_id=1')
-        self.store.conn.execute('DELETE FROM submission_sources WHERE submission_id=1')
-        # Record3 belongs to paper2; move it to paper1 to create a real mismatch.
-        self.store.conn.execute('UPDATE source_records SET paper_id=1 WHERE id=3')
-        self.store.conn.commit()
-        result = report(self.db, examples=0)
-        checks = result['evidence_relationship_checks']
-        self.assertEqual(checks['decisions_without_source_links'], 1)
-        self.assertEqual(checks['submissions_without_source_links'], 1)
-        self.assertEqual(checks['submission_source_paper_mismatches'], 1)
-        self.assertEqual(checks['decision_source_paper_mismatches'], 2)
-        self.assertEqual(self.store.conn.execute('SELECT paper_id FROM source_records WHERE id=3').fetchone()[0], 1)
-
-    def test_example_limit_does_not_change_global_counts(self):
-        add_history_fixture(self.store)
-        none, one = report(self.db, examples=0), report(self.db, examples=1)
-        self.assertEqual(none['counts'], one['counts'])
-        self.assertEqual(none['examples'], [])
-        self.assertEqual(len(one['examples']), 1)
-
-    def test_empty_snapshot_and_invalid_limit_do_not_create_missing_database(self):
-        empty = report(self.db)
-        self.assertTrue(all(v == 0 for v in empty['counts'].values()))
-        self.assertEqual(empty['latest_attempt_status_counts'], {})
-        absent = self.db.parent / 'absent.sqlite'
-        with self.assertRaisesRegex(ValueError, 'Examples'):
-            report(absent, examples=-1)
-        with self.assertRaisesRegex(ValueError, 'Existing database'):
-            report(absent)
-        self.assertFalse(absent.exists())
-
-    def test_truncated_example_keeps_the_cross_venue_acceptance_visible(self):
-        paper, record = self.store.record('fixture', 'many', 'https://example.org/many',
-                                          'Many attempts', 'Abstract', [])
-        for index in range(26):
-            accepted = index == 25
-            forum = f'BoundedForum{index}'
-            self.store.decision(paper, record, 'ICML' if accepted else 'ICLR', 2025, 'main', forum,
-                                'https://example.org/' + forum, 'accepted' if accepted else 'rejected',
-                                'Accept' if accepted else 'Reject', identities=[('openreview', forum)])
-        self.store.conn.commit()
-        result = report(self.db)
-        example, = result['examples']
-        self.assertEqual((example['attempt_count'], len(example['attempts'])), (26, 20))
-        self.assertTrue(example['attempts_truncated'])
-        self.assertEqual({row['latest_observed_status'] for row in example['attempts']},
-                         {'accepted', 'rejected'})
-        self.assertEqual(result['counts']['submissions'], 26)

tests/test_identifier_curation.py

@@ -1,185 +0,0 @@
-import copy
-import json
-from pathlib import Path
-import tempfile
-import unittest
-
-from paper_atlas.curation.identifiers import SCOPE, digest, json_bytes, prepare
-from paper_atlas.db.store import Store
-from paper_atlas.ingestion.records import ingest_file
-
-
-class IdentifierCurationTests(unittest.TestCase):
-    def setUp(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.tmp.cleanup)
-        self.root = Path(self.tmp.name)
-        self.output = self.root / 'prepared'
-        self.row = {'source':'dblp','external_id':'conf/uai/example','url':'https://example.org/paper',
-                    'title':'A sufficiently long example research paper title','abstract':None,
-                    'authors':['Jane Doe','John Smith'],'venue':'UAI','year':2001,'track':'main',
-                    'status':'accepted','tags':[{'namespace':'dblp:topic','value':'version\u2029study\x00'}],
-                    'metadata':{'pages':'203-210','raw_title':'Original\u2029title'}}
-        self.evidence = self.root / 'evidence.json'
-        self.evidence.write_bytes(json_bytes({'url':'https://example.org/archive','comment':'Conference version'}))
-        self.path = self.root / 'records.jsonl'
-        self.raw = json_bytes(self.row)
-        self.path.write_bytes(self.raw)
-        self.manifest = {'source':'dblp','venue':'UAI','year':2001,'track':'main','count':1,
-                         'list_url':'https://example.org/list','file_sha256':digest(self.raw),
-                         'status':'partial','missing_abstract_count':1,'parser_version':2}
-        self.path.with_suffix('.manifest.json').write_bytes(json_bytes(self.manifest))
-        self.plan = {'format_version':1,'inputs':[self.input(self.path)],'assertions':[
-            {'source':'dblp','external_id':self.row['external_id'],'record_sha256':digest(self.raw),
-             'identifiers':{'arxiv':'1408.1485'},'evidence':[{
-                 'file':str(self.evidence),'sha256':digest(self.evidence.read_bytes()),
-                 'url':'https://example.org/archive','checked_at':'2026-11-08T08:00:00Z',
-                 'note':'Reviewed title, authors, publication and version evidence'}]}]}
-
-    def input(self, path):
-        return {'file':str(path),'sha256':digest(path.read_bytes()),
-                'manifest_sha256':digest(path.with_suffix('.manifest.json').read_bytes())}
-
-    def run_plan(self, plan=None):
-        path = self.root / 'plan.json'
-        path.write_bytes(json_bytes(self.plan if plan is None else plan))
-        return prepare(path, self.output)
-
-    def test_only_identifiers_and_provenance_change_and_raw_inputs_survive(self):
-        result = self.run_plan()
-        self.assertEqual(self.path.read_bytes(), self.raw)
-        prepared = json.loads((self.output / self.path.name).read_bytes())
-        provenance = prepared['metadata'].pop('identifier_curation')
-        self.assertEqual(prepared.pop('identifiers'), {'arxiv':'1408.1485'})
-        self.assertEqual(prepared, self.row)
-        self.assertEqual(provenance[0]['record_sha256'], digest(self.raw))
-        self.assertEqual((self.output / provenance[0]['evidence'][0]['file']).read_bytes(), self.evidence.read_bytes())
-        manifest = json.loads((self.output / 'records.manifest.json').read_bytes())
-        for key, value in self.manifest.items():
-            if key != 'file_sha256': self.assertEqual(manifest[key], value)
-        self.assertEqual(manifest['file_sha256'], digest((self.output / self.path.name).read_bytes()))
-        self.assertEqual(result['assertions_applied'], 1)
-        self.assertEqual(result['identifiers_added'], 1)
-        self.assertEqual(result['verification_scope'], SCOPE)
-        self.assertFalse(result['semantic_identity_verified'])
-        self.assertFalse(result['database_written'])
-        self.assertEqual(list(self.output.glob('*.jsonl')), [self.output / self.path.name])
-        with self.assertRaisesRegex(ValueError, 'already exist'): self.run_plan()
-
-    def test_late_invalid_file_publishes_nothing(self):
-        second = self.root / 'second.jsonl'
-        second.write_bytes(json_bytes({**self.row,'external_id':'second'}))
-        manifest = {**self.manifest,'file_sha256':digest(second.read_bytes()),'count':2}
-        second.with_suffix('.manifest.json').write_bytes(json_bytes(manifest))
-        self.plan['inputs'].append(self.input(second))
-        with self.assertRaisesRegex(ValueError, 'count mismatch'): self.run_plan()
-        self.assertFalse(self.output.exists())
-        self.assertFalse(list(self.root.glob('.identifier-curation-*')))
-        self.assertEqual(self.path.read_bytes(), self.raw)
-
-    def test_unasserted_rows_keep_exact_physical_bytes_and_doi_is_additive(self):
-        untouched = (json.dumps({**self.row,'external_id':'unselected'},ensure_ascii=False,indent=None) + '  ').encode()
-        self.path.write_bytes(self.raw + untouched)
-        self.path.with_suffix('.manifest.json').write_bytes(json_bytes({**self.manifest,
-            'file_sha256':digest(self.path.read_bytes()),'count':2,'missing_abstract_count':2}))
-        self.plan['inputs'] = [self.input(self.path)]
-        self.plan['assertions'][0]['identifiers']['doi'] = '10.1234/example'
-        result = self.run_plan()
-        with (self.output / self.path.name).open('rb') as stream:
-            first = json.loads(next(stream))
-            self.assertEqual(next(stream), untouched)
-        self.assertEqual(first['identifiers'], {'arxiv':'1408.1485','doi':'10.1234/example'})
-        self.assertEqual(result['identifiers_added'], 2)
-
-    def test_missing_duplicate_and_mismatched_assertions_fail_closed(self):
-        for mode in ('missing','duplicate','line_hash','duplicate_input'):
-            with self.subTest(mode=mode):
-                plan = copy.deepcopy(self.plan)
-                assertion = plan['assertions'][0]
-                if mode == 'missing': assertion['external_id'] = 'absent'
-                elif mode == 'duplicate': plan['assertions'].append(copy.deepcopy(assertion))
-                elif mode == 'line_hash': assertion['record_sha256'] = '0' * 64
-                else:
-                    other = self.root / 'duplicate.jsonl'
-                    other.write_bytes(self.raw)
-                    other.with_suffix('.manifest.json').write_bytes(json_bytes(self.manifest))
-                    plan['inputs'].append(self.input(other))
-                with self.assertRaises(ValueError): self.run_plan(plan)
-                self.assertFalse(self.output.exists())
-
-    def test_identifier_conflict_does_not_overwrite_and_same_value_is_auditable(self):
-        self.row['identifiers'] = {'arxiv':'cs/0307069'}
-        self.path.write_bytes(json_bytes(self.row))
-        self.manifest['file_sha256'] = digest(self.path.read_bytes())
-        self.path.with_suffix('.manifest.json').write_bytes(json_bytes(self.manifest))
-        self.plan['inputs'] = [self.input(self.path)]
-        self.plan['assertions'][0]['record_sha256'] = digest(self.path.read_bytes())
-        with self.assertRaisesRegex(ValueError, 'identifier conflict'): self.run_plan()
-        self.assertFalse(self.output.exists())
-        self.plan['assertions'][0]['identifiers']['arxiv'] = 'cs/0307069'
-        self.assertEqual(self.run_plan()['identifiers_added'], 0)
-
-    def test_unsupported_changes_identifiers_and_unbound_evidence_are_rejected(self):
-        for mode in ('title','bad_month','version','unknown_scheme','doi_case','evidence_hash','credentials','timestamp'):
-            with self.subTest(mode=mode):
-                plan = copy.deepcopy(self.plan)
-                assertion = plan['assertions'][0]
-                evidence = assertion['evidence'][0]
-                if mode == 'title': assertion['title'] = 'Rewrite forbidden'
-                elif mode == 'bad_month': assertion['identifiers'] = {'arxiv':'1413.12345'}
-                elif mode == 'version': assertion['identifiers'] = {'arxiv':'1408.1485v2'}
-                elif mode == 'unknown_scheme': assertion['identifiers'] = {'url':'https://example.org'}
-                elif mode == 'doi_case': assertion['identifiers'] = {'doi':'10.1234/UPPER'}
-                elif mode == 'evidence_hash': evidence['sha256'] = '0' * 64
-                elif mode == 'credentials': evidence['url'] = 'https://user:secret@example.org'
-                else: evidence['checked_at'] = '2026-11-08T08:00:00'
-                with self.assertRaises(ValueError): self.run_plan(plan)
-                self.assertFalse(self.output.exists())
-
-    def test_input_and_manifest_hashes_and_duplicate_json_keys_are_checked(self):
-        for mode in ('input','manifest','duplicate_json','invalid_evidence_json'):
-            with self.subTest(mode=mode):
-                plan = copy.deepcopy(self.plan)
-                if mode == 'input':
-                    plan['inputs'][0]['sha256'] = '0' * 64
-                elif mode == 'manifest':
-                    plan['inputs'][0]['manifest_sha256'] = '0' * 64
-                elif mode == 'duplicate_json':
-                    raw = self.raw[:-2] + b',"source":"dblp"}\n'
-                    self.path.write_bytes(raw)
-                    self.path.with_suffix('.manifest.json').write_bytes(json_bytes({**self.manifest,'file_sha256':digest(raw)}))
-                    plan['inputs'] = [self.input(self.path)]
-                else:
-                    self.evidence.write_bytes(b'not json')
-                    plan['assertions'][0]['evidence'][0]['sha256'] = digest(self.evidence.read_bytes())
-                with self.assertRaises(ValueError): self.run_plan(plan)
-                self.assertFalse(self.output.exists())
-                self.path.write_bytes(self.raw)
-                self.path.with_suffix('.manifest.json').write_bytes(json_bytes(self.manifest))
-
-    def test_curated_anchor_import_does_not_merge_extended_version_or_its_history(self):
-        db = self.root / 'papers.sqlite'
-        store = Store(db)
-        try:
-            original, _ = store.record('arxiv','1408.1485','https://example.org/one',self.row['title'],None,self.row['authors'],{'arxiv':'1408.1485'})
-            extended, record = store.record('arxiv','cs/0307069','https://example.org/two',self.row['title'],None,self.row['authors'],{'arxiv':'cs/0307069'})
-            store.decision(extended,record,'ICLR',2025,'main','another-attempt','https://example.org/reject','rejected','Reject')
-            store.conn.commit()
-        finally:
-            store.conn.close()
-        self.run_plan()
-        ingest_file(db,self.output / self.path.name)
-        store = Store(db)
-        try:
-            c = store.conn
-            self.assertEqual(c.execute('SELECT count(*) FROM papers').fetchone()[0], 2)
-            self.assertEqual(c.execute('SELECT paper_id FROM source_records WHERE external_id=?',(self.row['external_id'],)).fetchone()[0], original)
-            self.assertEqual(c.execute('SELECT s.paper_id FROM submissions s JOIN editions e ON e.id=s.edition_id JOIN venues v ON v.id=e.venue_id WHERE v.acronym=?',('ICLR',)).fetchone()[0], extended)
-            self.assertEqual(c.execute('SELECT count(*) FROM paper_merges').fetchone()[0], 0)
-            self.assertEqual(c.execute('PRAGMA foreign_key_check').fetchall(), [])
-        finally:
-            store.conn.close()
-
-
-if __name__ == '__main__':
-    unittest.main()

tests/test_index_core.py

@@ -53,50 +53,6 @@ class StoreTests(unittest.TestCase):
         self.assertNotEqual(other,paper)
         self.assertEqual(self.store.conn.execute('SELECT count(*) FROM match_candidates').fetchone()[0],1)
 
-    def test_identifier_anchor_does_not_absorb_a_same_title_arxiv_version(self):
-        conference,first=self.record('arxiv','1408.1485')
-        extended,second=self.record('arxiv','cs/0307069')
-        self.store.decision(extended,second,'ICLR',2025,'main','separate','https://example.org/reject','rejected','Reject')
-        resolved,_=self.record('dblp','conf/uai/example',{'arxiv':'1408.1485'})
-        self.assertEqual(resolved,conference);self.assertNotEqual(conference,extended)
-        c=self.store.conn
-        self.assertEqual(c.execute('SELECT count(*) FROM papers').fetchone()[0],2)
-        self.assertEqual(c.execute('SELECT paper_id FROM submissions').fetchone()[0],extended)
-        self.assertEqual(c.execute('SELECT count(*) FROM paper_merges').fetchone()[0],0)
-        self.assertEqual(c.execute('SELECT count(*) FROM match_candidates').fetchone()[0],1)
-        # A refresh of the anchored original source is equally unambiguous.
-        self.assertEqual(self.record('arxiv','1408.1485')[0],conference)
-        self.assertEqual(c.execute('SELECT count(*) FROM papers').fetchone()[0],2)
-
-    def test_ambiguous_title_aborts_whole_file_without_merging_existing_entities(self):
-        self.record('arxiv','1408.1485');self.record('arxiv','cs/0307069')
-        self.store.conn.commit()
-        rows=[{'source':'dblp','external_id':'conf/uai/new','url':'https://example.org/new',
-               'title':'An unrelated earlier record in this file','abstract':None,'authors':[],
-               'venue':'UAI','year':2001,'track':'main','status':'accepted'},
-              {'source':'dblp','external_id':'conf/uai/ambiguous','url':'https://example.org/ambiguous',
-               'title':'A sufficiently long example research paper title','abstract':None,
-               'authors':['Jane Doe','John Smith'],'identifiers':{'doi':'10.0000/not-yet-known'},
-               'venue':'UAI','year':2001,'track':'main','status':'accepted'}]
-        path=Path(self.tmp.name)/'ambiguous.jsonl'
-        path.write_text(''.join(json.dumps(row)+'\n' for row in rows))
-        path.with_suffix('.manifest.json').write_text(json.dumps({'source':'dblp','list_url':'https://example.org/list','count':2}))
-        with self.assertRaisesRegex(ValueError,'Ambiguous paper identity'):ingest_file(self.db,path)
-        c=self.store.conn
-        for table,count in [('papers',2),('source_records',2),('submissions',0),('decisions',0),('paper_merges',0)]:
-            self.assertEqual(c.execute('SELECT count(*) FROM '+table).fetchone()[0],count,table)
-        self.assertEqual(c.execute('SELECT status FROM ingest_runs').fetchone()[0],'failed')
-
-    def test_explicit_bridge_merges_only_its_identifier_matches(self):
-        first,_=self.record('arxiv','2601.00001',authors=['First Author'])
-        second,_=self.record('arxiv','2601.00002',{'doi':'10.0000/bridge'},authors=['Second Author'])
-        unrelated,_=self.record('arxiv','2601.00003')
-        resolved,_=self.record('official','bridge',{'arxiv':'2601.00001','doi':'10.0000/bridge'})
-        self.assertEqual(resolved,min(first,second))
-        self.assertEqual(self.store.conn.execute('SELECT count(*) FROM papers').fetchone()[0],2)
-        self.assertIsNotNone(self.store.conn.execute('SELECT 1 FROM papers WHERE id=?',(unrelated,)).fetchone())
-        self.assertEqual(self.store.conn.execute('SELECT count(*) FROM paper_merges').fetchone()[0],1)
-
     def test_manifest_count_mismatch_rolls_back_records(self):
         path=Path(self.tmp.name)/'source.jsonl'
         path.write_text(json.dumps({'source':'pmlr','external_id':'v1/paper','url':'https://example.org/paper','title':'Paper','abstract':'Abstract','authors':[],'venue':'ICML','year':2023,'track':'main','status':'accepted'})+'\n')

tests/test_postgres.py

@@ -175,22 +175,6 @@ class PostgreSQLIntegrationTests(unittest.TestCase):
         finally:
             reader.close()
 
-    def test_history_audit_matches_sqlite_for_actual_postgresql_snapshot(self):
-        from paper_atlas.audits.histories import report
-        from tests.test_histories import add_history_fixture
-        store = Store(self.db)
-        try:
-            add_history_fixture(store)
-        finally:
-            store.conn.close()
-        expected = report(self.db)
-        self.assertEqual(self.migrate()['status'], 'complete')
-        actual = report(pg_service=self.service, pg_schema=self.target)
-        self.assertEqual(actual['engine'], 'postgresql')
-        self.assertEqual(actual['schema'], self.target)
-        for key in ('counts', 'latest_attempt_status_counts', 'evidence_relationship_checks', 'examples'):
-            self.assertEqual(actual[key], expected[key], key)
-
     def interrupt_after_first_table(self):
         calls = 0
         def interrupt(*args):

tests/test_postgres_ingestion.py

@@ -110,34 +110,6 @@ class PostgreSQLIngestionTests(unittest.TestCase):
         finally:
             reader.close()
 
-    def test_identity_anchor_keeps_other_arxiv_version_and_ambiguous_file_rolls_back(self):
-        title='An identical long research title shared by conference and extended versions'
-        authors=['Jane Doe','John Smith']
-        store=self.store()
-        try:
-            first,_=store.record('arxiv','1408.1485','https://arxiv.org/abs/1408.1485',title,'Conference abstract',authors)
-            second,_=store.record('arxiv','cs/0307069','https://arxiv.org/abs/cs/0307069',title,'Extended abstract',authors)
-            resolved,_=store.record('dblp','known','https://example.org/known',title,None,authors,{'arxiv':'1408.1485'})
-            self.assertEqual(resolved,first);self.assertNotEqual(first,second)
-            store.conn.commit()
-            self.assertEqual(store.conn.execute('SELECT count(*) FROM papers').fetchone()[0],3)
-            self.assertEqual(store.conn.execute('SELECT count(*) FROM paper_merges').fetchone()[0],1)  # migration fixture only
-            self.assertEqual(store.conn.execute('SELECT count(*) FROM match_candidates').fetchone()[0],1)
-        finally:store.conn.close()
-        rows=[self.row('official','earlier',status='accepted',venue='UAI',year=2001),
-              dict(self.row('official','ambiguous',status='accepted',venue='UAI',year=2001),
-                   title=title,abstract=None,authors=authors,identifiers={})]
-        with self.assertRaisesRegex(ValueError,'Ambiguous paper identity'):self.ingest(self.file('ambiguous-identity',rows))
-        store=self.store()
-        try:
-            self.assertEqual(store.conn.execute('SELECT count(*) FROM papers').fetchone()[0],3)
-            self.assertEqual(store.conn.execute('SELECT count(*) FROM source_records').fetchone()[0],4)
-            self.assertEqual(store.conn.execute('SELECT count(*) FROM submissions').fetchone()[0],1)
-            self.assertEqual(store.conn.execute('SELECT count(*) FROM paper_merges').fetchone()[0],1)
-            self.assertEqual(store.conn.execute('SELECT status FROM ingest_runs ORDER BY id DESC LIMIT 1').fetchone()[0],'failed')
-            self.assertEqual(store.conn.execute("SELECT count(*) FROM source_records WHERE external_id IN (?,?)",('earlier','ambiguous')).fetchone()[0],0)
-        finally:store.conn.close()
-
     def test_file_import_is_idempotent_and_refreshes_only_own_tags(self):
         row = self.row(); row['tags'] = [{'namespace': 'openreview_snapshot:area', 'value': 'theory'}]
         path = self.file('reject', [row]); self.ingest(path)

tests/test_public_openreview.py

@@ -45,10 +45,12 @@ class PublicOpenReviewTests(unittest.TestCase):
 
     def test_only_explicit_decisions_and_verified_scope_become_events(self):
         for value in ('Pending', 'Active', 'Submitted to NeurIPS 2025', 'TBD', '',
-                      'Low score', 'ICML 2025 Retracted by Authors', 'Do not reject'):
+                      'Low score', 'ICML 2025 Retracted by Authors', 'Do not reject',
+                      'Workshop', 'Poster Workshop', 'Oral Workshop'):
             self.assertIsNone(negative_status(value), value)
         self.assertEqual(negative_status('Reject'), 'rejected')
         self.assertEqual(negative_status('Desk rejected'), 'desk_rejected')
+        self.assertEqual(negative_status('Withdraw'), 'withdrawn')
         self.assertEqual(negative_status('NeurIPS 2023 Conference Withdrawn Submission'), 'withdrawn')
         for raw, expected in [('main', 'main'), ('Position', 'position'),
                               ('Datasets & Benchmarks', 'datasets_benchmarks')]:
@@ -98,6 +100,121 @@ class PublicOpenReviewTests(unittest.TestCase):
                 self.assertEqual(list(Path(tmp).glob('*.jsonl')), [])
                 self.assertFalse((Path(tmp) / 'public-openreview-inventory.json').exists())
 
+    def test_missing_title_is_held_without_losing_valid_negative_records(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            result = self.collect(tmp, {'venues/iclr/iclr2017.jsonl': [
+                self.row(id='SJUdkecgx', title=''),
+                self.row(id='NoTitle001', title=None),
+                self.row(id='Whitespace', title='  '),
+                self.row(id='ValidReject'),
+                self.row(id='Withdraw01', status='Withdraw'),
+                self.row(id='Workshop01', status='Workshop'),
+            ]}, families=['iclr'], years=[2017])
+            self.assertEqual(result['input_rows'], 6)
+            self.assertEqual(result['normalized_records'], 2)
+            self.assertEqual(result['source_files'][0]['excluded_or_held'],
+                             {'missing_title': 3, 'not_explicit_negative': 1})
+            held_path = Path(result['held_file'])
+            self.assertEqual(hashlib.sha256(held_path.read_bytes()).hexdigest(),
+                             result['held_file_sha256'])
+            held = [json.loads(line) for line in held_path.read_text().splitlines()]
+            self.assertEqual([row['id'] for row in held], ['SJUdkecgx', 'NoTitle001', 'Whitespace'])
+            self.assertTrue(all(row['reason'] == 'missing_title' and row['status'] == 'Reject'
+                                for row in held))
+            self.assertEqual([row['provenance']['source_line'] for row in held], [1, 2, 3])
+            self.assertNotIn('private@example.org', held_path.read_text())
+            self.assertNotIn('private review', held_path.read_text())
+            manifest = result['files'][0]
+            self.assertEqual((manifest['parser_version'], manifest['status']), (3, 'partial'))
+            rows = [json.loads(line) for line in Path(manifest['file']).read_text().splitlines()]
+            self.assertEqual([(row['identifiers']['openreview'], row['status']) for row in rows],
+                             [('ValidReject', 'rejected'), ('Withdraw01', 'withdrawn')])
+            for row in held:
+                self.assertEqual(row['provenance']['source_revision'], REVISION)
+
+    def test_nontext_title_still_fails_collection(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with self.assertRaisesRegex(ValueError, 'lacks a title'):
+                self.collect(tmp, {'venues/iclr/iclr2017.jsonl': [self.row(title=['invalid'])]},
+                             families=['iclr'], years=[2017])
+            self.assertFalse((Path(tmp) / 'public-openreview-inventory.json').exists())
+            self.assertEqual(list(Path(tmp).glob('*.jsonl')), [])
+
+    def workshop_cases(self):
+        return [
+            (2024, 'workshop_me_fomo', 'ICLR 2024 Workshop MEFoMo Withdrawn Submission', 'withdrawn', 'ME-FoMo'),
+            (2024, 'workshop_genai4dm', 'ICLR 2024 Workshop GenAI4DM Withdrawn Submission', 'withdrawn', 'GenAI4DM'),
+            (2025, 'workshop_agenticai', 'ICLR 2025 Workshop AgenticAI Reject', 'rejected', 'AgenticAI'),
+            (2025, 'workshop_lmrl', 'ICLR 2025 Workshop LMRL Withdrawn Submission', 'withdrawn', 'LMRL'),
+            (2026, 'workshop_llm_reasoning', 'ICLR 2026 Workshop LLM Reasoning Withdrawn Submission', 'withdrawn', 'LLM_Reasoning'),
+        ]
+
+    def test_iclr_workshop_labels_require_opt_in_and_retain_identity_evidence(self):
+        for year, track, label, status, group in self.workshop_cases():
+            with self.subTest(label=label):
+                raw = self.row(track=track, status=label)
+                self.assertEqual(normalize(raw, 'iclr', year, self.provenance()),
+                                 (None, 'separate_workshop'))
+                row, reason = normalize(raw, 'iclr', year, self.provenance(), True)
+                self.assertIsNone(reason)
+                self.assertEqual((row['venue'], row['year'], row['track'], row['status']),
+                                 ('ICLR', year, track, status))
+                self.assertEqual(row['raw_decision'], label)
+                self.assertEqual(row['metadata']['workshop_venueid'],
+                                 f'ICLR.cc/{year}/Workshop/{group}')
+                self.assertFalse(row['metadata']['original_decision_signature_verified'])
+                self.assertEqual(row['evidence_url'], 'https://example.org/pinned.jsonl#L7')
+                self.assertNotIn('private review', json.dumps(row))
+
+    def test_workshop_label_scope_conflicts_never_become_main_events(self):
+        for year, track, label, _, _ in self.workshop_cases():
+            for enabled in (False, True):
+                for wrong_track in ('main', 'workshop_other'):
+                    self.assertEqual(normalize(self.row(track=wrong_track, status=label),
+                                               'iclr', year, self.provenance(), enabled),
+                                     (None, 'conflicting_workshop_track'))
+                for family, wrong_year in [('icml', year), ('iclr', year + 1)]:
+                    with self.assertRaisesRegex(ValueError, 'conference year'):
+                        normalize(self.row(track=track, status=label), family,
+                                  wrong_year, self.provenance(), enabled)
+        row, reason = normalize(self.row(track='workshop_unknown',
+                                        status='ICLR 2026 Workshop Unknown Reject'),
+                                'iclr', 2026, self.provenance(), True)
+        self.assertIsNone(row)
+        self.assertEqual(reason, 'unmapped_negative_label')
+
+    def test_workshop_collection_and_import_keep_five_tracks_separate_from_main(self):
+        files = {}
+        for index, (year, track, label, _, _) in enumerate(self.workshop_cases()):
+            files.setdefault(f'venues/iclr/iclr{year}.jsonl', []).append(
+                self.row(id=f'Workshop{index:02}', track=track, status=label))
+        files['venues/iclr/iclr2024.jsonl'].append(self.row())
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            default = self.collect(root / 'default', files, families=['iclr'])
+            self.assertEqual(default['normalized_records'], 1)
+            held = [json.loads(line) for line in Path(default['held_file']).read_bytes().split(b'\n') if line]
+            self.assertEqual(len(held), 5)
+            self.assertTrue(all(row['reason'] == 'separate_workshop' for row in held))
+            selected = self.collect(root / 'selected', files, families=['iclr'], include_workshops=True)
+            self.assertEqual(selected['normalized_records'], 6)
+            self.assertEqual(len(selected['files']), 6)
+            self.assertEqual(Path(selected['held_file']).read_bytes(), b'')
+            db = root / 'db.sqlite'
+            for manifest in selected['files']:
+                self.assertEqual(manifest['parser_version'], 3)
+                ingest_file(db, manifest['file'])
+            store = Store(db)
+            try:
+                scopes = set(store.conn.execute('SELECT e.year,e.track,d.status FROM submissions s '
+                                               'JOIN editions e ON e.id=s.edition_id '
+                                               'JOIN decisions d ON d.submission_id=s.id'))
+                expected = {(year, track, status) for year, track, _, status, _ in self.workshop_cases()}
+                self.assertEqual(scopes, expected | {(2024, 'main', 'rejected')})
+                self.assertEqual(store.conn.execute('PRAGMA foreign_key_check').fetchall(), [])
+            finally:
+                store.conn.close()
+
     def test_mirror_reimport_preserves_one_attempt_and_later_acceptance_elsewhere(self):
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)
@@ -152,35 +269,6 @@ class PublicOpenReviewTests(unittest.TestCase):
             finally:
                 store.conn.close()
 
-    def test_unicode_separators_in_abstract_survive_audit_and_import(self):
-        for separator in ('\u0085', '\u2028', '\u2029'):
-            with self.subTest(separator=repr(separator)), tempfile.TemporaryDirectory() as tmp:
-                root = Path(tmp)
-                abstract = 'First paragraph' + separator + 'Second paragraph'
-                result = self.collect(root / 'source', {
-                    'venues/icml/icml2025.jsonl': [self.row(abstract=abstract)]})
-                path = Path(result['files'][0]['file'])
-                data = path.read_bytes()
-                self.assertIn(separator.encode(), data)
-                self.assertEqual(data.count(b'\n'), 1)
-                db = root / 'db.sqlite'
-                store = Store(db)
-                store.conn.close()
-                inventory = root / 'source/public-openreview-inventory.json'
-                before = audit(db, inventory, root / 'before.json')
-                self.assertEqual(before['status'], 'ready_for_serial_import')
-                self.assertEqual(before['records_checked'], 1)
-                ingest_file(db, path)
-                after = audit(db, inventory, root / 'after.json')
-                self.assertEqual(after['status'], 'ready_for_serial_import')
-                self.assertEqual(after['existing_same_edition_attempts'], 1)
-                store = Store(db)
-                try:
-                    self.assertEqual(store.conn.execute(
-                        'SELECT abstract FROM source_records').fetchone()[0], abstract)
-                finally:
-                    store.conn.close()
-
 
 if __name__ == '__main__':
     unittest.main()