Merge pull request '封装来源身份只读预检与投稿历史证据' (#51 ) from codex/source-identity-audit into main

Reviewed-on: #51
Add read-only source identity candidate audit with evidence shards
2026-11-10 06:55:25 +00:00 · 2026-11-10 02:55:27 +08:00 · 2026-11-09 18:49:37 +00:00 · 2026-11-09 18:49:29 +00:00 · 2026-11-10 02:18:38 +08:00 · 2026-11-10 01:12:45 +08:00
92 changed files with 30172 additions and 33 deletions
@@ -12,7 +12,7 @@ jobs:
      - name: Verify metadata storage and query commands
        run: |
          python3 -B - <<'PY'
-          import io, os, pathlib, re, subprocess, tarfile, tempfile, urllib.request
+          import gzip, io, json, os, pathlib, re, subprocess, tarfile, tempfile, urllib.request
          sha = os.environ['ARCHIVE_SHA']
          if not re.fullmatch(r'[0-9a-fA-F]{40,64}', sha):
              raise SystemExit('Invalid source commit')
@@ -48,17 +48,61 @@ jobs:
              outside.mkdir()
              subprocess.run([str(venv/'bin/paper-atlas'),'--help'],cwd=outside,check=True)
              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','cvf','--help'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','www-archive','--help'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','aamas-proceedings','--help'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','neurips-program','--help'],cwd=outside,check=True)
+              neurips_snapshots = root/'neurips2026-program-snapshots'
+              neurips_snapshots.mkdir()
+              (neurips_snapshots/'program-json.response').write_bytes(gzip.decompress((src/'tests/fixtures/neurips2026-program.json.gz').read_bytes()))
+              (neurips_snapshots/'receipts.json').write_bytes((src/'tests/fixtures/neurips2026-receipts.json').read_bytes())
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','neurips-program','--snapshots',str(neurips_snapshots),'--out',str(root/'installed-neurips2026-program')],cwd=outside,check=True)
+              neurips_report = json.loads((root/'installed-neurips2026-program/neurips-program-2026.json').read_text())
+              assert neurips_report['records'] == 9004 and len(neurips_report['held_presentations']) == 139
+              assert len(neurips_report['exact_duplicate_event_rows']) == 1 and neurips_report['folded_extra_presentation_rows'] == 132
+              assert not neurips_report['database_written'] and not neurips_report['pdfs_downloaded']
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','dblp-family','--help'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','aamas-proceedings','--year','2025','--snapshots',str(src/'tests/fixtures/aamas2025'),'--out',str(root/'installed-aamas2025')],cwd=outside,check=True)
+              aamas2026 = json.loads(gzip.decompress((src/'tests/fixtures/aamas2026-fixture.json.gz').read_bytes()))
+              aamas2026_snapshots = root/'aamas2026-snapshots'
+              aamas2026_snapshots.mkdir()
+              (aamas2026_snapshots/'contents.html').write_text(aamas2026['contents'])
+              (aamas2026_snapshots/'receipts.json').write_text(json.dumps(aamas2026['receipts']))
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','aamas-proceedings','--year','2026','--snapshots',str(aamas2026_snapshots),'--out',str(root/'installed-aamas2026')],cwd=outside,check=True)
+              aamas2026_report = json.loads((root/'installed-aamas2026/aamas-proceedings-2026.json').read_text())
+              assert aamas2026_report['records'] == 639 and len(aamas2026_report['held_publications']) == 1
+              assert aamas2026_report['status_counts'] == {'accepted': 638, 'withdrawn': 1}
+              assert not aamas2026_report['database_written'] and not aamas2026_report['pdfs_downloaded']
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','iclr-archive','--help'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','acl','--help'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','springer-selected','--help'],cwd=outside,check=True)
+              springer = json.loads(gzip.decompress((src/'tests/fixtures/springer-aistats1993-fixture.json.gz').read_bytes()))
+              for group in ('toc','chapters'):
+                  folder = root/'springer-snapshots'/group
+                  folder.mkdir(parents=True)
+                  for name, content in springer[group].items():
+                      (folder/name).write_text(content)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','collect','springer-selected','--toc-snapshots',str(root/'springer-snapshots/toc'),'--chapter-snapshots',str(root/'springer-snapshots/chapters'),'--out',str(root/'installed-springer')],cwd=outside,check=True)
+              springer_report = json.loads((root/'installed-springer/collection-report.json').read_bytes())
+              assert springer_report['records'] == 49 and not springer_report['database_written']
+              springer_manifest, = springer_report['files']
+              assert springer_manifest['status'] == 'partial' and springer_manifest['missing_abstract_count'] == 0
              subprocess.run([python,'-I','-B','-m','paper_atlas','maintain','postgres','--help'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','maintain','edition-tracks','--help'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','maintain','joint-editions','--help'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','maintain','event-identity','--help'],cwd=outside,check=True)
              subprocess.run([python,'-I','-B','-m','paper_atlas','import','records','--help'],cwd=outside,check=True)
              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','coverage','--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','audit','source-identities','--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','annotate','init','--db','installed.sqlite'],cwd=outside,check=True)
+              subprocess.run([python,'-I','-B','-m','paper_atlas','annotate','list','--db','installed.sqlite','--paper','1'],cwd=outside,check=True)
              subprocess.run([python,'-I','-B','-m','paper_atlas','audit','histories','--db','installed.sqlite','--examples','0'],cwd=outside,check=True)
          PY
@@ -6,8 +6,18 @@ Paper Atlas 将 arXiv、AI 会议论文集及公开投稿决定整理到可追

 项目仍在建设中。候选范围包含 43 个会议（含 ACM MM、MLSys），尚未完成全部历史数据和最终去重复核。实际进度以数据库、来源清单和覆盖报告为准，而不是仓库文件数量。

+当前主动补漏从 **2020 年**起；2000 年起已发现的名单、缺口与待办保存在[补漏恢复清单](docs/coverage/backfill-handoff-2026-11-10.md)，下次从这里接续。已有旧数据保留，范围排除不算补齐。
+
+AAMAS 2026 的官方 HTML 目录由 `collect aamas-proceedings --year 2026` 适配，区分 track 和发表形式，keynote 排除、撤稿证据单独保留；[采集与恢复说明](docs/aamas-proceedings.md)。采集不写数据库，仍需身份核验和增量导入。
+
+历史 ICLR 2014–2016 官方录用页由 `collect iclr-archive` 适配，保留主会/workshop及重复展示证据；运行和身份核验边界见 [历史档案说明](docs/coverage/iclr-archive-2014-2016.md)。
+
+`collect springer-selected` 核验限定的会后选集，分开保存会议年份、出版年份及选集事件身份。目前支持 AISTATS 1993 对应的 1994 年出版选集，原始会议决定仍须单独核查；配置、证据和恢复见 [会后选集说明](docs/springer-selected-volumes.md)。
+
 ## 项目结构

+ACL 1963 的 AMTCL 年会摘要与 1978 的 TINLAP-2 来源关系均按精确卷适配，保留原系列、出版形式和不明逐篇角色；不将 EarlyMT 全系列映射到 ACL，1965 的替代关系也不转成全局别名。来源、排除条目和恢复边界见 [ACL 早期来源核查](docs/coverage/acl-early-sources-2026-11-09.md)。
+
 ```text
 paper_atlas/
  cli.py                 统一命令入口
@@ -60,6 +70,16 @@ paper-atlas collect colm --cache /data/paper-index/raw/http-cache \
  --out /data/paper-index/collected
 ```

+NeurIPS 2026 的[官方节目采集器](docs/neurips-program.md)按 main、evaluations/datasets、position 分开保存，合并同一 forum 的口头与海报展示，保留期刊等未决关系；运行 `paper-atlas collect neurips-program`。它只生成元数据文件，身份核验和生产导入另行执行。
+
+早期主系列的Workshop名称按[ICML/IROS精确届次证据](docs/coverage/historical-primary-series-2026-11-09.md)识别，保留原名与范围证据；代码支持不代表已补齐生产数据。
+
+EWSL、EPS、ECP、EWSP 的[具体前身卷与完整快照要求](docs/coverage/historical-predecessors-2026-11-09.md)单独核验，保留原始系列及事件/出版年份；旧候选文件缺少 ECP/EWSP 时会明确提示，避免静默遗漏。
+
+AAMAS 的[官方论文集采集器](docs/aamas-proceedings.md)支持已核验的 2012、2025 版式，可从缓存或已校验快照采集元数据。2025 年目录含 476 条非 keynote 出版物，保留完整作者和机构，HTML 未提供摘要时留空；发表形式与投稿 track 分开，不根据主题推定主会轨道或研究类型。
+
+旧 DBLP 候选文件可能漏掉新命名空间。`collect dblp-family` 可从已校验的固定压缩快照和完整目录中[恢复指定 family 的原始候选](docs/dblp-family-recovery.md)，例如 `ifaamas`；恢复文件保留卷、keynote 和 workshop 等原始条目，需另做来源范围与身份核验。
+
 `paper-atlas collect --help` 查看来源；`paper-atlas import --help` 查看导入方式。完整批次步骤见[使用指南](docs/usage.md)。

 共享实例名为 `foundry-postgres`，数据位于 `foundry_data` 库的 `research` schema；其他项目可按权限复用同一组表。库名通过 libpq service 配置、schema 通过 search_path 或 `--pg-schema` 指定，不写死在查询中。PostgreSQL 凭据放在服务器权限为 `0600` 的 libpq service 文件中；命令行只使用服务名称。`paper-atlas maintain postgres --help` 提供迁移入口：先完整核验 21 张业务表，再发布目标 schema。SQLite FTS5 内部表由 PostgreSQL GIN 索引替代。切换后 SQLite 为只读备份；`import records`、`import arxiv` 和 `maintain backfill` 使用 `--pg-service foundry-research` 写入主库，整个写入会话只允许一个协调写入者，会议文件失败时整体回滚并保留失败批次记录。
@@ -87,3 +107,14 @@ paper-atlas collect colm --cache /data/paper-index/raw/http-cache \
 CI 在已授权的远程 runner 上运行测试、构建 wheel，并从源码目录外验证安装后的命令及随包资源。数据库全量去重和覆盖率是独立的数据验收步骤，不因代码测试通过而自动完成。

 开发通过工作分支和 PR 交付，由用户手动合并。
+
+早期WWW档案的可重放元数据采集、论文/海报分轨与待核查条目见 [WWW档案采集](docs/www-archive.md)。
+历史联合会议的既有届次归属可通过 [`maintain joint-editions`](docs/joint-editions.md) 先只读规划，再按计划哈希执行；保留论文与投稿决定来源，不重导入。
+同年多届的 `event_key`、显式迁移、旧文件刷新与查询边界见 [会议事件身份](docs/event-identity.md)。
+研究类型与自定义标签可通过 [`annotate`](docs/annotations.md) 显式初始化、添加和撤回；两者独立查询，保留证据及完整更正历史，不从会议轨道推断研究类型。
+
+整合后的运行版本依赖、交互约束和生产切换顺序见 [运行版本整合](docs/research-runtime.md)。
+
+已导入整卷的逐条轨道修正见 [edition-tracks 维护流程](docs/edition-tracks.md)：按完整证据生成只读计划，保留原投稿和决定 ID，事务性修正 edition、标识与覆盖，并防止旧整卷刷新覆盖分类。
+
+入库前可使用通用的[来源身份只读预检](docs/source-identity-audit.md)，导出候选论文、稳定标识和既有投稿决定证据；候选结果需要审核，不会自动批准导入。
@@ -0,0 +1,76 @@
+# AAMAS 官方论文集元数据
+
+`paper_atlas.collectors.aamas` 是按需运行的采集适配器，通过统一入口 `collect aamas-proceedings` 使用。支持已独立核验的 **AAMAS 2012、2025、2026** HTML 版式；其他年份需先核对官方目录和逐篇结构，再增加适配，不能仅替换年份。2025、2026 解析分别封装在 `paper_atlas.collectors.aamas2025`、`paper_atlas.collectors.aamas2026`。
+
+
+## AAMAS 2026
+
+2026 只读取[官方 HTML 目录](https://www.ifaamas.org/Proceedings/aamas2026/forms/contents.htm)，不下载 PDF。冻结目录 SHA256 `ce2bc7fc5da340930343901506a9ce37c0334d4068f07546431c9deee3f13de9`，643 个条目：keynote 3、research 338、extended abstract 185、AAAI 19、Blue Sky 17、doctoral 34、demo 44、JAAMAS 3。
+
+排除 3 个 keynote；research 的 p238 明确标注 `Retracted June 8, 2026`，完整题名、作者、栏目、日期、原文和来源回执保存在采集报告 `held_publications` 中，**不会输出 accepted 或 withdrawn 投稿记录**。当前决定模型没有独立 retracted 状态，后续须单独建模和核验；原始证据不能删除。任何新增或改变的撤稿标记都会停止采集，等待人工核查。
+
+另一个 extended abstract p3178 明确标注 `Withdrawn June 8, 2026`，输出 `withdrawn`，在 metadata 保留日期 `2026-06-08` 和日精度；原网页没有时区/时刻，不能伪造决定 timestamp，不补造其此前的接受决定或 PDF 链接。因此 639 个输出条目是 **638 accepted、1 withdrawn**，按六个 track 分组：`proceedings_unspecified` 522、`aaai_transfer` 19、`blue_sky` 17、`doctoral` 34、`demo` 44、`jaamas` 3。全文/扩展摘要是发表形式，不是研究类型；research 栏目不能证明每篇原始 main/special 投稿轨道。JAAMAS 保留期刊展示语义，不制造另一次独立审稿录用。
+
+[AAAI 转投详细政策](https://cyprusconferences.org/aamas2026/call-for-papers-aaai-track/) 要求基于 AAAI-26 rejected 稿件；[总览](https://cyprusconferences.org/aamas2026/calls/) 却写 AAAI-25，须保留冲突。采集器保留 AAAI 栏目归属，不据此生成原 AAAI 投稿 ID、年份或逐篇拒稿决定。目录不是原始决定 note，未来关联仍需逐篇证据。
+
+```sh
+paper-atlas collect aamas-proceedings --year 2026 \
+  --snapshots /data/paper-index/collected/aamas2026-primary-evidence-v1 \
+  --out /data/paper-index/collected/aamas2026-normalized-v1
+```
+
+在线模式将 `--snapshots` 换成 `--cache /data/paper-index/cache/aamas2026`。冻结模式 `receipts.json` 的 `receipts` 至少包含官方目录 URL、相对 `file`、`bytes`、`sha256`、`status=200` 和带时区 `finished_at`。拒绝越界路径、越界符号链接、失败状态、哈希/大小不符的页面。这里只读取目录对应回执，其他已冻结政策网页继续保留。
+
+输出六组 JSONL/manifest、原始 HTML 与最后发布的 `aamas-proceedings-2026.json`；统一入口沿用输出目录锁和暂存目录。manifest 全部为 `partial`，639 条 HTML 摘要缺失如实记录。发布编号使用年份和起始页，随机 PDF 文档 ID 单独保留，不能沿用 2025 的 pN.pdf 规则。
+
+首次部署先核对来源哈希和生产状态，再在新输出目录运行采集、独立比对 643 条标题/作者/栏目分区，随后做 PostgreSQL 身份预检与增量导入。采集、远程 CI 通过或目录含某个年份均不代表生产已导入、摘要齐全或最终去重完成。较早年份不自动启动补采，当前主动补漏范围按用户要求从 2020 年起。
+
+## AAMAS 2025
+
+2025 版式使用[官方首页](https://www.ifaamas.org/Proceedings/aamas2025/)和[出版目录](https://www.ifaamas.org/Proceedings/aamas2025/forms/contents.htm)。原始目录共 479 条：3 keynote、260 research paper、148 extended abstract、12 Blue Sky、25 doctoral、22 Demo 栏目、9 JAAMAS。排除 keynote，输出 476 条；Demo 栏目中的 p3000 是明确标题的 COMP24 竞赛报告，发表年份仍为 2025，格式记 `competition_report`、投稿 track 留作 `proceedings_unspecified`，保留原 Demo 栏目证据。其余输出按 track 分组为 409 unspecified、12 blue_sky、25 doctoral、21 demo、9 jaamas。
+
+作者按逐篇 BR 行解析，斜体机构原文另存，保留 Unicode、顺序及完整名单。HTML 没有提供摘要或逐篇 DOI，故 `abstract=null`、标识字典为空；只保存 PDF 链接，不下载研究 PDF。不能把 Research Paper Track 的所有条目推成 main，不能把目录缺席推为 rejected/withdrawn，也不能把出版格式标签当研究类型。
+
+2025 用法：`paper-atlas collect aamas-proceedings --year 2025 --snapshots /data/review/aamas2025 --out /data/paper-index/collected/aamas-2025`；在线模式改用 `--cache /data/paper-index/cache/aamas2025`，只请求上述两个 HTML 页面。快照目录包含原始 `index.html`、`contents.html` 和 `receipts.json`，凭据必须列出各原始 URL、文件、字节数、SHA256、`http_status=200` 和带时区 `at`。已恢复的凭据需保留 `at_precision=filesystem_write_time_recovered` 等说明，不能伪造 HTTP 头或请求时间。2026-11-09 保存的两个页面通过哈希校验；独立录用清单 URL 返回 403，失败保留，不绕过或依赖其完成采集。
+
+2025 命令同样使用目录锁、临时目录、最后写入采集报告。五个 JSONL/manifest 均保持 `partial`，记录摘要缺失数量；它不连接数据库。首次采集需独立核验全部标题/作者/栏目和 source IDs，随后做 PostgreSQL 身份预检、必要的逐条版本审核、原生导入与独立验收。若失败且没有完成报告，应先检查原始响应和错误，再使用新输出目录重跑，不重放已提交批次。代码验证、原始目录盘点和采集成功均不代表已导入生产或最终去重完成。
+
+## 来源与范围
+
+[官方论文集介绍](https://www.ifaamas.org/Proceedings/aamas2012/)及其 Full Papers、Extended Abstracts、Demos、Doctorial Consortium Abstracts 四个栏目分别列出 136、146、28、24 条，共 334 条。旧 DBLP 候选卷的 310 条不能替代这四类官方目录，也不能全部标记为主会全文。栏目数量来自 2026-11-09 冻结的原始页面；页面结构或数量发生变化时，采集器停止，留待重新核验。
+
+采集标题、逐篇作者、页面实际提供的摘要、官方条目 ID、目录锚点和 PDF 地址。**只保存 PDF 链接，不下载 PDF。** 全文页面的摘要藏在标题链接内部的 `abstract` 元素，作者链接里的 “has N papers” 是界面徽标，二者不会混入标题或姓名。未提供的摘要保存为 `null`，不会用标题、说明文字或其他论文填充。
+
+官方介绍说明了 general、robotics、virtual agents、innovative applications 等投稿轨道，但逐篇目录的主题会话不能独立证明某篇论文的投稿轨道。因此全文和扩展摘要均使用 `proceedings_unspecified`；演示、博士栏目使用 `demo`、`doctoral`。发表形式保留在 `metadata.publication_format` 和 `aamas_proceedings:publication_format` 标签中，会话原文单独保存。它们不是研究类型标注，也不会写入自定义 annotation。
+
+目录条目仅提供发表录用证据，不是原始决定信。`observed_at` 是页面采集时间，不能当作 2012 年的决定日期；官方介绍中的投稿、撤稿、录用汇总数不能识别逐篇拒稿或撤稿，采集器不会由总量相减生成这些决定。
+
+## 运行
+
+在已确认的远程运行环境中，使用 HTTP 缓存采集：
+
+```sh
+paper-atlas collect aamas-proceedings --year 2012 \
+  --cache /data/paper-index/cache/aamas \
+  --out /data/paper-index/collected/aamas-2012
+```
+
+也可使用已冻结的官方页面：
+
+```sh
+paper-atlas collect aamas-proceedings --year 2012 \
+  --snapshots /data/paper-index/collected/historical-next-source-evidence-v1 \
+  --out /data/paper-index/collected/aamas-2012
+```
+
+快照目录需含 `receipts.json`，其中每个响应包含原始 `url`、HTTP `status`、相对 `file`、`bytes`、`sha256` 和 `finished_at`。要求五个准确官方 URL 均唯一匹配且返回 200；验证全部字节数和哈希后才解析，不接受目录穿越或绝对文件路径。快照中其他来源的响应不会被当成 AAMAS 页面。
+
+输出为按数据库 track 分组的三个 JSONL 文件和对应 manifest、五份原始 HTML 证据，以及最后写出的 `aamas-proceedings-2012.json` 采集报告。锁文件避免同一输出目录并发运行。manifest 始终为 `partial`，记录发表形式数量和缺失摘要数；**采集命令不连接数据库，也不导入。**
+
+## 复核与恢复
+
+每条记录携带对应官方页面的 URL、采集时间、字节数、SHA-256 与输出内证据路径。重新运行前先检查已有采集报告和文件哈希；采集中断不等于主库已导入，报告缺失或哈希不一致的目录不能直接作为导入队列。输出中的原始证据应随文件一起保存。
+
+生产导入前仍需单独与主库核验稳定标识、标题、作者及已有投稿，按证据补充 DOI/arXiv 等标识；目录页上的作者计数徽标和会话 ID 不能作为这些标识。需要另建经过核验的增量清单、保护旧历史，完成独立验收后才能计入覆盖。跨来源同一论文不得仅因同题就新增或合并投稿。
+
+本功能的代码、测试或采集成功均不代表 AAMAS 2012 已导入生产，也不证明拒稿全集完整。全库最终去重、摘要和来源覆盖验收属于独立后续阶段。
@@ -0,0 +1,107 @@
+# Research types and custom annotations
+
+Research type describes a claimed characteristic of the work (for example a survey,
+benchmark, empirical study or replication). It is independent of topic, paper length,
+conference track, presentation format and acceptance status. No type is inferred from
+those fields. Multiple source-specific or human classifications may coexist; no
+cross-platform vocabulary mapping or automatic classifier is provided.
+
+`annotation_events` stores both kinds with an explicit `kind` discriminator:
+`research_type` and `tag` are separate domains, even when namespace/value strings
+happen to coincide. Existing platform labels remain in `tags` / `paper_tags`.
+Each assertion carries namespace, value, actor, reason, evidence key, optional source
+record and evidence URL, and the time it was recorded. This is observation time, not
+paper publication time or a conference decision date.
+
+Values are not forced into a global taxonomy: `custom:method=empirical` and
+`platform:declared_type=empirical` retain separate provenance. An explicit platform
+assertion API requires a source record belonging to that paper and matching the
+namespace prefix. The manual CLI only accepts `custom:*`, and cannot retract platform
+assertions. No source type has been automatically assigned to existing papers.
+
+## Initialize explicitly
+
+On the published PostgreSQL dataset, using its protected service file:
+
+```sh
+PGSERVICEFILE=/etc/paper-atlas/pg_service.conf paper-atlas annotate init \
+  --pg-service foundry-research --pg-schema research
+```
+
+This creates one optional table, its indexes, and an upgrade marker in one transaction,
+using the existing dataset writer lock. It does not copy data, change existing papers
+or decisions, or create a PostgreSQL instance. Repeating it is safe; an unexplained
+pre-existing table/marker mismatch fails closed. Readers and ordinary imports do not
+install the extension. Legacy datasets remain readable. A SQLite **sample** uses
+`--db sample.sqlite`; the cutover SQLite backup remains protected against writes.
+
+## Add and retract evidence
+
+Use the canonical paper ID returned by `query`. For a reviewed classification:
+
+```sh
+paper-atlas annotate assert --pg-service foundry-research --pg-schema research \
+  --paper "$PAPER_ID" --kind research_type --namespace custom:method \
+  --value empirical --evidence-key manual:abstract-review \
+  --actor reviewer --reason 'Classified from the explicitly described study design' \
+  --request-id "$REQUEST_ID"
+```
+
+`$REQUEST_ID` must be a new, stable identifier for this action (for example a UUID).
+Retry with the same request ID and identical content after an interrupted response;
+it returns the original event ID. Reusing that ID with changed content is rejected.
+A topic annotation uses `--kind tag --namespace custom:topic --value robotics` instead.
+Optional `--source-record` and `--evidence-url` attach additional evidence; the source
+record must belong to this paper. URLs are retained as evidence and are not fetched.
+
+To withdraw one particular assertion, use its returned event ID:
+
+```sh
+paper-atlas annotate retract --pg-service foundry-research --pg-schema research \
+  --event "$EVENT_ID" --actor reviewer --reason 'Classification corrected after review' \
+  --request-id "$RETRACTION_REQUEST_ID"
+```
+
+Retraction adds an event referencing that assertion, preserving its original content.
+It does not remove another contributor's assertion of the same label, platform tags,
+source metadata or submission/decision history. A retracted assertion can be asserted
+again with a new request ID and evidence; it is a new observation. The API does not
+update or delete past annotation events. Database administrators still control direct
+SQL access. Work reviewed as the same paper may subsequently be merged by the existing
+identity workflow: annotation IDs, original paper IDs, evidence and retraction links
+are retained while the canonical paper reference follows the surviving entity.
+
+## Query and analyze
+
+```sh
+paper-atlas query --pg-service foundry-research --pg-schema research \
+  --research-type custom:method=empirical
+paper-atlas query --pg-service foundry-research --pg-schema research \
+  --tag custom:topic=robotics
+paper-atlas query --pg-service foundry-research --pg-schema research \
+  --paper "$PAPER_ID" --annotation-history
+paper-atlas annotate list --pg-service foundry-research --pg-schema research \
+  --paper "$PAPER_ID" --history
+```
+
+`--tag` includes original platform labels and active annotation tags. It never matches
+research types. `--research-type` matches active type assertions only. Paper details
+return separate `tags` (existing provenance), `annotation_tags`, and `research_types`;
+`--annotation-history` additionally includes retractions. A missing extension yields
+empty annotation results rather than changing the database.
+
+For direct SQL analysis, active research-type evidence is:
+
+```sql
+SELECT a.* FROM research.annotation_events a
+WHERE a.kind = 'research_type' AND a.retracts_id IS NULL
+  AND NOT EXISTS (SELECT 1 FROM research.annotation_events r WHERE r.retracts_id = a.id);
+```
+
+Several independent assertions can support one label; count distinct papers/labels
+when appropriate rather than counting evidence rows as papers. Namespaces stay
+separate. Standard paper queries decode the PostgreSQL text codec; direct SQL consumers
+must honor the dataset's documented codec, including NUL/SOH values. SQLite-to-PostgreSQL
+migration recognizes an installed annotation extension and verifies its full row hashes,
+constraints and identity sequence along with the original business tables. An old
+21-table snapshot stays a 21-table migration; no synthetic annotations are generated.
@@ -1,5 +1,7 @@
 # 会议覆盖与公开决定核查

+**当前工作范围：2020 年起主动补漏。** 2000 年起已发现资料保留，恢复工作从 [补漏范围与恢复清单（2026-11-10）](backfill-handoff-2026-11-10.md) 开始；下文旧日期快照不改写，较早年份排除不算补齐。
+
 这是 2026-11-08 的首份核查基线，**完整逐年政策普查和最终去重仍未完成**。收录 43 个目标，不能把“有记录”当作“完整覆盖”。结构化清单见 [inventory-2026-11-08.json](inventory-2026-11-08.json)。清单中的 `policy_checks` 均限定所列年份和轨道；空数组表示尚未核实，绝不表示没有公开拒稿。

 ## 快照与复核
@@ -190,3 +192,7 @@ WWW早期逐来源核查见 `www-early-proceedings-2026-11-08.json`：1995春季
 WWW事件标识生产迁移已独立验收（报告SHA `f5dbb8a8`）：保留1399个原届次字段及IDs、59个Fall投稿和完整全库历史哈希。服务器已缓存46个官方HTML来源（约223KB），只作为后续维护式采集器的输入；尚未补导早期WWW论文，也未启用可选注解表。

 IJCAI 联办届次的逐条后续核查见 [2018/2022 分区与目录差集](ijcai-sections-2026-11-08.md) 和 [稳定 ID 映射](ijcai-sections-2026-11-08.json)。已定位 345 条非 main 分类及 2022 官方 HTML 缺失但官方文件仍存在的一条记录；生产分类尚未修正，不能把整卷数量作为 main 覆盖率。
+
+2026年11月9日的[当前历史年度缺口核对](historical-gaps-2026-11-09.md)单列135个历史会议—年份、14个2026年度及85个经范围修正的初步候选来源年度；它使用当前生产edition/别名快照，保留原固定快照不变。年度有记录不等于逐篇、逐track或公开拒稿历史完整。
+
+[早期NLP来源范围复核](historical-source-scope-2026-11-09.md)保留3份官方网页的响应哈希，排除4个COLING卷对ACL缺口的误匹配，并区分会议举办记录、目录可获取性与论文级覆盖；尚未导入或关闭这些年度缺口。
@@ -0,0 +1,64 @@
+# ACL 早期年份：会议存在、出版目录与逐篇资料分开核验
+
+固定普查中 ACL 1963–1978 仍有年份缺口。不能因为会议年表连续，就假设每年都有独立的正式论文集；也不能因为当前目录始于 1979，就断言此前没有摘要、通知或其他公开资料。本次不修改固定的 1,266 个目标年份基准。
+
+## 1978 年：限定 T78-1 的来源关系
+
+[同期年会通知](https://aclanthology.org/J77-4001.pdf)的 PDF 第 9–10 页（印刷页码 9–10）明确说明，1978 年 ACL 年会采用第二届 Theoretical Issues in Natural Language Processing 的形式，地点为 Urbana/Champaign，日期为 7 月 25–27 日。通知中的 ACM 联合赞助确认仍处于待确认状态，不能将该预告改写为已完成的行政决定。
+
+[1982 年 Donald E. Walker 的历史回顾](https://aclanthology.org/www.mt-archive.info/70/ACL-1982-Walker-1.pdf)第 3 页（印刷页码 91）的年会表及缩写说明，独立对应了 1978 年的时间、地点与 TNLP/TINLAP-2 关系。两份扫描件相关页已渲染并逐页目视核对，不仅依靠 OCR。
+
+[官方卷目录](https://aclanthology.org/volumes/T78-1/)与固定 XML `T78.xml` 保留原系列名 TINLAP、完整卷名、1978 年及编辑 David L. Waltz。适配仅接受精确的 collection `T78`、volume `1` 和上述字段组合；关键元数据变化会拒绝处理，等待重新核查。
+
+- 规范事件名使用 `ACL+TINLAP`，原系列名 `TINLAP`、原始 XML 的 `venue_codes: [tinlap]` 及证据均保留。
+- ACL/TINLAP 别名只挂在这一规范事件系列上，不把所有 TINLAP 年份都算成 ACL。T75、T87 及 T78 其他卷没有此例外。
+- 通知描述了邀请与提交论文两种参与方式，XML 没有逐篇角色。统一暂存为 `proceedings_unspecified`，不猜测每篇属于 invited、main 或 workshop。
+- XML 共 36 条条目，其中 T78-1036 是无作者的场次讨论问题列表。精确识别并在 manifest 的 `excluded_materials` 保留其标识、标题与原因；其余 35 条作为具名贡献整理。该排除不推广到所有无作者条目，已识别条目发生变化也须重新核查。
+- 全部 35 条 XML 均无摘要。出版目录中的 accepted 是来源观察；通知提及录用／不录用通知时间，不提供任何可识别的拒稿决定，不能制造 rejected 或 withdrawn。
+
+采集器仅生成元数据文件，不写业务数据库。真实来源逐条验收、PostgreSQL 身份预检、串行导入与独立验收仍是后续门槛。35 条来源不等于 35 个新增论文实体，更不等于完成全库去重。
+
+## 1963 年：AMTCL 旧名称与 EarlyMT 分类分开保留
+
+[ACL 官方历史介绍](https://2023.aclweb.org/participants/about_acl/)确认 AMTCL 是协会旧名称，1968 年改称 ACL。[1963 官方卷目录](https://aclanthology.org/volumes/1963.earlymt-1/)和固定 XML `1963.earlymt.xml` 明确记录 AMTCL 年会、Denver、1963 年 8 月 25–26 日。源目录将该卷归在 EarlyMT；这是资料分类，不能把其他 EarlyMT 会议全部变成 ACL。
+
+适配仅接受 collection `1963.earlymt`、volume `1`，并核对旧名称全称、年份、地点、日期和原始 venue code。规范会议为 ACL，保留 AMTCL 别名及原始 `earlymt` 分类。关键字段变化或重复时拒绝处理，等待重新审核。
+
+34 条均有作者和摘要，来源是出版摘要清单，记录 `published_abstract` 出版形式及 `acl_anthology:publication_format` 标签；逐篇 track 未提供，使用 `proceedings_unspecified`。`accepted` 只表示被列入该出版清单，不推断现代 main track、原始评审决定或任何拒稿记录。
+
+XML commit 与下文相同，SHA256 为 `4a4626d792ac507de0281cb358769f7246f4a0d6b6a9176ac02e61545c1635fc`。原始 fixture 为 `tests/fixtures/acl-1963-earlymt.xml`。官方历史 HTML SHA256 为 `0f6bc260c2b34c9e2a51d971aeb43c3270a5b15b6db1d6d41e50669f316345f3`，响应回执与固定 XML 保存在服务器 `/data/paper-index/collected/acl1963-scope-evidence-v1`。另有卷目录 HTML 回执保存在 `/data/paper-index/collected/historical-primary-candidates-20261109-v1`。未下载论文 PDF。
+
+使用下文相同采集命令，将 `--collection` 改为 `1963.earlymt`，输出到新的独立目录。采集结果需逐条验收和 PostgreSQL 身份预检，再进入增量导入；34 条来源不等于 34 个新增论文实体，代码测试通过也不代表生产覆盖已补齐。
+
+## 1965 年：替代关系不改写为别名
+
+Walker 回顾第 1 页（印刷页码 89）说明，1965 年 ICCL（后来称 COLING）替代了当年的年会。[官方 C65-1 目录](https://aclanthology.org/volumes/C65-1/)及 XML 仍以 COLING 标记该卷。这是限定年份的历史关系，不证明 COLING 与 ACL 是两个可全局互换的名字。
+
+本次保留 C65 原有 `COLING` 归属，不添加 ACL 全局别名、不重放已导入记录、不将某一年的日历关系推广到整个系列，也不据此悄悄减少固定普查缺口。其他 1963–1977 年资料仍须逐年核查；本次不能证明这些年份整体属于非归档例外。
+
+## 固定来源与恢复
+
+服务器证据目录：`/data/paper-index/collected/acl-early-source-evidence-v1`。五份官方响应均 HTTP 200，另有两份来自既有官方 XML checkout 的文件，已与 Git 对象逐字节核对。未下载论文全文集合；两份 PDF 是本次历史／行政取证资料，不进入论文全文库。
+
+| 文件 | SHA256 |
+|---|---|
+| `acl-venue.html` | `c60f64cb4d72e677aeb84a5844cde28a8d50579e1995f08e8c7801eed1e3fac5` |
+| `acl-history-1982.pdf` | `35c21bd4983975bcaccbb94bd8ab91c9019fc190feec1791255407cf18a7e49a` |
+| `acl-1978-notice.pdf` | `14b5deb471c55afb07d789529b95d0462a2a1a77df3dfba7fa1f5d3ab75eb411` |
+| `tinlap1978-volume.html` | `7e20d709f72f415819e4d17e3674b19dc7d871eabcf0cf8b4935f0392d775729` |
+| `coling1965-volume.html` | `0d2f2f49f2a311f9c0b80a8832f6476eb32f94f35abf36f6d2f2e10063ac880f` |
+| `T78.xml` | `f712f94cff0cba05f786b7ac31dad2ea9408fde2a17a04531130df623f57dd84` |
+| `C65.xml` | `572791610e20b7c6045d984d968e73a18a144bcb5c3da64112001c781826808e` |
+
+XML commit：`a7be623d01c48c61405dec31c871121cdbed5a01`。测试 fixture `tests/fixtures/acl-t78.xml` 是该原始文件，不是手工模拟论文；不包含 PDF。PDF 哈希建立完整性，不单独证明语义，语义依据是上述具体页面。
+
+在服务器使用既有命令，固定 checkout 并输出到新目录：
+
+```sh
+paper-atlas collect acl \
+  --checkout /data/paper-index/raw/metadata-checkouts/acl-anthology \
+  --collection T78 \
+  --out /data/paper-index/collected/acl-t78-source-v1
+```
+
+该命令会校验／更新官方 metadata checkout，实际 commit 必须以生成清单为准；严格重现本次取证时，使用已冻结的 XML 和上述 commit，不把更新后的内容冒充旧快照。不要将无 collection 限制的全部历史输出直接作为增量队列。采集完成不代表导入完成，恢复前先检查当前单元和报告，不因日志安静重启已执行的写入。
@@ -0,0 +1,52 @@
+# 补漏范围与恢复清单（2026-11-10）
+
+用户确定：**后续主动补漏从 2020 年起**。2000 年起已经发现的名单、缺口、资料组合和身份核查记录保留在项目中，供下次接着做；已有旧数据继续保留。停止补采的年份标为范围外或延期，不算作已补齐。
+
+本页是下一次工作的入口，结构化记录见 [backfill-handoff-2026-11-10.json](backfill-handoff-2026-11-10.json)。它保存 43 个会议的 2000–2026 已观察年份、缺年、官方目录文件入口、近期待办与恢复证据。旧的日期快照不改写，也不能当实时数据库。
+
+## 当前范围和年份差集
+
+依据生产只读快照 `2026-11-09 16:26:41.688509+00:00`，原全历史口径为 1266 个目标年份槽位：1208 已观察、43 个历史缺年、14 个 2026 缺年，以及 1 个 SysML 2018 非存档例外。原 135 个历史缺口中有 92 个通过数据补入解决；其余 43 个现在停止补采，不能因此宣称全部解决。
+
+- **2020–2025**：没有整年完全缺记录的目标槽位，但逐篇、track、摘要、公开负面决定仍不完整。
+- **2026**：NeurIPS、ECCV、RecSys、CIKM、ICDM、SDM、IROS、RSS、CoRL、ICAPS、AAMAS、ICASSP、ISMIR、ACM MM，共 14 个槽位。须逐个核查是否已经公开出版；不能将尚未发布的资料说成漏采。
+- **2000–2019 延期线索**：WWW 2000、ICAPS 2001 两个整年缺口；官方历届记录分别见 [WWW](www-editions-2026-11-08.json)、[ICAPS](icaps-editions-2026-11-08.json)。SysML 2018 是非存档首届，见 [MLSys](mlsys-editions-2026-11-08.json)，不能制造正式出版记录。
+- **2000 年前**：剩余 41 个历史缺年停止补采。旧来源文件继续保留作证据，不再作为当前工作队列。
+
+以上只判断目标会议年份是否至少有一条投稿记录，绝不等于目录完整、独立论文数量或最终去重验收。
+
+## 近期资料与恢复位置
+
+服务器采集根目录为 `/data/paper-index/collected`，本地证据备份为 `/Users/zzyang/Documents/Codex/2026-11-06/paper-index`。这些目录提供大体积原始文件，仓库 JSON 提供路径、状态和可用哈希；恢复前先验证文件存在、哈希和生产实际状态。
+
+| 资料 | 当前状态 | 下一步与证据入口 |
+| --- | --- | --- |
+| AAMAS 2026 | 官方目录 643 条，3 个 keynote 排除；640 个非 keynote 中含 1 个明确撤稿。尚未导入 | `aamas2026-primary-evidence-v1/` 保存官方 HTML、回执、逐项目录、审计和校验清单。八个标题差异/撤稿前缀条目需核查。先扩展正式 collector 并远程验证，再做新 PostgreSQL 身份预检。 |
+| CVPR 2026 Findings | 941 条摘要已核验，尚未导入 | `cvf-2026-verified/recovery-audit.json`；原 404 与 RVLF/FVLF 路径更正证据保留。先核对 manifests、track 和实体关系。 |
+| AAMAS 2025 | 476 个非 keynote 来源中，240 已验收、236 待身份核查 | `aamas2025-import225-v1/` 与 `aamas2025-import15-v1/` 是已消费批次，禁止重放。15 条最近验收报告哈希见 JSON。余下资料从当前身份候选与新只读基线继续。 |
+| RSS 2025 | 163 条目录中 162 已验收，`2025/p117` 待核查 | 保留 spinal/RMCC 关系问题；查看工作状态键 `rss2025_held7_primary_evidence_v1`，不能重跑已消费的 6/88/54/14 批次。 |
+| 近期公开负面决定首批 | 1625 条已验收：1624 rejected、1 withdrawn | `public-negative-postgresql-import-postcheck-v1.json`；仅该批次验收，不是公开拒稿全集，不要重放。 |
+
+AAMAS 2026 官方目录分区：research 338、extended abstracts 185、AAAI 19、Blue Sky 17、doctoral 34、demo 44、JAAMAS 3，另有 keynote 3。JAAMAS 是期刊展示关系，不能凭目录再造一次独立审稿录用。官方撤稿条目在 research 分区，不能把全目录都标为当前 accepted。
+
+AAAI 转投政策有年份冲突：[详细征稿页](https://cyprusconferences.org/aamas2026/call-for-papers-aaai-track/) 指 AAAI-26 rejected，[总览](https://cyprusconferences.org/aamas2026/calls/) 写 AAAI-25。保留两份证据；19 个 AAAI track 条目不能直接转成 19 条有原始 note 的拒稿决定。原投稿 ID、逐篇决定和版本关系仍需核实。
+
+## 2000–2019 已发现但延期的身份与名单工作
+
+- **AAMAS 2012**：官方 334 条，319 已独立验收、15 个身份条目保留待查。验收报告 `aamas2012-import-v1/postgresql-postcheck-v1.json`，哈希在 JSON；已验收 319 条及被替代的 316 条计划均不得重放。来源布局与用法见 [AAMAS 适配说明](../aamas-proceedings.md)。
+- **UAI 2008**：官方 programme 与归档资料确认了四篇独立论文，但部分原始 DBLP 键的标题、作者、页码、出版链接对应仍有冲突。JSON 保留四组候选、arXiv ID、官方题名及归档报告哈希。之前仅根据页码推断题名/作者错误的结论已撤回，未应用纠正；恢复时不得据此覆盖或合并。
+- **其他名单**：本目录全部 `*-editions-2026-11-08.json` 保留各会议官方年份及来源；[历史缺口](historical-gaps-2026-11-09.md)、[来源候选](historical-source-candidates-2026-11-09.json)、[来源范围](historical-source-scope-2026-11-09.md)、[主系列](historical-primary-series-2026-11-09.md)、[前身会议](historical-predecessors-2026-11-09.md)、[ICLR 档案](iclr-archive-2014-2016.md)继续留档。这些旧报告的“缺失”可能已被后续导入解决，恢复时必须对照当前状态，不能直接当可执行队列。
+
+## 公开拒稿资料不能遗漏
+
+结构化清单保留最近已查的政策 URL、限定年份和可用性结论。优先继续 UAI 2024–2026 的 opt-in 公开拒稿来源、EMNLP 2023 的公开集合范围及其他目标的逐年核查；平台使用 OpenReview 不能证明 rejected 公开。访问受限如实记录，不绕过 Challenge。
+
+保留 rejected、desk rejected、withdrawn、retracted、resubmit 的区别；评审建议不等于最终决定。COLM 2026 的不公开政策只适用于已核实年份，不能推广到其他会议。PaperCopilot 与原 OpenReview、镜像间有重叠，候选计数不能相加。论文先被 A 拒绝再被 B 录用时，两次投稿、决定、来源与证据全部保留。
+
+## 下次启动顺序
+
+1. 读取本页和 JSON，再核实服务器工作状态、明确的 systemd invocation 与终态报告。权威工作状态 `/Users/zzyang/Documents/Codex/2026-11-06/paper-index/work-state.json` 中部分旧字段会过期；以最新验收和实际查询为准。
+2. 当前主动范围为 2020 起，2000–2019 只恢复线索，不自动启动其采集。先检查新来源是否已导入，验收过的队列禁止重放。
+3. 使用现有 `foundry-postgres` 的 `foundry_data.research`。当前已验证 writer 为提交 `714f745bd5c3fbc742be1efae0b31ab37a55e21f` 的固定 release；恢复时重新确认，不使用旧 `/data/paper-index/code` 替代。服务配置仅由服务器受保护文件读取，不复制密码。
+4. 对待导入资料做新只读身份预检，处理稳定标识、短标题、作者/版本差异、track 与跨会历史，再生成小范围增量队列。每批独立验收，SQLite 只读备份保持保护。
+5. 编译、测试或 wheel 构建仅在已确认 `ces-control:host` runner 执行。代码按工作分支交付 PR，等待用户手动合并。范围内导入结束后仍须全库去重、近似标题/作者冲突、来源-年份-track、摘要、约束、实际全文查询验收；不能用单批导入或 CI 成功替代。
@@ -0,0 +1,867 @@
+{
+  "snapshot_at": "2026-11-08 16:34:40.741334+00:00",
+  "scope": "Official first-pass conference-year census vs current populated editions and real aliases. Missing year means no imported attempt in that year, not missing paper count or proof all other years complete. Includes announced/nonarchival exceptions below.",
+  "venues": [
+    {
+      "venue": "NeurIPS",
+      "expected_years": 40,
+      "observed_expected_years": 39,
+      "missing_years": [
+        2026
+      ],
+      "missing_count": 1,
+      "canonical_matches": [
+        "NeurIPS"
+      ]
+    },
+    {
+      "venue": "ICML",
+      "expected_years": 43,
+      "observed_expected_years": 14,
+      "missing_years": [
+        1980,
+        1983,
+        1985,
+        1987,
+        1988,
+        1989,
+        1990,
+        1991,
+        1992,
+        1993,
+        1994,
+        1995,
+        1996,
+        1997,
+        1998,
+        1999,
+        2000,
+        2001,
+        2002,
+        2003,
+        2004,
+        2005,
+        2006,
+        2007,
+        2008,
+        2009,
+        2010,
+        2011,
+        2012
+      ],
+      "missing_count": 29,
+      "canonical_matches": [
+        "ICML"
+      ]
+    },
+    {
+      "venue": "ICLR",
+      "expected_years": 14,
+      "observed_expected_years": 11,
+      "missing_years": [
+        2014,
+        2015,
+        2016
+      ],
+      "missing_count": 3,
+      "canonical_matches": [
+        "ICLR"
+      ]
+    },
+    {
+      "venue": "COLM",
+      "expected_years": 3,
+      "observed_expected_years": 3,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "COLM"
+      ]
+    },
+    {
+      "venue": "COLT",
+      "expected_years": 39,
+      "observed_expected_years": 39,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "COLT"
+      ]
+    },
+    {
+      "venue": "AISTATS",
+      "expected_years": 29,
+      "observed_expected_years": 25,
+      "missing_years": [
+        1985,
+        1989,
+        1991,
+        1993
+      ],
+      "missing_count": 4,
+      "canonical_matches": [
+        "AISTATS"
+      ]
+    },
+    {
+      "venue": "UAI",
+      "expected_years": 42,
+      "observed_expected_years": 42,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "UAI"
+      ]
+    },
+    {
+      "venue": "CLeaR",
+      "expected_years": 5,
+      "observed_expected_years": 5,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "CLEAR"
+      ]
+    },
+    {
+      "venue": "ACL",
+      "expected_years": 64,
+      "observed_expected_years": 48,
+      "missing_years": [
+        1963,
+        1964,
+        1965,
+        1966,
+        1967,
+        1968,
+        1969,
+        1970,
+        1971,
+        1972,
+        1973,
+        1974,
+        1975,
+        1976,
+        1977,
+        1978
+      ],
+      "missing_count": 16,
+      "canonical_matches": [
+        "ACL",
+        "ACL+COLING",
+        "ACL+EACL"
+      ]
+    },
+    {
+      "venue": "EMNLP",
+      "expected_years": 31,
+      "observed_expected_years": 31,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "CoNLL+EMNLP",
+        "EMNLP"
+      ]
+    },
+    {
+      "venue": "NAACL",
+      "expected_years": 18,
+      "observed_expected_years": 18,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "NAACL"
+      ]
+    },
+    {
+      "venue": "EACL",
+      "expected_years": 19,
+      "observed_expected_years": 19,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "ACL+EACL",
+        "EACL"
+      ]
+    },
+    {
+      "venue": "COLING",
+      "expected_years": 31,
+      "observed_expected_years": 28,
+      "missing_years": [
+        1971,
+        1976,
+        1978
+      ],
+      "missing_count": 3,
+      "canonical_matches": [
+        "ACL+COLING",
+        "COLING",
+        "COLING+LREC"
+      ]
+    },
+    {
+      "venue": "CoNLL",
+      "expected_years": 30,
+      "observed_expected_years": 30,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "CoNLL",
+        "CoNLL+EMNLP"
+      ]
+    },
+    {
+      "venue": "CVPR",
+      "expected_years": 39,
+      "observed_expected_years": 14,
+      "missing_years": [
+        1983,
+        1985,
+        1986,
+        1988,
+        1989,
+        1991,
+        1992,
+        1993,
+        1994,
+        1996,
+        1997,
+        1998,
+        1999,
+        2000,
+        2001,
+        2003,
+        2004,
+        2005,
+        2006,
+        2007,
+        2008,
+        2009,
+        2010,
+        2011,
+        2012
+      ],
+      "missing_count": 25,
+      "canonical_matches": [
+        "CVPR"
+      ]
+    },
+    {
+      "venue": "ICCV",
+      "expected_years": 20,
+      "observed_expected_years": 7,
+      "missing_years": [
+        1987,
+        1988,
+        1990,
+        1993,
+        1995,
+        1998,
+        1999,
+        2001,
+        2003,
+        2005,
+        2007,
+        2009,
+        2011
+      ],
+      "missing_count": 13,
+      "canonical_matches": [
+        "ICCV"
+      ]
+    },
+    {
+      "venue": "ECCV",
+      "expected_years": 19,
+      "observed_expected_years": 4,
+      "missing_years": [
+        1990,
+        1992,
+        1994,
+        1996,
+        1998,
+        2000,
+        2002,
+        2004,
+        2006,
+        2008,
+        2010,
+        2012,
+        2014,
+        2016,
+        2026
+      ],
+      "missing_count": 15,
+      "canonical_matches": [
+        "ECCV"
+      ]
+    },
+    {
+      "venue": "AAAI",
+      "expected_years": 40,
+      "observed_expected_years": 40,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "AAAI",
+        "AAAI+IAAI"
+      ]
+    },
+    {
+      "venue": "IJCAI",
+      "expected_years": 35,
+      "observed_expected_years": 35,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "ECAI+IJCAI",
+        "IJCAI"
+      ]
+    },
+    {
+      "venue": "ECAI",
+      "expected_years": 29,
+      "observed_expected_years": 27,
+      "missing_years": [
+        1974,
+        1980
+      ],
+      "missing_count": 2,
+      "canonical_matches": [
+        "ECAI",
+        "ECAI+IJCAI"
+      ]
+    },
+    {
+      "venue": "KDD",
+      "expected_years": 32,
+      "observed_expected_years": 32,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "KDD"
+      ]
+    },
+    {
+      "venue": "SIGIR",
+      "expected_years": 50,
+      "observed_expected_years": 50,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "SIGIR"
+      ]
+    },
+    {
+      "venue": "WWW",
+      "expected_years": 33,
+      "observed_expected_years": 27,
+      "missing_years": [
+        1994,
+        1996,
+        1997,
+        1998,
+        1999,
+        2000
+      ],
+      "missing_count": 6,
+      "canonical_matches": [
+        "WWW"
+      ]
+    },
+    {
+      "venue": "WSDM",
+      "expected_years": 19,
+      "observed_expected_years": 19,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "WSDM"
+      ]
+    },
+    {
+      "venue": "RecSys",
+      "expected_years": 20,
+      "observed_expected_years": 19,
+      "missing_years": [
+        2026
+      ],
+      "missing_count": 1,
+      "canonical_matches": [
+        "RecSys"
+      ]
+    },
+    {
+      "venue": "CIKM",
+      "expected_years": 35,
+      "observed_expected_years": 34,
+      "missing_years": [
+        2026
+      ],
+      "missing_count": 1,
+      "canonical_matches": [
+        "CIKM"
+      ]
+    },
+    {
+      "venue": "ICDM",
+      "expected_years": 26,
+      "observed_expected_years": 25,
+      "missing_years": [
+        2026
+      ],
+      "missing_count": 1,
+      "canonical_matches": [
+        "ICDM"
+      ]
+    },
+    {
+      "venue": "SDM",
+      "expected_years": 26,
+      "observed_expected_years": 25,
+      "missing_years": [
+        2026
+      ],
+      "missing_count": 1,
+      "canonical_matches": [
+        "SDM"
+      ]
+    },
+    {
+      "venue": "ECML-PKDD",
+      "expected_years": 38,
+      "observed_expected_years": 33,
+      "missing_years": [
+        1986,
+        1987,
+        1988,
+        1989,
+        1991
+      ],
+      "missing_count": 5,
+      "canonical_matches": [
+        "ECML",
+        "ECML-PKDD",
+        "PKDD"
+      ]
+    },
+    {
+      "venue": "ICRA",
+      "expected_years": 43,
+      "observed_expected_years": 43,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "ICRA"
+      ]
+    },
+    {
+      "venue": "IROS",
+      "expected_years": 39,
+      "observed_expected_years": 35,
+      "missing_years": [
+        1988,
+        1989,
+        1990,
+        2026
+      ],
+      "missing_count": 4,
+      "canonical_matches": [
+        "IROS"
+      ]
+    },
+    {
+      "venue": "RSS",
+      "expected_years": 22,
+      "observed_expected_years": 20,
+      "missing_years": [
+        2025,
+        2026
+      ],
+      "missing_count": 2,
+      "canonical_matches": [
+        "RSS"
+      ]
+    },
+    {
+      "venue": "CoRL",
+      "expected_years": 10,
+      "observed_expected_years": 9,
+      "missing_years": [
+        2026
+      ],
+      "missing_count": 1,
+      "canonical_matches": [
+        "CORL"
+      ]
+    },
+    {
+      "venue": "ICAPS",
+      "expected_years": 37,
+      "observed_expected_years": 28,
+      "missing_years": [
+        1990,
+        1991,
+        1992,
+        1993,
+        1995,
+        1997,
+        1999,
+        2001,
+        2026
+      ],
+      "missing_count": 9,
+      "canonical_matches": [
+        "AIPS",
+        "ICAPS"
+      ]
+    },
+    {
+      "venue": "KR",
+      "expected_years": 23,
+      "observed_expected_years": 23,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "KR"
+      ]
+    },
+    {
+      "venue": "AAMAS",
+      "expected_years": 25,
+      "observed_expected_years": 22,
+      "missing_years": [
+        2012,
+        2025,
+        2026
+      ],
+      "missing_count": 3,
+      "canonical_matches": [
+        "AAMAS"
+      ]
+    },
+    {
+      "venue": "ICASSP",
+      "expected_years": 51,
+      "observed_expected_years": 49,
+      "missing_years": [
+        1977,
+        2026
+      ],
+      "missing_count": 2,
+      "canonical_matches": [
+        "ICASSP"
+      ]
+    },
+    {
+      "venue": "INTERSPEECH",
+      "expected_years": 39,
+      "observed_expected_years": 39,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "ECST",
+        "EUROSPEECH",
+        "ICSLP",
+        "INTERSPEECH"
+      ]
+    },
+    {
+      "venue": "ISMIR",
+      "expected_years": 27,
+      "observed_expected_years": 26,
+      "missing_years": [
+        2026
+      ],
+      "missing_count": 1,
+      "canonical_matches": [
+        "ISMIR"
+      ]
+    },
+    {
+      "venue": "MICCAI",
+      "expected_years": 29,
+      "observed_expected_years": 29,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "MICCAI"
+      ]
+    },
+    {
+      "venue": "FAccT",
+      "expected_years": 9,
+      "observed_expected_years": 9,
+      "missing_years": [],
+      "missing_count": 0,
+      "canonical_matches": [
+        "FAccT"
+      ]
+    },
+    {
+      "venue": "MLSys",
+      "expected_years": 9,
+      "observed_expected_years": 8,
+      "missing_years": [
+        2018
+      ],
+      "missing_count": 1,
+      "canonical_matches": [
+        "MLSys"
+      ]
+    },
+    {
+      "venue": "MM",
+      "expected_years": 34,
+      "observed_expected_years": 33,
+      "missing_years": [
+        2026
+      ],
+      "missing_count": 1,
+      "canonical_matches": [
+        "MM"
+      ]
+    }
+  ],
+  "expected_venue_years": 1266,
+  "missing_venue_years": 150,
+  "venues_with_missing_years": 25,
+  "known_nonpublication_exceptions": [
+    {
+      "venue": "NeurIPS",
+      "year": 2026,
+      "reason": "announced;not in proceedings index at census"
+    },
+    {
+      "venue": "CoRL",
+      "year": 2026,
+      "reason": "not in publisher proceedings index at census"
+    },
+    {
+      "venue": "MLSys",
+      "year": 2018,
+      "reason": "first non-archival SysML meeting; not a missing formal publication volume"
+    }
+  ],
+  "historical_missing_years_excluding_nonarchival_2018": 135,
+  "historical_venues_with_missing_years": 16,
+  "historical_gaps": [
+    {
+      "venue": "ICML",
+      "years": [
+        1980,
+        1983,
+        1985,
+        1987,
+        1988,
+        1989,
+        1990,
+        1991,
+        1992,
+        1993,
+        1994,
+        1995,
+        1996,
+        1997,
+        1998,
+        1999,
+        2000,
+        2001,
+        2002,
+        2003,
+        2004,
+        2005,
+        2006,
+        2007,
+        2008,
+        2009,
+        2010,
+        2011,
+        2012
+      ]
+    },
+    {
+      "venue": "ICLR",
+      "years": [
+        2014,
+        2015,
+        2016
+      ]
+    },
+    {
+      "venue": "AISTATS",
+      "years": [
+        1985,
+        1989,
+        1991,
+        1993
+      ]
+    },
+    {
+      "venue": "ACL",
+      "years": [
+        1963,
+        1964,
+        1965,
+        1966,
+        1967,
+        1968,
+        1969,
+        1970,
+        1971,
+        1972,
+        1973,
+        1974,
+        1975,
+        1976,
+        1977,
+        1978
+      ]
+    },
+    {
+      "venue": "COLING",
+      "years": [
+        1971,
+        1976,
+        1978
+      ]
+    },
+    {
+      "venue": "CVPR",
+      "years": [
+        1983,
+        1985,
+        1986,
+        1988,
+        1989,
+        1991,
+        1992,
+        1993,
+        1994,
+        1996,
+        1997,
+        1998,
+        1999,
+        2000,
+        2001,
+        2003,
+        2004,
+        2005,
+        2006,
+        2007,
+        2008,
+        2009,
+        2010,
+        2011,
+        2012
+      ]
+    },
+    {
+      "venue": "ICCV",
+      "years": [
+        1987,
+        1988,
+        1990,
+        1993,
+        1995,
+        1998,
+        1999,
+        2001,
+        2003,
+        2005,
+        2007,
+        2009,
+        2011
+      ]
+    },
+    {
+      "venue": "ECCV",
+      "years": [
+        1990,
+        1992,
+        1994,
+        1996,
+        1998,
+        2000,
+        2002,
+        2004,
+        2006,
+        2008,
+        2010,
+        2012,
+        2014,
+        2016
+      ]
+    },
+    {
+      "venue": "ECAI",
+      "years": [
+        1974,
+        1980
+      ]
+    },
+    {
+      "venue": "WWW",
+      "years": [
+        1994,
+        1996,
+        1997,
+        1998,
+        1999,
+        2000
+      ]
+    },
+    {
+      "venue": "ECML-PKDD",
+      "years": [
+        1986,
+        1987,
+        1988,
+        1989,
+        1991
+      ]
+    },
+    {
+      "venue": "IROS",
+      "years": [
+        1988,
+        1989,
+        1990
+      ]
+    },
+    {
+      "venue": "RSS",
+      "years": [
+        2025
+      ]
+    },
+    {
+      "venue": "ICAPS",
+      "years": [
+        1990,
+        1991,
+        1992,
+        1993,
+        1995,
+        1997,
+        1999,
+        2001
+      ]
+    },
+    {
+      "venue": "AAMAS",
+      "years": [
+        2012,
+        2025
+      ]
+    },
+    {
+      "venue": "ICASSP",
+      "years": [
+        1977
+      ]
+    }
+  ],
+  "current_2026_gaps": 14
+}
@@ -0,0 +1,58 @@
+# 历史年度缺口的当前核对
+
+生产只读快照：2026-11-08 16:34:40.741334 UTC（北京时间11月9日00:34），foundry_data/research。对比已核实的43份首轮官方会议年度清单，使用当前有投稿记录的edition及真实venue_aliases，不沿用旧固定快照的missing_years。
+
+- 清单共1266个会议—年份位置，当前有150个位置尚无投稿记录，涉及25个目标会议。
+- 其中2025年及以前136个；排除已明确非存档的SysML2018首届，剩**135个历史年度待补采或核实，涉及16个会议**。
+- 另有14个2026年度待核实。已知NeurIPS2026和CoRL2026在首轮核查时尚未进入论文集索引，不能一律当已公开论文遗漏；其他年度也需逐个核实发布时间。
+
+这些是“整年没有任何投稿记录”的数量，不是缺论文篇数，也不是完整性百分比。一个年份只有少数记录、只有公开拒稿或缺了某个track，仍会被计作“已有年度”；这些更细缺口及公开拒稿的逐年可获得性尚须继续核验。会议别名共享的联合届次不能当成两批独立论文，未见录用也不能推断拒稿。
+
+| 会议 | 历史缺口年份数 |
+| --- | ---: |
+| ICML | 29 |
+| CVPR | 25 |
+| ACL | 16 |
+| ECCV | 14 |
+| ICCV | 13 |
+| ICAPS | 8 |
+| WWW | 6 |
+| ECML-PKDD | 5 |
+| AISTATS | 4 |
+| ICLR、COLING、IROS | 各3 |
+| ECAI、AAMAS | 各2 |
+| RSS、ICASSP | 各1 |
+
+[完整逐年结果](historical-gaps-2026-11-09.json) 保留43目标的官方预期、现有年份数、缺失年份与规范会议匹配。原始只读生产导出保存在 `/data/paper-index/collected/historical-gap-current-20261109-v1.json`。 导出SHA256 `580cdea6dd9869adafe9bc28fb75cf3854bb290ad65aa5a600d9bc368a528b93`。年度对照清单为 `docs/coverage/inventory-2026-11-08.json`；候选来源文件绑定的输入哈希与本目录缺口JSON逐字节一致。来源清单的年份和哈希沿用相应 `*-editions-2026-11-08.json`，不是本轮重新访问所有会议网站；2026发布状态需要后续更新。
+
+## 候选来源与下一步
+
+另一次只读目录核查在现有、已校验的DBLP快照中，为135个历史年度中的**85个**匹配到初步候选论文集，另**50个**尚未按本轮规则匹配到，需要继续识别目录键或寻找官方来源。未匹配不等于会议没举办、未出版或没有公开来源。
+
+[候选卷清单](historical-source-candidates-2026-11-09.json) 保留卷key、标题、出版年份、原始bibliographic counts和出版者链接。初筛使用目标family映射内的四位卷key年份或卷标题唯一显式年份，再按具体会议身份复核；两位键、出版年份与会议年份差异、前身系列及其他目录命名可能漏匹配。原始计数可能含workshop、前言、索引或多个卷，**不能当可直接导入的录用论文数量**。
+
+后续[来源范围复核](historical-source-scope-2026-11-09.md)排除了4个误归ACL的COLING卷，因此候选年度由89修正为85、未匹配年度由46增至50。原卷及排除理由保留在JSON中；135个历史年度缺口不因此改变。ACL1963–1978与COLING1971/1976/1978在当前Anthology目录未列出，继续记为来源待核实，不能一律称作已公开但漏采的论文集。
+
+优先核查已有候选卷较集中的CVPR22年、ICCV12年、ECCV14年和ICML25年。其中ICML早期workshop名称可能属于官方主系列前身，也可能是附属workshop，须对照官方届次证据逐卷区分，不能靠标题包含workshop一刀切。所有候选须经过范围、稳定标识、重复/冲突、原始字段和覆盖预检；这一步没有导入候选卷。
+
+## 复核方法
+
+只读获取当前有记录的edition，不连接papers大文本或标签表：
+
+```sql
+WITH counts AS (
+  SELECT edition_id,count(*) AS submissions
+  FROM submissions GROUP BY edition_id
+)
+SELECT e.id,e.venue_id,v.acronym,e.year,e.track,e.event_key,counts.submissions
+FROM editions e JOIN venues v ON v.id=e.venue_id
+JOIN counts ON counts.edition_id=e.id ORDER BY e.id;
+
+SELECT venue_id,alias FROM venue_aliases ORDER BY venue_id,alias;
+```
+
+逐目标取规范会议名或别名相等的edition年份集合，与该目标edition_census.expected_years做集合差；再把2026与明确非存档的SysML2018单列。保留原始导出与校验哈希，不把每个matched year误当逐篇/逐track完整。
+
+与本清单同一阶段的WWW补采只补1995年现有poster轨道，不新增缺失年度，所以即使其15条增量已验收，135这个年度计数也不会随之下降。早期1994年的50条正式展示候选、307条混合节目候选共357条仍需核实；其中并非每条都是论文。
+
+本清单用于明确第14步剩余范围，不代表第14步完成，也不替代所有导入结束后的第16步全库去重、摘要、约束和实际查询验收。
@@ -0,0 +1,53 @@
+# EWSL 与规划会议前身的来源范围
+
+本项扩展 DBLP 元数据适配：核对具体历史卷，保留 EWSL、EPS、ECP、EWSP 原始系列名称，并使用已有会议别名关系关联 ECML-PKDD 或 ICAPS。它不把历史论文的原始会议名称替换成后来的会议，也不从卷的存在推断有逐篇数据。
+
+## 证据与已核验边界
+
+[ECML-PKDD 2011 官方历史页](https://ecmlpkdd2011.org/pastConferences.php)与 [ICAPS 官方系列历史](https://www.icaps-conference.org/conference-series/)分别提供系列前身关系。2026-11-09 冻结页面 SHA-256 为：
+
+- ECML-PKDD：`c3ecdb032aeacf6a365aace5457773827d1405872ad9bc6be6fc05851d5e68d6`。
+- ICAPS：`de1d217660cb819825f58112cdaf774d0f68da6ed87e3e90a59055e52f152081`。
+
+与固定 DBLP 2026-11-01 快照的完整 proceedings 目录对照后，仅对下列具体卷识别前身主系列：
+
+| 原始系列 | 事件年 | DBLP 卷 key | 卷出版年 | 原始逐篇书目计数 |
+|---|---:|---|---:|---:|
+| EWSL | 1987 | `conf/ecml/1987` | 1987 | 16 |
+| EWSL | 1988 | `conf/ecml/1988` | 1988 | 21 |
+| EWSL | 1989 | `conf/ecml/1989` | 1989 | 0 |
+| EWSL | 1991 | `conf/ecml/1991` | 1991 | 44 |
+| EPS | 1990 | `conf/aips/1990` | 1990 | 48 |
+| ECP | 1997 | `conf/ecp/1997` | 1997 | 35 |
+| ECP | 1999 | `conf/ecp/1999` | 2000 | 28 |
+| EWSP | 1991 | `conf/ewsp/1991` | 1991 | 10 |
+
+合计 202 条是原始 `inproceedings` 书目计数，尚未经过前言等材料排除、身份核查与生产验收，不能作为新论文数量。EWSL 1989 在当前 catalogue 中有卷信息，但未匹配到 `inproceedings` 条目；其他记录类型和其他来源仍待核查。代码支持它的范围规则不表示已补上这一年的论文。
+
+核验同时要求来源 family、booktitle 基名、空轨道后缀、完整 proceedings key、完整标题及卷出版年与固定证据一致。邻近年份、标题附加内容、`w` 卷后缀或工作坊 booktitle 均不能继承此范围。ECP、EWSP 及 EPS 的未知卷保持待审。原有 AIPS、ICML/IROS、AISTATS/COLT 规则保持各自边界。
+
+EWSL 的主轨道仍属于 `EWSL`，通过 `ECML-PKDD` 别名纳入家族查询；EPS、ECP、EWSP 保留原名，通过 `ICAPS` 别名关联。`main` 在此表示该原始系列的主轨道。原始 booktitle、作者、论文书目年、卷标题、卷出版年、事件年及历史页 URL 分开保存在 metadata 中。例如 ECP 1999 的事件年 1999 与卷出版年 2000 都保留，不用其中一个覆盖另一个。
+
+## 候选文件与完整快照
+
+旧的窄范围 `dblp-ai-candidates.jsonl` 未纳入 `ecp`、`ewsp` family，但完整 catalogue 的 proceedings 与 volume_counts 中有它们。新的 catalogue 导出会纳入这两个 family。
+
+选择 ICAPS 且截止年达到 EWSP 1991 或 ECP 1997 时，若候选 manifest 缺少相应 family，`collect dblp --candidates` 会明确报错，要求使用原始完整 `--archive`。错误发生在写输出之前，不会把遗漏当作成功采集。选择其他会议或截止 EPS 1990 的旧候选采集不受这项新家族检查影响。
+
+在已确认的远程运行环境中使用完整快照：
+
+```sh
+paper-atlas collect dblp \
+  --catalogue /data/paper-index/collected/dblp/dblp-catalogue.sqlite \
+  --archive /path/to/pinned-dblp.xml.gz --dtd /path/to/pinned-dblp.dtd \
+  --venue ECML-PKDD --venue ICAPS --through-year 2001 \
+  --out /data/paper-index/collected/historical-predecessors
+```
+
+完整快照与 DTD 均沿用现有固定身份校验。该命令也会输出已覆盖的其他年度；生产导入前须单独筛选目标卷与年度，检查 raw source、前言材料、稳定标识、标题、作者及现有投稿，不能直接导入整个输出目录。不会下载论文 PDF。
+
+## 验证和当前限制
+
+回归检查使用独立保存的八卷原始目录 fixture，合成论文只用于隔离测试；不代表真实逐篇来源。检查原始系列/别名、完整标题和年份边界、旧候选文件显式失败、扩展 family 的 catalogue 导出、原生导入后的元数据与关系。
+
+代码、测试、采集和生产导入是不同阶段。新范围不表示本批数据已采集或已导入，更不表示公开拒稿、摘要或最终去重完整。原始书目仅提供发表条目证据，不是原始决定信；没有记录不能推断为拒稿或未举办。后续各批需保留独立验收报告，保护既有跨会投稿、决定与标签历史。
@@ -0,0 +1,33 @@
+# ICML 与 IROS 早期主系列的来源范围
+
+本轮修正采集阶段的届次识别，不修改任何现有生产投稿轨道或历史。正式主系列曾以Workshop命名，不等于附属workshop；也不能反过来把所有旧workshop升为主会。
+
+## 已核实的精确范围
+
+| 会议 | 论文集键 | 依据与行为 |
+| --- | --- | --- |
+| ICML | `conf/icml/1988`、`1989`、`1990`、`1991`、`1992` | [官方历史](https://icml.cc/Conferences/2008/past_icmls.shtml.html)将其列为第5–9届，年份与举办地对应固定目录中的完整标题。1989/1991/1992的Workshop名称不再导致主系列被默认排除；1988/1990保留main并增加来源范围证据 |
+| IROS | `conf/iros/1988`、`1989`、`1990` | [IEEE RAS官方历届目录](https://www.ieee-ras.org/conferences-workshops/financially-co-sponsored/iros/iros-past-and-future-venues/)列出三届与论文集链接，地点及日期对应固定目录标题；这些是IROS主系列 |
+
+规则同时要求family、booktitle基础别名（ML或IROS）、空轨道后缀、完整精确论文集键、匹配的事件年份及固定完整标题。仍执行原有书目年份核查：与事件年不同且标题无明确事件年时拒绝推断。ML91原始标题没有四位年份，使用精确1991卷键、完整标题、逐篇书目年和官方第8届记录，不从两位标题代码猜世纪。
+
+`1991w`/`1988w`等卷键、booktitle中的Workshops后缀、不同届次/地点/完整标题、未列入的年份均不会获得上述主系列豁免。AISTATS/COLT既有精确规则保留；真正的附属workshop仍受默认不采集workshop的边界约束。
+
+## 原始字段、决定与后续导入
+
+采集器仍保存原始proceedings标题（包括Workshop）、书目年、原始作者名、完整来源书目字段及稳定标识；新增 `track_scope_note` 与官方 `track_scope_evidence_url`。接受状态仍只源自该论文的inproceedings书目证据；不从历史目录生成占位论文或拒稿，也不重新导入已经存在的记录。
+
+新规则的输出必须重新做原始来源/标题/作者/稳定标识与现有库冲突预检，再按增量导入。此前被隔离的ICML1988/1990记录不能仅凭代码规则而直接解除全部冲突。当前正在运行的历史批次使用原固定版本和文件，不能在运行中替换其源码或输入。
+
+## 验证与证据
+
+新增回归覆盖：ICML三届Workshop名称、IROS最初三届、ICML原Conference名称的两届、错误卷键/后缀/标题/未知年份，以及归一化记录经过原生文件导入后保留轨道证据。构建与测试仅在已授权的ces-control远程runner执行，本机仅做语法和文本/JSON一致性检查；结果以相应commit的CI回执为准。
+
+官方HTML在工作证据目录 `paper-index/historical-primary-series-evidence-v1/`，附响应状态、字节数、时间与SHA256；仅取元数据网页，没有下载论文全文。
+
+| 来源 | UTC采样时间 | HTTP | 字节数 | SHA256 |
+| --- | --- | ---: | ---: | --- |
+| [icml-history](https://icml.cc/Conferences/2008/past_icmls.shtml.html) | 2026-11-08T18:36:43.043135+00:00 | 200 | 11993 | `80cce886fe985551339a52b13c4077acf827e8fcc01555f854dc24077bdebdf0` |
+| [iros-history](https://www.ieee-ras.org/conferences-workshops/financially-co-sponsored/iros/iros-past-and-future-venues/) | 2026-11-08T18:36:45.687171+00:00 | 200 | 466059 | `fdb4594621e68567e1099f5c88aae53de835b7b8146025148c3b1968df990697` |
+
+本次不关闭历史年度缺口，也不替代全部导入后的全库去重、来源/年度/track覆盖、摘要和实际查询验收。
@@ -0,0 +1,32 @@
+# 早期 NLP 来源范围复核
+
+核查时间：2026-11-08 18:27 UTC（北京时间11月9日）。本轮只修正来源候选和记录可获得性，没有操作生产数据库。
+
+## 跨会议候选修正
+
+先前候选清单将 `conf/coling/1965`、`1967`、`1969`、`1973` 匹配到 ACL 年会缺口。这四卷标题明确属于 COLING；[COLING 官方 Anthology 目录](https://aclanthology.org/venues/coling/)将它们列在 COLING 下。出版者写作 ACL 或目标映射包含 COLING，不足以证明某一年是 ACL 联办届次。
+
+从 ACL 候选中排除上述四卷，原始卷字段和排除理由保留在[候选JSON](historical-source-candidates-2026-11-09.json)的 `excluded_cross_venue_candidates` 中。135个历史会议—年份位置仍未关闭；有初步候选来源的年度由89修正为85，尚未匹配的由46增至50。这些数字是目录初筛结果，不是已验证可导入的论文数。
+
+联合届次仍按具体年度的明确会议身份处理，例如有官方联办证据的卷可以属于多个会议。不能一律排除跨family卷，也不能把联合卷重复导入为两批论文。
+
+## 来源待核实的早期年份
+
+| 范围 | 本轮官方来源观察 | 处理 |
+| --- | --- | --- |
+| ACL 1963–1978，共16年 | [ACL 官方 Anthology 目录](https://aclanthology.org/venues/acl/)目前从1979年列起 | 保留历史举办清单；逐年核实是否有可索引发表材料，不能据会议举办就断言漏采正式论文集，也不据目录缺失断言未出版 |
+| COLING 1971、1976、1978 | [主办委员会历史](https://ufal.mff.cuni.cz/iccl-old)列出这三届；当前Anthology COLING目录未列出 | 来源缺口继续开放，需要主办方或出版者逐篇索引；不生成占位论文或录用/拒稿记录 |
+
+这19个位置不能用其他会议的卷补齐，也不能因本轮未找到目录而删除。公开拒稿可获得性是独立核查，不从论文集或录用清单缺失推断。
+
+## 证据与复核
+
+三份原始HTML及 `receipts.json` 保存在工作证据目录 `paper-index/nlp-history-source-review-v1/`；结构化响应URL、时间、状态、字节数和完整SHA256收录于候选JSON的 `scope_review.evidence`。三次响应均为HTTP200；未获取论文全文。
+
+| 官方来源 | 响应SHA256 |
+| --- | --- |
+| [acl-venue](https://aclanthology.org/venues/acl/) | `d04c188c0769e065f18ca9c0246f70086e2f7027ce3efe5ea0f2cdc641796b72` |
+| [coling-venue](https://aclanthology.org/venues/coling/) | `8e7ec0a2915bfbccaa26b7a7558a9cf977c4aadc119794516ecebb826f61623f` |
+| [iccl-history](https://ufal.mff.cuni.cz/iccl-old) | `c5286dc51236c90685d22543ff1f7b209adcb3eedb82a7b1ac2115c8dd0169fc` |
+
+复核时先校验保存的原始响应哈希，再读取目录中的会议身份和年度。实时网页若已变化，应另存新响应和时间，不能把新内容套用旧哈希。本次不改最初会议年度清单或生产年度快照，不代表第14步覆盖验收或第16步最终全库审计完成。
@@ -0,0 +1,44 @@
+# ICLR 2014–2016 官方历史录用档案
+
+此适配器是长期维护工具的一部分，按需运行。只识别已经独立核对的三种页面布局；后续页面发生变化必须重新核查，不能放松计数或轨道边界以使采集成功。
+
+| 官方页面 | 页面链接次数 | 整理后的不同记录 |
+|---|---:|---:|
+| [2014 Conference Proceedings](https://iclr.cc/archive/2014/conference-proceedings/) | 35 | main 35 |
+| [2015 accepted-main](https://iclr.cc/archive/www/doku.php%3Fid=iclr2015:accepted-main.html) | 116 | main 31、workshop 74 |
+| [2016 accepted-main](https://iclr.cc/archive/www/doku.php%3Fid=iclr2016:accepted-main.html) | 80 | main 80 |
+
+2015 的 11 篇 oral 全部再次出现在 poster 段落中。相同年份、轨道及 arXiv 标识的重复展示只生成一条来源记录，但每次展示的标题、作者显示字符串、链接、版本和段落均保留在 `source_variants`。两处标题或解析作者冲突时停止采集、等待人工核查。不同年份或不同轨道不合并投稿。
+
+2014 的作者以分号列出，一条有末尾分号，一条标题和作者斜体块不在普通段落中，部分作者段落拆成多个格式片段；必须读取完整作者段落或独立斜体块，不能只读首个格式片段。2016 的代码链接不属于作者。保留原文，解析结果不替代来源证据。oral、poster 作为 `iclr_archive:presentation` 标签，不改成独立投稿轨道。arXiv 版本留在来源变体中，稳定标识使用去版本号的编号。
+
+## 来源快照与运行
+
+2026-11-09 已冻结的官方响应 SHA256：
+
+- 2014：`a33858176fbffae0066ed3c10310f7dd98a66d12a36334b6339ef1f915ef07af`
+- 2015：`131491663742cb084662a4804009b8318e0fa7bc184d4a9044d16dd28f05b888`
+- 2016：`7320b8652431793b6ea0743f871ee446bf08b6361ccd4e421b6b53449e71f4f6`
+
+在服务器运行，输出新目录，不下载论文 PDF：
+
+```sh
+paper-atlas collect iclr-archive --year 2015 \
+  --snapshots /data/paper-index/collected/historical-next-source-evidence-v1 \
+  --out /data/paper-index/collected/iclr-archive-source-v1/2015
+
+# 或重新下载官方 HTML，并保留 HTTP 缓存与收据
+paper-atlas collect iclr-archive --year 2016 \
+  --cache /data/paper-index/cache/iclr-archive \
+  --out /data/paper-index/collected/iclr-archive-source-v1/2016
+```
+
+冻结输入目录必须包含 `receipts.json`，每项有精确 `url`、HTTP `status: 200`、相对 `file`、`bytes`、`sha256` 和带时区的 `finished_at`。读取时重新核对尺寸、哈希和路径；拒绝越界及指向目录外的软链接。已完成输出不可覆盖，应检查报告后另建明确版本目录。解析或计数失败时不生成完成报告，也不导入数据库。
+
+输出分轨道 JSONL、manifest、原始 HTML 证据和年度采集报告。仅支持这三年已审查的页面。2014 workshop、其他未列轨道、逐篇摘要及公开拒稿范围尚未通过这些页面核验，不能据此声称完整。缺席不代表 rejected、withdrawn 或从未被录用。
+
+## 导入前后的边界
+
+这三页合计 220 条不同来源记录，不等于新增 220 篇论文；同一工作可能已存在于 arXiv 或其他会议。先核验来源字段与原始页面，再执行 PostgreSQL 只读预检，比较稳定标识、标题、作者和原始来源。标题/作者差异、版本关联及冲突必须保留证据并明确评估；不能仅靠标题猜测身份，也不能覆盖原有摘要。
+
+采集器不连接数据库。正式导入使用既有 `import records`，必须有新的生产保护基线和独立验收；全部导入结束后仍需全库去重和历史覆盖审计。来自官方录用清单的 accepted 是清单观察，不是原始审稿决定签名或决定日期。
@@ -0,0 +1,201 @@
+{
+  "format": 1,
+  "source_cache_sha256": "8a65562f3490497cada2919ec77827134beabd5ec9c3690dec3625e2318aa54e",
+  "records": [
+    {
+      "entry_id": "45",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/45/index.html",
+      "individual_sha256": "83bede6afc9a7039fae2dd1f28274a394418b34f5d5632590b913617580bda1a",
+      "title": "WISE - World Wide Information System for R&D; Efforts",
+      "authors": [
+        "Fritz Loseries",
+        "Veronika Samara",
+        "Bodo Urban"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "16",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/16/index.html",
+      "individual_sha256": "cf76da903eaeaa27d19857fdaa13220f6821559bf4ac22844fae10abbaa6f3f3",
+      "title": "The World Wide Web as a Tool for Collaborative Inter-Agency Projects: Creation of an Environmental Metadata Database for the Analysis of the Venice Lagoon Ecosystem.",
+      "authors": [
+        "Mirko Labbri"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "17",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/17/index.html",
+      "individual_sha256": "0578fec9c82e8f2f98c4de0f1bcc44011ebb84c53353fdcc423a69cf70673bc2",
+      "title": "NetRepreneur",
+      "authors": [
+        "Kari-Pekka Turtiainen",
+        "Antti Auer"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "29",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/29/index.html",
+      "individual_sha256": "624ad3f685de1163411e33e90488975d848a63243fd7ffbed0862c6fb58c4140",
+      "title": "Mosaic TueV 2.4.3: Multilingual GUI and Improvements towards User Friendliness",
+      "authors": [
+        "Mike Bretz",
+        "Uwe Koch",
+        "Paul de Bra"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "13",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/13/index.html",
+      "individual_sha256": "02409321a3403a94d8362a9862f4960386ea9c344fb47f4bcdf9eae128e8b46e",
+      "title": "Using a WWW Browser as an Alternative User Interface for Interactive Applications",
+      "authors": [
+        "Frank Lonczewski"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "36",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/36/index.html",
+      "individual_sha256": "ed9dada4ea5903cb8f0a4e75f2958416a6e32647fbf3530e58edd9abf26070ce",
+      "title": "HyperSource: A Hypermedia Program Development And Documentation System",
+      "authors": [
+        "Jan Oliver Borchers"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "57",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/57/index.html",
+      "individual_sha256": "3ad4206ad28a19823172cd2845f636fe7a461c251940e9a93deb8f6484b8a984",
+      "title": "Progressive Image Transmission Capability (PROTRAC) on the World Wide Web",
+      "authors": [
+        "Vojislav Lalich-Petrich",
+        "Gaurav Bhatia",
+        "Larry Davis"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "38",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/38/index.html",
+      "individual_sha256": "940370acc5e6a954b197053fe451e466a904d1f0ac82c8fe4e6ca455faf2c927",
+      "title": "Measuring the Web with Lycos",
+      "authors": [
+        "Michael L. Mauldin"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": "Official abstract listing has no abstract. Canonical HTML has body sections but no explicit abstract; body is not substituted as a summary."
+    },
+    {
+      "entry_id": "05",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/05/index.html",
+      "individual_sha256": "1858be87d6e7f47476e1cb8fb4793c0fce3b8a6ff653bcfd4a35089e0520f177",
+      "title": "Virtual Places - Adding people to the web",
+      "authors": [
+        "Yosi Mass"
+      ],
+      "author_source": "author_index",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": "Official abstract listing and canonical HTML have no abstract. Canonical page identifies a contact and links PostScript; no full-text download. Author identity comes from author index, not inferred from contact role."
+    },
+    {
+      "entry_id": "37",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/37/index.html",
+      "individual_sha256": "b700a0a51b7a82a5f88373ae0283bb369d1cf6f455acff7d91cd7313fa8b3adf",
+      "title": "The Internet Public Library: Serving a Global Community",
+      "authors": [
+        "Susan Schweitzer"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "41",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/41/index.html",
+      "individual_sha256": "397b474109f9c1240a77d0f490f2b02dd35fae93febbb7397d1b2a31759a8ec1",
+      "title": "Graphical Browsing in the WorldWideWeb and the MultiMedia Forum",
+      "authors": [
+        "Rainer Pagé",
+        "Klaus Süllow"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "47",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/47/index.html",
+      "individual_sha256": "52eb4bfdd658730a222c98170b72dabf9cbcc5ffd2ada1e900b826baf2b02833",
+      "title": "Interoperating Advanced Hypermedia Systems with WWW",
+      "authors": [
+        "Jian Zhang",
+        "Martin Fruehauf",
+        "Thomas Kirste"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "50",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/50/index.html",
+      "individual_sha256": "8dc8b0561bd8b1b106c5b209a973c695c3cc9df5288450d4a01fe32541476b7e",
+      "title": "Web Enabled Agile Manufacturing",
+      "authors": [
+        "S. V. Iyer",
+        "T. Singh",
+        "U. Ravaioli",
+        "R. E. DeVor",
+        "S. G. Kapoor",
+        "G. Veknatasubramian"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "55",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/55/index.html",
+      "individual_sha256": "21780cd4047f513e8c9aeced5247002e27cf71719f08de85c6531b57a9e5058d",
+      "title": "Weblets: Fundamental Building Blocks for WWW Tools",
+      "authors": [
+        "Thomas J. Watt Jr."
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    },
+    {
+      "entry_id": "59",
+      "individual_url": "https://archives.iw3c2.org/www3/proceedings/posters/59/index.html",
+      "individual_sha256": "fed4cc9dcaee350a12c5e4b6fa9c99be9bead25a81632512d31566400d3d0fad",
+      "title": "Usenet and the World-Wide Web",
+      "authors": [
+        "M. L. Grant"
+      ],
+      "author_source": "canonical_byline",
+      "reason": "Reviewed canonical H1 and explicit authorship for this exact linked poster entry; retain abstract-heading and author-index title variants without fuzzy matching.",
+      "missing_abstract_reason": ""
+    }
+  ]
+}
@@ -0,0 +1,37 @@
+# DBLP family 候选恢复
+
+DBLP 的会议命名空间会变化。旧候选过滤器包含 `atal`、`aamas`，遗漏了 `ifaamas`；2026-11-01 固定快照的完整目录实际已有 `conf/ifaamas/2025` 和 `conf/ifaamas/2026`。新目录盘点已把 `ifaamas` 纳入广泛候选范围，已有快照也可按需恢复，无需重新下载或重建完整目录。
+
+## 运行
+
+在已有元数据的服务器运行：
+
+```sh
+paper-atlas collect dblp-family \
+  --archive /data/paper-index/raw/dblp-2026-11-01.xml.gz \
+  --dtd /data/paper-index/raw/dblp-2023-06-28.dtd \
+  --catalogue /data/paper-index/collected/dblp/dblp-catalogue.sqlite \
+  --family ifaamas \
+  --out /data/paper-index/collected/ifaamas-recovered
+```
+
+`--family` 可以重复，但仅接受项目明确列出的候选 family。`--out` 必须尚不存在。同名输出由文件锁防止并发恢复；任务运行中应观测原任务，不能因为日志间隔长就重复启动。完整扫描会定期打印进度。
+
+命令重新验证固定压缩包 SHA256、DTD MD5 与大小，并只读打开目录。目录旁的 `dblp-ai-candidates.manifest.json` 必须属于同一个快照和 DTD，包含完整记录类型计数。旧候选文件不作为完整性依据，也不会被改写。
+
+恢复扫描使用项目原有 XML 流式解析器，仅允许已校验的本地 DTD，不联网读取 XML 实体。最终会比对完整快照的记录总数、逐 family 数量和全部选中卷的原始元数据。全部一致后才原子发布输出目录；失败时不发布半成品，也不覆盖既有文件。排查明确终止的失败任务后，可用尚不存在的输出目录重新运行。
+
+## 输出与后续流程
+
+- `dblp-family-candidates.jsonl`：原始 `inproceedings` 和 `proceedings`，保留书目 key、原始作者、标题、年份、卷引用、出版链接等字段。
+- `recovery-manifest.json`：快照、DTD、目录凭据哈希，完整扫描数量、逐 family 数量、选中卷、旧候选文件的已知数量及输出哈希。状态为 `recovered_raw_candidates_pending_scope_review`。
+
+恢复结果没有新增规范化的 `venue`、`track` 或决定标签，也不是 `import records` 的输入队列。`ifaamas` 的整卷可能混有研究论文、扩展摘要、keynote、博士生、演示和 JAAMAS 展示。目录过滤修复不会把这些条目统一标成 main；规范化的范围映射仍需第一方逐栏目证据。
+
+后续先用官方目录核对标题、页码、作者及发表形式，再查数据库稳定标识和候选实体，保留每次投稿、决定和标签来源。只有审核后的新增分区才能原生导入并独立验收；已验收的来源记录不能重放。单个年份有记录不代表逐篇、track、摘要或公开拒稿覆盖完整。
+
+## 2026-11-09 核查实例
+
+对既有固定快照的独立原始元数据恢复发现 `ifaamas` 有 1,122 条出版物候选及 2 卷：2025 年 479 条、2026 年 643 条。2025 年的 479 条标题与起始页均对应官方目录，其中 3 条 keynote 应排除，余下 476 条出版物需逐项处理。该数字包含已经验收的 225 条来源，不是 1,122 篇可新增论文。
+
+此实例说明过滤遗漏的影响，不代表恢复命令已完成生产导入。2026 年仍需核验官方出版清单、栏目、身份及逐次决定；缺少录用记录不能推断为拒稿。最终全库去重、覆盖和查询审计继续单独进行。
@@ -0,0 +1,45 @@
+# 按证据修正既有投稿的轨道
+
+`paper-atlas maintain edition-tracks` 用于已导入整卷论文集、后来取得逐条官方分区证据的情形。它更正原投稿的 edition 归属，保留投稿 ID、所有决定和来源关系；不会重新导入论文、合并实体、生成研究方法标签或推断拒稿。支持独立 SQLite 样本和共享 PostgreSQL；不得写入已冻结的生产 SQLite 备份。
+
+## 证据与完整范围
+
+先核实官方目录、稳定 DOI、原始来源记录和分区，保存原始页面及 SHA256。输入 JSON 为 `{"format":1,"records":[...]}`，每条必须包含：
+
+| 字段 | 含义 |
+| --- | --- |
+| `submission_id`、`source_record_id`、`external_id` | 原有投稿、主来源记录及主来源投稿标识 |
+| `source`、`doi` | 原来源名称及其 metadata.record_identifiers 中的 DOI |
+| `from_edition_id`、`year`、`venue` | 原 edition 及其真实年份和规范会议名 |
+| `venue_names` | 规范会议名加全部已有别名；必须与库中一致 |
+| `track` | 经核实的目标轨道，使用小写字母、数字、下划线；范围未明确可用 proceedings_unspecified |
+| `section` | 官方分区原文或明确的未确定说明，不推断研究方法 |
+| `evidence_url`、`evidence_sha256` | 已人工/独立核实的 HTTPS 原始证据和内容哈希 |
+
+输入必须列出每个原 edition 的**全部**投稿，包含留在原轨道的记录。工具核对身份、DOI、单来源发表观察、现有别名、完整范围以及目标冲突；不自动解释 HTML，也不把填写了 URL/哈希当成已证明内容。核查者应先独立证明每条分区对应关系。
+
+多来源共同拥有的投稿、有非 accepted 决定历史的投稿、已有分类修订、非空目标 edition、目标已有覆盖或标识等情形会停止，需要专门核对。每个原 edition 须有一个明确来源清单；其他来源或多清单覆盖需先另行协调。本功能不是任意批量移动或跨会合并工具。
+
+## 只读计划、事务执行和验收
+
+```sh
+paper-atlas maintain edition-tracks \
+  --pg-service foundry-research --pg-schema research \
+  --inventory reviewed-inventory.json --out plan.json
+
+sha256sum plan.json
+
+paper-atlas maintain edition-tracks \
+  --pg-service foundry-research --pg-schema research \
+  --plan plan.json --plan-sha256 <上一步的完整SHA256> --out applied.json
+```
+
+报告路径必须是已有目录中的新文件。预检只读。执行使用 PostgreSQL 单写入 advisory lock，或 SQLite BEGIN IMMEDIATE；整个分类修正、逐来源证据、标识、覆盖及验收在一个事务中完成。计划绑定数据库身份、全部来源文本/非修订元数据、标签、可选 annotation_events、投稿/决定/来源/标识内容及原覆盖快照；过期即停止。失败回滚数据，PostgreSQL 序列可能留下正常间隙，不能用 max(id) 当数量。
+
+目标 edition 沿用原会议、年份、event_key，不删除或重命名原 edition。只更正既有 submissions.edition_id 和对应 submission_identifiers.edition_id。原文、来源检索时间、决定 ID/状态/证据及各表来源关系不变。
+
+分类证据写入来源元数据的保留字段 `edition_scope_curation_v1`，包括原范围、目标 edition、官方分区、URL、哈希和计划摘要。普通来源导入不能伪造或替换此字段；后续 record 刷新保留修订。相同来源投稿通过旧范围调用 decision 时仍路由到修正后的 edition。旧整卷 main 文件通过 import records 刷新会报错并回滚，要求先按核实轨道重新整理，避免覆盖正确的统计。
+
+覆盖保留原清单 URL、cursor、成功时间，按实际目标分配 expected_count/imported_count 并标 partial；本工具核实分类，未核实摘要或所有来源完整性。原覆盖整行保留在计划中，不能继续将整卷数当 main 论文数。应用后校验原 edition 身份、全部受保护内容、分类、标识、修订字段和覆盖；相同计划再次执行仅在这些验收条件仍成立时返回 already_applied。
+
+生产使用前必须在已确认 runner 完成软件验证。正式数据修正后仍需独立验收，并在最终全库审计中复核；单元测试和应用回执不能代替生产验收。
@@ -0,0 +1,44 @@
+# 同年多届会议的事件身份
+
+`venue`、`year`、`track` 描述系列、年份和投稿轨道；`event_key` 区分同系列、同年、同轨道的实际会议事件。例如 WWW 1995 的春季与秋季会议分别使用 `www-1995-spring` 和 `www-1995-fall`，两者仍是 `main`。相同论文可以在两届有不同投稿与决定；论文去重不会把这两次投稿合成一次。
+
+普通单届数据继续使用空键。新输入在同一组已有具名事件或已知同年多届时必须提供明确键；不能任选第一个 edition。已有来源刷新可依据自己的原投稿关系回到原事件，不能被显式改到另一事件。精确固定 DBLP 快照、WWW Fall 书目名、1995 年及 `www1995f.html` 卷共同支持旧秋季文件的归属；不按标题猜年份或季节。
+
+规范 JSONL 行及 manifest 都可提供 `event_key`，非空值限制为最多80个小写字母、数字及 `._:-`，首字符为字母或数字。manifest 提供键时，每行必须一致；一份文件仍仅对应一个事件及轨道。跨行冲突会回滚整份业务导入。身份回填同样按事件选择，不能借机把来源移到另一届。
+
+## 新样本与既有数据
+
+新建 SQLite 样本的 `editions` 唯一键为 `(venue_id, year, track, event_key)`。已有 SQLite/PostgreSQL 不会因普通读写命令自动升级。其普通单届导入继续可用；WWW1994/1995或带事件键的导入会要求先迁移。冻结的 SQLite 生产备份仍受 cutover 标记保护，不能写入或升级。
+
+先在 PostgreSQL 生成只读计划：
+
+```sh
+PGSERVICEFILE=/etc/paper-atlas/pg_service.conf paper-atlas maintain event-identity \
+  --pg-service foundry-research --pg-schema research --out /data/paper-index/event-plan.json
+```
+
+检查计划的数据库身份、原 edition IDs、业务表数量、目标来源与历史指纹。计数也包含已显式启用的可选注解表。精确计数在同一快照中按主键分页，每页最多5000行，只读取主键；不使用估计行数。CLI向stderr持续报告计数进度，避免大库长时间无输出。已有未标记 WWW1995 edition 必须逐投稿都有固定 DBLP Fall 卷证据，才会只为原 edition 填入 `www-1995-fall`；缺证或混合卷会拒绝计划。本文命令不表示生产已经迁移。
+
+应用时传入同一文件及命令输出的文件 SHA256：
+
+```sh
+PGSERVICEFILE=/etc/paper-atlas/pg_service.conf paper-atlas maintain event-identity \
+  --pg-service foundry-research --pg-schema research \
+  --apply-plan /data/paper-index/event-plan.json --plan-sha256 PLAN_FILE_SHA256 \
+  --out /data/paper-index/event-applied.json
+```
+
+原生 PostgreSQL writer 使用现有 schema advisory lock，并在事务中锁定 editions，核对计划后添加列及替换唯一约束。SQLite 样本使用独占写事务，重建父表时保留 IDs，并在提交前检查外键；不级联删除子记录。额外列、未知唯一约束或 SQLite 额外索引会拒绝自动升级，须单独评估。未改变原版四列的排序内容哈希、任何业务表数量或目标投稿/决定/来源内容，才可提交；失败回滚。迁移标记与 DDL 同事务。原计划立即重试为 `already_applied`；若后续业务已经变化，应重新生成计划，不重放旧计划。
+
+ECML 与 PKDD 的联合举办前事件已有不同 venue/edition，保持原身份即可。这项迁移不会把它们合并，也不会创建新的论文、投稿或决定。WWW 春季及1994两届的逐篇采集、来源核验和导入仍须另做。
+
+## 查询与验收
+
+```sh
+paper-atlas query --pg-service foundry-research --pg-schema research \
+  --venue WWW --year 1995 --track main --event-key www-1995-fall
+```
+
+详细投稿历史及 `known_acceptances` 返回 `event_key`。`--event-key` 可与 `--status` 一起限定同一事件中的最新已知决定。未迁移的旧库仍可普通查询，其事件键为空；不能声称已经区分季节。`audit histories` 的新库事件输出也保留键。
+
+远程测试应覆盖同一作品的两届独立投稿、拒稿后另一届录用、原 IDs 与 Unicode/NUL 来源内容保留、旧文件刷新、歧义及错误键拒绝、整文件回滚、明确事件的身份回填、旧计划失效、重试与真实 PostgreSQL 迁移。生产应用后还须独立核验约束、来源和历史、全文索引及 foundry-core 健康；单元测试不替代生产或最终全库去重验收。
@@ -0,0 +1,67 @@
+# Repairing joint conference membership
+
+EURAI's [official history](https://www.eurai.org/ecai/history) identifies ECAI 2018
+and 2022 as joint IJCAI/ECAI conferences. The pinned DBLP volumes
+`conf/ijcai/2018` and `conf/ijcai/2022` use `IJCAI` as their booktitle and title.
+Existing records can therefore already be present under IJCAI while an ECAI query
+shows a missing year. Adding ECAI as a global alias to the ordinary IJCAI venue
+would incorrectly include all other IJCAI years.
+
+The existing canonical `ECAI+IJCAI` venue has both member aliases. This maintenance
+command changes only the venue reference of the two existing `main` edition rows.
+Edition IDs, submission IDs, decisions, source text, authors, identifiers, tags,
+source links and coverage records stay intact. It does not merge or create papers
+or submissions, resolve per-paper tracks, or turn reviews into negative decisions.
+The DBLP collector applies the joint mapping only to these two exact main volume
+keys; original booktitle/title remain in source metadata with the membership evidence.
+The shared ingestion entry point also resolves these exact pinned source volumes before
+creating an edition, so refreshing an older normalized file cannot recreate a separate
+IJCAI edition. Other sources, years, workshop volumes and additional tracks retain their existing rules.
+
+## Review a read-only plan
+
+Use a runtime containing this repair command. The configured PostgreSQL writer lock
+is used only for the apply operation; do not replace a newer ingestion runtime with
+an older main-based feature branch.
+
+```sh
+PGSERVICEFILE=/etc/paper-atlas/pg_service.conf paper-atlas maintain joint-editions \
+  --pg-service foundry-research --pg-schema research --out joint-plan.json
+```
+
+The preflight requires the existing joint venue and exactly its two member aliases,
+one nonempty unambiguous edition per year, and matching pinned DBLP volume evidence
+for every existing submission. A colliding target edition, missing provenance or
+unexpected source scope fails closed. The plan binds current database/schema, IDs,
+counts and full fingerprints of affected papers, identifiers, source records, tags,
+submissions, decisions and their provenance, and coverage rows. Observation time is
+recorded separately from conference year. These are scoped checks, not a final global
+identity or conference completeness audit.
+
+## Apply the exact reviewed plan
+
+Compute the file's SHA256 after review and pass it explicitly:
+
+```sh
+PGSERVICEFILE=/etc/paper-atlas/pg_service.conf paper-atlas maintain joint-editions \
+  --pg-service foundry-research --pg-schema research --plan joint-plan.json \
+  --plan-sha256 "$PLAN_SHA256" --out joint-applied.json
+```
+
+The plan hash is checked before opening a writer. Current evidence is checked again
+under the dataset writer lock; both edition updates and an audit marker commit in one
+transaction. Protected row hashes are checked again before commit. Changed evidence
+requires a fresh reviewed plan. Existing output reports are preserved; choose a new
+path for another run. SQLite samples use `--db sample.sqlite`; the frozen production
+backup remains protected.
+
+If a response is lost after commit, rerun with the same plan and a new output path.
+When protected evidence is unchanged and both editions already point to the joint
+venue, the result is `already_joint` with zero updates. It does not replay imports or
+regenerate source records. Keep the plan, apply report and independent postcheck
+alongside collection evidence. The audit marker is `joint_ijcai_ecai_2018_2022_v1`.
+
+Publication counts can differ between the DBLP volume and the current publisher
+page. This membership repair preserves all existing rows rather than deleting entries
+to force an aggregate match; section-level main/invited/other classification and
+publication completeness require separate per-paper evidence.
@@ -0,0 +1,56 @@
+# NeurIPS 官方节目元数据
+
+`paper-atlas collect neurips-program` 是按需运行的采集器，当前核验范围是 2026 年的[官方 orals/posters JSON](https://neurips.cc/static/virtual/data/neurips-2026-orals-posters.json)。它只请求这个固定公开元数据文件，不连接数据库，不请求 OpenReview API，不下载 PDF、视频或个人资料页。模块位于 `paper_atlas.collectors.neurips_program`，通过统一 CLI 使用。
+
+## 已核验快照
+
+2026-11-09T17:57:40Z 冻结的原始响应共 20,447,021 字节，SHA256 `879293a863057fa05370443b3b5ddee12a10eeb37c810abc6c1d53f71f545997`。原始 `count=9276` 与结果数组长度一致，`next`、`previous` 均为空；这只证明此份公开文件已完整取得，不是全部会议出版物或公开拒稿全集。
+
+按官方逐条 `sourceurl` 中的明确投稿来源分开处理：
+
+| 原始 OpenReview group | 数据库 track | 不同 forum 数 |
+| --- | --- | ---: |
+| `NeurIPS.cc/2026/Conference` | `main` | 7896 |
+| `NeurIPS.cc/2026/Evaluations_and_Datasets_Track` | `evaluations_datasets` | 971 |
+| `NeurIPS.cc/2026/Position_Paper_Track` | `position` | 137 |
+| 合计 | | 9004 |
+
+只接受已核验的显式 `Accept`、`Accept (poster/spotlight/oral)` 标签，保留原始大小写和文本。未知来源、决定、展示类型、可见性或无法验证的 forum 链接进入 `held_presentations`，不推成 accepted 或 rejected。空标题、缺少作者、相同 event ID 不同内容、同一 forum 的题名/作者/来源/决定冲突会停止采集。
+
+原 9276 行中，event 154866 有一条内容完全相同的重复行，单独保留其原始行号；另外 132 个口头展示与同 forum 的海报合并为一条投稿候选，完整保留两种展示及时间、场次、原始带符号 `sourceid`。负数 `sourceid` 不能被解释为拒稿或另一次投稿，也不转换为全局论文标识。
+
+其余 139 行单独留档：87 个期刊展示、36 个 Bridging the Future 展示、16 个未提供明确投稿来源的条目。这些不因缺少链接而被推为拒稿，也不能被冒充为独立主会审稿录用。后续须核实原期刊发表、认证、复现或其他展示关系。
+
+9004 条是不同 forum 的来源记录，不是已经新增 9004 篇独立科学论文。不同 forum 即使题名和作者相同也保留各自投稿；跨会及版本关系另行核验。题名、完整作者顺序和机构取自原始 JSON，口头与海报不是研究类型；展示标签独立使用 `neurips_program:presentation_format` namespace。节目中的未来展示时间不冒充决定时间。
+
+## 运行与恢复
+
+在线模式只请求一个固定元数据 URL，并复用受限大小的响应缓存：
+
+```sh
+paper-atlas collect neurips-program \
+  --cache /data/paper-index/cache/neurips2026-program \
+  --out /data/paper-index/collected/neurips2026-program-YYYYMMDD
+```
+
+冻结模式只读 `receipts.json` 对应的原始文件：
+
+```sh
+paper-atlas collect neurips-program \
+  --snapshots /data/paper-index/collected/neurips2026-program-probe-v1 \
+  --out /data/paper-index/collected/neurips2026-program-normalized-v1
+```
+
+快照回执包含精确 `url`、相对 `file`、`bytes`、`sha256`、`status=200` 和带时区的 `finished_at`。拒绝越界路径/符号链接、重复回执、失败响应、大小或哈希不符。在线模式沿用项目 HTTP 缓存和限速，验证回执时间后保存原始 JSON。输出目录有互斥锁，完成报告最后发布；已有完成报告时要求新建输出目录，避免覆盖后误重放。
+
+输出三个 track 的 JSONL/manifest、原始 JSON 证据和 `neurips-program-2026.json`。manifest 始终为 `partial`；原始节目 JSON 没有摘要，9004 条 `abstract=null` 和缺失原因如实保存，不能用别篇摘要填充。命令终端只输出数量与路径，完整待处理展示与原始行号在报告中。
+
+恢复时先校验文件和回执，使用同一完整快照生成新输出；若已有完成报告或导入回执，先核实实际来源绑定和 checkpoint，不重放已消费队列。生成文件后还需 PostgreSQL 身份预检、关联审核、增量队列、原生导入和独立验收；源文件成功、CI 通过均不能替代生产导入或最终全库去重。
+
+## 目录差异与公开拒稿限制
+
+同期[官网 Downloads 页面](https://neurips.cc/Downloads/2026)的活动总数不是本 JSON 的论文总数。逐个 poster ID/题名对照后，网页另有 event 155165（Lemon）未出现在本 JSON 中，须单独取得并审核元数据，不能补造其 track 或 forum。16 个未提供来源的条目在 JSON 中使用通用 session URL，而网页有各自 poster URL；原值保留，不能因 URL 映射差异制造新论文。
+
+[2026 Main Track Handbook](https://neurips.cc/Conferences/2026/MainTrackHandbook)明确允许 rejected 作者选择公开。当前无账号公开 notes API 请求返回 `ChallengeRequiredError`、HTTP 403，失败原文和回执保留，不绕过验证；因此不能把本 accepted 节目文件当作拒稿数据源或据此推断拒稿是否存在。官网下载表单的 JSON 导出也曾超时，未取得导出内容，已改用独立公开静态节目文件并保留失败证据，不重试超时导出。
+
+当前主动补漏范围从 2020 年起。期刊/展示关系、网页独有条目、摘要和公开负面决定仍有待办；冻结资料和代码适配不代表完整会议覆盖。
@@ -0,0 +1,49 @@
+# Integrated research runtime
+
+This branch composes the independently reviewed identity guards (PR25), incremental
+coverage (PR27), joint-edition refresh guard (PR29), event identity (PR30), and optional
+annotation support (PR28). It starts from main 1b81d1a and preserves their commits;
+it is an explicit integration dependency, not evidence that those PRs have merged.
+Users merge through Gitea manually. Review this combined diff against main, including
+its conflict resolutions, before using it as the maintained runtime.
+
+The shared Store preserves stable source/identifier anchors before title matching,
+rejects ambiguous unanchored matches, resolves pinned IJCAI/ECAI volumes before event
+lookup, and selects same-year events by event_key. Incremental manifests for a named
+or ambiguous event must state event_key; their parent count and optimistic update
+are checked against that exact event, not the first venue/year/track match.
+
+Query filters compose event_key, status, tags and research type. An earlier rejected
+attempt and a later known acceptance remain distinct; neither annotations nor track
+names infer a research type. Installing this code does not initialize annotation_events.
+Event plans count that optional table when present, alongside the original business
+rows. Annotation initialization and event identity upgrade remain explicit commands
+with their own transactional checks. Neither command imports historical records.
+
+## Production sequencing
+
+1. Verify the exact integrated commit on the approved ces-control runner, including
+   the real PostgreSQL interaction tests and wheel/installed CLI checks.
+2. Stage that exact source in a separate release directory and verify package hashes;
+   leave the current runtime and frozen SQLite backup intact.
+3. Inspect live writers and coordinate through the existing database writer lock.
+   Generate a fresh read-only event plan using that integrated release. Check its
+   database/schema identity, all business counts and preserved history hashes. A plan
+   from before further data or optional-schema changes must not be reused.
+4. Apply only that reviewed file with its actual SHA256, in one transaction. Independently
+   verify the constraint, original edition IDs and fields, assigned Fall source, source
+   and history bytes, ordinary queries, full-text queries and foundry health.
+5. Use the verified integrated release for subsequent writes. Older writers lacking
+   event identity support must not resume against the upgraded schema. Annotation
+   initialization requires a separate explicit operation and acceptance.
+
+These are operational requirements, not claims of completed production deployment.
+The production event-key migration and optional annotation activation have not occurred
+at preparation time. Existing migration/import/repair acceptance remains valid; do not
+rerun those jobs to install source code. Cross-feature tests use disposable fixtures
+and PostgreSQL schemas, never the production research tables.
+
+Coverage output also returns event_key for each independent edition ID. Two same-year
+main events keep their own status/source counts; venue paper totals remain distinct
+work counts rather than sums across events. Legacy datasets without the event column
+return an empty event key and remain read-only compatible.
@@ -0,0 +1,21 @@
+# 来源身份只读预检
+
+`audit source-identities` 在 PostgreSQL 的同一 `REPEATABLE READ READ ONLY` 快照中，检查规范化 JSONL 的来源绑定、稳定标识及精确标题候选，并导出候选论文的原始来源和投稿决定历史。用于入库前评审，不执行导入、合并或标识修改。
+
+```sh
+PGSERVICEFILE=/etc/paper-atlas/pg_service.conf paper-atlas audit source-identities \
+  --pg-service foundry-research --pg-schema research \
+  --files /data/paper-index/collected/example/main.jsonl \
+          /data/paper-index/collected/example/position.jsonl \
+  --out /data/paper-index/collected/example-identity-preflight-v1
+```
+
+每个 JSONL 必须有同名 `.manifest.json`，包含 `source`、`venue`、`year`、`track`、`count` 和 `file_sha256`。逐行校验届次、显式决定状态、标识类型和跨文件来源主键唯一性；文件哈希和数量必须相符。只读取调用者指定的文件，不跟随 manifest 中的绝对 `file` 路径；原始行哈希包含换行符。原始 JSONL 和 manifest 应与报告一起保留。
+
+输出目录必须不存在，防止复用旧报告或覆盖证据。失败会保留 `failed.json` 及已完成分片，不能把部分输出当成功；排查后使用新的输出目录重新核查。成功报告 `postgresql-preflight.json` 最后原子写入，记录输入哈希、数据库快照和每条候选。实体详情存为 `entities/<分片>/<paper_id>.json.gz`，报告中列出压缩文件的 SHA-256；包含完整 paper、标识和限量原始来源、投稿、决定及出处。每篇最多保留 100 条来源、200 次投稿，每次投稿最多 200 条决定，每组决定或投稿出处最多 100 条，所有截断均显式标记。精确标题最多取 21 个候选；达到上限即标记，不能据此推算总数。这里没有计算全表精确数量。
+
+候选分类用于安排审核：既有来源记录需要核对并避免重放，多个绑定冲突必须暂缓；单个 DOI、arXiv 或 OpenReview 绑定也可能错误，必须核对原文、标题、作者和历史。作者比较保留完整规范化姓名的重复次数，但姓名相同不能证明是同一个人。未找到精确标题或标识不能证明是新作品，仍需近似标题、版本和跨会历史核查。
+
+所有条目固定为 `not_approved_for_import`，批准数量为 0。不要直接把此报告当成 curation 计划或导入队列。后续获批导入前应重新检查实时来源绑定；来源摘要缺失不得覆盖已有摘要，旧拒稿与新录用应作为不同投稿经历保留。本命令不能代替所有导入结束后的全库去重、覆盖和约束验收。
+
+构建与测试仅在已确认的 `ces-control:host` 远程 runner 执行。集成测试使用已有 PostgreSQL 服务做真实只读候选查询，不往生产库添加测试记录。
@@ -0,0 +1,36 @@
+# 会后选集的元数据采集
+
+`collect springer-selected` 读取已冻结、带 HTTP 回执的公开 HTML，不访问 PDF、不写业务库。目前仅支持核验过的 *Selecting Models from Data: Artificial Intelligence and Statistics IV*，书籍 DOI 为 `10.1007/978-1-4612-2660-4`。增加其他卷前必须另行核对会议关系、目录、年份和字段格式。
+
+[会议官方旧站](https://www.gatsby.ucl.ac.uk/aistats/workshops.html)区分现场分发的 Preliminary Papers 与之后修订、再次评审的选集。[出版社卷说明](https://link.springer.com/book/10.1007/978-1-4612-2660-4)将本书关联到 1993 年 1 月的第四届 workshop，书籍出版年份为 1994。三页目录共有 49 个章节 DOI；分区 Front Matter 不作为章节论文导入。
+
+规范记录保留：
+
+- 会议年份 1993、独立 track `selected_volume` 与事件标识 `aistats-1993-selected-volume-1994`；出版年份单独记为 1994。
+- 章节本身的 DOI、作者原始引用写法及顺序、姓名首字母、标题、摘要、页码和逐页原始证据。不扩写作者首字母。
+- 明确提供本章 `publication_doi` 投稿出版标识，不把它转移到旧的原始会议评审记录，也不因短标题相同而强制合并实体。
+- `springer_selected_volume:publication_format` 标签与独立来源 namespace。
+- `accepted` 仅表示章节已列入这本出版选集，原始 1993 投稿评审决定、决定日期和全部录用清单均未知。后续原会议 main、拒稿或撤稿证据可以独立保留。
+
+不能据此宣称会议全部录用、全部投稿或公开拒稿覆盖完整，也不能把出版社机器添加的关键词视为作者标签。未命中选集不等于被拒。
+
+## 按需运行与恢复
+
+输入分别是卷目录/旧站说明和章节页的快照目录。每个目录的 `receipts.json` 包含 `responses` 列表，每条保留 `url`、`final_url`、`file`、`http_status`、`headers`、`bytes`、`sha256`、`at`。需要三页目录、官方旧站说明及全部 49 个章节页面。
+
+```sh
+paper-atlas collect springer-selected \
+  --toc-snapshots /data/paper-index/collected/aistats1993-book-evidence-v1 \
+  --chapter-snapshots /data/paper-index/collected/aistats1993-chapter-evidence-v1 \
+  --out /data/paper-index/collected/aistats1993-source-v1
+```
+
+采集器验证回执和内容哈希、文件路径、HTTP 类型、目录/章节 DOI 和标题、作者格式、出版年份及页码。Springer 对公开元数据返回的同路径 `cookies_not_supported` 诊断参数会原样保留；不接受其他域、路径、分页变化或未知查询参数。官方旧站说明固定哈希为 `6db205b9dbc82b4a096556efd2aa67e065cad8e0bd6351176b1962ffd1fca179`，变化时须重新审核。
+
+全部文件先核验，输出使用排他锁和暂存目录，完成报告最后发布。已有输出拒绝覆盖；发现不完整或已消费文件，应先查运行状态与报告，另建明确版本目录，不能重放生产导入。
+
+输出 JSONL 配套 manifest 始终为 `partial`。收集完成后还必须做 PostgreSQL 稳定标识/标题/作者身份预检、排除已导入记录、准备限定增量文件、保存旧数据保护基线、原生导入和独立验收。49 条来源不代表 49 个新增论文实体，全部来源处理后仍须全库去重审计。
+
+## 固定测试资料
+
+`tests/fixtures/springer-aistats1993-fixture.json.gz` 保存 4 份范围/目录 HTML、49 份章节 HTML、原始请求回执及独立原始字段审计的预期元数据，SHA256 为 `94028fd37080f9d8027e5790e379cc151ee6eab17ed0d1dcc0f59e6e75f9d4d0`。摘要按 HTML 段落边界分隔；未修改原始 HTML 或回执。它是压缩的公开元数据测试资料，不包含论文 PDF。测试覆盖全部真实章节字段、缺失和漂移输入、来源安全边界、幂等导入及旧拒稿历史保留。构建和测试只在已授权远程 runner 执行。
@@ -0,0 +1,111 @@
+# Early WWW archive collector
+
+`paper-atlas collect www-archive` is a maintained metadata adapter. It reads official
+IW3C2 archive HTML, keeps exact source hashes, and separates importable rows from
+program entries that still need review. It fetches no PDF, follows no paper-body or
+reference link, and makes no database connection.
+
+For a fresh source snapshot on the server:
+
+```sh
+paper-atlas collect www-archive \
+  --http-cache /data/paper-index/cache/www-archive \
+  --source-cache /data/paper-index/collected/www-archive-source-v2 \
+  --out /data/paper-index/collected/www-archive-normalized-v2
+```
+
+For reproducible offline replay of the already verified snapshot:
+
+```sh
+paper-atlas collect www-archive \
+  --source-cache /data/paper-index/collected/www-early-archive-source-v1 \
+  --source-cache-sha256 c9388ccef44486e0684c9ee9e8620a465cdc4574e6bc9ea9391d743e01a3312c \
+  --out /data/paper-index/collected/www-archive-normalized-v1
+```
+
+Use a new output directory for another batch. Existing snapshots and normalized
+batches are never overwritten. The manifest hash binds every source URL, byte count,
+response hash and cache filename. Plain files must remain directly within the cache;
+symlinks, escaping paths, duplicate URLs, non-200 responses and altered bytes fail.
+The command uses UTF-8 where valid and explicitly records an ISO-8859-1 fallback for
+older pages; original bytes remain authoritative for encoding corrections.
+
+## Evidence and outputs
+
+- WWW3 Spring 1995 papers use `event_key=www-1995-spring`, `track=main`. The author,
+  session and abstract indexes must have the same nonempty entry-ID set. The ID is
+  local to this exact event and proceedings section, never a DOI or OpenReview ID.
+- Posters remain `track=poster`. An abstract without a linked author-index entry
+  stays in review even when another index has a placeholder `#` link for it.
+- Paper URLs must agree between author and session indexes. A malformed whitespace
+  URL in the abstract list may use the exact event/entry-ID match only when both
+  independent indexes corroborate the same clean URL. The original href is retained.
+- Canonical names come from the explicitly labeled author index. The source lists
+  them alphabetically; this is **not** original byline order. Both the raw index names
+  and the full abstract-page byline/affiliation text remain in metadata. No person ID
+  or cross-source identity is inferred from a name. Conflicting titles or missing
+  abstracts stay in review. Topic keywords are not treated as an abstract.
+- WWW1 1994 formal presentations and WWW2 1994 mixed categories remain review
+  candidates. The first list contains uncertain business-track annotations and a
+  count discrepancy; the second contains panels, tutorials, products and other
+  activities. Neither presentation listing nor a missing full-text link establishes
+  a regular-paper acceptance or a rejection. Raw category/title/name claims are kept.
+
+The main and poster JSONL files have independent manifests with explicit event key,
+track, count and SHA256. `source_listing_count` records the full recognized abstract
+listing, while `held_entry_count` records excluded entries; neither is a ready-row
+count. Their status stays `partial`: a verified linked subset does
+not prove complete event coverage. `review-candidates.jsonl` contains nested
+candidates and reasons, with no importable decision status. It is excluded from
+`import-queue.json`. `report.json` accounts for ready/held records and every source
+used. Newlines delimit JSONL; Unicode U+2028/U+2029 inside metadata are not line breaks.
+The output is published only after all required source and scope checks pass.
+
+## Before importing
+
+This independent collector branch starts from main; it does not include or silently
+install the event-aware writer. Its output requires the reviewed integrated runtime
+from PR31 (or a main revision containing that implementation). The production event
+schema migration has been independently accepted, preserving existing edition1212
+and its 59 Fall submissions; that is not an import of the Spring proceedings.
+
+Inspect held entries and original author names, preflight every ready row against
+current PostgreSQL stable identifiers and candidate identities, and verify the
+source/year/track/event coverage before running `import records`. When a ready subset
+excludes held entries, preserve the independently known listing total in the existing
+incremental-coverage protocol: bind a freshly checked parent count and expected count,
+and set the full expected count from this manifest. A new source uses previous count
+0 and previous expected count null; an existing source requires its actual current
+values. These live parent values are not guessed by the offline collector. Do not automatically
+run this queue against an older writer. Preserve extended versions and independent
+submission/decision evidence, and keep unresolved identities held. A normalization
+report or passing tests alone do not establish production import, complete historical
+coverage or final global deduplication.
+
+Initial fixed-cache replay (64ced7a, CI1057): 38 main papers and38 posters ready;
+372 entries held (50 first-conference fields,307 mixed program entries,15 posters).
+Independent report44dfd070 verified source hashes,counts and author evidence, finding
+one existing exact-title candidate. That publication is explicitly linked to
+arXiv1811.12161 by its WWW1995/journal-reference declaration; arXiv1810.07232 is a
+different1997 invited chapter and remains separate despite the overlap note. This
+is a preparation observation, not evidence of completed production import or final
+global deduplication.
+
+## 以单篇官方页面核实待处理 poster
+
+作者索引漏链接、摘要目录使用短标题或标题存在拼写差异时，不放宽全局标题匹配。可以先取得单篇官方 HTML，人工核对 H1、署名区与原目录同一 entry URL，再提供带 SHA256 的逐条核查文件：
+
+```sh
+paper-atlas collect www-archive \
+  --source-cache /data/paper-index/collected/www-poster-reviewed-source-v2 \
+  --source-cache-sha256 8a65562f3490497cada2919ec77827134beabd5ec9c3690dec3625e2318aa54e \
+  --reviewed-posters docs/coverage/www-1995-posters-reviewed-2026-11-09.json \
+  --reviewed-posters-sha256 <核查文件的SHA256> \
+  --out <新的输出目录>
+```
+
+[1995 年15条poster的核查输入](coverage/www-1995-posters-reviewed-2026-11-09.json) 绑定61页来源快照：原46页和补取的15页单篇HTML。程序验证输入文件及快照哈希、单篇页面哈希、完全一致的 canonical H1、原摘要目录中的同一URL/entry ID及作者证据，不通过相似标题猜身份。规范标题采用单篇H1，摘要目录标题及作者索引标题均在 metadata 中保留。
+
+`author_source=canonical_byline` 表示名字出现在H1之后、摘要/关键词或下一节标题之前的署名区域，由逐条核查明确选出，不从全文引用或机构猜作者；保留原始缩写、顺序、重音和拼写。只有 `author_source=author_index` 时使用原作者索引顺序并逐项核对；05的单篇页面写的是联系人，作者身份使用原作者索引证据，不由联系人角色推断。核查输入是审阅后的数据声明，程序的字符串/哈希检查不代替人工识别署名语义。
+
+38和05的来源没有可明确引用的摘要。保留 `abstract=null` 和逐条缺失原因，manifest准确报告 missing_abstract_count，继续标partial；正文、联系方式及PostScript链接不当作摘要，也不下载正文。缺摘要不等于拒稿或未发表。本批输出仍包含原先已验收记录，正式导入前必须只取新增external ID，检查实时覆盖父记录并按incremental模式准备，不能直接重导入全部输出。
@@ -45,6 +45,8 @@ def report(db, registry, *, pg_service=None, pg_schema=None):
            database, schema = identity[0], identity[1]
        else:
            database, schema = str(Path(db).resolve()), None
+        from paper_atlas.db.events import has_event_key
+        event = 'e.event_key' if has_event_key(connection) else "''"
        latest = _status_counts(connection, latest=True)
        observations = _status_counts(connection, latest=False)
        # Aggregate the paper join once for the whole snapshot. Repeating it
@@ -73,9 +75,9 @@ def report(db, registry, *, pg_service=None, pg_schema=None):
            params = (acronym, acronym)
            editions = []
            for row in connection.execute('''SELECT e.id,v.id AS venue_id,v.acronym AS canonical_venue,
-                    e.year,e.track FROM editions e JOIN venues v ON v.id=e.venue_id
+                    e.year,e.track,''' + event + ''' AS event_key FROM editions e JOIN venues v ON v.id=e.venue_id
                    WHERE ''' + scope + '''
-                    ORDER BY e.year,e.track,v.acronym''', params):
+                    ORDER BY e.year,e.track,event_key,v.acronym,e.id''', params):
                edition = dict(row)
                edition.update(edition_counts.get(row['id'], {
                    'submissions': 0, 'papers': 0, 'papers_without_abstract_text': 0}))
@@ -124,7 +124,11 @@ def report(db=None, *, pg_service=None, pg_schema=None, examples=20):
                sample_attempts.append(rows)

        current = []
-        for raw in connection.execute(ATTEMPTS):
+        from paper_atlas.db.events import has_event_key
+        attempts_sql = ATTEMPTS
+        if has_event_key(connection):
+            attempts_sql = attempts_sql.replace('e.year,e.track,', 'e.year,e.track,e.event_key,', 1).replace('e.year,e.track\n', 'e.year,e.track,e.event_key\n')
+        for raw in connection.execute(attempts_sql):
            row = dict(raw)
            if current and row['paper_id'] != current[0]['paper_id']:
                consume(current)
@@ -0,0 +1,252 @@
+"""Read-only, evidence-preserving identity candidates for normalized source files.
+
+A candidate is never permission to import or merge. Absence of an exact match is
+never proof of a new work. Run again against a fresh snapshot before curation.
+"""
+import argparse
+from collections import Counter
+import gzip
+import hashlib
+import json
+from pathlib import Path
+
+from paper_atlas.db.store import author_keys, normalized
+from paper_atlas.db.submissions import timestamp
+from paper_atlas.postgres.client import ReadConnection
+
+STATUSES = {'accepted', 'rejected', 'desk_rejected', 'withdrawn', 'under_review', 'unknown'}
+
+
+def digest(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def authors_multiset(authors):
+    # author_keys intentionally removes duplicates; identity review must retain them.
+    return Counter(key for author in authors for key in author_keys([author]))
+
+
+def load_inputs(files):
+    records, inputs, seen = [], [], set()
+    for filename in files:
+        path = Path(filename).resolve()
+        manifest_path = path.with_suffix('.manifest.json')
+        raw_manifest = manifest_path.read_bytes()
+        manifest = json.loads(raw_manifest)
+        hasher, count = hashlib.sha256(), 0
+        with path.open('rb') as stream:
+            for line_number, line in enumerate(stream, 1):
+                hasher.update(line)
+                row = json.loads(line)
+                for key in ('source', 'external_id', 'title', 'venue', 'track'):
+                    if not isinstance(row.get(key), str) or not row[key].strip():
+                        raise ValueError(f'Invalid {key}: {path.name}:{line_number}')
+                if type(row.get('year')) is not int or row.get('status') not in STATUSES:
+                    raise ValueError('Invalid year or explicit source status')
+                for key in ('source', 'venue', 'year', 'track'):
+                    if row[key] != manifest.get(key):
+                        raise ValueError(f'Manifest scope mismatch: {key}')
+                authors = row.get('authors')
+                if not isinstance(authors, list) or any(not isinstance(a, (str, list, dict)) for a in authors):
+                    raise ValueError('Invalid authors')
+                identifiers = row.get('identifiers', {})
+                if not isinstance(identifiers, dict) or any(
+                        not isinstance(k, str) or not k.strip() or not isinstance(v, str) or not v.strip()
+                        for k, v in identifiers.items()):
+                    raise ValueError('Identifiers must contain singular nonempty strings')
+                key = (row['source'], row['external_id'])
+                if key in seen:
+                    raise ValueError('Duplicate source/external_id across inputs')
+                seen.add(key)
+                record = {k: row[k] for k in ('source', 'external_id', 'title', 'authors',
+                                              'venue', 'year', 'track', 'status')}
+                record.update(identifiers=identifiers, file=str(path), line=line_number,
+                              raw_line_sha256=digest(line), source_record_hits=[],
+                              identifier_hits=[], title_candidate_ids=[])
+                records.append(record)
+                count += 1
+        if not count or count != manifest.get('count') or hasher.hexdigest() != manifest.get('file_sha256'):
+            raise ValueError('Input count/hash mismatch or empty input')
+        inputs.append({'file': str(path), 'file_sha256': hasher.hexdigest(), 'count': count,
+                       'manifest_sha256': digest(raw_manifest), 'manifest': manifest})
+    if not records:
+        raise ValueError('At least one nonempty input is required')
+    return records, inputs
+
+
+def _lookup(connection, values, columns, lateral):
+    """Bound scalar VALUES allow the existing text codec to encode each key."""
+    width = len(columns)
+    for start in range(0, len(values), 100):
+        batch = values[start:start + 100]
+        sql = 'WITH keys(' + ','.join(columns) + ') AS (VALUES ' + ','.join(
+            '(' + ','.join(['?'] * width) + ')' for _ in batch) + ') SELECT keys.n,hit.* FROM keys JOIN LATERAL (' + lateral + ') hit ON true'
+        for row in connection.execute(sql, tuple(value for item in batch for value in item)):
+            yield dict(row)
+
+
+def find_candidates(connection, records):
+    source_keys = [(i, row['source'], row['external_id']) for i, row in enumerate(records)]
+    for hit in _lookup(connection, source_keys, ('n', 'source', 'external_id'), '''
+            SELECT r.id,r.paper_id FROM sources s JOIN source_records r ON r.source_id=s.id
+            WHERE s.name=keys.source AND r.external_id=keys.external_id'''):
+        records[hit.pop('n')]['source_record_hits'].append(hit)
+    identifiers = []
+    for i, row in enumerate(records):
+        pairs = {(row['source'], row['external_id']), *row['identifiers'].items()}
+        identifiers.extend((i, scheme, value) for scheme, value in sorted(pairs))
+    for hit in _lookup(connection, identifiers, ('n', 'scheme', 'value'), '''
+            SELECT scheme,value,paper_id FROM identifiers
+            WHERE scheme=keys.scheme AND value=keys.value'''):
+        records[hit.pop('n')]['identifier_hits'].append(hit)
+    title_keys = [(i, normalized(row['title'])) for i, row in enumerate(records)]
+    for hit in _lookup(connection, title_keys, ('n', 'title_key'), '''
+            SELECT id AS paper_id FROM papers WHERE title_key=keys.title_key ORDER BY id LIMIT 21'''):
+        records[hit['n']]['title_candidate_ids'].append(hit['paper_id'])
+
+
+def entity_packet(connection, paper_id):
+    paper = connection.execute('SELECT * FROM papers WHERE id=?', (paper_id,)).fetchone()
+    if paper is None:
+        raise RuntimeError('Candidate disappeared from read-only snapshot')
+    sources = [dict(r) for r in connection.execute('''SELECT r.*,s.name AS source
+        FROM source_records r JOIN sources s ON s.id=r.source_id
+        WHERE r.paper_id=? ORDER BY r.id LIMIT 101''', (paper_id,))]
+    attempts = [dict(r) for r in connection.execute('''SELECT s.*,v.acronym AS venue,e.year,e.track,e.event_key
+        FROM submissions s JOIN editions e ON e.id=s.edition_id JOIN venues v ON v.id=e.venue_id
+        WHERE s.paper_id=? ORDER BY s.id LIMIT 201''', (paper_id,))]
+    packet = {'paper': dict(paper), 'identifiers': [dict(r) for r in connection.execute(
+        'SELECT * FROM identifiers WHERE paper_id=? ORDER BY scheme,value', (paper_id,))],
+        'source_records': sources[:100], 'source_records_truncated': len(sources) > 100,
+        'attempts': attempts[:200], 'attempts_truncated': len(attempts) > 200}
+    for attempt in packet['attempts']:
+        observations = [dict(r) for r in connection.execute(
+            'SELECT * FROM decisions WHERE submission_id=? ORDER BY id LIMIT 201', (attempt['id'],))]
+        attempt['decisions'], attempt['decisions_truncated'] = observations[:200], len(observations) > 200
+        provenance = [dict(r) for r in connection.execute('''SELECT ss.*,r.external_id,s.name AS source
+            FROM submission_sources ss JOIN source_records r ON r.id=ss.source_record_id
+            JOIN sources s ON s.id=r.source_id WHERE ss.submission_id=?
+            ORDER BY ss.source_record_id,ss.source_submission_id LIMIT 101''', (attempt['id'],))]
+        attempt['sources'], attempt['sources_truncated'] = provenance[:100], len(provenance) > 100
+        for decision in attempt['decisions']:
+            provenance = [dict(r) for r in connection.execute('''SELECT ds.*,r.external_id,s.name AS source
+                FROM decision_sources ds JOIN source_records r ON r.id=ds.source_record_id
+                JOIN sources s ON s.id=r.source_id WHERE ds.decision_id=?
+                ORDER BY ds.source_record_id,ds.source_decision_id LIMIT 101''', (decision['id'],))]
+            decision['sources'], decision['sources_truncated'] = provenance[:100], len(provenance) > 100
+    return packet
+
+
+def classify(record, entities):
+    anchors = {r['paper_id'] for r in record['source_record_hits'] + record['identifier_hits']}
+    titles = record['title_candidate_ids']
+    flags = []
+    own_authors = authors_multiset(record['authors'])
+    if not own_authors:
+        flags.append('missing_source_authors')
+    if any(n > 1 for n in own_authors.values()):
+        flags.append('duplicate_normalized_author_names')
+    if len(normalized(record['title'])) < 25:
+        flags.append('short_title')
+    comparisons = []
+    for pid in sorted(anchors | set(titles)):
+        entity = entities[pid]
+        other = authors_multiset(entity['authors'])
+        comparisons.append({'paper_id': pid,
+            'normalized_title_equal': normalized(record['title']) == normalized(entity['title']),
+            'nonempty_author_multiset_equal': bool(own_authors) and own_authors == other,
+            'author_name_overlap': sorted(own_authors.keys() & other.keys())})
+    if len(anchors) > 1:
+        kind = 'conflicting_existing_bindings_hold'
+    elif record['source_record_hits']:
+        kind = 'existing_source_record_reconcile_no_replay'
+    elif anchors:
+        kind = 'existing_identifier_binding_requires_review'
+    elif len(titles) >= 21:
+        kind = 'title_candidate_limit_reached_hold'
+    elif not titles:
+        kind = 'no_exact_match_not_proof_of_novelty'
+    elif len(titles) > 1:
+        kind = 'multiple_exact_title_entities_hold'
+    elif comparisons[0]['nonempty_author_multiset_equal']:
+        kind = 'one_exact_title_author_multiset_requires_review'
+    elif comparisons[0]['author_name_overlap']:
+        kind = 'partial_author_overlap_requires_review'
+    else:
+        kind = 'no_author_agreement_hold'
+    return {'kind': kind, 'flags': flags, 'comparisons': comparisons,
+            'title_candidates_truncated': len(titles) >= 21,
+            'decision': 'not_approved_for_import'}
+
+
+def _atomic_json(path, value):
+    temporary = path.with_suffix(path.suffix + '.part')
+    with temporary.open('w', encoding='utf-8') as stream:
+        json.dump(value, stream, ensure_ascii=False, indent=2)
+        stream.write('\n')
+    temporary.replace(path)
+
+
+def audit(files, out, *, pg_service, pg_schema):
+    # Reject input corruption before opening a database connection or reserving output.
+    records, inputs = load_inputs(files)
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=False)
+    (out / 'audit.lock').write_text(timestamp() + '\n')
+    connection = None
+    try:
+        connection = ReadConnection(pg_service, pg_schema)
+        connection.execute("SET LOCAL statement_timeout='60s'")
+        if connection.execute('SHOW transaction_read_only').fetchone()[0] != 'on':
+            raise RuntimeError('A read-only transaction is required')
+        snapshot = dict(connection.execute('''SELECT current_database() AS database,current_schema() AS schema,
+            transaction_timestamp()::text AS transaction_at,pg_current_snapshot()::text AS snapshot''').fetchone())
+        find_candidates(connection, records)
+        ids = sorted({hit['paper_id'] for row in records for hit in row['source_record_hits'] + row['identifier_hits']} |
+                     {pid for row in records for pid in row['title_candidate_ids']})
+        entities, index = {}, {}
+        for number, pid in enumerate(ids, 1):
+            packet = entity_packet(connection, pid)
+            relative = Path('entities') / str(pid // 10000) / f'{pid}.json.gz'
+            target = out / relative
+            target.parent.mkdir(parents=True, exist_ok=True)
+            raw = gzip.compress(json.dumps(packet, ensure_ascii=False).encode(), mtime=0)
+            target.write_bytes(raw)
+            index[str(pid)] = {'file': relative.as_posix(), 'sha256': digest(raw)}
+            entities[pid] = {'title': packet['paper']['title'],
+                             'authors': json.loads(packet['paper']['authors_json'])}
+            if number % 250 == 0 or number == len(ids):
+                print(json.dumps({'phase': 'entity_evidence', 'completed': number, 'total': len(ids)}), flush=True)
+        kinds = Counter()
+        for row in records:
+            row.update(classify(row, entities))
+            kinds[row['kind']] += 1
+        report = {'status': 'completed_read_only_candidates_not_import_approval',
+                  'started_snapshot': snapshot, 'completed_at': timestamp(), 'transaction_read_only': True,
+                  'database_written': False, 'approved_for_import': 0, 'records': len(records),
+                  'kind_counts': dict(kinds), 'inputs': inputs, 'entities': index, 'entries': records,
+                  'limitations': ['Exact keys only; no match does not establish a new work.',
+                      'Name agreement does not prove person or scientific-work identity.',
+                      'Bound identifiers can be incorrect; review titles, authors and original evidence.',
+                      'Source/history limits are explicit in compressed entity packets.',
+                      'Not a final whole-database deduplication or coverage audit.']}
+        _atomic_json(out / 'postgresql-preflight.json', report)
+        return report
+    except Exception as error:
+        _atomic_json(out / 'failed.json', {'status': 'failed_no_import_approval',
+                     'error_type': type(error).__name__, 'database_written': False})
+        raise
+    finally:
+        if connection is not None:
+            connection.close()
+
+
+def main(argv=None, *, prog=None):
+    parser = argparse.ArgumentParser(prog=prog, description=__doc__)
+    parser.add_argument('--files', nargs='+', required=True, type=Path)
+    parser.add_argument('--pg-service', required=True)
+    parser.add_argument('--pg-schema', required=True)
+    parser.add_argument('--out', required=True, type=Path)
+    args = parser.parse_args(argv)
+    report = audit(args.files, args.out, pg_service=args.pg_service, pg_schema=args.pg_schema)
+    print(json.dumps({k: report[k] for k in ('status', 'records', 'kind_counts', 'approved_for_import')}, ensure_ascii=False))
@@ -6,12 +6,15 @@ from paper_atlas import __version__


 COMMANDS = {
+    ('annotate',): ('paper_atlas.curation.annotations', {}, '管理独立的研究类型与自定义标签证据'),
    ('curate','identifiers'): ('paper_atlas.curation.identifiers', {}, '按证据补充稳定标识并生成独立待导入文件'),
    ('query',): ('paper_atlas.querying', {}, '查询论文、标签和投稿历史'),
    ('coverage',): ('paper_atlas.audits.coverage', {}, '查看全部候选会议的覆盖情况'),
    ('download',): ('paper_atlas.io.snapshots', {}, '下载并校验固定版本快照'),
    ('collect','pmlr'): ('paper_atlas.collectors.pmlr', {}, 'PMLR 官方元数据'),
    ('collect','acl'): ('paper_atlas.collectors.acl', {}, 'ACL Anthology XML'),
+    ('collect','springer-selected'): ('paper_atlas.collectors.springer_selected', {}, '核验限定的会后选集章节与原会议关系'),
+    ('collect','iclr-archive'): ('paper_atlas.collectors.iclr_archive', {}, '核对ICLR 2014–2016官方历史录用档案'),
    ('collect','iclr-program'): ('paper_atlas.collectors.iclr', {}, 'ICLR 官方公开程序'),
    ('collect','iclr-snapshot'): ('paper_atlas.collectors.openreview', {}, 'ICLR 公开投稿与决定快照'),
    ('collect','public-openreview'): ('paper_atlas.collectors.public_openreview', {}, '核验其他会议的公开拒稿及撤稿标签'),
@@ -22,10 +25,17 @@ COMMANDS = {
    ('collect','mlsys'): ('paper_atlas.collectors.proceedings', {'source':'mlsys'}, 'MLSys 官方历年标题与摘要'),
    ('collect','cvf'): ('paper_atlas.collectors.vision', {'source':'cvf'}, 'CVPR / ICCV 官方开放目录'),
    ('collect','ecva'): ('paper_atlas.collectors.vision', {'source':'ecva'}, 'ECCV 官方开放目录'),
+    ('collect','aamas-proceedings'): ('paper_atlas.collectors.aamas', {}, '按官方目录区分 AAMAS 发表形式和摘要'),
+    ('collect','neurips-program'): ('paper_atlas.collectors.neurips_program', {}, '按公开节目来源区分 NeurIPS 2026 投稿与重复展示'),
+    ('collect','www-archive'): ('paper_atlas.collectors.www_archive', {}, '核验早期WWW官方档案并分开待核查条目'),
    ('collect','dblp'): ('paper_atlas.collectors.dblp_records', {}, '核对并整理 DBLP 历史发表记录'),
+    ('collect','dblp-family'): ('paper_atlas.collectors.dblp_recovery', {}, '从固定快照恢复指定 DBLP family 的原始候选'),
    ('catalogue','dblp'): ('paper_atlas.collectors.dblp', {}, '盘点 DBLP 历史会议目录'),
    ('import','arxiv'): ('paper_atlas.ingestion.arxiv', {}, '导入 arXiv 元数据 ZIP'),
    ('import','records'): ('paper_atlas.ingestion.records', {}, '导入核验过的会议文件'),
+    ('maintain','edition-tracks'): ('paper_atlas.ingestion.edition_tracks', {}, '按逐条来源证据修正既有投稿轨道并保护刷新'),
+    ('maintain','joint-editions'): ('paper_atlas.ingestion.joint_editions', {}, '按已核验计划修正既有联合会议届次归属'),
+    ('maintain','event-identity'): ('paper_atlas.ingestion.event_identity', {}, '按核验计划增加同年会议事件身份'),
    ('maintain','merge'): ('paper_atlas.ingestion.maintenance', {}, '协调单写入合并与恢复'),
    ('maintain','backfill'): ('paper_atlas.ingestion.backfill', {}, '回填既有投稿的来源身份'),
    ('maintain','arxiv-tags'): ('paper_atlas.ingestion.arxiv_tags', {}, '恢复逐来源记录的 arXiv 类别证据'),
@@ -36,6 +46,7 @@ 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','source-identities'): ('paper_atlas.audits.source_identity', {}, '只读核对来源文件的身份候选与既有投稿历史'),
    ('audit','histories'): ('paper_atlas.audits.histories', {}, '只读核对跨会议投稿历史及决定来源关系'),
 }

@@ -0,0 +1,216 @@
+"""Official AAMAS proceedings metadata, with publication format separate from track."""
+import argparse
+from collections import Counter, defaultdict
+import fcntl
+import hashlib
+import json
+from pathlib import Path
+import re
+import tempfile
+from urllib.parse import urljoin, urlsplit
+
+from paper_atlas.db.submissions import timestamp
+from paper_atlas.io.html import Document, Node, clean
+from paper_atlas.io.http import fetch
+
+SOURCE = 'aamas_proceedings'
+ROOT = 'https://www.ifaamas.org/Proceedings/aamas2012/'
+# Counts independently checked against the frozen publisher sections. This
+# adapter deliberately refuses other editions/layouts until they are reviewed.
+SECTIONS = {
+    'fullpapers': ('Full Papers', 'full_paper', 'proceedings_unspecified', 136),
+    'extabstracts': ('Extended Abstracts', 'extended_abstract', 'proceedings_unspecified', 146),
+    'demos': ('Demos', 'demo', 'demo', 28),
+    'doctorals': ('Doctorial Consortium Abstracts', 'doctoral_abstract', 'doctoral', 24),
+}
+
+
+def classes(node):
+    return set(node.attrs.get('class', '').split())
+
+
+def text_without(node, omitted):
+    if node.tag in ('script', 'style') or classes(node) & omitted:
+        return ''
+    parts = [text_without(child, omitted) if isinstance(child, Node) else child
+             for child in node.children]
+    value = ''.join(parts)
+    return ' '+value+' ' if node.tag in ('p', 'div', 'section', 'li', 'br') else value
+
+
+def one(nodes, description):
+    if len(nodes) != 1:
+        raise ValueError('Expected one '+description)
+    return nodes[0]
+
+
+def parse_section(html, section, observed_at, evidence):
+    heading, publication_format, track, _ = SECTIONS[section]
+    document = Document(html)
+    titles = [clean(n.text()) for n in document.root.walk() if n.tag == 'title']
+    if titles != [heading+' - AAMAS 2012']:
+        raise ValueError('Unexpected proceedings edition or section title')
+    headings = [clean(n.text()) for n in document.root.walk() if n.tag == 'h1']
+    if headings != [heading]:
+        raise ValueError('Unexpected proceedings section heading')
+    url = ROOT+'resources/'+section+'.html'
+    records = []
+    seen = set()
+    session = None
+    for node in document.root.walk():
+        if node.tag == 'h2' and 'section' in classes(node):
+            session = {'id': node.attrs.get('id'), 'title': clean(node.text())}
+        if node.tag != 'div' or 'paper' not in classes(node):
+            continue
+        paper_id = node.attrs.get('id', '')
+        if not re.fullmatch(r'[A-Za-z0-9]+_[0-9]+', paper_id) or paper_id in seen:
+            raise ValueError('Missing or repeated publisher paper ID')
+        seen.add(paper_id)
+        title_node = one([n for n in node.walk() if n.tag == 'span' and 'title' in classes(n)], 'paper title')
+        link = one([n for n in title_node.children if isinstance(n, Node) and n.tag == 'a'], 'paper link')
+        paper_url = urljoin(url, link.attrs.get('href', ''))
+        if paper_url != ROOT+'papers/'+paper_id+'.pdf':
+            raise ValueError('Paper link differs from publisher ID or official host')
+        title = clean(text_without(link, {'abstract'}))
+        abstract_nodes = [n for n in link.walk() if n.tag == 'span' and 'abstract' in classes(n)]
+        if len(abstract_nodes) > 1:
+            raise ValueError('Multiple abstracts for one paper')
+        abstract = (clean(abstract_nodes[0].text()) or None) if abstract_nodes else None
+        author_node = one([n for n in node.walk() if n.tag == 'span' and 'authors' in classes(n)], 'author list')
+        author_display = clean(text_without(author_node, {'amount'}))
+        authors = [clean(name) for name in author_display.split(',')]
+        if not title or not author_display or any(not name for name in authors):
+            raise ValueError('Empty paper title or author')
+        tags = [{'namespace': 'aamas_proceedings:publication_format', 'value': publication_format}]
+        if session:
+            tags.append({'namespace': 'aamas_proceedings:session', 'value': session['title']})
+        records.append({
+            'source': SOURCE, 'external_id': '2012/'+paper_id,
+            'url': url+'#'+paper_id, 'title': title, 'abstract': abstract,
+            'authors': authors, 'identifiers': {}, 'venue': 'AAMAS', 'venue_aliases': [],
+            'year': 2012, 'track': track, 'status': 'accepted',
+            'observed_at': observed_at,
+            'raw_decision': 'listed in official AAMAS 2012 proceedings '+heading,
+            'metadata': {'publisher_paper_id': paper_id, 'paper_url': paper_url,
+                         'section_url': url, 'section_heading': heading,
+                         'publication_format': publication_format, 'session': session,
+                         'authors_display': author_display, 'source_evidence': evidence,
+                         'publication_evidence': 'official published proceedings entry; not an original decision note',
+                         'track_scope_note': ('Full papers and extended abstracts include general and special submission tracks; '
+                                              'session topics do not establish an individual submission track.'
+                                              if track == 'proceedings_unspecified' else 'Explicit publisher section.'),
+                         'decision_date_precision': 'not_supplied'},
+            'tags': tags})
+    if not records:
+        raise ValueError('No publisher paper entries found')
+    return records
+
+
+def read_pages(cache=None, snapshots=None):
+    if bool(cache) == bool(snapshots):
+        raise ValueError('Choose exactly one HTTP cache or frozen snapshot directory')
+    urls = {'introduction': ROOT, **{key: ROOT+'resources/'+key+'.html' for key in SECTIONS}}
+    pages = {}
+    receipts = []
+    frozen = json.loads((Path(snapshots)/'receipts.json').read_text())['receipts'] if snapshots else []
+    for key, url in urls.items():
+        if snapshots:
+            receipt = one([r for r in frozen if r['url'] == url], 'frozen response receipt')
+            filename = Path(receipt['file'])
+            if filename.is_absolute() or '..' in filename.parts or receipt.get('status') != 200:
+                raise ValueError('Unsafe or unsuccessful frozen response')
+            data = (Path(snapshots)/filename).read_bytes()
+            if len(data) > 8*1024**2 or hashlib.sha256(data).hexdigest() != receipt['sha256'] or len(data) != receipt['bytes']:
+                raise ValueError('Frozen publisher response checksum or size mismatch')
+            observed = receipt['finished_at']
+        else:
+            data = fetch(url, cache, 8*1024**2, delay=1)
+            receipt = json.loads((Path(cache)/hashlib.sha256(url.encode()).hexdigest()).with_suffix('.json').read_text())
+            observed = receipt['retrieved_at']
+        evidence = {'url': url, 'sha256': hashlib.sha256(data).hexdigest(), 'bytes': len(data),
+                    'file': 'evidence/'+hashlib.sha256(data).hexdigest()+'.html', 'observed_at': observed,
+                    'http_status': 200, 'response_receipt': receipt}
+        pages[key] = (data, evidence)
+        receipts.append(evidence)
+    return pages, receipts
+
+
+def _collect(year, out, *, cache=None, snapshots=None):
+    if year == 2026:
+        from paper_atlas.collectors.aamas2026 import collect as collect_2026
+        return collect_2026(out, cache=cache, snapshots=snapshots)
+    if year == 2025:
+        from paper_atlas.collectors.aamas2025 import collect as collect_2025
+        return collect_2025(out, cache=cache, snapshots=snapshots)
+    if year != 2012:
+        raise ValueError('Only the independently reviewed AAMAS 2012 layout is supported')
+    pages, receipts = read_pages(cache, snapshots)
+    intro = Document(pages['introduction'][0].decode('utf-8'))
+    if [clean(n.text()) for n in intro.root.walk() if n.tag == 'title'] != ['AAMAS 2012']:
+        raise ValueError('Unexpected proceedings introduction')
+    records = []
+    for section, (_, _, _, expected) in SECTIONS.items():
+        data, evidence = pages[section]
+        group = parse_section(data.decode('utf-8'), section, evidence['observed_at'], evidence)
+        if len(group) != expected:
+            raise ValueError('Publisher section count differs from reviewed inventory: '+section)
+        records.extend(group)
+    if len({r['external_id'] for r in records}) != len(records):
+        raise ValueError('Paper IDs collide across publisher sections')
+    grouped = defaultdict(list)
+    for record in records:
+        grouped[record['track']].append(record)
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    files = []
+    with tempfile.TemporaryDirectory(prefix='.aamas-', dir=out) as temporary:
+        stage = Path(temporary)
+        (stage/'evidence').mkdir()
+        for data, evidence in pages.values():
+            (stage/evidence['file']).write_bytes(data)
+        for track, group in sorted(grouped.items()):
+            path = stage/f'aamas-proceedings-2012-{track}.jsonl'
+            path.write_text(''.join(json.dumps(r, ensure_ascii=False)+'\n' for r in group))
+            manifest = {'source': SOURCE, 'parser_version': 1, 'venue': 'AAMAS', 'year': 2012, 'track': track,
+                        'count': len(group), 'file': str(out/path.name), 'file_sha256': hashlib.sha256(path.read_bytes()).hexdigest(),
+                        'list_url': ROOT, 'status': 'partial', 'missing_abstract_count': sum(not r['abstract'] for r in group),
+                        'publication_format_counts': dict(Counter(r['metadata']['publication_format'] for r in group)),
+                        'note': 'Publisher sections verified; individual full/extended submission track, decision history and independent identities still need review.'}
+            path.with_suffix('.manifest.json').write_text(json.dumps(manifest, ensure_ascii=False, indent=2)+'\n')
+            files.append(manifest)
+        result = {'source': SOURCE, 'year': year, 'finished_at': timestamp(), 'status': 'collected_pending_identity_review',
+                  'records': len(records), 'files': files, 'source_receipts': receipts,
+                  'publication_format_counts': dict(Counter(r['metadata']['publication_format'] for r in records)),
+                  'database_written': False, 'pdfs_downloaded': False,
+                  'note': 'Aggregate submission/withdrawal totals do not identify individual rejected or withdrawn papers.'}
+        (stage/'aamas-proceedings-2012.json').write_text(json.dumps(result, ensure_ascii=False, indent=2)+'\n')
+        # Validated files first; write the completed collection report last.
+        (out/'evidence').mkdir(exist_ok=True)
+        for path in (stage/'evidence').iterdir():
+            path.replace(out/'evidence'/path.name)
+        for path in stage.iterdir():
+            if path.is_file() and path.name != 'aamas-proceedings-2012.json':
+                path.replace(out/path.name)
+        (stage/'aamas-proceedings-2012.json').replace(out/'aamas-proceedings-2012.json')
+    return result
+
+
+def collect(year, out, *, cache=None, snapshots=None):
+    if year not in (2012, 2025, 2026):
+        raise ValueError('Only independently reviewed AAMAS 2012/2025/2026 layouts are supported')
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    with (out/'aamas.collect.lock').open('a') as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        return _collect(year, out, cache=cache, snapshots=snapshots)
+
+
+def main(argv=None, *, prog=None):
+    parser = argparse.ArgumentParser(prog=prog)
+    parser.add_argument('--year', type=int, choices=[2012, 2025, 2026], required=True)
+    parser.add_argument('--out', required=True)
+    source = parser.add_mutually_exclusive_group(required=True)
+    source.add_argument('--cache')
+    source.add_argument('--snapshots')
+    args = parser.parse_args(argv)
+    print(json.dumps(collect(args.year, args.out, cache=args.cache, snapshots=args.snapshots), ensure_ascii=False))
@@ -0,0 +1,183 @@
+"""Reviewed AAMAS 2025 publisher TOC; HTML metadata only, never paper PDFs."""
+from collections import Counter, defaultdict
+import hashlib
+import json
+from pathlib import Path
+import re
+import tempfile
+
+from paper_atlas.db.submissions import timestamp
+from paper_atlas.io.html import Document, Node, clean
+from paper_atlas.io.http import fetch
+
+ROOT = 'https://www.ifaamas.org/Proceedings/aamas2025/'
+URLS = {'index': ROOT, 'contents': ROOT+'forms/contents.htm'}
+TITLE = 'AAMAS 2025: Proceedings of the 2025 International Conference on Autonomous Agents and Multiagent Systems'
+SECTIONS = {
+    '1': ('Keynote Talks', 'keynote', 'keynote', 3),
+    '2': ('Research Paper Track', 'full_paper', 'proceedings_unspecified', 260),
+    '3': ('Extended Abstracts', 'extended_abstract', 'proceedings_unspecified', 148),
+    '4': ('Blue Sky Ideas', 'blue_sky_paper', 'blue_sky', 12),
+    '5': ('Doctoral Consortium', 'doctoral_abstract', 'doctoral', 25),
+    '6': ('Demo Track', 'demo', 'demo', 22),
+    '7': ('JAAMAS Track', 'journal_presentation', 'jaamas', 9),
+}
+COMPETITION_TITLE = '[COMP24] The Automated Negotiating Agents Competition (ANAC) 2024 Challenges and Results'
+PAPER = re.compile(r'\.\./pdfs/p([0-9]+)\.pdf')
+
+
+def one(items, label):
+    if len(items) != 1:
+        raise ValueError('Expected one '+label)
+    return items[0]
+
+
+def parse_contents(html, evidence):
+    doc = Document(html)
+    if [clean(n.text()) for n in doc.root.walk() if n.tag == 'title'] != [TITLE]:
+        raise ValueError('Unexpected AAMAS proceedings title/year')
+    for paragraph in doc.root.walk():
+        if paragraph.tag != 'p' or any(n is not paragraph and n.tag == 'p' for n in paragraph.walk()):
+            continue
+        anchors = [n.attrs['name'] for n in paragraph.walk() if n.tag == 'a' and n.attrs.get('name') in SECTIONS]
+        if anchors and (len(anchors) != 1 or clean(paragraph.text()) != SECTIONS[anchors[0]][0]):
+            raise ValueError('Publisher section heading differs from reviewed layout')
+    section = None
+    headers = []
+    records, excluded, counts, seen = [], [], Counter(), set()
+    for node in doc.root.walk():
+        if node.tag == 'a' and node.attrs.get('name') in SECTIONS:
+            section = node.attrs['name']
+            headers.append(section)
+        if node.tag != 'p' or any(n is not node and n.tag == 'p' for n in node.walk()):
+            continue
+        links = [n for n in node.walk() if n.tag == 'a' and PAPER.fullmatch(n.attrs.get('href', ''))]
+        if not links:
+            continue
+        link = one(links, 'paper link per paragraph')
+        if section not in SECTIONS:
+            raise ValueError('Paper outside a reviewed publisher section')
+        page = int(PAPER.fullmatch(link.attrs['href'])[1])
+        if page in seen:
+            raise ValueError('Repeated publisher paper/page ID')
+        seen.add(page)
+        title = clean(link.text())
+        if not title:
+            raise ValueError('Empty paper title')
+        # Names are outside italicized affiliations and separated by explicit BRs.
+        font = one([n for n in node.walk() if n.tag == 'font' and n.attrs.get('color', '').lower() == '#222222'], 'ordered author block')
+        authors, affiliations = [], []
+        name, affiliation = '', ''
+        def flush():
+            nonlocal name, affiliation
+            if clean(name) or clean(affiliation):
+                if not clean(name):
+                    raise ValueError('Affiliation without author')
+                authors.append(clean(name)); affiliations.append(clean(affiliation))
+            name, affiliation = '', ''
+        for child in font.children:
+            if isinstance(child, str):
+                name += child
+            elif child.tag == 'br':
+                flush()
+            elif child.tag == 'i':
+                affiliation += child.text()
+            else:
+                raise ValueError('Unreviewed author markup: '+child.tag)
+        flush()
+        if not authors:
+            raise ValueError('Empty author list')
+        heading, publication_format, track, _ = SECTIONS[section]
+        counts[section] += 1
+        if section == '1':
+            excluded.append({'publisher_page': page, 'title': title, 'authors': authors, 'reason': 'publisher keynote talk, not a research-paper submission'})
+            continue
+        note = 'Explicit publisher section; section topics are not research types.'
+        if track == 'proceedings_unspecified':
+            note = 'Published format is known; individual main/special submission track is not provided.'
+        if page == 3000:
+            if section != '6' or title != COMPETITION_TITLE:
+                raise ValueError('Competition report differs from reviewed publisher entry')
+            publication_format, track = 'competition_report', 'proceedings_unspecified'
+            note = 'Publisher places this competition report in Demo Track; no individual demonstration submission is inferred.'
+        records.append({
+            'source': 'aamas_proceedings', 'external_id': '2025/p'+str(page),
+            'url': URLS['contents']+'#'+section, 'title': title, 'abstract': None,
+            'authors': authors, 'identifiers': {}, 'venue': 'AAMAS', 'venue_aliases': [],
+            'year': 2025, 'track': track, 'status': 'accepted',
+            'observed_at': evidence['observed_at'],
+            'raw_decision': 'listed in official AAMAS 2025 published proceedings '+heading,
+            'tags': [{'namespace': 'aamas_proceedings:publication_format', 'value': publication_format}],
+            'metadata': {'publisher_page': page, 'paper_url': ROOT+'pdfs/p'+str(page)+'.pdf',
+                         'section_url': URLS['contents'], 'section_anchor': section,
+                         'section_heading': heading, 'publication_format': publication_format,
+                         'author_affiliations': affiliations, 'source_evidence': evidence,
+                         'track_scope_note': note, 'decision_date_precision': 'not_supplied',
+                         'missing_abstract_reason': 'Publisher HTML supplies no abstract; research PDF not downloaded.',
+                         'publication_evidence': 'Published proceedings entry, not an original decision note.'}})
+    if headers != list(SECTIONS) or dict(counts) != {k: v[3] for k, v in SECTIONS.items()}:
+        raise ValueError('Publisher section inventory differs from reviewed 2025 layout')
+    if len(records) != 476 or len(excluded) != 3 or sum(r['metadata']['publication_format'] == 'competition_report' for r in records) != 1:
+        raise ValueError('Unexpected publication partition')
+    return records, excluded
+
+
+def read_pages(cache, snapshots):
+    if bool(cache) == bool(snapshots):
+        raise ValueError('Choose exactly one cache or frozen snapshot directory')
+    frozen = json.loads((Path(snapshots)/'receipts.json').read_text())['receipts'] if snapshots else []
+    pages = {}
+    for key, url in URLS.items():
+        if snapshots:
+            r = one([r for r in frozen if r['url'] == url], 'frozen response receipt')
+            filename = Path(r['file']); base = Path(snapshots).resolve()
+            if filename.is_absolute() or '..' in filename.parts or not (base/filename).resolve().is_relative_to(base) or r.get('http_status') != 200:
+                raise ValueError('Unsafe or unsuccessful publisher response')
+            data = (base/filename).read_bytes()
+            if len(data) > 8*1024**2 or len(data) != r['bytes'] or hashlib.sha256(data).hexdigest() != r['sha256']:
+                raise ValueError('Frozen publisher response checksum/size mismatch')
+            observed = r['at']
+        else:
+            data = fetch(url, cache, 8*1024**2, delay=1)
+            r = json.loads((Path(cache)/hashlib.sha256(url.encode()).hexdigest()).with_suffix('.json').read_text())
+            observed = r['retrieved_at']
+        timestamp(observed)
+        pages[key] = data, {'url': url, 'sha256': hashlib.sha256(data).hexdigest(), 'bytes': len(data),
+                            'file': 'evidence/'+hashlib.sha256(data).hexdigest()+'.html',
+                            'observed_at': observed, 'http_status': 200, 'response_receipt': r}
+    return pages
+
+
+def collect(out, *, cache=None, snapshots=None):
+    pages = read_pages(cache, snapshots)
+    if [clean(n.text()) for n in Document(pages['index'][0].decode('utf-8')).root.walk() if n.tag == 'title'] != [TITLE]:
+        raise ValueError('Unexpected AAMAS 2025 introduction')
+    records, excluded = parse_contents(pages['contents'][0].decode('utf-8'), pages['contents'][1])
+    grouped = defaultdict(list)
+    for row in records: grouped[row['track']].append(row)
+    out = Path(out); out.mkdir(parents=True, exist_ok=True); files = []
+    with tempfile.TemporaryDirectory(prefix='.aamas2025-', dir=out) as temporary:
+        stage = Path(temporary); (stage/'evidence').mkdir()
+        for data, e in pages.values(): (stage/e['file']).write_bytes(data)
+        for track, group in sorted(grouped.items()):
+            p = stage/f'aamas-proceedings-2025-{track}.jsonl'
+            p.write_text(''.join(json.dumps(r, ensure_ascii=False)+'\n' for r in group))
+            m = {'source': 'aamas_proceedings', 'parser_version': 2, 'venue': 'AAMAS', 'year': 2025,
+                 'track': track, 'count': len(group), 'file': str(out/p.name), 'file_sha256': hashlib.sha256(p.read_bytes()).hexdigest(),
+                 'list_url': URLS['contents'], 'status': 'partial', 'missing_abstract_count': len(group),
+                 'publication_format_counts': dict(Counter(r['metadata']['publication_format'] for r in group)),
+                 'note': 'Complete published TOC partition; HTML abstracts absent, identities and submission-track scope require independent review.'}
+            p.with_suffix('.manifest.json').write_text(json.dumps(m, ensure_ascii=False, indent=2)+'\n'); files.append(m)
+        result = {'source': 'aamas_proceedings', 'year': 2025, 'finished_at': timestamp(),
+                  'status': 'collected_pending_identity_review', 'records': len(records), 'files': files,
+                  'excluded_publications': excluded, 'source_receipts': [e for _, e in pages.values()],
+                  'publication_format_counts': dict(Counter(r['metadata']['publication_format'] for r in records)),
+                  'database_written': False, 'pdfs_downloaded': False,
+                  'note': 'Neither absence from proceedings nor aggregate rejection/withdrawal counts identify an individual negative decision.'}
+        report = 'aamas-proceedings-2025.json'; (stage/report).write_text(json.dumps(result, ensure_ascii=False, indent=2)+'\n')
+        (out/'evidence').mkdir(exist_ok=True)
+        for p in (stage/'evidence').iterdir(): p.replace(out/'evidence'/p.name)
+        for p in stage.iterdir():
+            if p.is_file() and p.name != report: p.replace(out/p.name)
+        (stage/report).replace(out/report)
+    return result
@@ -0,0 +1,219 @@
+"""Reviewed AAMAS 2026 HTML metadata; retractions stay outside accepted queues."""
+from collections import Counter, defaultdict
+import hashlib
+import json
+from pathlib import Path
+import re
+import tempfile
+
+from paper_atlas.collectors.aamas2025 import one
+from paper_atlas.db.submissions import timestamp
+from paper_atlas.io.html import Document, Node, clean
+from paper_atlas.io.http import fetch
+
+ROOT = 'https://www.ifaamas.org/Proceedings/aamas2026/'
+URL = ROOT+'forms/contents.htm'
+TITLE = 'AAMAS 2026: Proceedings of the 2026 International Conference on Autonomous Agents and Multiagent Systems'
+SECTIONS = {
+    'K': ('Keynote Talks', 'keynote', 'keynote', 3),
+    'R': ('Research Paper Track', 'full_paper', 'proceedings_unspecified', 338),
+    '1': ('Extended Abstracts', 'extended_abstract', 'proceedings_unspecified', 185),
+    'A': ('AAAI Track', 'full_paper', 'aaai_transfer', 19),
+    'B': ('Blue Sky Ideas Track', 'blue_sky_paper', 'blue_sky', 17),
+    'C': ('Doctoral Consortium', 'doctoral_abstract', 'doctoral', 34),
+    'D': ('Demonstration Track', 'demo', 'demo', 44),
+    'J': ('JAAMAS Track', 'journal_presentation', 'jaamas', 3),
+}
+PDF = re.compile(r'\.\./pdfs/([A-Z]{4}[0-9]{4})\.pdf')
+RETRACTION_TITLE = 'Unifying Model-Free Efficiency and Model-Based Representations via Latent Dynamics'
+WITHDRAWAL_TITLE = 'Cognitive Heterogeneity and Behavioral Biases in Multi-Stage Supply Chains: Evidence from LLM-Based Agent Simulations'
+
+
+def parse_authors(paragraph):
+    font = one([n for n in paragraph.walk() if n.tag == 'font' and
+                n.attrs.get('color', '').lower() == '#222222'], 'ordered author block')
+    authors, affiliations = [], []
+    name, affiliation = '', ''
+    def flush():
+        nonlocal name, affiliation
+        if clean(name) or clean(affiliation):
+            if not clean(name):
+                raise ValueError('Affiliation without author')
+            authors.append(clean(name)); affiliations.append(clean(affiliation))
+        name, affiliation = '', ''
+    for child in font.children:
+        if isinstance(child, str):
+            name += child
+        elif child.tag == 'br':
+            flush()
+        elif child.tag == 'i':
+            affiliation += child.text()
+        else:
+            raise ValueError('Unreviewed author markup: '+child.tag)
+    flush()
+    if not authors:
+        raise ValueError('Empty author list')
+    return authors, affiliations
+
+
+def parse_contents(html, evidence):
+    doc = Document(html)
+    if [clean(n.text()) for n in doc.root.walk() if n.tag == 'title'] != [TITLE]:
+        raise ValueError('Unexpected AAMAS proceedings title/year')
+    section = None
+    headers, records, excluded, held = [], [], [], []
+    counts, seen_pages, seen_pdf_ids = Counter(), set(), set()
+    for node in doc.root.walk():
+        if node.tag != 'p' or any(n is not node and n.tag == 'p' for n in node.walk()):
+            continue
+        anchors = [n.attrs['name'] for n in node.walk() if n.tag == 'a' and n.attrs.get('name') in SECTIONS]
+        if anchors:
+            section = one(anchors, 'section anchor')
+            if clean(node.text()) != SECTIONS[section][0]:
+                raise ValueError('Publisher section heading differs from reviewed layout')
+            headers.append(section)
+        page_fonts = [n for n in node.walk() if n.tag == 'font' and
+                      n.attrs.get('color', '').lower() == '#444444']
+        if not page_fonts:
+            continue
+        page_text = clean(one(page_fonts, 'page marker').text())
+        page_match = re.fullmatch(r'\(Page ([1-9][0-9]*)\)', page_text)
+        if not page_match or section not in SECTIONS:
+            raise ValueError('Invalid page or paper outside reviewed sections')
+        page = int(page_match[1])
+        if page in seen_pages:
+            raise ValueError('Repeated publisher page ID')
+        seen_pages.add(page)
+        title_node = one([n for n in node.walk() if n.tag == 'strong'], 'paper title')
+        title = clean(title_node.text())
+        if not title:
+            raise ValueError('Empty paper title')
+        authors, affiliations = parse_authors(node)
+        link = one([n for n in node.walk() if n.tag == 'a' and 'href' in n.attrs], 'paper link')
+        href = link.attrs['href']
+        title_nodes = {id(n) for n in title_node.walk()}
+        retractions = [clean(n.text()) for n in link.walk() if n.tag == 'i' and id(n) not in title_nodes]
+        heading, publication_format, track, _ = SECTIONS[section]
+        counts[section] += 1
+        metadata = {'publisher_page': page, 'section_url': URL, 'section_anchor': section,
+                    'section_heading': heading, 'publication_format': publication_format,
+                    'author_affiliations': affiliations, 'source_evidence': evidence,
+                    'decision_date_precision': 'not_supplied',
+                    'missing_abstract_reason': 'Publisher HTML supplies no abstract; research PDF not downloaded.',
+                    'publication_evidence': 'Published proceedings entry, not an original decision note.'}
+        withdrawn = retractions == ['Withdrawn June 8, 2026']
+        if withdrawn:
+            if (section, page, title, href) != ('1', 3178, WITHDRAWAL_TITLE, ''):
+                raise ValueError('Unreviewed withdrawal notice')
+            metadata.update({'publication_state': 'withdrawn',
+                             'withdrawal_date': '2026-06-08',
+                             'raw_publication_state': retractions[0],
+                             'decision_date_precision': 'day',
+                             'publication_evidence': 'Explicit dated publisher withdrawal notice, not an original review decision note.'})
+        elif retractions:
+            if (section, page, title, href, retractions) != ('R', 238, RETRACTION_TITLE, '', ['Retracted June 8, 2026']):
+                raise ValueError('Unreviewed retraction or publication status markup')
+            held.append({'source': 'aamas_proceedings', 'external_id': '2026/p238',
+                         'title': title, 'authors': authors, 'year': 2026, 'track': track,
+                         'url': URL+'#R', 'abstract': None, 'identifiers': {},
+                         'observed_at': evidence['observed_at'], 'metadata': metadata,
+                         'publication_state': 'retracted', 'retraction_date': '2026-06-08',
+                         'raw_publication_state': retractions[0],
+                         'hold_reason': 'Explicit retraction; not an accepted/withdrawn submission assertion. Dedicated decision modeling and identity review required.'})
+            continue
+        if not withdrawn:
+            match = PDF.fullmatch(href)
+            if not match or match[1] in seen_pdf_ids:
+                raise ValueError('Invalid or repeated publisher PDF ID')
+            seen_pdf_ids.add(match[1])
+            metadata.update({'publisher_document_id': match[1], 'paper_url': ROOT+'pdfs/'+match[1]+'.pdf'})
+        if section == 'K':
+            excluded.append({'publisher_page': page, 'title': title, 'authors': authors,
+                             'metadata': metadata, 'reason': 'Publisher keynote, not a research submission.'})
+            continue
+        metadata['track_scope_note'] = ('Published format known; individual main/special submission track not established.'
+                                        if track == 'proceedings_unspecified' else 'Explicit publisher section.')
+        if section == 'A':
+            metadata['prior_submission_note'] = 'AAAI transfer section does not supply original submission IDs or individual prior decision notes; none inferred.'
+        if section == 'J':
+            metadata['track_scope_note'] = 'Journal presentation; not another independent journal review or research-track acceptance.'
+        records.append({'source': 'aamas_proceedings', 'external_id': '2026/p'+str(page),
+                        'url': URL+'#'+section, 'title': title, 'abstract': None,
+                        'authors': authors, 'identifiers': {}, 'venue': 'AAMAS', 'venue_aliases': [],
+                        'year': 2026, 'track': track, 'status': 'withdrawn' if withdrawn else 'accepted',
+                        'observed_at': evidence['observed_at'],
+                        'raw_decision': retractions[0] if withdrawn else 'listed in official AAMAS 2026 published proceedings '+heading,
+                        'metadata': metadata,
+                        'tags': [{'namespace': 'aamas_proceedings:publication_format', 'value': publication_format}]})
+    if headers != list(SECTIONS) or dict(counts) != {k: v[3] for k, v in SECTIONS.items()}:
+        raise ValueError('Publisher section inventory differs from reviewed 2026 layout')
+    if (len(records), len(excluded), len(held)) != (639, 3, 1):
+        raise ValueError('Unexpected accepted/keynote/retraction partition')
+    if Counter(r['status'] for r in records) != {'accepted': 638, 'withdrawn': 1}:
+        raise ValueError('Unexpected publisher publication-state partition')
+    return records, excluded, held
+
+
+def read_page(cache, snapshots):
+    if bool(cache) == bool(snapshots):
+        raise ValueError('Choose exactly one cache or frozen snapshot directory')
+    if snapshots:
+        base = Path(snapshots).resolve()
+        frozen = json.loads((base/'receipts.json').read_text())['receipts']
+        r = one([r for r in frozen if r['url'] == URL], 'frozen response receipt')
+        filename = Path(r['file'])
+        if (filename.is_absolute() or '..' in filename.parts or
+                not (base/filename).resolve().is_relative_to(base) or r.get('status') != 200):
+            raise ValueError('Unsafe or unsuccessful publisher response')
+        data = (base/filename).read_bytes()
+        if len(data) > 8*1024**2 or len(data) != r['bytes'] or hashlib.sha256(data).hexdigest() != r['sha256']:
+            raise ValueError('Frozen publisher response checksum/size mismatch')
+        observed = r['finished_at']
+    else:
+        data = fetch(URL, cache, 8*1024**2, delay=1)
+        r = json.loads((Path(cache)/hashlib.sha256(URL.encode()).hexdigest()).with_suffix('.json').read_text())
+        observed = r['retrieved_at']
+    timestamp(observed)
+    return data, {'url': URL, 'sha256': hashlib.sha256(data).hexdigest(), 'bytes': len(data),
+                  'file': 'evidence/'+hashlib.sha256(data).hexdigest()+'.html',
+                  'observed_at': observed, 'http_status': 200, 'response_receipt': r}
+
+
+def collect(out, *, cache=None, snapshots=None):
+    data, evidence = read_page(cache, snapshots)
+    records, excluded, held = parse_contents(data.decode('utf-8'), evidence)
+    grouped = defaultdict(list)
+    for row in records:
+        grouped[row['track']].append(row)
+    out = Path(out); out.mkdir(parents=True, exist_ok=True); files = []
+    with tempfile.TemporaryDirectory(prefix='.aamas2026-', dir=out) as temporary:
+        stage = Path(temporary); (stage/'evidence').mkdir()
+        (stage/evidence['file']).write_bytes(data)
+        for track, group in sorted(grouped.items()):
+            p = stage/f'aamas-proceedings-2026-{track}.jsonl'
+            p.write_text(''.join(json.dumps(r, ensure_ascii=False)+'\n' for r in group))
+            manifest = {'source': 'aamas_proceedings', 'parser_version': 3, 'venue': 'AAMAS', 'year': 2026,
+                        'track': track, 'count': len(group), 'file': str(out/p.name),
+                        'file_sha256': hashlib.sha256(p.read_bytes()).hexdigest(), 'list_url': URL,
+                        'status': 'partial', 'missing_abstract_count': len(group),
+                        'status_counts': dict(Counter(r['status'] for r in group)),
+                        'publication_format_counts': dict(Counter(r['metadata']['publication_format'] for r in group)),
+                        'note': 'Reviewed TOC partition excluding keynote/retracted entries; identity and full submission history remain unverified.'}
+            p.with_suffix('.manifest.json').write_text(json.dumps(manifest, ensure_ascii=False, indent=2)+'\n')
+            files.append(manifest)
+        result = {'source': 'aamas_proceedings', 'year': 2026, 'finished_at': timestamp(),
+                  'status': 'collected_pending_identity_review', 'records': len(records), 'files': files,
+                  'excluded_publications': excluded, 'held_publications': held,
+                  'status_counts': dict(Counter(r['status'] for r in records)),
+                  'source_receipts': [evidence], 'database_written': False, 'pdfs_downloaded': False,
+                  'note': 'Retraction evidence held separately; publication is not an original decision note, and absence is not rejection.'}
+        report = 'aamas-proceedings-2026.json'
+        (stage/report).write_text(json.dumps(result, ensure_ascii=False, indent=2)+'\n')
+        (out/'evidence').mkdir(exist_ok=True)
+        for p in (stage/'evidence').iterdir():
+            p.replace(out/'evidence'/p.name)
+        for p in stage.iterdir():
+            if p.is_file() and p.name != report:
+                p.replace(out/p.name)
+        (stage/report).replace(out/report)
+    return result
@@ -6,6 +6,7 @@ import xml.etree.ElementTree as ET
 from pathlib import Path

 from paper_atlas.io.git_metadata import checkout_metadata
+from paper_atlas.collectors.acl_historical import event_scope, material_reason

 VENUES={'acl':'ACL','emnlp':'EMNLP','naacl':'NAACL','eacl':'EACL','coling':'COLING','conll':'CoNLL'}

@@ -29,7 +30,10 @@ def paper_id(collection,volume,number):
    return f'{collection}-{int(volume):0{width}d}{int(number):0{digits}d}'


-def volume_scope(meta,volume):
+def volume_scope(meta,volume,collection=None):
+    historical=event_scope(meta,volume,collection)
+    if historical:
+        return historical['canonical_venue'],historical['venue_aliases'],historical['track']
    codes=[text(n).lower() for n in meta.findall('venue')]
    book=text(meta.find('booktitle'))
    lower=book.lower()
@@ -59,7 +63,7 @@ def collect_xml(path,out,commit):
        vid=volume.attrib['id']
        meta=volume.find('meta')
        if meta is None:raise ValueError('Volume metadata missing')
-        scope=volume_scope(meta,vid)
+        scope=volume_scope(meta,vid,collection)
        key=f'{collection}-{vid}'
        if scope is None:
            results.append({'volume':key,'status':'excluded_by_venue','venue_codes':[text(n) for n in meta.findall('venue')],'booktitle':text(meta.find('booktitle')),'year':text(meta.find('year'))})
@@ -70,12 +74,18 @@ def collect_xml(path,out,commit):
        year=int(year_text)
        records=[]
        frontmatter=0
+        excluded_materials=[]
+        historical=event_scope(meta,vid,collection)
        for paper in volume.findall('paper'):
            pid=paper.attrib['id']
            if int(pid)==0:
                frontmatter+=1
                continue
            identifier=paper_id(collection,vid,pid)
+            reason=material_reason(collection,vid,paper)
+            if reason:
+                excluded_materials.append({'external_id':identifier,'title':text(paper.find('title')),'reason':reason})
+                continue
            doi=text(paper.find('doi'))
            if doi.startswith('10.18653/v1/') and doi.split('10.18653/v1/',1)[1].casefold()!=identifier.casefold():
                raise ValueError('Official DOI disagrees with constructed Anthology ID: '+identifier)
@@ -83,6 +93,11 @@ def collect_xml(path,out,commit):
            if not title:raise ValueError('Missing paper title: '+identifier)
            authors=[{'given':text(a.find('first')),'family':text(a.find('last'))} for a in paper.findall('author')]
            records.append({'source':'acl_anthology','external_id':identifier,'url':f'https://aclanthology.org/{identifier}/','title':title,'abstract':text(paper.find('abstract')) or None,'authors':authors,'identifiers':{'acl':identifier,'doi':doi},'venue':venue,'venue_aliases':aliases if len(aliases)>1 else [],'year':year,'track':track,'status':'accepted','raw_decision':'listed in authoritative ACL Anthology proceedings XML','metadata':{'collection':collection,'volume':vid,'booktitle':text(meta.find('booktitle')),'venue_codes':[text(n) for n in meta.findall('venue')],'pages':text(paper.find('pages')),'publisher':text(meta.find('publisher')),'metadata_commit':commit,'source_xml':f'https://github.com/acl-org/acl-anthology/blob/{commit}/data/xml/{collection}.xml'}})
+            if historical:
+                records[-1]['metadata']['historical_event_scope']=historical
+                if historical.get('publication_format'):
+                    records[-1]['metadata']['publication_format']=historical['publication_format']
+                    records[-1]['tags']=[{'namespace':'acl_anthology:publication_format','value':historical['publication_format']}]
        if not records:
            results.append({'volume':key,'status':'unavailable','reason':'no research paper elements after excluding front matter'})
            continue
@@ -93,7 +108,7 @@ def collect_xml(path,out,commit):
            for record in records:output.write(json.dumps(record,ensure_ascii=False)+'\n')
        part.replace(target)
        missing=sum(not row['abstract'] for row in records)
-        manifest={'source':'acl_anthology','venue':venue,'year':year,'track':track,'count':len(records),'xml_paper_elements':len(volume.findall('paper')),'excluded_frontmatter':frontmatter,'missing_abstract_count':missing,'list_url':f'https://aclanthology.org/{key}/','metadata_commit':commit,'file':str(target),'status':'partial' if missing else 'collected'}
+        manifest={'source':'acl_anthology','venue':venue,'year':year,'track':track,'count':len(records),'xml_paper_elements':len(volume.findall('paper')),'excluded_frontmatter':frontmatter,'excluded_materials':excluded_materials,'missing_abstract_count':missing,'list_url':f'https://aclanthology.org/{key}/','metadata_commit':commit,'file':str(target),'status':'partial' if missing else 'collected'}
        target.with_suffix('.manifest.json').write_text(json.dumps(manifest,indent=2))
        results.append(manifest)
        print(json.dumps(manifest),flush=True)
@@ -0,0 +1,76 @@
+"""Reviewed edition-specific scope; never alias entire source classifications."""
+
+HISTORY_URL = 'https://aclanthology.org/www.mt-archive.info/70/ACL-1982-Walker-1.pdf'
+NOTICE_URL = 'https://aclanthology.org/J77-4001.pdf'
+BOOK = 'Theoretical Issues in Natural Language Processing-2'
+MATERIAL_TITLE = 'List of questions suggested for consideration in each session'
+
+
+def text(node):
+    return ' '.join(''.join(node.itertext()).split()) if node is not None else ''
+
+
+def event_scope(meta, volume, collection):
+    if (collection, volume) == ('1963.earlymt', '1'):
+        return amtcl1963_scope(meta)
+    if (collection, volume) != ('T78', '1'):
+        return None
+    if ([text(n) for n in meta.findall('venue')] != ['tinlap']
+            or [text(n) for n in meta.findall('year')] != ['1978']
+            or [text(n) for n in meta.findall('booktitle')] != [BOOK]
+            or [(text(n.find('first')), text(n.find('last'))) for n in meta.findall('editor')]
+               != [('David L.', 'Waltz')]):
+        raise ValueError('Reviewed T78-1 scope metadata changed; independent review required')
+    return {
+        'collection': 'T78', 'volume': '1', 'original_venue': 'TINLAP',
+        'event_year': 1978, 'event_dates': ['1978-07-25', '1978-07-27'],
+        'relationship': 'ACL annual meeting took the form of TINLAP-2',
+        'canonical_venue': 'ACL+TINLAP', 'venue_aliases': ['ACL', 'TINLAP'],
+        'track': 'proceedings_unspecified',
+        'track_scope_note': 'Invited and submitted contributions are described at volume level; individual roles are not identified in XML.',
+        'evidence': [
+            {'url': NOTICE_URL, 'sha256': '14b5deb471c55afb07d789529b95d0462a2a1a77df3dfba7fa1f5d3ab75eb411',
+             'pdf_pages': [9, 10], 'printed_pages': ['9', '10'],
+             'scope': 'Contemporary annual meeting notice, not individual decision notes; ACM confirmation was pending in this notice.'},
+            {'url': HISTORY_URL, 'sha256': '35c21bd4983975bcaccbb94bd8ab91c9019fc190feec1791255407cf18a7e49a',
+             'pdf_pages': [3], 'printed_pages': ['91'],
+             'scope': 'Retrospective annual meeting table and TNLP abbreviation confirm the 1978 event association.'},
+        ],
+    }
+
+
+def amtcl1963_scope(meta):
+    expected = {
+        'venue': ['earlymt'], 'year': ['1963'],
+        'booktitle': ['Proceedings of the Annual meeting of the Association for Machine Translation and Computational Linguistics'],
+        'address': ['Denver, Colorado'], 'month': ['25-26 August'],
+    }
+    if any([text(n) for n in meta.findall(field)] != values
+           for field, values in expected.items()):
+        raise ValueError('Reviewed AMTCL 1963 scope metadata changed; independent review required')
+    return {
+        'collection': '1963.earlymt', 'volume': '1', 'original_venue': 'EarlyMT',
+        'original_event_name': 'Association for Machine Translation and Computational Linguistics',
+        'event_year': 1963, 'event_dates': ['1963-08-25', '1963-08-26'],
+        'relationship': 'Annual meeting under the former name of ACL; EarlyMT is the source classification, not a global ACL alias.',
+        'canonical_venue': 'ACL', 'venue_aliases': ['ACL', 'AMTCL'],
+        'track': 'proceedings_unspecified',
+        'track_scope_note': 'Published abstracts with named authors; individual submission tracks and original decision notes are not supplied.',
+        'publication_format': 'published_abstract',
+        'evidence': [
+            {'url': 'https://2023.aclweb.org/participants/about_acl/',
+             'sha256': '0f6bc260c2b34c9e2a51d971aeb43c3270a5b15b6db1d6d41e50669f316345f3',
+             'scope': 'Official ACL history identifies AMTCL as the former name, changed to ACL in 1968.'},
+            {'url': 'https://github.com/acl-org/acl-anthology/blob/a7be623d01c48c61405dec31c871121cdbed5a01/data/xml/1963.earlymt.xml',
+             'sha256': '4a4626d792ac507de0281cb358769f7246f4a0d6b6a9176ac02e61545c1635fc',
+             'scope': 'Official XML supplies the exact annual meeting title, dates, location and 34 contributions; hash is XML, not HTML.'},
+        ],
+    }
+
+
+def material_reason(collection, volume, paper):
+    if (collection, volume, paper.attrib.get('id')) != ('T78', '1', '36'):
+        return None
+    if text(paper.find('title')) != MATERIAL_TITLE or paper.findall('author'):
+        raise ValueError('Reviewed T78-1036 material changed; independent review required')
+    return 'Session question list, not an authored research contribution; no decision inferred.'
@@ -20,7 +20,7 @@ DTD_MD5='96e4283e71886dec2173718957293648'
 DTD_NAMES={'dblp.dtd','dblp-2023-06-28.dtd'}
 RELEASE='https://doi.org/10.4230/dblp.xml.2026-11-01'
 # Broad discovery candidates, including historical names; not a venue mapping.
-FAMILIES=set('nips icml iclr colm colt aistats uai clear acl emnlp naacl eacl coling conll cvpr iccv eccv aaai ijcai ecai kdd sigir www wsdm recsys cikm icdm sdm ecml pkdd ecmlpkdd icra iros rss corl aips icaps kr atal aamas icassp interspeech eurospeech icslp ismir miccai fat facct lrec mm mlsys'.split())
+FAMILIES=set('nips icml iclr colm colt aistats uai clear acl emnlp naacl eacl coling conll cvpr iccv eccv aaai ijcai ecai kdd sigir www wsdm recsys cikm icdm sdm ecml pkdd ecmlpkdd icra iros rss corl aips icaps ecp ewsp kr atal aamas ifaamas icassp interspeech eurospeech icslp ismir miccai fat facct lrec mm mlsys'.split())


 def records(archive,dtd_bytes):
@@ -0,0 +1,45 @@
+"""Exact predecessor volumes, with original names and independent family histories."""
+ECML_HISTORY = 'https://ecmlpkdd2011.org/pastConferences.php'
+ICAPS_HISTORY = 'https://www.icaps-conference.org/conference-series/'
+
+# family/year: booktitle, original series, target family, publication year, full title
+VOLUMES = {
+    ('ecml', 1987): ('EWSL', 'EWSL', 'ECML-PKDD', 1987,
+        'Progress in Machine Learning - Proceedings of EWSL 87: 2nd European Working Session on Learning, Bled, Yugoslavia, May 1987'),
+    ('ecml', 1988): ('EWSL', 'EWSL', 'ECML-PKDD', 1988,
+        'Proceedings of the Third European Working Session on Learning, EWSL 1988, Turing Institute, Glasgow, UK, October 3-5, 1988'),
+    ('ecml', 1989): ('EWSL', 'EWSL', 'ECML-PKDD', 1989,
+        'Proceedings of the 4th European Working Session on Learning, Montpellier, France, 4-6 December 1989'),
+    ('ecml', 1991): ('EWSL', 'EWSL', 'ECML-PKDD', 1991,
+        'Machine Learning - EWSL-91, European Working Session on Learning, Porto, Portugal, March 6-8, 1991, Proceedings'),
+    ('aips', 1990): ('Expert Planning Systems', 'EPS', 'ICAPS', 1990,
+        'Proceedings of the First International Conference on Expert Planning Systems, Brighton, UK, June 27-29, 1990'),
+    ('ecp', 1997): ('ECP', 'ECP', 'ICAPS', 1997,
+        "Recent Advances in AI Planning, 4th European Conference on Planning, ECP'97, Toulouse, France, September 24-26, 1997, Proceedings"),
+    ('ecp', 1999): ('ECP', 'ECP', 'ICAPS', 2000,
+        "Recent Advances in AI Planning, 5th European Conference on Planning, ECP'99, Durham, UK, September 8-10, 1999, Proceedings"),
+    ('ewsp', 1991): ('EWSP', 'EWSP', 'ICAPS', 1991,
+        "European Workshop on Planning, EWSP '91, Sankt Augustin, Germany, March 18-19, 1991, Proceedings"),
+}
+
+
+def predecessor_scope(family, base, suffix, volume, year, title):
+    definition = VOLUMES.get((family, year))
+    if definition is None:
+        return None
+    book, original, target, publication_year, expected_title = definition
+    if (suffix or base != book or volume['key'] != f'conf/{family}/{year}'
+            or title != expected_title or volume['fields'].get('year') != [str(publication_year)]):
+        return None
+    return {'original_series': original, 'target_family': target,
+            'history_url': ECML_HISTORY if target == 'ECML-PKDD' else ICAPS_HISTORY,
+            'proceedings_key': volume['key'], 'proceedings_title': title,
+            'event_year': year, 'proceedings_year_fields': list(volume['fields']['year'])}
+
+
+def missing_candidate_families(targets, families, through_year):
+    # These two families were absent from the earlier narrowed candidate JSONL,
+    # although their proceedings and volume_counts exist in the full catalogue.
+    required = {family for (family, year), definition in VOLUMES.items()
+                if family in ('ecp', 'ewsp') and definition[2] in targets and year <= through_year}
+    return sorted(family for family in required if not families.get(family))
@@ -15,6 +15,7 @@ from urllib.parse import parse_qs,unquote,urlsplit
 from paper_atlas.config import DEFAULT_REGISTRY
 from paper_atlas.collectors.dblp import XML_SHA,DTD_MD5,RELEASE,records
 from paper_atlas.collectors.dblp_scope import scope
+from paper_atlas.collectors.dblp_predecessors import missing_candidate_families
 from paper_atlas.db.submissions import timestamp
 from paper_atlas.io.snapshots import digest_file
 from paper_atlas.io.publication_ids import mlsys_id
@@ -88,6 +89,10 @@ def normalize_row(row,volumes,targets,include_workshops=False,through_year=2026)
              'scope_rule':edition['rule'],'author_names_raw':fields.get('author',[]),'publtype':row.get('publtype'),
              'bibliography':{key:value for key,value in fields.items() if key in ('booktitle','year','ee','url','pages','volume','number','publisher','series','isbn')},
              'ambiguous_identifiers':ambiguous,'publication_evidence':'inproceedings bibliography; not an original decision note'}
+    if edition.get('historical_predecessor_evidence'):
+        metadata['historical_predecessor_evidence'] = edition['historical_predecessor_evidence']
+    if edition.get('joint_edition_evidence'):
+        metadata['joint_edition_evidence'] = edition['joint_edition_evidence']
    if edition.get('track_scope_note'):
        metadata['track_scope_note']=edition['track_scope_note']
    if edition.get('track_scope_evidence_url'):
@@ -122,8 +127,9 @@ def collect(catalogue,out,venues=None,candidates=None,archive=None,dtd=None,incl
        families = manifest.get('candidate_family_counts', {})
        missing = [venue for venue, family in [('MM', 'mm'), ('MLSys', 'mlsys')]
                   if venue in targets and not families.get(family)]
+        missing += ['ICAPS/'+family for family in missing_candidate_families(targets, families, through_year)]
        if missing:
-            raise ValueError('Candidate file predates requested families ' + ', '.join(missing) + '; use the original --archive')
+            raise ValueError('Candidate file omits requested families ' + ', '.join(missing) + '; use the original --archive')
    out=Path(out);out.mkdir(parents=True,exist_ok=True)
    with (out/'dblp.normalize.lock').open('a') as lock:
        fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
@@ -0,0 +1,156 @@
+"""Recover raw family candidates from a pinned snapshot and its existing catalogue.
+
+The old candidate file is not an exhaustive source: earlier discovery filters
+can omit an entire namespace. This command checks the complete snapshot and
+catalogue, without assigning venues, tracks, acceptance or paper identities.
+"""
+import argparse
+from collections import Counter
+from contextlib import closing
+import fcntl
+import json
+from pathlib import Path
+import re
+import sqlite3
+import tempfile
+
+from paper_atlas.collectors.dblp import DTD_MD5, FAMILIES, RELEASE, XML_SHA, family, records
+from paper_atlas.db.submissions import timestamp
+from paper_atlas.io.snapshots import digest_file
+
+
+def catalogue_evidence(catalogue, families, expected_sha, expected_dtd_md5):
+    manifest_path = catalogue.with_name('dblp-ai-candidates.manifest.json')
+    manifest = json.loads(manifest_path.read_text())
+    if (manifest.get('snapshot_sha256') != expected_sha
+            or manifest.get('dtd_md5') != expected_dtd_md5):
+        raise ValueError('Catalogue belongs to a different snapshot or DTD')
+    totals = manifest.get('record_types', {})
+    if (set(totals) != {'proceedings', 'inproceedings'}
+            or any(type(n) is not int or n < 0 for n in totals.values())
+            or type(manifest.get('records_scanned')) is not int
+            or sum(totals.values()) != manifest['records_scanned']):
+        raise ValueError('Incomplete catalogue record totals')
+    counts = Counter()
+    volumes = {}
+    # The catalogue is evidence, never a writable recovery destination.
+    with closing(sqlite3.connect(catalogue.resolve().as_uri() + '?mode=ro', uri=True)) as c:
+        for name in families:
+            found = c.execute('SELECT record_type,count FROM family_counts WHERE family=?',
+                              (name,)).fetchall()
+            if not found or not any(n for _, n in found):
+                raise ValueError('Family absent from complete catalogue: ' + name)
+            for kind, count in found:
+                if kind not in totals or type(count) is not int or count < 0:
+                    raise ValueError('Invalid catalogue family count')
+                counts[(name, kind)] = count
+            for key, raw in c.execute('SELECT key,metadata_json FROM proceedings WHERE family=?',
+                                      (name,)):
+                row = json.loads(raw)
+                if (family(key) != name or row.get('key') != key
+                        or row.get('record_type') != 'proceedings'):
+                    raise ValueError('Invalid catalogue proceedings evidence')
+                volumes[key] = row
+    if len(volumes) != sum(counts[(name, 'proceedings')] for name in families):
+        raise ValueError('Catalogue proceedings count differs from volume records')
+    return manifest, digest_file(manifest_path)['sha256'], counts, volumes
+
+
+def recover(archive, dtd, catalogue, out, families, *, expected_sha=XML_SHA,
+            expected_dtd_md5=DTD_MD5):
+    families = list(families)
+    if (not families or any(not isinstance(name, str)
+                           or not re.fullmatch(r'[a-z][a-z0-9-]*', name)
+                           or name not in FAMILIES for name in families)):
+        raise ValueError('Select an explicitly supported discovery family')
+    families = sorted(set(families))
+    archive, dtd, catalogue = Path(archive), Path(dtd), Path(catalogue)
+    output = Path(out).absolute()
+    if output.exists() or output.is_symlink():
+        raise ValueError('Recovery output must not already exist')
+    output.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = output.parent / ('.' + output.name + '.recovery.lock')
+    with lock_path.open('a') as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        if output.exists() or output.is_symlink():
+            raise ValueError('Recovery output appeared before scan')
+        actual = digest_file(archive)
+        if actual['sha256'] != expected_sha:
+            raise ValueError('DBLP snapshot checksum mismatch')
+        if dtd.stat().st_size > 128 * 1024 or digest_file(dtd)['md5'] != expected_dtd_md5:
+            raise ValueError('DBLP DTD checksum mismatch or size limit')
+        manifest, manifest_sha, expected, volumes = catalogue_evidence(
+            catalogue, families, expected_sha, expected_dtd_md5)
+        totals, found = Counter(), Counter()
+        seen_keys, found_volumes = set(), set()
+        with tempfile.TemporaryDirectory(prefix='.dblp-family-', dir=output.parent) as tmp:
+            stage = Path(tmp) / 'recovered'
+            stage.mkdir()
+            target = stage / 'dblp-family-candidates.jsonl'
+            with target.open('w') as stream:
+                for row in records(archive, dtd.read_bytes()):
+                    totals[row['record_type']] += 1
+                    name = family(row['key'])
+                    if name in families:
+                        if row['key'] in seen_keys:
+                            raise ValueError('Duplicate raw bibliographic key')
+                        seen_keys.add(row['key'])
+                        found[(name, row['record_type'])] += 1
+                        if row['record_type'] == 'proceedings':
+                            if volumes.get(row['key']) != row:
+                                raise ValueError('Raw proceedings differs from catalogue evidence')
+                            found_volumes.add(row['key'])
+                        stream.write(json.dumps(row, ensure_ascii=False) + '\n')
+                    scanned = sum(totals.values())
+                    if scanned % 250000 == 0:
+                        print(json.dumps({'status': 'scanning_raw_family_candidates',
+                                          'records_scanned': scanned,
+                                          'recovered_records': sum(found.values())}), flush=True)
+            if (totals != Counter(manifest['record_types'])
+                    or sum(totals.values()) != manifest['records_scanned']):
+                raise ValueError('Complete snapshot totals differ from catalogue')
+            if found != expected or found_volumes != volumes.keys():
+                raise ValueError('Recovered family totals differ from catalogue')
+            report = {
+                'format_version': 1, 'source': 'dblp',
+                'status': 'recovered_raw_candidates_pending_scope_review',
+                'finished_at': timestamp(), 'source_release': RELEASE,
+                'snapshot_sha256': actual['sha256'], 'dtd_md5': expected_dtd_md5,
+                'catalogue_manifest_sha256': manifest_sha, 'families': families,
+                'records_scanned': sum(totals.values()), 'record_types': dict(totals),
+                'recovered_records': sum(found.values()),
+                'recovered_publications': sum(found[(n, 'inproceedings')] for n in families),
+                'recovered_volumes': len(found_volumes),
+                'family_counts': [{'family': name, 'record_type': kind, 'count': count}
+                                  for (name, kind), count in sorted(found.items())],
+                'old_candidate_family_counts': {
+                    name: manifest.get('candidate_family_counts', {}).get(name, 0)
+                    for name in families},
+                'catalogue_volumes': [volumes[k] for k in sorted(volumes)],
+                'file': str(output / target.name),
+                'file_sha256': digest_file(target)['sha256'], 'database_written': False,
+                'note': 'Raw bibliographic candidates, including volume records and possible '
+                        'keynotes/workshops. No venue, track, acceptance or work identity '
+                        'inferred. Requires primary-source scope and identity review; '
+                        'not a normalized import queue. Existing imported sources must '
+                        'not be replayed.',
+            }
+            # Deliberately not an import-records sidecar manifest.
+            (stage / 'recovery-manifest.json').write_text(
+                json.dumps(report, ensure_ascii=False, indent=2) + '\n')
+            if output.exists() or output.is_symlink():
+                raise ValueError('Recovery output appeared during scan')
+            stage.rename(output)
+    return report
+
+
+def main(argv=None, *, prog=None):
+    parser = argparse.ArgumentParser(prog=prog, description=__doc__)
+    parser.add_argument('--archive', required=True, type=Path)
+    parser.add_argument('--dtd', required=True, type=Path)
+    parser.add_argument('--catalogue', required=True, type=Path)
+    parser.add_argument('--family', required=True, action='append', choices=sorted(FAMILIES))
+    parser.add_argument('--out', required=True, type=Path)
+    args = parser.parse_args(argv)
+    print(json.dumps(recover(args.archive, args.dtd, args.catalogue, args.out, args.family),
+                     ensure_ascii=False))
@@ -1,6 +1,8 @@
 """Explicit bibliographic aliases; a directory family alone is not venue evidence."""
 import re

+from paper_atlas.collectors.dblp_predecessors import predecessor_scope
+

 # Ordered long/joint names precede their shorter forms.
 BOOKS = {
@@ -27,7 +29,8 @@ BOOKS = {
    'pkdd':[('ECML/PKDD','ECML-PKDD',[]),('ECML PKDD','ECML-PKDD',[]),('PKDD','PKDD',['ECML-PKDD'])],
    'icra':[('ICRA','ICRA',[])], 'iros':[('IROS','IROS',[])],
    'rss':[('Robotics: Science and Systems','RSS',[])], 'corl':[('CoRL','CoRL',[])],
-    'aips':[('ICAPS','ICAPS',[]),('AIPS','AIPS',['ICAPS'])], 'icaps':[('ICAPS','ICAPS',[])],
+    'aips':[('ICAPS','ICAPS',[]),('AIPS','AIPS',['ICAPS']),('Expert Planning Systems','EPS',['ICAPS'])], 'icaps':[('ICAPS','ICAPS',[])],
+    'ecp':[('ECP','ECP',['ICAPS'])], 'ewsp':[('EWSP','EWSP',['ICAPS'])],
    'kr':[('KR','KR',[])], 'atal':[('AAMAS','AAMAS',[])],
    'icassp':[('ICASSP','ICASSP',[])],
    'interspeech':[('INTERSPEECH','INTERSPEECH',[]),('EUROSPEECH','EUROSPEECH',['INTERSPEECH']),('ICSLP','ICSLP',['INTERSPEECH']),('ECST','ECST',['INTERSPEECH'])],
@@ -54,7 +57,34 @@ HISTORICAL_WORKSHOP_TITLES = {
 }


+# Exact pinned volume titles corroborated by official series histories. The
+# original title (including Workshop) remains in source metadata. In particular
+# ML91 has no four-digit year in its title; its exact key/title and bibliographic
+# year are checked independently, rather than guessing a title year.
+HISTORICAL_PRIMARY_EVIDENCE = {
+    'icml': ('ML', 'https://icml.cc/Conferences/2008/past_icmls.shtml.html'),
+    'iros': ('IROS', 'https://www.ieee-ras.org/conferences-workshops/financially-co-sponsored/iros/iros-past-and-future-venues/'),
+}
+HISTORICAL_PRIMARY_TITLES = {
+    ('icml', 1988): 'Machine Learning, Proceedings of the Fifth International Conference on Machine Learning, Ann Arbor, Michigan, USA, June 12-14, 1988',
+    ('icml', 1989): 'Proceedings of the Sixth International Workshop on Machine Learning (ML 1989), Cornell University, Ithaca, New York, USA, June 26-27, 1989',
+    ('icml', 1990): 'Machine Learning, Proceedings of the Seventh International Conference on Machine Learning, Austin, Texas, USA, June 21-23, 1990',
+    ('icml', 1991): 'Proceedings of the Eighth International Workshop (ML91), Northwestern University, Evanston, Illinois, USA',
+    ('icml', 1992): 'Proceedings of the Ninth International Workshop on Machine Learning (ML 1992), Aberdeen, Scotland, UK, July 1-3, 1992',
+    ('iros', 1988): "IEEE International Workshop on Intelligent Robots and Systems '88, Proceedings. IROS 1988, Tokyo, Japan, October 31 - November 2, 1988",
+    ('iros', 1989): "IEEE International Workshop on Intelligent Robots and Systems '89, Proceedings. IROS 1989, September 4-6, 1989, Tsukuba, Japan",
+    ('iros', 1990): "IEEE International Workshop on Intelligent Robots and Systems '90, Towards a New Frontier of Applications, Proceedings. IROS 1990, July 3-6, 1990, Ibaraki, Japan",
+}
+
+
 def historical_track(family, base, suffix, volume_key, year, title):
+    primary = HISTORICAL_PRIMARY_EVIDENCE.get(family)
+    if (primary and not suffix and base.casefold() == primary[0].casefold()
+            and volume_key == f'conf/{family}/{year}'
+            and title == HISTORICAL_PRIMARY_TITLES.get((family, year))):
+        return ('main',
+                'Historical primary series; exact proceedings key, complete title and bibliographic/event year corroborated by official series history. Workshop in this original title is not an affiliated track.',
+                primary[1])
    if suffix or base.casefold() != family or volume_key != f'conf/{family}/{year}':
        return None
    prefix = HISTORICAL_WORKSHOP_TITLES.get((family, year))
@@ -108,7 +138,11 @@ def scope(row,volume,through_year=2026):
    if len(bibliographic)!=1 or not re.fullmatch(r'\d{4}',bibliographic[0]):return None,'ambiguous_bibliographic_year'
    if int(bibliographic[0])!=year and not re.search(r'\b'+str(year)+r'\b',title):return None,'unverified_year_difference'
    text=(suffix+' '+title).casefold();track='main'
-    historical = historical_track(family, base, suffix, volume['key'], year, title)
+    predecessor = predecessor_scope(family, base, suffix, volume, year, title)
+    if (family in ('ecp', 'ewsp') or (family == 'aips' and base == 'Expert Planning Systems')) and not predecessor:
+        return None, 'unverified_historical_predecessor'
+    historical = (('main', 'Historical predecessor; exact volume, full title, event and publication years verified; original series retained.', predecessor['history_url'])
+                  if predecessor else historical_track(family, base, suffix, volume['key'], year, title))
    if historical:track=historical[0]
    elif 'findings' in text:track='findings'
    elif 'shared task' in text:track='shared_task'
@@ -131,8 +165,17 @@ def scope(row,volume,through_year=2026):
    elif suffix.casefold() in ('poster','posters') and venue not in ('ICLR','ACL','EMNLP','NAACL','EACL','COLING','CoNLL'):track='poster'
    if venue=='AAAI+IAAI':track='proceedings_unspecified'
    if venue=='AAMAS' and year<2002:return None,'predecessor_not_aamas'
+    joint_evidence = None
+    if (family == 'ijcai' and base == 'IJCAI' and track == 'main'
+            and year in (2018, 2022) and volume['key'] == 'conf/ijcai/' + str(year)):
+        venue, aliases = 'ECAI+IJCAI', ['ECAI', 'IJCAI']
+        joint_evidence = 'https://www.eurai.org/ecai/history'
    result = {'venue':venue,'venue_aliases':aliases,'year':year,'track':track,'bibliographic_year':int(bibliographic[0]),
              'rule':family+':'+base,'proceedings_title':title,'edition_year_basis':year_basis}
+    if predecessor:
+        result['historical_predecessor_evidence'] = predecessor
+    if joint_evidence:
+        result['joint_edition_evidence'] = joint_evidence
    if historical:
        result['track_scope_note'] = historical[1]
        result['track_scope_evidence_url'] = historical[2]
@@ -0,0 +1,225 @@
+"""Frozen official ICLR 2014–2016 lists; presentation evidence is not a track."""
+import argparse
+from collections import Counter, defaultdict
+import fcntl
+import hashlib
+import json
+from pathlib import Path
+import re
+import tempfile
+from urllib.parse import urlsplit
+
+from paper_atlas.db.submissions import timestamp
+from paper_atlas.io.html import Document, Node, clean
+from paper_atlas.io.http import fetch
+
+SOURCE = 'iclr_archive'
+PAGES = {
+    2014: ('https://iclr.cc/archive/2014/conference-proceedings/', {'main': 35}),
+    2015: ('https://iclr.cc/archive/www/doku.php%3Fid=iclr2015:accepted-main.html', {'main': 31, 'workshop': 74}),
+    2016: ('https://iclr.cc/archive/www/doku.php%3Fid=iclr2016:accepted-main.html', {'main': 80}),
+}
+SECTIONS = {
+    2015: {'Main Conference - Oral Presentations': ('main', 'oral'),
+           'Main Conference - Poster Presentations': ('main', 'poster'),
+           'Workshop Papers': ('workshop', 'workshop')},
+    2016: {'Oral Presentations': ('main', 'oral'), 'Poster Presentations': ('main', 'poster')},
+}
+
+
+def arxiv_link(url):
+    parsed = urlsplit(url)
+    if parsed.hostname != 'arxiv.org':
+        return None
+    match = re.fullmatch(r'/(?:abs|pdf)/(\d{4}\.\d{4,5})(v[1-9]\d*)?(?:\.pdf)?', parsed.path)
+    if (parsed.scheme not in ('http', 'https') or parsed.netloc != 'arxiv.org'
+            or parsed.query or parsed.fragment or not match):
+        raise ValueError('Unexpected official arXiv link')
+    return match[1], match[2] or None
+
+
+def without_links(node):
+    if node.tag in ('a', 'script', 'style'):
+        return ''
+    value = ''.join(without_links(n) if isinstance(n, Node) else n for n in node.children)
+    return ' '+value+' ' if node.tag in ('div', 'li', 'p', 'br') else value
+
+
+def authors(display, year):
+    parts = display.rstrip(';').split(';') if year == 2014 else re.split(r',\s*(?:and\s+)?|\s+and\s+', display)
+    names = [clean(p) for p in parts]
+    if not names or any(not name for name in names):
+        raise ValueError('Missing author or unsupported author delimiter')
+    return names
+
+
+def parse_page(html, year, evidence):
+    if year not in PAGES:
+        raise ValueError('Unreviewed ICLR archive year')
+    document = Document(html)
+    nodes = list(document.root.walk())
+    headings = [clean(n.text()) for n in nodes if n.tag in ('h1', 'h2', 'h3')]
+    if year == 2014:
+        if 'Conference Proceedings' not in headings or 'conference papers accepted' not in clean(document.root.text()):
+            raise ValueError('Unexpected ICLR 2014 accepted list')
+    elif (set(SECTIONS[year]) - set(headings)
+          or (year == 2016 and 'Accepted Papers (Conference Track)' not in headings)):
+        raise ValueError('Unexpected ICLR accepted sections')
+    entries = []
+    section = None
+    for index, node in enumerate(nodes):
+        if node.tag in ('h1', 'h2', 'h3'):
+            section = clean(node.text())
+        if year == 2014:
+            if node.tag != 'a' or not arxiv_link(node.attrs.get('href', '')):
+                continue
+            link = node
+            # This archived Google Sites page has an entry outside a paragraph.
+            # Authors can span several differently formatted italic spans.
+            # Read their whole paragraph, never only the first styled fragment.
+            display = None
+            for following in nodes[index+sum(1 for _ in link.walk()):]:
+                if following.tag == 'a' and arxiv_link(following.attrs.get('href', '')):
+                    break
+                if following.tag in ('i', 'em') or (following.tag == 'p' and any(
+                        n.tag in ('i', 'em') or 'font-style:italic' in n.attrs.get('style', '').replace(' ', '')
+                        for n in following.walk())):
+                    text = clean(following.text())
+                    if text:
+                        display = text
+                        break
+            if not display:
+                raise ValueError('Missing explicit ICLR 2014 author span')
+            track, presentation = 'main', 'conference'
+        else:
+            if node.tag != 'li':
+                continue
+            links = [n for n in node.walk() if n.tag == 'a' and arxiv_link(n.attrs.get('href', ''))]
+            if not links:
+                continue
+            if len(links) != 1 or section not in SECTIONS[year]:
+                raise ValueError('Ambiguous paper link or unknown accepted section')
+            link, = links
+            display = clean(without_links(node)).lstrip(',').strip()
+            track, presentation = SECTIONS[year][section]
+        arxiv, version = arxiv_link(link.attrs['href'])
+        title = clean(link.text())
+        if not title:
+            raise ValueError('Empty official title')
+        entries.append({'arxiv': arxiv, 'version': version, 'title': title,
+                        'authors': authors(display, year), 'authors_display': display,
+                        'paper_url': link.attrs['href'], 'track': track,
+                        'section': section, 'presentation': presentation})
+    # Check every arXiv occurrence, including links outside the expected layout.
+    occurrences = sum(n.tag == 'a' and bool(arxiv_link(n.attrs.get('href', ''))) for n in nodes)
+    if len(entries) != occurrences or not entries:
+        raise ValueError('Some official paper links were not parsed')
+    grouped = defaultdict(list)
+    for entry in entries:
+        grouped[(entry['track'], entry['arxiv'])].append(entry)
+    result = []
+    for (track, arxiv), variants in grouped.items():
+        first = variants[0]
+        if any((v['title'], v['authors']) != (first['title'], first['authors']) for v in variants):
+            raise ValueError('Repeated presentation has conflicting title or authors; review required')
+        presentations = sorted({v['presentation'] for v in variants})
+        result.append({'source': SOURCE, 'external_id': f'{year}/{track}/{arxiv}',
+                       'url': PAGES[year][0], 'title': first['title'], 'abstract': None,
+                       'authors': first['authors'], 'identifiers': {'arxiv': arxiv},
+                       'venue': 'ICLR', 'venue_aliases': [], 'year': year, 'track': track,
+                       'status': 'accepted', 'observed_at': evidence['observed_at'],
+                       'raw_decision': 'listed in official ICLR accepted '+track+' list',
+                       'metadata': {'source_evidence': evidence, 'source_variants': variants,
+                                    'presentations': presentations, 'decision_date_precision': 'not_supplied',
+                                    'identity_note': 'Official arXiv link, not title matching; validate canonical identity before import.',
+                                    'decision_evidence': 'Archived accepted list, not an original decision note.'},
+                       'tags': [{'namespace': SOURCE+':presentation', 'value': value} for value in presentations]})
+    return result
+
+
+def read_page(year, *, cache=None, snapshots=None):
+    if bool(cache) == bool(snapshots):
+        raise ValueError('Choose exactly one cache or frozen snapshot directory')
+    url = PAGES[year][0]
+    if snapshots:
+        root = Path(snapshots).resolve()
+        receipts = json.loads((root/'receipts.json').read_bytes())['receipts']
+        matches = [r for r in receipts if r['url'] == url]
+        if len(matches) != 1:
+            raise ValueError('Expected one exact official response receipt')
+        receipt, = matches
+        filename = Path(receipt['file'])
+        path = root/filename
+        if (filename.is_absolute() or '..' in filename.parts or not path.resolve().is_relative_to(root)
+                or receipt['status'] != 200):
+            raise ValueError('Unsafe or unsuccessful archive snapshot')
+        data = path.read_bytes()
+        if (len(data) > 8*1024**2 or len(data) != receipt['bytes']
+                or hashlib.sha256(data).hexdigest() != receipt['sha256']):
+            raise ValueError('Archive snapshot checksum or size differs')
+        observed = timestamp(receipt['finished_at'])
+    else:
+        data = fetch(url, cache, 8*1024**2, delay=1)
+        receipt = json.loads((Path(cache)/hashlib.sha256(url.encode()).hexdigest()).with_suffix('.json').read_bytes())
+        observed = timestamp(receipt['retrieved_at'])
+    evidence = {'url': url, 'sha256': hashlib.sha256(data).hexdigest(), 'bytes': len(data),
+                'file': 'evidence/'+hashlib.sha256(data).hexdigest()+'.html',
+                'observed_at': observed, 'http_status': 200, 'response_receipt': receipt}
+    return data, evidence
+
+
+def collect(year, out, *, cache=None, snapshots=None):
+    if year not in PAGES:
+        raise ValueError('Only independently reviewed ICLR archive years are supported')
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    with (out/'iclr-archive.collect.lock').open('a') as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        report = out/f'iclr-archive-{year}.json'
+        if report.exists():
+            raise FileExistsError('Existing completed archive output must be inspected, not overwritten')
+        data, evidence = read_page(year, cache=cache, snapshots=snapshots)
+        records = parse_page(data.decode('utf-8'), year, evidence)
+        counts = Counter(r['track'] for r in records)
+        if dict(counts) != PAGES[year][1]:
+            raise ValueError('Distinct archive entries differ from reviewed inventory')
+        files = []
+        with tempfile.TemporaryDirectory(prefix='.iclr-archive-', dir=out) as temporary:
+            stage = Path(temporary)
+            (stage/'evidence').mkdir()
+            (stage/evidence['file']).write_bytes(data)
+            for track in sorted(counts):
+                group = [r for r in records if r['track'] == track]
+                path = stage/f'iclr-archive-{year}-{track}.jsonl'
+                path.write_text(''.join(json.dumps(r, ensure_ascii=False)+'\n' for r in group))
+                manifest = {'source': SOURCE, 'parser_version': 1, 'venue': 'ICLR', 'year': year,
+                            'track': track, 'count': len(group), 'file': str(out/path.name),
+                            'file_sha256': hashlib.sha256(path.read_bytes()).hexdigest(),
+                            'list_url': PAGES[year][0], 'status': 'partial', 'missing_abstract_count': len(group)}
+                path.with_suffix('.manifest.json').write_text(json.dumps(manifest, ensure_ascii=False, indent=2)+'\n')
+                files.append(manifest)
+            result = {'source': SOURCE, 'year': year, 'records': len(records), 'files': files,
+                      'source_evidence': evidence, 'database_written': False, 'pdfs_downloaded': False,
+                      'status': 'collected_pending_identity_review',
+                      'note': 'Accepted list only. Oral/poster are presentation evidence; absent papers are not rejected. '
+                              'ICLR2014 workshop and other unlisted tracks remain outside these reviewed pages.'}
+            (stage/report.name).write_text(json.dumps(result, ensure_ascii=False, indent=2)+'\n')
+            (out/'evidence').mkdir(exist_ok=True)
+            for path in (stage/'evidence').iterdir():
+                path.replace(out/'evidence'/path.name)
+            for path in stage.iterdir():
+                if path.is_file() and path.name != report.name:
+                    path.replace(out/path.name)
+            (stage/report.name).replace(report)
+        return result
+
+
+def main(argv=None, *, prog=None):
+    parser = argparse.ArgumentParser(prog=prog)
+    parser.add_argument('--year', type=int, choices=sorted(PAGES), required=True)
+    parser.add_argument('--out', required=True)
+    source = parser.add_mutually_exclusive_group(required=True)
+    source.add_argument('--cache')
+    source.add_argument('--snapshots')
+    args = parser.parse_args(argv)
+    print(json.dumps(collect(args.year, args.out, cache=args.cache, snapshots=args.snapshots), ensure_ascii=False))
@@ -0,0 +1,218 @@
+"""Official NeurIPS program metadata, with presentations separate from submissions."""
+import argparse
+from collections import Counter, defaultdict
+import fcntl
+import hashlib
+import json
+from pathlib import Path
+import re
+import tempfile
+from urllib.parse import parse_qs, urlsplit
+
+from paper_atlas.db.submissions import timestamp
+from paper_atlas.io.http import fetch
+
+URL = 'https://neurips.cc/static/virtual/data/neurips-2026-orals-posters.json'
+GROUPS = {
+    'https://openreview.net/group?id=NeurIPS.cc/2026/Conference': 'main',
+    'https://openreview.net/group?id=NeurIPS.cc/2026/Evaluations_and_Datasets_Track': 'evaluations_datasets',
+    'https://openreview.net/group?id=NeurIPS.cc/2026/Position_Paper_Track': 'position',
+}
+ACCEPTED = {'Accept', 'Accept (poster)', 'Accept (spotlight)', 'Accept (oral)',
+            'Accept (Spotlight)', 'Accept (Oral)'}
+LIMIT = 64*1024**2
+
+
+def forum_id(url):
+    if not isinstance(url, str):
+        return None
+    try:
+        parsed = urlsplit(url)
+    except ValueError:
+        return None
+    query = parse_qs(parsed.query, keep_blank_values=True)
+    if (parsed.scheme != 'https' or parsed.netloc != 'openreview.net' or
+            parsed.path != '/forum' or parsed.fragment or set(query) != {'id'} or
+            len(query['id']) != 1 or not re.fullmatch(r'[A-Za-z0-9_-]{8,32}', query['id'][0])):
+        return None
+    return query['id'][0]
+
+
+def parse_program(data, evidence):
+    root = json.loads(data)
+    if (not isinstance(root, dict) or not {'count', 'next', 'previous', 'results'} <= set(root) or
+            not isinstance(root.get('results'), list) or
+            type(root.get('count')) is not int or root['count'] != len(root['results']) or
+            root.get('next') is not None or root.get('previous') is not None):
+        raise ValueError('Expected one complete, nonpaginated public program snapshot')
+    if not root['results']:
+        raise ValueError('Empty program snapshot')
+    events, grouped, held, duplicates = {}, defaultdict(list), [], []
+    for index, event in enumerate(root['results']):
+        if not isinstance(event, dict) or type(event.get('id')) is not int or event['id'] <= 0:
+            raise ValueError('Missing stable event ID')
+        eid = event['id']
+        if eid in events:
+            first_index, first = events[eid]
+            if first != event:
+                raise ValueError('Conflicting payloads share one publisher event ID')
+            duplicates.append({'event_id': eid, 'first_row': first_index, 'duplicate_row': index})
+            continue
+        events[eid] = index, event
+        origin = event.get('sourceurl')
+        reason = None
+        if not isinstance(origin, str) or origin not in GROUPS:
+            reason = ('journal_presentation_requires_original_publication_relation'
+                      if isinstance(origin, str) and origin.startswith('journal-track/') else
+                      'bridging_future_scope_requires_review' if origin == 'neurips2026-bridging-the-future' else
+                      'unreviewed_or_missing_submission_origin')
+        elif event.get('visible') is not True:
+            reason = 'program_visibility_requires_review'
+        elif not isinstance(event.get('decision'), str) or event['decision'] not in ACCEPTED:
+            reason = 'unreviewed_decision_label'
+        elif event.get('event_type') not in ('Poster', 'Oral'):
+            reason = 'unreviewed_presentation_type'
+        forum = forum_id(event.get('paper_url'))
+        if reason is None and forum is None:
+            reason = 'missing_or_invalid_original_submission_link'
+        if reason:
+            held.append({'row': index, 'event_id': eid, 'reason': reason, 'raw_event': event})
+            continue
+        if (not isinstance(event.get('name'), str) or not event['name'].strip() or
+                not isinstance(event.get('authors'), list) or not event['authors'] or
+                any(not isinstance(a, dict) or not isinstance(a.get('fullname'), str) or
+                    not a['fullname'].strip() for a in event['authors'])):
+            raise ValueError('Empty title or incomplete ordered author list')
+        if not isinstance(event.get('virtualsite_url'), str) or not re.fullmatch(
+                r'/virtual/2026/(?:poster|oral)/'+str(eid), event['virtualsite_url']):
+            raise ValueError('Publisher event URL differs from year/type/ID')
+        grouped[forum].append((index, event))
+    records = []
+    folded = 0
+    for forum, observations in sorted(grouped.items()):
+        # Signed sourceid values are preserved verbatim in the presentation
+        # evidence; they are not independent submissions or scientific works.
+        signatures = {json.dumps([e['name'], e['authors'], e['sourceurl'], e['decision']],
+                                 ensure_ascii=False, sort_keys=True) for _, e in observations}
+        if len(signatures) != 1:
+            raise ValueError('Title, authors, origin or decision disagree for one forum')
+        posters = [e for _, e in observations if e['event_type'] == 'Poster']
+        event = posters[0] if posters else observations[0][1]
+        track = GROUPS[event['sourceurl']]
+        presentations = []
+        for index, e in observations:
+            presentations.append({'row': index, 'event_id': e['id'], 'uid': e.get('uid'),
+                                  'sourceid': e.get('sourceid'), 'event_type': e['event_type'],
+                                  'eventtype': e.get('eventtype'), 'program_url': e['virtualsite_url'],
+                                  'session': e.get('session'), 'starttime': e.get('starttime'),
+                                  'endtime': e.get('endtime'), 'parent_id': e.get('parent_id'),
+                                  'raw_decision': e['decision']})
+        formats = sorted({e['event_type'] for _, e in observations})
+        records.append({
+            'source': 'neurips_program', 'external_id': '2026/'+forum,
+            'url': event['paper_url'], 'title': event['name'], 'abstract': None,
+            'authors': [a['fullname'] for a in event['authors']],
+            'identifiers': {'openreview': forum}, 'venue': 'NeurIPS', 'venue_aliases': [],
+            'year': 2026, 'track': track, 'status': 'accepted',
+            'observed_at': evidence['observed_at'], 'raw_decision': event['decision'],
+            'metadata': {'source_group_url': event['sourceurl'], 'forum_id': forum,
+                         'author_affiliations': [a.get('institution') for a in event['authors']],
+                         'presentations': presentations, 'source_evidence': evidence,
+                         'publication_evidence': 'Explicit accepted label in official conference program; not an original decision note or proof of proceedings publication.',
+                         'decision_date_precision': 'not_supplied',
+                         'missing_abstract_reason': 'Program JSON does not contain abstracts; paper HTML/PDF not fetched by this command.',
+                         'identity_scope_note': 'One record per original forum, not one scientific work per event. Other venues/versions require independent identity review.'},
+            'tags': [{'namespace': 'neurips_program:presentation_format', 'value': value}
+                     for value in formats]})
+        folded += len(observations)-1
+    if not records:
+        raise ValueError('No reviewed submission origins found')
+    if root['count'] != len(records)+len(held)+len(duplicates)+folded:
+        raise ValueError('Program partition failed')
+    return records, held, duplicates, folded
+
+
+def read_program(cache, snapshots):
+    if bool(cache) == bool(snapshots):
+        raise ValueError('Choose exactly one cache or frozen snapshot directory')
+    if snapshots:
+        base = Path(snapshots).resolve()
+        matches = [r for r in json.loads((base/'receipts.json').read_text())['receipts'] if r['url'] == URL]
+        if len(matches) != 1:
+            raise ValueError('Expected one official program receipt')
+        r = matches[0]; filename = Path(r['file'])
+        if (filename.is_absolute() or '..' in filename.parts or
+                not (base/filename).resolve().is_relative_to(base) or r.get('status') != 200):
+            raise ValueError('Unsafe or unsuccessful frozen program response')
+        data = (base/filename).read_bytes()
+        if len(data) > LIMIT or len(data) != r['bytes'] or hashlib.sha256(data).hexdigest() != r['sha256']:
+            raise ValueError('Frozen program checksum/size mismatch')
+        observed = r['finished_at']
+    else:
+        data = fetch(URL, cache, LIMIT, delay=1)
+        r = json.loads((Path(cache)/hashlib.sha256(URL.encode()).hexdigest()).with_suffix('.json').read_text())
+        observed = r['retrieved_at']
+    timestamp(observed)
+    return data, {'url': URL, 'sha256': hashlib.sha256(data).hexdigest(), 'bytes': len(data),
+                  'file': 'evidence/'+hashlib.sha256(data).hexdigest()+'.json',
+                  'observed_at': observed, 'http_status': 200, 'response_receipt': r}
+
+
+def collect(out, *, cache=None, snapshots=None):
+    out = Path(out); out.mkdir(parents=True, exist_ok=True)
+    report_name = 'neurips-program-2026.json'
+    with (out/'neurips-program.collect.lock').open('a') as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        if (out/report_name).exists():
+            raise ValueError('Completed collection exists; use a new directory and reconcile before refresh')
+        data, evidence = read_program(cache, snapshots)
+        records, held, duplicates, folded = parse_program(data, evidence)
+        groups = defaultdict(list)
+        for r in records:
+            groups[r['track']].append(r)
+        files = []
+        with tempfile.TemporaryDirectory(prefix='.neurips-program-', dir=out) as temporary:
+            stage = Path(temporary); (stage/'evidence').mkdir()
+            (stage/evidence['file']).write_bytes(data)
+            for track, group in sorted(groups.items()):
+                p = stage/f'neurips-program-2026-{track}.jsonl'
+                p.write_text(''.join(json.dumps(r, ensure_ascii=False)+'\n' for r in group))
+                manifest = {'source': 'neurips_program', 'parser_version': 1, 'venue': 'NeurIPS',
+                            'year': 2026, 'track': track, 'count': len(group), 'file': str(out/p.name),
+                            'file_sha256': hashlib.sha256(p.read_bytes()).hexdigest(), 'list_url': URL,
+                            'status': 'partial', 'missing_abstract_count': len(group),
+                            'note': 'Reviewed forum-level program partition; not full current proceedings, abstracts, public rejection coverage or scientific-work dedup.'}
+                p.with_suffix('.manifest.json').write_text(json.dumps(manifest, ensure_ascii=False, indent=2)+'\n')
+                files.append(manifest)
+            result = {'source': 'neurips_program', 'year': 2026, 'finished_at': timestamp(),
+                      'status': 'collected_pending_identity_review', 'records': len(records), 'files': files,
+                      'held_presentations': held, 'exact_duplicate_event_rows': duplicates,
+                      'folded_extra_presentation_rows': folded, 'source_receipts': [evidence],
+                      'database_written': False, 'pdfs_downloaded': False,
+                      'note': 'Public program only; rejected opt-in availability needs a separate source. Journals, bridging and missing origins remain held; absence is not rejection.'}
+            (stage/report_name).write_text(json.dumps(result, ensure_ascii=False, indent=2)+'\n')
+            (out/'evidence').mkdir(exist_ok=True)
+            for p in (stage/'evidence').iterdir():
+                p.replace(out/'evidence'/p.name)
+            for p in stage.iterdir():
+                if p.is_file() and p.name != report_name:
+                    p.replace(out/p.name)
+            (stage/report_name).replace(out/report_name)
+        return result
+
+
+def main(argv=None, *, prog=None):
+    parser = argparse.ArgumentParser(prog=prog)
+    parser.add_argument('--out', required=True)
+    source = parser.add_mutually_exclusive_group(required=True)
+    source.add_argument('--cache')
+    source.add_argument('--snapshots')
+    args = parser.parse_args(argv)
+    result = collect(args.out, cache=args.cache, snapshots=args.snapshots)
+    print(json.dumps({'source': result['source'], 'year': 2026, 'status': result['status'],
+                      'records': result['records'], 'files': result['files'],
+                      'held_presentations': len(result['held_presentations']),
+                      'exact_duplicate_event_rows': len(result['exact_duplicate_event_rows']),
+                      'folded_extra_presentation_rows': result['folded_extra_presentation_rows'],
+                      'report_file': str(Path(args.out)/'neurips-program-2026.json'),
+                      'database_written': False, 'pdfs_downloaded': False}, ensure_ascii=False))
@@ -0,0 +1,231 @@
+"""Reviewed postconference selected volumes from frozen public HTML metadata."""
+import argparse
+from collections import defaultdict
+import fcntl
+import hashlib
+import json
+from pathlib import Path
+import re
+import tempfile
+from urllib.parse import parse_qs, urlsplit
+
+from paper_atlas.db.submissions import timestamp
+from paper_atlas.io.html import Document, clean
+
+SOURCE = 'springer_selected_volume'
+BOOK = '10.1007/978-1-4612-2660-4'
+BOOK_URL = 'https://link.springer.com/book/'+BOOK
+HISTORY_URL = 'https://www.gatsby.ucl.ac.uk/aistats/workshops.html'
+HISTORY_SHA = '6db205b9dbc82b4a096556efd2aa67e065cad8e0bd6351176b1962ffd1fca179'
+SCOPE = {
+    'venue': 'AISTATS', 'year': 1993, 'track': 'selected_volume',
+    'event_key': 'aistats-1993-selected-volume-1994',
+    'publication_year': 1994, 'book_doi': BOOK,
+    'book_title': 'Selecting Models from Data', 'expected_chapters': 49,
+    'relationship': 'Selected workshop papers were revised and rereviewed for later publication; this is not the original complete workshop decision list.',
+}
+
+
+def snapshot_index(root):
+    root = Path(root).resolve()
+    receipts = json.loads((root/'receipts.json').read_bytes())['responses']
+    index = {}
+    for receipt in receipts:
+        url = receipt['url']
+        if url in index:
+            raise ValueError('Duplicate snapshot URL')
+        index[url] = (root, receipt)
+    return index
+
+
+def read_page(index, url):
+    if url not in index:
+        raise ValueError('Missing required public HTML snapshot: '+url)
+    root, receipt = index[url]
+    filename = Path(receipt['file'])
+    path = root/filename
+    content_type = {k.lower():v for k,v in receipt.get('headers', {}).items()}.get('content-type', '')
+    requested, final = urlsplit(url), urlsplit(receipt.get('final_url', ''))
+    query = parse_qs(final.query, keep_blank_values=True)
+    original_query = parse_qs(requested.query, keep_blank_values=True)
+    # Springer returns the public metadata with an explicit cookie diagnostic.
+    # Retain that final URL verbatim; accept no other redirect or changed page.
+    if query != original_query and requested.netloc == 'link.springer.com':
+        if (query.pop('error', None) != ['cookies_not_supported']
+                or not re.fullmatch(r'[0-9a-f-]{36}', ''.join(query.pop('code', [])))):
+            raise ValueError('Unreviewed Springer redirect query')
+    if (filename.is_absolute() or '..' in filename.parts or not path.resolve().is_relative_to(root)
+            or receipt.get('http_status') != 200
+            or (final.scheme, final.netloc, final.path) != (requested.scheme, requested.netloc, requested.path)
+            or final.fragment or query != original_query
+            or 'text/html' not in content_type.lower()):
+        raise ValueError('Unsafe, redirected or unsuccessful public HTML snapshot')
+    raw = path.read_bytes()
+    digest = hashlib.sha256(raw).hexdigest()
+    if len(raw) > 2_000_000 or len(raw) != receipt['bytes'] or digest != receipt['sha256']:
+        raise ValueError('Snapshot checksum or size differs')
+    evidence = {'url':url, 'sha256':digest, 'bytes':len(raw),
+                'file':'evidence/'+digest+'.html', 'http_status':200,
+                'observed_at':timestamp(receipt['at']), 'response_receipt':receipt}
+    return raw, evidence
+
+
+def parse_toc(html, *, excluded_materials=None):
+    entries = {}
+    for node in Document(html).root.walk():
+        if node.tag != 'li' or node.attrs.get('data-test') != 'chapter':
+            continue
+        links = [n for n in node.walk() if n.tag == 'a' and re.fullmatch(
+            r'/chapter/'+re.escape(BOOK)+r'_[1-9]\d*', n.attrs.get('href', ''))]
+        if not links:
+            headings = [clean(n.text()) for n in node.walk() if n.tag in ('h3','h4')]
+            frontmatter = [n.attrs.get('href','') for n in node.walk()
+                           if n.tag == 'a' and n.attrs.get('data-test') == 'front-matter-pdf']
+            if headings == ['Front Matter'] and len(frontmatter) == 1:
+                if excluded_materials is not None:
+                    excluded_materials.append({'title':'Front Matter', 'url':frontmatter[0],
+                                               'reason':'Section front matter without a chapter DOI; not an authored chapter.'})
+                continue
+        if len(links) != 1:
+            raise ValueError('Chapter entry lacks one reviewed-book DOI')
+        link, = links
+        doi = link.attrs['href'].removeprefix('/chapter/')
+        if doi in entries or not clean(link.text()):
+            raise ValueError('Duplicate DOI or missing chapter title')
+        entries[doi] = clean(link.text())
+    return entries
+
+
+def parse_chapter(html, doi):
+    nodes = list(Document(html).root.walk())
+    meta = defaultdict(list)
+    for node in nodes:
+        if node.tag == 'meta' and node.attrs.get('name', '').startswith('citation_'):
+            meta[node.attrs['name']].append(node.attrs.get('content', ''))
+    def one(key):
+        values = meta[key]
+        if len(values) != 1 or not values[0]:
+            raise ValueError('Missing or ambiguous citation field: '+key)
+        return values[0]
+    if (one('citation_doi') != doi or one('citation_inbook_title') != SCOPE['book_title']
+            or one('citation_publication_date') != str(SCOPE['publication_year'])):
+        raise ValueError('Chapter DOI, book or publication year differs from reviewed scope')
+    raw_authors = meta['citation_author']
+    if not raw_authors:
+        raise ValueError('Missing named chapter authors')
+    authors = []
+    for raw in raw_authors:
+        if raw.count(',') != 1:
+            raise ValueError('Unreviewed citation author format')
+        family, given = [clean(s) for s in raw.split(',', 1)]
+        if not family or not given:
+            raise ValueError('Incomplete citation author')
+        authors.append({'given':given, 'family':family})
+    abstract_nodes = [n for n in nodes if n.attrs.get('id') == 'Abs1-content']
+    if len(abstract_nodes) > 1:
+        raise ValueError('Ambiguous abstract section')
+    abstract = clean(abstract_nodes[0].text()) if abstract_nodes else None
+    first, last = one('citation_firstpage'), one('citation_lastpage')
+    if not first.isdigit() or not last.isdigit() or int(first) > int(last):
+        raise ValueError('Invalid chapter pages')
+    return {'doi':doi, 'title':one('citation_title'), 'authors':authors,
+            'authors_citation_raw':list(raw_authors), 'abstract':abstract or None,
+            'first_page':first, 'last_page':last}
+
+
+def record_for(chapter, evidence, scope_evidence):
+    return {
+        'source':SOURCE, 'external_id':chapter['doi'],
+        'url':'https://link.springer.com/chapter/'+chapter['doi'],
+        'title':chapter['title'], 'abstract':chapter['abstract'], 'authors':chapter['authors'],
+        'identifiers':{'doi':chapter['doi']},
+        'submission_identifiers':[{'scheme':'publication_doi','value':chapter['doi']}],
+        **{k:SCOPE[k] for k in ('venue','year','track','event_key')},
+        'status':'accepted', 'observed_at':evidence['observed_at'],
+        'raw_decision':'listed in the 1994 selected postconference volume; original 1993 review decision not supplied',
+        'tags':[{'namespace':SOURCE+':publication_format','value':'selected_volume_chapter'}],
+        'metadata':{
+            'publication_format':'selected_volume_chapter', 'bibliographic_year':1994,
+            'related_workshop_year':1993, 'book_doi':BOOK, 'book_title':SCOPE['book_title'],
+            'year_basis':'Reviewed workshop year; bibliographic publication year is separately retained.',
+            'first_page':chapter['first_page'], 'last_page':chapter['last_page'],
+            'authors_citation_raw':chapter['authors_citation_raw'],
+            'publication_evidence':'Published selected-volume chapter, not an original workshop decision note.',
+            'scope_relationship':SCOPE['relationship'], 'decision_date_precision':'not_supplied',
+            'source_evidence':evidence, 'scope_evidence':scope_evidence,
+        },
+    }
+
+
+def collect(out, *, toc_snapshots, chapter_snapshots):
+    toc_index, chapter_index = snapshot_index(toc_snapshots), snapshot_index(chapter_snapshots)
+    frozen = {}
+    def read(index, url):
+        raw, evidence = read_page(index, url)
+        frozen[evidence['file']] = raw
+        return raw.decode('utf-8'), evidence
+    history, history_evidence = read(toc_index, HISTORY_URL)
+    if hashlib.sha256(history.encode()).hexdigest() != HISTORY_SHA:
+        raise ValueError('Reviewed selected-volume relationship evidence changed')
+    scope_evidence = [history_evidence]
+    titles, excluded = {}, []
+    for page in range(1, 4):
+        html, evidence = read(toc_index, BOOK_URL+('?page='+str(page) if page > 1 else ''))
+        scope_evidence.append(evidence)
+        entries = parse_toc(html, excluded_materials=excluded)
+        if titles.keys() & entries.keys():
+            raise ValueError('DOI repeated across TOC pages')
+        titles.update(entries)
+    expected = {BOOK+'_'+str(i) for i in range(1, 50)}
+    if titles.keys() != expected:
+        raise ValueError('Reviewed 49-chapter inventory changed')
+    chapter_urls = {'https://link.springer.com/chapter/'+doi for doi in expected}
+    if chapter_index.keys() != chapter_urls:
+        raise ValueError('Missing or extraneous chapter snapshot')
+    records = []
+    for doi in sorted(expected, key=lambda s:int(s.rsplit('_',1)[1])):
+        html, evidence = read(chapter_index, 'https://link.springer.com/chapter/'+doi)
+        chapter = parse_chapter(html, doi)
+        if chapter['title'] != titles[doi]:
+            raise ValueError('Chapter title disagrees with official TOC')
+        records.append(record_for(chapter, evidence, scope_evidence))
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    with (out/'springer-selected.collect.lock').open('a') as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        if any(p.name != 'springer-selected.collect.lock' for p in out.iterdir()):
+            raise FileExistsError('Existing output must be inspected, not overwritten')
+        with tempfile.TemporaryDirectory(prefix='.springer-selected-', dir=out) as temporary:
+            stage = Path(temporary)
+            (stage/'evidence').mkdir()
+            for filename, raw in frozen.items():
+                (stage/filename).write_bytes(raw)
+            path = stage/'springer-aistats-1993-selected-volume.jsonl'
+            path.write_text(''.join(json.dumps(r,ensure_ascii=False)+'\n' for r in records))
+            manifest = {'source':SOURCE, 'parser_version':1,
+                        **{k:SCOPE[k] for k in ('venue','year','track','event_key')},
+                        'count':len(records), 'file':str(out/path.name),
+                        'file_sha256':hashlib.sha256(path.read_bytes()).hexdigest(),
+                        'list_url':BOOK_URL, 'status':'partial',
+                        'excluded_materials':excluded,
+                        'missing_abstract_count':sum(not r['abstract'] for r in records)}
+            path.with_suffix('.manifest.json').write_text(json.dumps(manifest,indent=2)+'\n')
+            report = {'status':'collected_pending_identity_review', 'records':len(records),
+                      'files':[manifest], 'reviewed_scope':SCOPE, 'database_written':False,
+                      'pdfs_downloaded':False, 'scope_evidence':scope_evidence}
+            (stage/'collection-report.json').write_text(json.dumps(report,ensure_ascii=False,indent=2)+'\n')
+            for item in stage.iterdir():
+                if item.name != 'collection-report.json':
+                    item.replace(out/item.name)
+            (stage/'collection-report.json').replace(out/'collection-report.json')
+    return report
+
+
+def main(argv=None, *, prog=None):
+    parser = argparse.ArgumentParser(prog=prog)
+    parser.add_argument('--toc-snapshots', required=True)
+    parser.add_argument('--chapter-snapshots', required=True)
+    parser.add_argument('--out', required=True)
+    args = parser.parse_args(argv)
+    print(json.dumps(collect(args.out, toc_snapshots=args.toc_snapshots,
+                             chapter_snapshots=args.chapter_snapshots),ensure_ascii=False))
@@ -0,0 +1,340 @@
+"""Reproducible early WWW metadata; unresolved program entries stay outside imports."""
+import argparse
+from collections import defaultdict
+import hashlib
+from html.parser import HTMLParser
+import json
+from pathlib import Path
+import re
+import tempfile
+from urllib.parse import urljoin, urlsplit
+
+from paper_atlas.io.html import Document, clean
+from paper_atlas.io.http import fetch
+
+ROOT = 'https://archives.iw3c2.org/'
+SPRING = ROOT+'www3/proceedings/'
+FALL = ROOT+'www2/Proceedings/WWW2_Proceedings.html'
+SEEDS = [ROOT+'www1/PrelimProcs.html', ROOT+'www1/Proceedings.html', FALL,
+         SPRING+'proceedings.html', *[SPRING+'papers/'+x+'.html' for x in ('author','session','abstract')],
+         *[SPRING+'posters/'+x+'.html' for x in ('author','abstract')]]
+
+
+def decode(raw):
+    try:
+        return raw.decode('utf-8-sig'), 'utf-8'
+    except UnicodeDecodeError:
+        return raw.decode('iso-8859-1'), 'iso-8859-1 fallback; original bytes retained'
+
+
+def text(html):
+    return re.sub(r'[ \t\r\n\f\v]+',' ',Document(html).root.text()).strip(' \t\r\n\f\v')
+
+
+def anchors(html):
+    return [(n.attrs.get('href',''),clean(n.text())) for n in Document(html).root.walk() if n.tag=='a']
+
+
+def source_url(url):
+    p=urlsplit(url)
+    if p.scheme!='https' or p.netloc!='archives.iw3c2.org' or p.query or p.fragment or not p.path.endswith('.html'):
+        raise ValueError('Only exact official archive HTML source URLs are allowed')
+    return url
+
+
+class Sources:
+    def __init__(self, directory, expected_sha256):
+        self.root=Path(directory).resolve();manifest=self.root/'manifest.json';raw=manifest.read_bytes()
+        if hashlib.sha256(raw).hexdigest()!=expected_sha256:
+            raise ValueError('Source cache manifest checksum mismatch')
+        self.rows={};self.used=set()
+        for row in json.loads(raw)['sources']:
+            url=source_url(row['url'])
+            if url in self.rows or row.get('status')!=200:
+                raise ValueError('Duplicate or incomplete source response')
+            p=self.root/row['file']
+            if p.is_symlink() or p.parent!=self.root or not p.is_file():
+                raise ValueError('Source cache paths must be plain files directly within the cache')
+            data=p.read_bytes()
+            if len(data)>2*1024**2 or len(data)!=row['bytes'] or hashlib.sha256(data).hexdigest()!=row['sha256']:
+                raise ValueError('Source response checksum or size mismatch')
+            self.rows[url]={'raw':data,'receipt':row}
+
+    def read(self,url):
+        source_url(url)
+        if url not in self.rows:
+            raise ValueError('Required source missing from cache: '+url)
+        self.used.add(url)
+        return decode(self.rows[url]['raw'])[0]
+
+    def proof(self,urls):
+        return [{'url':url,'sha256':self.rows[url]['receipt']['sha256'],
+                 'encoding':decode(self.rows[url]['raw'])[1]} for url in sorted(set(urls))]
+
+
+def download_sources(http_cache, directory):
+    directory=Path(directory)
+    if directory.exists():
+        raise ValueError('Refusing to overwrite a source snapshot')
+    directory.mkdir(parents=True)
+    responses={url:fetch(url,http_cache,2*1024**2) for url in SEEDS}
+    html=decode(responses[FALL])[0]
+    for href,label in anchors(html):
+        if href!='Author_Inst.html' and href.endswith('.html'):
+            url=source_url(urljoin(FALL,href))
+            if not url.startswith(ROOT+'www2/Proceedings/'):
+                raise ValueError('Unexpected fall category source')
+            responses[url]=fetch(url,http_cache,2*1024**2)
+    receipts=[]
+    for i,(url,raw) in enumerate(sorted(responses.items())):
+        name='source-'+str(i).zfill(2)+'.html';(directory/name).write_bytes(raw)
+        receipts.append({'url':url,'status':200,'file':name,'bytes':len(raw),'sha256':hashlib.sha256(raw).hexdigest()})
+    manifest=directory/'manifest.json';manifest.write_text(json.dumps({'sources':receipts},indent=2)+'\n')
+    return hashlib.sha256(manifest.read_bytes()).hexdigest()
+
+
+def identity(href,track):
+    url=urljoin(SPRING+track+'/',href);p=urlsplit(url)
+    match=re.fullmatch(r'/www3/proceedings/'+track+r'/(\d+)/[^?#]+',p.path)
+    if p.scheme=='https' and p.netloc=='archives.iw3c2.org' and not p.query and not p.fragment and match:
+        return match[1],url
+    return None
+
+
+class AuthorIndex(HTMLParser):
+    def __init__(self,html,track):
+        super().__init__(convert_charrefs=True);self.track=track;self.name='';self.bold=None;self.link=None;self.link_text=[]
+        self.entries=defaultdict(lambda:{'authors':[],'urls':set(),'titles':set()});self.feed(html)
+
+    def handle_starttag(self,tag,attrs):
+        if tag=='b':self.bold=[]
+        if tag=='a':self.link=dict(attrs).get('href');self.link_text=[]
+
+    def handle_data(self,data):
+        if self.bold is not None:self.bold.append(data)
+        if self.link is not None:self.link_text.append(data)
+
+    def handle_endtag(self,tag):
+        if tag=='b' and self.bold is not None:
+            self.name=clean(''.join(self.bold));self.bold=None
+        if tag=='a' and self.link is not None:
+            own=identity(self.link,self.track)
+            if own:
+                key,url=own;entry=self.entries[key];entry['urls'].add(url);entry['titles'].add(clean(''.join(self.link_text)))
+                if not self.name:raise ValueError('Paper link has no archive author context')
+                if self.name not in entry['authors']:entry['authors'].append(self.name)
+            self.link=None
+
+
+def sections(html):
+    """Use explicit h3 boundaries; old HTML omits many p/li closing tags."""
+    result=[]
+    for chunk in re.split(r'<h3\b[^>]*>',html,flags=re.I)[1:]:
+        parts=re.split(r'</h3\s*>',chunk,maxsplit=1,flags=re.I)
+        if len(parts)!=2:raise ValueError('Unclosed archive entry heading')
+        heading,body=parts
+        body=re.split(r'<(?:hr|h2|address)\b',body,maxsplit=1,flags=re.I)[0]
+        author=re.search(r'<i\b[^>]*>(.*?)</i\s*>',body,re.I|re.S)
+        paragraphs=[]
+        for paragraph in re.findall(r'<p\b[^>]*>(.*?)(?=</p\s*>|<p\b|$)',body,re.I|re.S):
+            value=text(paragraph)
+            if value and not value.casefold().startswith('keywords:'):paragraphs.append(value)
+        result.append({'heading':heading,'title':text(heading),'abstract':'\n\n'.join(paragraphs)or None,
+                       'author_byline_raw':text(author[1])if author else None})
+    if not result:raise ValueError('No explicit archive entry headings')
+    return result
+
+
+def reviewed_posters(sources, path, expected_sha256, cache_sha256):
+    if path is None:
+        if expected_sha256:raise ValueError('Reviewed poster path required')
+        return {},None
+    raw=Path(path).read_bytes()
+    if hashlib.sha256(raw).hexdigest()!=expected_sha256:raise ValueError('Reviewed poster checksum mismatch')
+    review=json.loads(raw)
+    if set(review)!={'format','source_cache_sha256','records'} or review['format']!=1 or review['source_cache_sha256']!=cache_sha256:
+        raise ValueError('Reviewed poster snapshot binding differs')
+    if not isinstance(review['records'],list) or not 0<len(review['records'])<=100:
+        raise ValueError('Bounded nonempty poster review required')
+    result={}
+    for row in review['records']:
+        if set(row)!={'entry_id','individual_url','individual_sha256','title','authors','author_source','reason','missing_abstract_reason'}:
+            raise ValueError('Unexpected reviewed poster fields')
+        key=row['entry_id'];own=identity(row['individual_url'],'posters')
+        if not isinstance(key,str) or not own or own[0]!=key or key in result:
+            raise ValueError('Reviewed poster identity duplicated or outside canonical entry')
+        if row['author_source'] not in ('canonical_byline','author_index') or not isinstance(row['authors'],list) or not row['authors'] or any(not isinstance(a,str) or not a.strip()for a in row['authors']):
+            raise ValueError('Explicit author evidence required')
+        if len(set(row['authors']))!=len(row['authors']) or not isinstance(row['reason'],str) or not row['reason'].strip():
+            raise ValueError('Reviewed author order/reason invalid')
+        if sources.rows.get(own[1],{}).get('receipt',{}).get('sha256')!=row['individual_sha256']:
+            raise ValueError('Individual poster page checksum differs')
+        page=sources.read(own[1]);headings=re.findall(r'<h1\b[^>]*>(.*?)</h1\s*>',page,re.I|re.S)
+        if len(headings)!=1 or text(headings[0])!=row['title']:
+            raise ValueError('Reviewed title differs from exact canonical H1')
+        header=re.split(r'</h1\s*>',page,maxsplit=1,flags=re.I)[1]
+        header=re.split(r'<h[23]\b',header,maxsplit=1,flags=re.I)[0]
+        header=re.split(r'\b(?:keywords|abstract)\s*:',text(header),maxsplit=1,flags=re.I)[0]
+        if row['author_source']=='canonical_byline' and any(a.casefold() not in header.casefold()for a in row['authors']):
+            raise ValueError('Reviewed author absent from canonical byline region')
+        result[key]={**row,'canonical_byline_region_raw':header}
+    return result,hashlib.sha256(raw).hexdigest()
+
+
+def reviewed_row(sources,key,url,item,authors,review):
+    if url!=review['individual_url']:
+        raise ValueError('Reviewed canonical page differs from abstract-entry URL')
+    if authors and authors['urls']!={url}:
+        raise ValueError('Reviewed poster author-index URL disagrees')
+    if review['author_source']=='author_index':
+        names=[]
+        for name in authors['authors']if authors else []:
+            parts=name.split(',');names.append(clean(parts[1]+' '+parts[0])if len(parts)==2 else name)
+        if names!=review['authors']:raise ValueError('Reviewed author-index evidence differs')
+    missing=review['missing_abstract_reason']
+    if not isinstance(missing,str) or bool(missing.strip())==bool(item['abstract']):
+        raise ValueError('Missing abstract requires explicit reason; never invent a summary')
+    urls=[SPRING+'posters/author.html',SPRING+'posters/abstract.html',url]
+    return {'source':'www_archive','external_id':'www3:posters:'+key,'url':url,'title':review['title'],
+            'abstract':item['abstract'],'authors':review['authors'],'identifiers':{},'venue':'WWW','year':1995,
+            'track':'poster','event_key':'www-1995-spring','status':'accepted','raw_decision':'listed in official posters proceedings',
+            'metadata':{'entry_id':key,'source_evidence':sources.proof(urls),'abstract_heading_title_raw':item['title'],
+                        'author_byline_raw':item['author_byline_raw'],'author_index_raw':authors['authors']if authors else [],
+                        'author_index_titles_raw':sorted(authors['titles'])if authors else [],'abstract_href_raw':url,
+                        'author_order':review['author_source'],'reviewed_poster_identity':review,
+                        'missing_abstract_reason':missing or None},
+            'tags':[{'namespace':'www_archive:proceedings_section','value':'posters'}]}
+
+
+def spring_rows(sources,track,reviews=None):
+    base=SPRING+track+'/';author_url=base+'author.html';abstract_url=base+'abstract.html'
+    authors=AuthorIndex(sources.read(author_url),track).entries
+    listing=sections(sources.read(abstract_url));by_id={};held=[];session={}
+    if track=='papers':
+        session_url=base+'session.html'
+        for href,title in anchors(sources.read(session_url)):
+            own=identity(href,track)
+            if own:
+                key,url=own
+                if key in session:raise ValueError('Duplicate main session entry ID')
+                session[key]=url
+    for item in listing:
+        links=[identity(h,track)for h,t in anchors(item['heading'])if identity(h,track)]
+        if len(links)!=1:
+            held.append({'reason':'unverified_heading_identity','evidence':abstract_url,'candidate':item});continue
+        key,url=links[0]
+        if key in by_id:raise ValueError('Duplicate abstract entry ID')
+        by_id[key]=(url,item)
+    if not by_id:raise ValueError('No stable abstract entry IDs')
+    if track=='papers' and (set(authors)!=set(by_id) or set(session)!=set(by_id)):
+        raise ValueError('Main author/session/abstract entry ID sets disagree')
+    if set(authors)-set(by_id):raise ValueError('Author index has entries outside the abstract listing')
+    reviews=reviews or {}
+    if set(reviews)-set(by_id):raise ValueError('Reviewed poster outside abstract listing')
+    rows=[]
+    for key,(url,item) in by_id.items():
+        if key in reviews:
+            if track!='posters':raise ValueError('Reviews only apply to poster entries')
+            rows.append(reviewed_row(sources,key,url,item,authors.get(key),reviews[key]));continue
+        if key not in authors:
+            held.append({'reason':'abstract_entry_missing_linked_author_index','entry_id':key,'evidence':abstract_url,'candidate':item});continue
+        alternatives=authors[key]['urls']
+        if len(alternatives)!=1:raise ValueError('Ambiguous author-index paper URL')
+        canonical=next(iter(alternatives))
+        if track=='papers' and session[key]!=canonical:raise ValueError('Main author/session paper URLs disagree')
+        if url!=canonical and (track!='papers' or not re.search(r'\s',url)):
+            raise ValueError('Uncorroborated archive URL discrepancy')
+        if not item['abstract']:
+            held.append({'reason':'missing_abstract','entry_id':key,'evidence':abstract_url,'candidate':item});continue
+        if item['title'].casefold() not in {t.casefold() for t in authors[key]['titles']}:
+            held.append({'reason':'abstract_and_author_index_titles_disagree','entry_id':key,'evidence':abstract_url,'candidate':item,'author_index_titles':sorted(authors[key]['titles'])});continue
+        names=[]
+        for name in authors[key]['authors']:
+            parts=name.split(',')
+            names.append(clean(parts[1]+' '+parts[0])if len(parts)==2 else name)
+        proof_urls=[author_url,abstract_url]+([session_url]if track=='papers'else[])
+        rows.append({'source':'www_archive','external_id':'www3:'+track+':'+key,'url':canonical,
+                     'title':item['title'],'abstract':item['abstract'],'authors':names,'identifiers':{},
+                     'venue':'WWW','year':1995,'track':'main'if track=='papers'else'poster','event_key':'www-1995-spring',
+                     'status':'accepted','raw_decision':'listed in official '+track+' proceedings',
+                     'metadata':{'entry_id':key,'source_evidence':sources.proof(proof_urls),
+                                 'author_index_raw':authors[key]['authors'],'author_index_titles_raw':sorted(authors[key]['titles']),'author_order':'archive author-index order, not original byline rank',
+                                 'author_byline_raw':item['author_byline_raw'],'abstract_href_raw':url,
+                                 'url_corroborated_by_author_and_session':url!=canonical},
+                     'tags':[{'namespace':'www_archive:proceedings_section','value':track}]})
+    return rows,held,{'abstract_entries':len(by_id),'linked_author_entries':len(authors),'ready':len(rows),'held':len(held)}
+
+
+def early_review(sources):
+    held=[];url=ROOT+'www1/PrelimProcs.html';html=sources.read(url)
+    for ordinal,chunk in enumerate(re.split(r'<li\b[^>]*>',html,flags=re.I)[1:],1):
+        title=re.search(r'<em>Title:</em>\s*<b>(.*?)</b>',chunk,re.I|re.S)
+        if not title:raise ValueError('Unclassified first-conference entry')
+        names=re.findall(r'<em>Author:</em>(.*?)(?=<br\b)',chunk,re.I|re.S)
+        held.append({'reason':'formal_presentation_scope_and_count_need_review','event_key':'www-1994-spring',
+                     'ordinal':ordinal,'evidence':url,'candidate':{'title':text(title[1]),
+                     'authors_raw':[re.sub(r'\s*<[^>]+>','',text(n)).strip()for n in names],
+                     'keywords_raw':text(re.search(r'<em>Keywords:</em>(.*?)(?=<br\b)',chunk,re.I|re.S)[1]) if re.search(r'<em>Keywords:</em>(.*?)(?=<br\b)',chunk,re.I|re.S)else None},
+                     'source_evidence':sources.proof([url])})
+    if not held:raise ValueError('First-conference presentation listing empty')
+    category_urls={}
+    for href,label in anchors(sources.read(FALL)):
+        if href!='Author_Inst.html' and href.endswith('.html'):
+            category_url=source_url(urljoin(FALL,href))
+            if not category_url.startswith(ROOT+'www2/Proceedings/'):raise ValueError('Unexpected fall category')
+            category_urls[category_url]=label
+    if not category_urls:raise ValueError('Fall archive category listing empty')
+    for url,label in sorted(category_urls.items()):
+        html=sources.read(url)
+        for ordinal,chunk in enumerate(re.split(r'<dt\b[^>]*>',html,flags=re.I)[1:],1):
+            fields=re.split(r'<dd\b[^>]*>',chunk,maxsplit=1,flags=re.I)
+            title=text(fields[0]);raw_byline=text(re.split(r'</dl\b',fields[1],maxsplit=1,flags=re.I)[0]) if len(fields)==2 else None
+            if title:
+                held.append({'reason':'mixed_program_category_not_verified_paper_acceptance','event_key':'www-1994-fall',
+                             'category':label,'ordinal':ordinal,'evidence':url,'candidate':{'title':title,'authors_raw':raw_byline},
+                             'source_evidence':sources.proof([FALL,url])})
+    return held,{'first_conference_fields':sum(r['event_key']=='www-1994-spring'for r in held),'fall_categories':len(category_urls),
+                 'fall_program_entries':sum(r['event_key']=='www-1994-fall'for r in held)}
+
+
+def collect(source_cache,cache_sha256,out,*,reviewed=None,reviewed_sha256=None):
+    out=Path(out)
+    if out.exists():raise ValueError('Refusing to overwrite an existing normalized batch')
+    sources=Sources(source_cache,cache_sha256);groups={};held=[];counts={}
+    reviews,review_sha=reviewed_posters(sources,reviewed,reviewed_sha256,cache_sha256)
+    for track in ('papers','posters'):
+        rows,review,counts[track]=spring_rows(sources,track,reviews if track=='posters'else None);groups[track]=rows;held.extend(review)
+    review,counts['earlier']=early_review(sources);held.extend(review)
+    for item in held:
+        if 'source_evidence' not in item:item['source_evidence']=sources.proof([item['evidence']])
+    out.parent.mkdir(parents=True,exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix='.www-archive-',dir=out.parent)as tmp:
+        stage=Path(tmp);queue=[]
+        for track,rows in groups.items():
+            if not rows:continue
+            filename='www-1995-spring-'+('main'if track=='papers'else'poster')+'.jsonl';raw=''.join(json.dumps(r,ensure_ascii=False)+'\n'for r in rows).encode();(stage/filename).write_bytes(raw)
+            manifest={'source':'www_archive','parser_version':2 if review_sha else 1,'venue':'WWW','year':1995,'track':rows[0]['track'],'event_key':'www-1995-spring',
+                      'list_url':SPRING+track+'/abstract.html','count':len(rows),'status':'partial','file_sha256':hashlib.sha256(raw).hexdigest(),
+                      'missing_abstract_count':sum(not bool((r['abstract']or '').strip())for r in rows),'source_listing_count':counts[track]['abstract_entries'],'held_entry_count':counts[track]['held'],'source_cache_sha256':cache_sha256,'scope':'Verified linked archive entries; held entries and other event tracks excluded, not complete event coverage.'}
+            (stage/filename).with_suffix('.manifest.json').write_text(json.dumps(manifest,indent=2)+'\n');queue.append(str(out/filename))
+        (stage/'review-candidates.jsonl').write_text(''.join(json.dumps(r,ensure_ascii=False)+'\n'for r in held))
+        report={'status':'normalized_not_imported','source_cache_sha256':cache_sha256,'counts':counts,'ready':sum(len(r)for r in groups.values()),'held':len(held),
+                'source_evidence':sources.proof(sources.used),'files':queue,'scope':'Early WWW archive only; no PDF fetching, no rejected/withdrawn inference, no database access. Event-aware importer required.'}
+        if review_sha:report['reviewed_posters_sha256']=review_sha
+        (stage/'report.json').write_text(json.dumps(report,ensure_ascii=False,indent=2)+'\n')
+        (stage/'import-queue.json').write_text(json.dumps({'files':queue},indent=2)+'\n')
+        stage.rename(out)
+    return report
+
+
+def main(argv=None,*,prog=None):
+    p=argparse.ArgumentParser(prog=prog);p.add_argument('--source-cache',required=True);p.add_argument('--source-cache-sha256');p.add_argument('--http-cache');p.add_argument('--out',required=True)
+    p.add_argument('--reviewed-posters');p.add_argument('--reviewed-posters-sha256')
+    args=p.parse_args(argv)
+    if bool(args.http_cache)==bool(args.source_cache_sha256):p.error('Choose a fresh --http-cache download or an existing --source-cache-sha256 snapshot')
+    sha=download_sources(args.http_cache,args.source_cache)if args.http_cache else args.source_cache_sha256
+    if bool(args.reviewed_posters)!=bool(args.reviewed_posters_sha256):p.error('Reviewed poster file and SHA256 must be supplied together')
+    print(json.dumps(collect(args.source_cache,sha,args.out,reviewed=args.reviewed_posters,reviewed_sha256=args.reviewed_posters_sha256),ensure_ascii=False),flush=True)
+
+
+if __name__=='__main__':main()
@@ -1 +1 @@
-"""Offline, evidence-bound preparation of metadata for separate ingestion."""
+"""Evidence-bound identity preparation and independent type/tag annotations."""
@@ -0,0 +1,218 @@
+"""Append-only tag/type assertions and explicit retractions; no inferred labels."""
+import argparse
+from contextlib import closing
+from importlib.resources import files
+import json
+import re
+from urllib.parse import urlparse
+
+from paper_atlas.db.backend import database_arguments, inserted_id, open_read_connection, open_store
+from paper_atlas.db.submissions import timestamp
+
+TABLE = 'annotation_events'
+MIGRATION = 'annotation_events_v1'
+COLUMNS = ('id', 'request_id', 'paper_id', 'original_paper_id', 'kind', 'namespace',
+           'value', 'source_record_id', 'evidence_key', 'evidence_url', 'reason',
+           'actor', 'observed_at', 'retracts_id')
+ACTIVE = '''a.retracts_id IS NULL AND NOT EXISTS
+    (SELECT 1 FROM annotation_events removed WHERE removed.retracts_id=a.id)'''
+
+
+def available(conn):
+    if getattr(conn, 'postgres', False):
+        if hasattr(conn, 'has_table'):
+            return conn.has_table(TABLE)
+        return bool(conn.execute("SELECT 1 FROM information_schema.tables WHERE table_schema=current_schema() AND table_name=?", (TABLE,)).fetchone())
+    return bool(conn.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (TABLE,)).fetchone())
+
+
+def _begin_write(conn):
+    if not getattr(conn, 'postgres', False) and not conn.in_transaction:
+        conn.execute('BEGIN IMMEDIATE')
+
+
+def initialize(conn):
+    """Explicit transactional schema extension; does not rescan or rewrite papers."""
+    _begin_write(conn)
+    exists = available(conn)
+    marker = conn.execute('SELECT 1 FROM schema_migrations WHERE name=?', (MIGRATION,)).fetchone()
+    if exists != bool(marker):
+        raise RuntimeError('Annotation table/upgrade marker mismatch; inspect before changing schema')
+    if exists:
+        result = conn.execute('SELECT * FROM annotation_events LIMIT 0')
+        description = result.cursor.description if getattr(conn, 'postgres', False) else result.description
+        if tuple(d[0] for d in description) != COLUMNS:
+            raise RuntimeError('Unexpected annotation schema')
+        return False
+    ddl = files('paper_atlas.db').joinpath('annotations.sql').read_text()
+    if getattr(conn, 'postgres', False):
+        ddl = re.sub(r'\bINTEGER\b', 'BIGINT', ddl)
+        ddl = re.sub(r'\bTEXT\b', 'TEXT COLLATE "C"', ddl)
+        ddl = ddl.replace('id BIGINT PRIMARY KEY', 'id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY', 1)
+    for statement in ddl.split(';'):
+        if statement.strip():
+            conn.execute(statement)
+    conn.execute('INSERT INTO schema_migrations(name) VALUES(?)', (MIGRATION,))
+    return True
+
+
+def _text(value, name, limit=512):
+    if not isinstance(value, str) or not value.strip() or len(value) > limit:
+        raise ValueError(name + ' must be nonempty text of at most ' + str(limit) + ' characters')
+    return value
+
+
+def _id(value, name):
+    if type(value) is not int or value <= 0:
+        raise ValueError(name + ' must be a positive integer')
+    return value
+
+
+def _url(value):
+    if value is not None:
+        _text(value, 'evidence_url', 4096)
+        parsed = urlparse(value)
+        if parsed.scheme not in ('https', 'http') or not parsed.hostname or parsed.username or parsed.password:
+            raise ValueError('evidence_url must be an HTTP(S) URL without credentials')
+    return value
+
+
+def _require(conn):
+    if not available(conn) or not conn.execute('SELECT 1 FROM schema_migrations WHERE name=?', (MIGRATION,)).fetchone():
+        raise RuntimeError('Run paper-atlas annotate init explicitly before adding annotations')
+
+
+def _row(row):
+    return dict(zip(COLUMNS, (row[i] for i in range(len(COLUMNS)))))
+
+
+def _replay(conn, request_id, payload):
+    old = conn.execute('SELECT * FROM annotation_events WHERE request_id=?', (request_id,)).fetchone()
+    if old is None:
+        return None
+    old = _row(old)
+    if any(old[k] != value for k, value in payload.items()):
+        raise ValueError('request_id already identifies different annotation content')
+    return old['id']
+
+
+def assert_annotation(conn, paper, kind, namespace, value, *, request_id, evidence_key,
+                      reason, actor, evidence_url=None, source_record_id=None):
+    _begin_write(conn)
+    _require(conn)
+    paper = _id(paper, 'paper')
+    if kind not in ('tag', 'research_type'):
+        raise ValueError('kind must be tag or research_type')
+    _text(namespace, 'namespace', 128)
+    if not re.fullmatch(r'[a-z][a-z0-9_]*:[a-z][a-z0-9_.-]*', namespace):
+        raise ValueError('namespace must have an explicit source:scope')
+    payload = dict(original_paper_id=paper, kind=kind, namespace=namespace,
+                   value=_text(value, 'value'), request_id=_text(request_id, 'request_id', 128),
+                   source_record_id=source_record_id, evidence_key=_text(evidence_key, 'evidence_key', 256),
+                   reason=_text(reason, 'reason', 8192), actor=_text(actor, 'actor', 256),
+                   evidence_url=_url(evidence_url), retracts_id=None)
+    if source_record_id is not None:
+        _id(source_record_id, 'source_record_id')
+    replay = _replay(conn, request_id, payload)
+    if replay is not None:
+        return replay
+    if not conn.execute('SELECT 1 FROM papers WHERE id=?', (paper,)).fetchone():
+        raise ValueError('Existing canonical paper required; no automatic identity merge')
+    prefix = namespace.split(':', 1)[0]
+    if prefix != 'custom' and source_record_id is None:
+        raise ValueError('Platform annotations require their own source record')
+    if source_record_id is not None:
+        source = conn.execute('''SELECT r.paper_id,s.name FROM source_records r
+            JOIN sources s ON s.id=r.source_id WHERE r.id=?''', (source_record_id,)).fetchone()
+        if not source or source[0] != paper or (prefix != 'custom' and prefix != source[1]):
+            raise ValueError('Annotation source record/namespace must belong to this paper and platform')
+    payload.update(paper_id=paper, observed_at=timestamp())
+    fields = tuple(payload)
+    return inserted_id(conn, 'INSERT INTO annotation_events(' + ','.join(fields) + ') VALUES(' +
+                       ','.join('?' for _ in fields) + ')', tuple(payload[k] for k in fields))
+
+
+def retract_annotation(conn, event, *, request_id, reason, actor, evidence_url=None, custom_only=False):
+    _begin_write(conn)
+    _require(conn)
+    event = _id(event, 'event')
+    payload = dict(request_id=_text(request_id, 'request_id', 128), retracts_id=event,
+                   reason=_text(reason, 'reason', 8192), actor=_text(actor, 'actor', 256), evidence_url=_url(evidence_url))
+    target = conn.execute('SELECT * FROM annotation_events WHERE id=?', (event,)).fetchone()
+    if target is None or target[-1] is not None:
+        raise ValueError('Retraction must reference an existing assertion')
+    target = _row(target)
+    if custom_only and not target['namespace'].startswith('custom:'):
+        raise ValueError('Manual CLI cannot retract platform evidence')
+    replay = _replay(conn, request_id, payload)
+    if replay is not None:
+        return replay
+    if conn.execute('SELECT 1 FROM annotation_events WHERE retracts_id=?', (event,)).fetchone():
+        raise ValueError('Assertion already retracted; its history is retained')
+    payload.update({k: target[k] for k in ('paper_id', 'original_paper_id', 'kind', 'namespace', 'value', 'source_record_id', 'evidence_key')})
+    payload['observed_at'] = timestamp()
+    fields = tuple(payload)
+    return inserted_id(conn, 'INSERT INTO annotation_events(' + ','.join(fields) + ') VALUES(' +
+                       ','.join('?' for _ in fields) + ')', tuple(payload[k] for k in fields))
+
+
+def observations(conn, paper, *, kind=None, history=False):
+    if not available(conn):
+        return []
+    where = ['a.paper_id=?']; params = [_id(paper, 'paper')]
+    if not history:
+        where.append(ACTIVE)
+    if kind is not None:
+        if kind not in ('tag', 'research_type'):
+            raise ValueError('Invalid annotation kind')
+        where.append('a.kind=?'); params.append(kind)
+    return [_row(r) for r in conn.execute('SELECT a.* FROM annotation_events a WHERE ' +
+                                         ' AND '.join(where) + ' ORDER BY a.id', params)]
+
+
+def main(argv=None, *, prog=None):
+    parser = argparse.ArgumentParser(prog=prog, description='显式初始化、追加或撤回带证据的自定义标签和研究类型')
+    actions = parser.add_subparsers(dest='action', required=True)
+    for action in ('init', 'assert', 'retract', 'list'):
+        p = actions.add_parser(action)
+        database_arguments(p)
+        if action in ('assert', 'retract'):
+            for field in ('request-id', 'reason', 'actor'):
+                p.add_argument('--' + field, required=True)
+            p.add_argument('--evidence-url')
+        if action in ('assert', 'list'):
+            p.add_argument('--paper', type=int, required=True)
+            p.add_argument('--kind', choices=('tag', 'research_type'), required=action == 'assert')
+        if action == 'assert':
+            for field in ('namespace', 'value', 'evidence-key'):
+                p.add_argument('--' + field, required=True)
+            p.add_argument('--source-record', type=int)
+        if action == 'retract':
+            p.add_argument('--event', type=int, required=True)
+        if action == 'list':
+            p.add_argument('--history', action='store_true')
+    args = parser.parse_args(argv)
+    if args.action == 'list':
+        with closing(open_read_connection(args.db, pg_service=args.pg_service, pg_schema=args.pg_schema)) as conn:
+            result = observations(conn, args.paper, kind=args.kind, history=args.history)
+    else:
+        if args.action == 'assert' and not args.namespace.startswith('custom:'):
+            parser.error('Manual CLI requires custom:* namespace; platform assertions use validated source APIs')
+        with closing(open_store(args.db, pg_service=args.pg_service, pg_schema=args.pg_schema).conn) as conn:
+            try:
+                if not getattr(conn, 'postgres', False):
+                    conn.commit()
+                    conn.execute('BEGIN IMMEDIATE')
+                if args.action == 'init':
+                    result = {'initialized': initialize(conn)}
+                else:
+                    kwargs = dict(request_id=args.request_id, reason=args.reason, actor=args.actor, evidence_url=args.evidence_url)
+                    event = (assert_annotation(conn, args.paper, args.kind, args.namespace, args.value,
+                              evidence_key=args.evidence_key, source_record_id=args.source_record, **kwargs)
+                             if args.action == 'assert' else retract_annotation(conn, args.event, custom_only=True, **kwargs))
+                    result = {'event_id': event}
+                conn.commit()
+            except BaseException:
+                conn.rollback()
+                raise
+    print(json.dumps(result, ensure_ascii=False, indent=2))
@@ -0,0 +1,15 @@
+CREATE TABLE annotation_events (
+ id INTEGER PRIMARY KEY,
+ request_id TEXT NOT NULL UNIQUE,
+ paper_id INTEGER NOT NULL REFERENCES papers(id),
+ original_paper_id INTEGER NOT NULL,
+ kind TEXT NOT NULL CHECK(kind IN ('tag','research_type')),
+ namespace TEXT NOT NULL, value TEXT NOT NULL,
+ source_record_id INTEGER REFERENCES source_records(id),
+ evidence_key TEXT NOT NULL, evidence_url TEXT,
+ reason TEXT NOT NULL, actor TEXT NOT NULL, observed_at TEXT NOT NULL,
+ retracts_id INTEGER UNIQUE REFERENCES annotation_events(id),
+ CHECK(retracts_id IS NULL OR retracts_id<>id)
+);
+CREATE INDEX annotation_events_paper ON annotation_events(paper_id,kind,id);
+CREATE INDEX annotation_events_label ON annotation_events(kind,namespace,value,paper_id);
@@ -0,0 +1,38 @@
+"""Retain reviewed event scopes when a source refresh repeats a whole-volume label."""
+import json
+
+KEY = 'edition_scope_curation_v1'
+
+
+def preserve(metadata, previous):
+    old = json.loads(previous).get(KEY) if previous else None
+    if KEY in metadata and metadata[KEY] != old:
+        raise ValueError('Source import cannot supply or replace reviewed edition scope')
+    if old is not None:
+        metadata[KEY] = old
+    return metadata
+
+
+def resolve(c, record, external, venue, year, track, event_key):
+    row = c.execute('SELECT metadata_json FROM source_records WHERE id=?', (record,)).fetchone()
+    entries = json.loads(row[0]).get(KEY, []) if row else []
+    if not isinstance(entries, list):
+        raise ValueError('Invalid reviewed edition scope')
+    applicable = []
+    for entry in entries:
+        if entry['external_id'] != external:
+            continue
+        old, target = entry['from'], entry['target']
+        if int(year) != old['year'] or venue not in entry['venue_names']:
+            continue
+        if track not in (old['track'], target['track']):
+            continue
+        if event_key is not None and event_key != old['event_key']:
+            continue
+        current = c.execute('SELECT venue_id,year,track,event_key FROM editions WHERE id=?', (target['edition_id'],)).fetchone()
+        if not current or [current[i] for i in range(4)] != [target[k] for k in ('venue_id','year','track','event_key')]:
+            raise ValueError('Reviewed target edition has changed')
+        applicable.append(target['edition_id'])
+    if len(applicable) > 1:
+        raise ValueError('Ambiguous reviewed edition scope')
+    return applicable[0] if applicable else None
@@ -0,0 +1,71 @@
+"""Stable event identity within a venue/year/track, independent of paper identity."""
+import json
+import re
+
+
+def has_event_key(c):
+    if getattr(c, 'postgres', False):
+        return bool(c.execute("SELECT 1 FROM information_schema.columns WHERE table_schema=current_schema() AND table_name='editions' AND column_name='event_key'").fetchone())
+    return any(row[1] == 'event_key' for row in c.execute('PRAGMA table_info(editions)'))
+
+
+def validate_event_key(value):
+    if value is not None and (not isinstance(value, str) or
+            (value != '' and not re.fullmatch(r'[a-z0-9][a-z0-9._:-]{0,79}', value))):
+        raise ValueError('Invalid conference event_key')
+    return value
+
+
+def pinned_www_fall(source, metadata):
+    from paper_atlas.collectors.dblp import XML_SHA
+    b = metadata.get('bibliography') or {}
+    urls = b.get('url') or []
+    return (source == 'dblp' and metadata.get('snapshot_sha256') == XML_SHA
+            and metadata.get('bibliographic_year') == 1995
+            and str(metadata.get('proceedings_key', '')).startswith('conf/www/')
+            and b.get('booktitle') == ['WWW (Fall)'] and len(urls) == 1
+            and urls[0].split('#')[0] == 'db/conf/www/www1995f.html')
+
+
+def find_edition(store, venue_id, venue, year, track, record, external_id,
+                 event_key=None, *, create=True):
+    c = store.conn
+    validate_event_key(event_key)
+    enabled = has_event_key(c) if getattr(store, 'event_identity', None) is None else store.event_identity
+    known_multi = venue.upper() == 'WWW' and int(year) in (1994, 1995)
+    source = c.execute('SELECT src.name,r.metadata_json FROM source_records r JOIN sources src ON src.id=r.source_id WHERE r.id=?', (record,)).fetchone()
+    inferred = ('www-1995-fall' if known_multi and int(year) == 1995 and source
+                and pinned_www_fall(source[0], json.loads(source[1])) else None)
+    if inferred:
+        if event_key is not None and event_key != inferred:
+            raise ValueError('event_key conflicts with pinned WWW Fall source evidence')
+        event_key = inferred
+    if not enabled:
+        if event_key or known_multi:
+            raise ValueError('Explicit event identity migration required before this conference import')
+        row = c.execute('SELECT id FROM editions WHERE venue_id=? AND year=? AND track=?', (venue_id, year, track)).fetchone()
+        if row or not create:
+            return row[0] if row else None
+        c.execute('INSERT INTO editions(venue_id,year,track) VALUES(?,?,?) ON CONFLICT DO NOTHING', (venue_id, year, track))
+        return c.execute('SELECT id FROM editions WHERE venue_id=? AND year=? AND track=?', (venue_id, year, track)).fetchone()[0]
+    anchored = c.execute('''SELECT DISTINCT e.id,e.event_key FROM editions e JOIN submissions s ON s.edition_id=e.id
+        JOIN submission_sources ss ON ss.submission_id=s.id WHERE e.venue_id=? AND e.year=? AND e.track=?
+        AND ss.source_record_id=? AND ss.source_submission_id=?''', (venue_id, year, track, record, external_id)).fetchall()
+    if len(anchored) > 1:
+        raise ValueError('Source record already has ambiguous conference events')
+    if anchored:
+        if event_key is not None and event_key != anchored[0][1]:
+            raise ValueError('Cannot move an existing source to another conference event')
+        event_key = anchored[0][1]
+    if event_key is None:
+        rows = c.execute('SELECT event_key FROM editions WHERE venue_id=? AND year=? AND track=?', (venue_id, year, track)).fetchall()
+        if len(rows) > 1 or any(row[0] for row in rows):
+            raise ValueError('Explicit event_key required; conference event is ambiguous')
+        event_key = ''
+    if known_multi and not event_key:
+        raise ValueError('Explicit event_key required for same-year WWW events')
+    row = c.execute('SELECT id FROM editions WHERE venue_id=? AND year=? AND track=? AND event_key=?', (venue_id, year, track, event_key)).fetchone()
+    if row or not create:
+        return row[0] if row else None
+    c.execute('INSERT INTO editions(venue_id,year,track,event_key) VALUES(?,?,?,?) ON CONFLICT DO NOTHING', (venue_id, year, track, event_key))
+    return c.execute('SELECT id FROM editions WHERE venue_id=? AND year=? AND track=? AND event_key=?', (venue_id, year, track, event_key)).fetchone()[0]
@@ -29,7 +29,8 @@ CREATE TABLE IF NOT EXISTS venues (
 CREATE TABLE IF NOT EXISTS editions (
 id INTEGER PRIMARY KEY, venue_id INTEGER NOT NULL REFERENCES venues(id),
 year INTEGER NOT NULL, track TEXT NOT NULL DEFAULT 'main',
- UNIQUE(venue_id,year,track)
+ event_key TEXT NOT NULL DEFAULT '',
+ UNIQUE(venue_id,year,track,event_key)
 );
 CREATE TABLE IF NOT EXISTS venue_aliases (
 venue_id INTEGER NOT NULL REFERENCES venues(id), alias TEXT NOT NULL,
@@ -36,6 +36,8 @@ class Store:
        self.conn.execute('PRAGMA synchronous=NORMAL')
        self.conn.execute('PRAGMA cache_size=-32768')
        migrate_sources(self.conn)
+        from paper_atlas.db.events import has_event_key
+        self.event_identity = has_event_key(self.conn)

    def source(self,name,url):
        self.conn.execute('INSERT INTO sources(name,homepage) VALUES(?,?) ON CONFLICT DO NOTHING',(name,url))
@@ -55,6 +57,9 @@ class Store:
        c.execute('UPDATE identifiers SET paper_id=? WHERE paper_id=?',(target,other))
        c.execute('UPDATE source_records SET paper_id=? WHERE paper_id=?',(target,other))
        c.execute('UPDATE submissions SET paper_id=? WHERE paper_id=?',(target,other))
+        from paper_atlas.curation.annotations import available
+        if available(c):
+            c.execute('UPDATE annotation_events SET paper_id=? WHERE paper_id=?', (target,other))
        c.execute('INSERT INTO paper_tags SELECT ?,tag_id,source_record_id,evidence_key FROM paper_tags WHERE paper_id=? ON CONFLICT DO NOTHING',(target,other))
        c.execute('DELETE FROM paper_tags WHERE paper_id=?',(other,))
        c.execute('UPDATE paper_merges SET surviving_paper_id=? WHERE surviving_paper_id=?',(target,other))
@@ -91,6 +96,8 @@ class Store:
            if found:
                matches.add(found[0])
        old = c.execute('SELECT paper_id,title,abstract,retrieved_at,metadata_json FROM source_records WHERE source_id=? AND external_id=?',(source_id:=self.source(source,url),external_id)).fetchone()
+        from paper_atlas.db.edition_scopes import preserve
+        metadata = preserve(dict(metadata or {}), old[4] if old else None)
        if old:
            matches.add(old[0])
        key = normalized(title)
@@ -148,15 +155,32 @@ class Store:
            tag=c.execute('SELECT id FROM tags WHERE namespace=? AND value=?',(namespace,value)).fetchone()[0]
            c.execute('INSERT INTO paper_tags VALUES(?,?,?,?) ON CONFLICT DO NOTHING',(paper,tag,record,evidence))

-    def decision(self,paper,record,venue,year,track,external_id,url,status,raw_value,aliases=None,identities=None,observed_at=None,decision_date=None,source_decision_id='',submitted_at=None,guard_status=False):
+    def decision(self,paper,record,venue,year,track,external_id,url,status,raw_value,aliases=None,identities=None,observed_at=None,decision_date=None,source_decision_id='',submitted_at=None,guard_status=False,event_key=None):
        c = self.conn
+        # An already collected file may still call these exact pinned volumes
+        # IJCAI. Resolve membership before finding/creating an edition so a
+        # later refresh cannot split the repaired joint event again.
+        if venue == 'IJCAI' and year in (2018,2022) and track == 'main':
+            from paper_atlas.collectors.dblp import XML_SHA
+            evidence=c.execute('SELECT src.name,r.metadata_json FROM source_records r JOIN sources src ON src.id=r.source_id WHERE r.id=?',(record,)).fetchone()
+            if evidence and evidence[0] == 'dblp':
+                metadata=json.loads(evidence[1])
+                if (metadata.get('snapshot_sha256') == XML_SHA
+                        and metadata.get('proceedings_key') == 'conf/ijcai/'+str(year)
+                        and metadata.get('bibliographic_year') == year
+                        and (metadata.get('bibliography') or {}).get('booktitle') in (['IJCAI'],['IJCAI/ECAI'])):
+                    venue='ECAI+IJCAI'
+                    aliases=sorted(set(aliases or []) | {'ECAI','IJCAI'})
        existing=c.execute('SELECT id FROM venues WHERE lower(acronym)=lower(?)',(venue,)).fetchone()
        if existing:venue_id=existing[0]
        else:venue_id=inserted_id(c,"INSERT INTO venues(acronym,name,field,venue_type) VALUES(?,?,?,'conference')",(venue,venue,'unclassified'))
        for alias in aliases or []:
            c.execute('INSERT INTO venue_aliases VALUES(?,?) ON CONFLICT DO NOTHING',(venue_id,alias))
-        c.execute('INSERT INTO editions(venue_id,year,track) VALUES(?,?,?) ON CONFLICT DO NOTHING',(venue_id,int(year),track))
-        edition = c.execute('SELECT id FROM editions WHERE venue_id=? AND year=? AND track=?',(venue_id,int(year),track)).fetchone()[0]
+        from paper_atlas.db.events import find_edition
+        from paper_atlas.db.edition_scopes import resolve
+        edition = resolve(c,record,external_id,venue,year,track,event_key)
+        if edition is None:
+            edition = find_edition(self,venue_id,venue,int(year),track,record,external_id,event_key)
        # A previous event in this row may already have merged the input paper.
        paper=c.execute('SELECT paper_id FROM source_records WHERE id=?',(record,)).fetchone()[0]
        submission=attach_submission(self,edition,paper,record,external_id,identities or [])
@@ -4,7 +4,7 @@ import re
 from paper_atlas.io.publication_ids import mlsys_id


-PUBLICATIONS={'pmlr','acl_anthology','colm','neurips','mlsys','cvf','ecva','dblp'}
+PUBLICATIONS={'pmlr','acl_anthology','colm','neurips','mlsys','cvf','ecva','dblp','aamas_proceedings'}


 def timestamp(value=None):
@@ -37,9 +37,14 @@ def backfill(db,files, *, pg_service=None, pg_schema=None):
                    seen.add(row['external_id'])
                    if any(row.get(key)!=manifest.get(key) for key in ('source','venue','year','track')):
                        raise ValueError('Evidence row differs from edition manifest')
+                    if 'event_key' in manifest and row.get('event_key')!=manifest['event_key']:
+                        raise ValueError('Event identity differs from manifest')
                    require_track_record(row, manifest)
                    record=c.execute('SELECT r.id,r.paper_id,r.metadata_json FROM source_records r JOIN sources s ON s.id=r.source_id WHERE s.name=? AND r.external_id=?',(row['source'],row['external_id'])).fetchone()
-                    edition=c.execute('SELECT e.id FROM editions e JOIN venues v ON v.id=e.venue_id WHERE lower(v.acronym)=lower(?) AND e.year=? AND e.track=?',(row['venue'],row['year'],row['track'])).fetchone()
+                    from paper_atlas.db.events import find_edition
+                    venue=c.execute('SELECT id FROM venues WHERE lower(acronym)=lower(?)',(row['venue'],)).fetchone()
+                    eid=find_edition(store,venue[0],row['venue'],row['year'],row['track'],record[0],row['external_id'],row.get('event_key'),create=False) if record and venue else None
+                    edition=(eid,) if eid is not None else None
                    if not record or not edition:raise ValueError('Evidence backfill requires an already imported record and edition')
                    if not c.execute('SELECT 1 FROM submission_sources ss JOIN submissions s ON s.id=ss.submission_id WHERE ss.source_record_id=? AND ss.source_submission_id=? AND s.edition_id=?',(record[0],row['external_id'],edition[0])).fetchone():
                        raise ValueError('No existing submission to backfill')
@@ -0,0 +1,245 @@
+"""Snapshot-bound reclassification of existing attempts, without reimport or merge."""
+import argparse
+from collections import Counter
+from contextlib import closing
+import hashlib
+import json
+from pathlib import Path
+import re
+
+from paper_atlas.db.backend import database_arguments, open_read_connection, open_store, inserted_id
+from paper_atlas.db.edition_scopes import KEY
+from paper_atlas.ingestion.event_identity import database_identity, digest, values
+
+MARKER = 'edition_tracks_v1:'
+
+
+def validate(inventory):
+    if (not isinstance(inventory, dict) or inventory.get('format') != 1
+            or not isinstance(inventory.get('records'), list) or not 0 < len(inventory['records']) <= 10000):
+        raise ValueError('Nonempty bounded reviewed inventory required')
+    ids = set(); records = set()
+    for row in inventory['records']:
+        required = {'submission_id','source_record_id','external_id','source','doi','from_edition_id',
+                    'year','venue','venue_names','track','section','evidence_url','evidence_sha256'}
+        if not isinstance(row, dict) or set(row) != required:
+            raise ValueError('Unexpected inventory record fields')
+        for field in ('submission_id','source_record_id','from_edition_id','year'):
+            if type(row[field]) is not int or row[field] <= 0:
+                raise ValueError('Positive integer inventory identity required')
+        if row['submission_id'] in ids or row['source_record_id'] in records:
+            raise ValueError('Repeated submission/source identity in inventory')
+        ids.add(row['submission_id']); records.add(row['source_record_id'])
+        for field in ('external_id','source','doi','venue','section','evidence_url'):
+            if not isinstance(row[field], str) or not row[field].strip():
+                raise ValueError('Missing inventory evidence field')
+        if (not isinstance(row['venue_names'], list) or not row['venue_names']
+                or not all(isinstance(v,str) and v for v in row['venue_names'])
+                or row['venue'] not in row['venue_names']
+                or not re.fullmatch(r'[a-z][a-z0-9_]{0,63}', row['track'])
+                or not re.fullmatch(r'[0-9a-f]{64}', row['evidence_sha256'])
+                or not row['evidence_url'].startswith('https://')):
+            raise ValueError('Invalid scope or evidence binding')
+    return inventory
+
+
+def bounded(c, sql, params):
+    rows = values(c.execute(sql+' LIMIT 100001', params))
+    if len(rows) > 100000:
+        raise ValueError('Protected scope exceeds bounded reclassification limit')
+    return rows
+
+
+def protect(c, ids):
+    marks = ','.join('?' for _ in ids)
+    subs = 'SELECT id FROM submissions WHERE id IN ('+marks+')'
+    papers = 'SELECT paper_id FROM submissions WHERE id IN ('+marks+')'
+    decisions = 'SELECT id FROM decisions WHERE submission_id IN ('+subs+')'
+    queries = {
+        'submissions': ('SELECT id,paper_id,source_record_id,source_submission_id,submitted_at FROM submissions WHERE id IN ('+marks+') ORDER BY id'),
+        'submission_identifiers': ('SELECT scheme,value,submission_id FROM submission_identifiers WHERE submission_id IN ('+subs+') ORDER BY submission_id,scheme,value'),
+        'submission_sources': ('SELECT * FROM submission_sources WHERE submission_id IN ('+subs+') ORDER BY submission_id,source_record_id,source_submission_id'),
+        'decisions': ('SELECT * FROM decisions WHERE submission_id IN ('+subs+') ORDER BY id'),
+        'decision_sources': ('SELECT * FROM decision_sources WHERE decision_id IN ('+decisions+') ORDER BY decision_id,source_record_id,source_decision_id'),
+        'papers': ('SELECT * FROM papers WHERE id IN ('+papers+') ORDER BY id'),
+        'identifiers': ('SELECT * FROM identifiers WHERE paper_id IN ('+papers+') ORDER BY scheme,value'),
+        'paper_tags': ('SELECT * FROM paper_tags WHERE paper_id IN ('+papers+') ORDER BY paper_id,tag_id,evidence_key'),
+    }
+    from paper_atlas.curation.annotations import available
+    if available(c):
+        queries['annotation_events'] = 'SELECT * FROM annotation_events WHERE paper_id IN ('+papers+') ORDER BY id'
+    result = {table: {'rows':len(rows), 'sha256':digest(rows)} for table, sql in queries.items()
+              for rows in [bounded(c,sql,ids)]}
+    rows = bounded(c, 'SELECT r.* FROM source_records r WHERE r.id IN (SELECT source_record_id FROM submission_sources WHERE submission_id IN ('+subs+')) ORDER BY r.id', ids)
+    # Only the reviewed curation field may change; every other metadata value
+    # and all raw text/IDs/retrieval times remain protected.
+    for row in rows:
+        metadata = json.loads(row[8]); metadata.pop(KEY,None); row[8] = metadata
+    result['source_records'] = {'rows':len(rows), 'sha256':digest(rows)}
+    return result
+
+
+def inspect(c, inventory):
+    validate(inventory); changes=[]; ids=tuple(sorted(r['submission_id']for r in inventory['records']))
+    original = sorted({r['from_edition_id'] for r in inventory['records']})
+    actual_ids = {r[0] for r in c.execute('SELECT id FROM submissions WHERE edition_id IN ('+','.join('?'for _ in original)+')', original)}
+    if actual_ids != set(ids):
+        raise ValueError('Inventory must cover every attempt in each original edition')
+    for row in inventory['records']:
+        current = c.execute('''SELECT s.edition_id,s.source_record_id,s.source_submission_id,s.paper_id,
+            e.venue_id,e.year,e.track,e.event_key,v.acronym,r.external_id,r.metadata_json,src.name
+            FROM submissions s JOIN editions e ON e.id=s.edition_id JOIN venues v ON v.id=e.venue_id
+            JOIN source_records r ON r.id=s.source_record_id JOIN sources src ON src.id=r.source_id WHERE s.id=?''',(row['submission_id'],)).fetchone()
+        if not current or [current[i]for i in (0,1,2,5,8,9,11)] != [row[k]for k in ('from_edition_id','source_record_id','external_id','year','venue','external_id','source')]:
+            raise ValueError('Submission identity/scope differs from inventory')
+        aliases={r[0]for r in c.execute('SELECT alias FROM venue_aliases WHERE venue_id=?',(current[4],))}|{current[8]}
+        if set(row['venue_names'])!=aliases:
+            raise ValueError('Venue names differ from current aliases')
+        metadata=json.loads(current[10])
+        if KEY in metadata:
+            raise ValueError('Existing curated scope requires explicit reconciliation')
+        if (metadata.get('record_identifiers') or {}).get('doi') != row['doi']:
+            raise ValueError('Stable DOI differs from reviewed source evidence')
+        links=values(c.execute('SELECT source_record_id,source_submission_id FROM submission_sources WHERE submission_id=?',(row['submission_id'],)))
+        if links != [[row['source_record_id'],row['external_id']]]:
+            raise ValueError('Shared-source attempt requires separate reconciliation')
+        decisions=values(c.execute('SELECT status FROM decisions WHERE submission_id=?',(row['submission_id'],)))
+        if not decisions or any(d[0]!='accepted'for d in decisions):
+            raise ValueError('Only publication observations can use this track correction')
+        target=c.execute('SELECT id FROM editions WHERE venue_id=? AND year=? AND track=? AND event_key=?',(current[4],current[5],row['track'],current[7])).fetchone()
+        if target and target[0] != current[0]:
+            if c.execute('SELECT 1 FROM submissions WHERE edition_id=? LIMIT 1',(target[0],)).fetchone():
+                raise ValueError('Nonempty target edition requires separate reconciliation')
+            if c.execute('SELECT 1 FROM submission_identifiers WHERE edition_id=? LIMIT 1',(target[0],)).fetchone():
+                raise ValueError('Target identifier scope already exists')
+            if c.execute('SELECT 1 FROM edition_sources WHERE edition_id=? LIMIT 1',(target[0],)).fetchone():
+                raise ValueError('Target coverage already exists; reconcile first')
+        if c.execute('SELECT 1 FROM submission_identifiers WHERE submission_id=? AND edition_id<>? LIMIT 1',(row['submission_id'],current[0])).fetchone():
+            raise ValueError('Existing identifier edition is inconsistent')
+        changes.append({**row,'from_track':current[6],'event_key':current[7], 'venue_id':current[4],
+                        'target_edition_id':target[0]if target else None})
+    coverage=bounded(c,'SELECT * FROM edition_sources WHERE edition_id IN ('+','.join('?'for _ in original)+') ORDER BY edition_id,source_id,list_url',original)
+    if Counter(row[0]for row in coverage)!=Counter({edition:1 for edition in original}):
+        raise ValueError('Exactly one original coverage listing per edition required')
+    return {'records':changes, 'protected':protect(c,ids), 'coverage':coverage,
+            'editions':bounded(c,'SELECT * FROM editions WHERE id IN ('+','.join('?'for _ in original)+') ORDER BY id',original)}
+
+
+def proposal(c, inventory, identity):
+    return {'format':1,'database':identity,'inventory':inventory,'before':inspect(c,inventory)}
+
+
+def verify(c, plan):
+    records=plan['before']['records']; ids=tuple(sorted(r['submission_id']for r in records))
+    if protect(c,ids)!=plan['before']['protected']:
+        raise ValueError('Protected history/text/tags/identities changed; roll back')
+    for row in records:
+        event=c.execute('''SELECT e.id,e.venue_id,e.year,e.track,e.event_key FROM submissions s JOIN editions e ON e.id=s.edition_id WHERE s.id=?''',(row['submission_id'],)).fetchone()
+        if not event or [event[i]for i in range(1,5)] != [row['venue_id'],row['year'],row['track'],row['event_key']]:
+            raise ValueError('Target track assignment failed')
+        if c.execute('SELECT 1 FROM submission_identifiers WHERE submission_id=? AND edition_id<>? LIMIT 1',(row['submission_id'],event[0])).fetchone():
+            raise ValueError('Target identifier assignment failed')
+        metadata=json.loads(c.execute('SELECT metadata_json FROM source_records WHERE id=?',(row['source_record_id'],)).fetchone()[0])
+        if row['track'] != row['from_track']:
+            if metadata.get(KEY) != [curation(row,event[0],digest(plan))]:
+                raise ValueError('Reviewed refresh protection missing or changed')
+        elif KEY in metadata:
+            raise ValueError('Unexpected scope revision on unchanged track')
+    original=sorted({r['from_edition_id']for r in records})
+    if bounded(c,'SELECT * FROM editions WHERE id IN ('+','.join('?'for _ in original)+') ORDER BY id',original)!=plan['before']['editions']:
+        raise ValueError('Original edition identities changed')
+    for old in plan['before']['coverage']:
+        edition,source,url,_,_,_,cursor,success,_=old
+        expected=Counter()
+        for row in records:
+            if row['from_edition_id']==edition:
+                target=c.execute('SELECT edition_id FROM submissions WHERE id=?',(row['submission_id'],)).fetchone()[0]
+                expected[target]+=1
+        for target,number in expected.items():
+            actual=c.execute('SELECT status,expected_count,imported_count,cursor,last_success_at,last_error FROM edition_sources WHERE edition_id=? AND source_id=? AND list_url=?',(target,source,url)).fetchone()
+            note='Track scope corrected from reviewed per-record evidence; original whole-volume coverage retained in plan '+digest(plan)
+            if actual is None or [actual[i]for i in range(6)]!=['partial',number,number,cursor,success,note]:
+                raise ValueError('Corrected coverage differs from reviewed scope')
+    return {'records_verified':len(records),'protected':plan['before']['protected']}
+
+
+def curation(row, target, signature):
+    return {'external_id':row['external_id'], 'venue_names':sorted(set(row['venue_names'])),
+            'from':{'edition_id':row['from_edition_id'],'year':row['year'],'track':row['from_track'],'event_key':row['event_key']},
+            'target':{'edition_id':target,'venue_id':row['venue_id'],'year':row['year'],'track':row['track'],'event_key':row['event_key']},
+            'section':row['section'],'evidence_url':row['evidence_url'],'evidence_sha256':row['evidence_sha256'],'plan_digest':signature}
+
+
+def apply_plan(c, plan):
+    if plan.get('format') != 1:
+        raise ValueError('Unsupported plan format')
+    signature=digest(plan);marker=MARKER+signature
+    if c.execute('SELECT 1 FROM schema_migrations WHERE name=?',(marker,)).fetchone():
+        return {'status':'already_applied','events_moved':0,**verify(c,plan)}
+    if inspect(c,plan['inventory']) != plan['before']:
+        raise ValueError('Stale track plan; create and review a fresh plan')
+    targets={}; counts=Counter(); moved=0
+    for row in plan['before']['records']:
+        key=(row['venue_id'],row['year'],row['track'],row['event_key'])
+        if key not in targets:
+            found=c.execute('SELECT id FROM editions WHERE venue_id=? AND year=? AND track=? AND event_key=?',key).fetchone()
+            targets[key]=found[0]if found else inserted_id(c,'INSERT INTO editions(venue_id,year,track,event_key) VALUES(?,?,?,?)',key)
+        target=targets[key];counts[(row['from_edition_id'],target)]+=1
+        if target != row['from_edition_id']:
+            c.execute('UPDATE submission_identifiers SET edition_id=? WHERE submission_id=?',(target,row['submission_id']))
+            if c.execute('UPDATE submissions SET edition_id=? WHERE id=? AND edition_id=?',(target,row['submission_id'],row['from_edition_id'])).rowcount!=1:
+                raise ValueError('Concurrent submission change')
+            metadata=json.loads(c.execute('SELECT metadata_json FROM source_records WHERE id=?',(row['source_record_id'],)).fetchone()[0]);metadata[KEY]=[curation(row,target,signature)]
+            c.execute('UPDATE source_records SET metadata_json=? WHERE id=?',(json.dumps(metadata,ensure_ascii=False),row['source_record_id']));moved+=1
+    # Preserve each original source URL and timestamps, but do not retain its
+    # old whole-volume count as main-track coverage. Partial is deliberate:
+    # this operation verifies scope, not abstracts or all possible sources.
+    for old in plan['before']['coverage']:
+        edition,source,url,status,expected,imported,cursor,success,error=old
+        own={r['submission_id'] for r in plan['before']['records']if r['from_edition_id']==edition}
+        source_name=c.execute('SELECT name FROM sources WHERE id=?',(source,)).fetchone()[0]
+        if {r['source']for r in plan['before']['records']if r['submission_id']in own}!={source_name}:
+            raise ValueError('Coverage includes a source outside the reviewed inventory')
+        for (origin,target),number in counts.items():
+            if origin!=edition:continue
+            note='Track scope corrected from reviewed per-record evidence; original whole-volume coverage retained in plan '+signature
+            c.execute('''INSERT INTO edition_sources(edition_id,source_id,list_url,status,expected_count,imported_count,cursor,last_success_at,last_error)
+                VALUES(?,?,?,?,?,?,?,?,?) ON CONFLICT(edition_id,source_id,list_url) DO UPDATE SET status=excluded.status,
+                expected_count=excluded.expected_count,imported_count=excluded.imported_count,last_error=excluded.last_error''',
+                (target,source,url,'partial',number,number,cursor,success,note))
+    result=verify(c,plan)
+    c.execute('INSERT INTO schema_migrations(name) VALUES(?)',(marker,))
+    return {'status':'applied','events_moved':moved,**result}
+
+
+def run(db,out,*,pg_service=None,pg_schema=None,inventory=None,plan=None,plan_sha256=None):
+    out=Path(out)
+    if out.exists() or not out.parent.is_dir():raise ValueError('New report path in existing directory required')
+    expected=None
+    if plan:
+        raw=Path(plan).read_bytes()
+        if hashlib.sha256(raw).hexdigest()!=plan_sha256:raise ValueError('Plan hash differs')
+        expected=json.loads(raw);validate(expected['inventory'])
+    elif plan_sha256:raise ValueError('Plan path required')
+    if bool(expected)==bool(inventory):raise ValueError('Choose inventory preflight or apply plan')
+    if expected is None:
+        with closing(open_read_connection(db,pg_service=pg_service,pg_schema=pg_schema))as c:
+            result=proposal(c,validate(json.loads(Path(inventory).read_bytes())),database_identity(c,db))
+    else:
+        store=open_store(db,pg_service=pg_service,pg_schema=pg_schema)
+        with closing(store.conn)as c:
+            try:
+                if expected['database']!=database_identity(c,db):raise ValueError('Plan belongs to another database')
+                if not getattr(c,'postgres',False):c.commit();c.execute('BEGIN IMMEDIATE')
+                result=apply_plan(c,expected);c.commit()
+            except BaseException:c.rollback();raise
+    out.write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n');return result
+
+
+def main(argv=None,*,prog=None):
+    p=argparse.ArgumentParser(prog=prog);database_arguments(p)
+    p.add_argument('--inventory');p.add_argument('--plan');p.add_argument('--plan-sha256');p.add_argument('--out',required=True)
+    a=p.parse_args(argv)
+    if bool(a.plan)!=bool(a.plan_sha256):p.error('--plan and --plan-sha256 must be supplied together')
+    r=run(a.db,a.out,pg_service=a.pg_service,pg_schema=a.pg_schema,inventory=a.inventory,plan=a.plan,plan_sha256=a.plan_sha256)
+    print(json.dumps({'status':r.get('status','planned'),'events_moved':r.get('events_moved',0),'out':a.out}),flush=True)
@@ -0,0 +1,221 @@
+"""Explicit, plan-bound edition event-key upgrade; never reimport submissions."""
+import argparse
+from contextlib import closing
+import hashlib
+import json
+from pathlib import Path
+import sqlite3
+import sys
+
+from paper_atlas.db.backend import database_arguments, open_read_connection, require_sqlite_writable
+from paper_atlas.db.events import has_event_key, pinned_www_fall
+from paper_atlas.postgres.schema import TABLES, OPTIONAL_TABLES, quote
+
+MARKER = 'edition_event_identity_v1:'
+
+
+def digest(value):
+    return hashlib.sha256(json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(',', ':')).encode()).hexdigest()
+
+
+def values(rows):
+    return [[r[i] for i in range(len(r))] for r in rows]
+
+
+def exact_counts(c, *, page_size=5000, progress=None):
+    """Count every row in the same snapshot through bounded primary-key pages."""
+    if not isinstance(page_size, int) or page_size < 1:
+        raise ValueError('Positive count page size required')
+    result = {}
+    if getattr(c, 'postgres', False):
+        optional = [table for table in OPTIONAL_TABLES if c.execute("SELECT 1 FROM information_schema.tables WHERE table_schema=current_schema() AND table_name=?", (table,)).fetchone()]
+    else:
+        optional = [table for table in OPTIONAL_TABLES if c.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (table,)).fetchone()]
+    for table in (*TABLES, *optional):
+        if table == 'schema_migrations':
+            continue
+        if getattr(c, 'postgres', False):
+            columns = [r[0] for r in c.execute("SELECT a.attname FROM pg_constraint pc JOIN pg_attribute a ON a.attrelid=pc.conrelid AND a.attnum=ANY(pc.conkey) WHERE pc.conrelid=?::regclass AND pc.contype='p' ORDER BY array_position(pc.conkey,a.attnum)", (table,))]
+        else:
+            columns = [r[1] for r in sorted(c.execute('PRAGMA table_info('+quote(table)+')'), key=lambda r:r[5]) if r[5]]
+        if not columns:
+            raise ValueError('Primary key required for exact count: '+table)
+        fields = ','.join(quote(column) for column in columns)
+        last = None; count = 0; pages = 0
+        if progress:
+            progress({'table':table, 'rows_counted':0, 'complete':False})
+        while True:
+            where = (' WHERE ('+fields+') > ('+','.join('?' for _ in columns)+')') if last is not None else ''
+            batch = values(c.execute('SELECT '+fields+' FROM '+quote(table)+where+' ORDER BY '+fields+' LIMIT ?', (*last, page_size) if last is not None else (page_size,)).fetchall())
+            count += len(batch); pages += 1
+            complete = len(batch) < page_size
+            if progress and (complete or pages % 20 == 0):
+                progress({'table':table, 'rows_counted':count, 'complete':complete})
+            if complete:
+                break
+            last = batch[-1]
+        result[table] = count
+    return result
+
+
+def inspect(c, *, progress=None):
+    enabled = has_event_key(c)
+    if getattr(c, 'postgres', False):
+        columns = [r[0] for r in c.execute("SELECT column_name FROM information_schema.columns WHERE table_schema=current_schema() AND table_name='editions' ORDER BY ordinal_position")]
+        unique = [r[0] for r in c.execute("SELECT pg_get_constraintdef(oid) FROM pg_constraint WHERE conrelid='editions'::regclass AND contype='u'")]
+        expected_unique = ['UNIQUE (venue_id, year, track, event_key)' if enabled else 'UNIQUE (venue_id, year, track)']
+    else:
+        columns = [r[1] for r in c.execute('PRAGMA table_info(editions)')]
+        indexes = list(c.execute('PRAGMA index_list(editions)'))
+        unique = [tuple(r[2] for r in c.execute('PRAGMA index_info('+quote(index[1])+')')) for index in indexes if index[2]]
+        expected_unique = [('venue_id','year','track','event_key') if enabled else ('venue_id','year','track')]
+        if len(indexes) != 1:
+            raise ValueError('Unexpected edition indexes; require a reviewed migration')
+    if columns != ['id','venue_id','year','track'] + (['event_key'] if enabled else []) or unique != expected_unique:
+        raise ValueError('Unexpected edition schema; require a reviewed migration')
+    rows = values(c.execute('SELECT id,venue_id,year,track FROM editions ORDER BY id'))
+    keys = values(c.execute('SELECT id,event_key FROM editions ORDER BY id')) if enabled else [[r[0], ''] for r in rows]
+    counts = exact_counts(c, progress=progress)
+    targets = values(c.execute("SELECT e.id FROM editions e JOIN venues v ON v.id=e.venue_id WHERE v.acronym='WWW' AND e.year=1995 AND e.track='main' ORDER BY e.id"))
+    assignments = []
+    for (eid,) in targets:
+        current_key = dict(keys)[eid]
+        if current_key:
+            continue
+        evidence = values(c.execute('''SELECT s.id,src.name,r.id,r.external_id,r.metadata_json FROM submissions s
+            JOIN submission_sources ss ON ss.submission_id=s.id JOIN source_records r ON r.id=ss.source_record_id
+            JOIN sources src ON src.id=r.source_id WHERE s.edition_id=? ORDER BY s.id,r.id''', (eid,)))
+        count = c.execute('SELECT count(*) FROM submissions WHERE edition_id=?', (eid,)).fetchone()[0]
+        supported = {r[0] for r in evidence if pinned_www_fall(r[1], json.loads(r[4]))}
+        if not count or len(supported) != count:
+            raise ValueError('Existing unlabelled WWW1995 edition lacks complete pinned Fall evidence')
+        assignments.append({'edition_id':eid, 'event_key':'www-1995-fall', 'submissions':count,
+                            'source_evidence_sha256':digest(evidence)})
+    # Protect all rows in the affected attempt history, including non-DBLP evidence.
+    target_ids = [r[0] for r in targets]
+    protected = {}
+    for table,sql in {
+        'submissions': 'SELECT s.* FROM submissions s WHERE s.edition_id IN ({}) ORDER BY s.id',
+        'decisions': 'SELECT d.* FROM decisions d JOIN submissions s ON s.id=d.submission_id WHERE s.edition_id IN ({}) ORDER BY d.id',
+        'submission_sources': 'SELECT ss.* FROM submission_sources ss JOIN submissions s ON s.id=ss.submission_id WHERE s.edition_id IN ({}) ORDER BY ss.submission_id,ss.source_record_id,ss.source_submission_id',
+        'decision_sources': 'SELECT ds.* FROM decision_sources ds JOIN decisions d ON d.id=ds.decision_id JOIN submissions s ON s.id=d.submission_id WHERE s.edition_id IN ({}) ORDER BY ds.decision_id,ds.source_record_id,ds.source_decision_id',
+        'source_records': 'SELECT DISTINCT r.* FROM source_records r JOIN submission_sources ss ON ss.source_record_id=r.id JOIN submissions s ON s.id=ss.submission_id WHERE s.edition_id IN ({}) ORDER BY r.id',
+    }.items():
+        records = values(c.execute(sql.format(','.join('?' for _ in target_ids)), target_ids)) if target_ids else []
+        protected[table] = {'count':len(records), 'sha256':digest(records)}
+    return {'event_column':enabled, 'editions_sha256':digest(rows), 'edition_ids':[r[0] for r in rows],
+            'event_keys':keys, 'counts':counts, 'assignments':assignments, 'protected':protected}
+
+
+def database_identity(c, db=None):
+    if getattr(c, 'postgres', False):
+        r = c.execute('SELECT current_database(),current_schema()').fetchone()
+        return {'engine':'postgres', 'database':r[0], 'schema':r[1]}
+    return {'engine':'sqlite', 'path':str(Path(db).resolve())}
+
+
+def plan(db=None, *, pg_service=None, pg_schema=None, progress=None):
+    with closing(open_read_connection(db, pg_service=pg_service, pg_schema=pg_schema)) as c:
+        return {'format':1, 'database':database_identity(c, db), 'before':inspect(c, progress=progress)}
+
+
+def apply_plan(c, proposal, *, progress=None):
+    before = proposal['before']
+    if proposal.get('format') != 1:
+        raise ValueError('Unsupported event identity plan')
+    if getattr(c, 'postgres', False):
+        c.execute('LOCK TABLE editions IN ACCESS EXCLUSIVE MODE')
+    current = inspect(c, progress=progress)
+    signature = digest(proposal)
+    marker = MARKER + signature
+    if c.execute('SELECT 1 FROM schema_migrations WHERE name=?', (marker,)).fetchone():
+        expected_keys = dict(before['event_keys'])
+        expected_keys.update({a['edition_id']:a['event_key'] for a in before['assignments']})
+        if (not current['event_column'] or current['editions_sha256'] != before['editions_sha256']
+                or current['protected'] != before['protected'] or current['counts'] != before['counts']
+                or dict(current['event_keys']) != expected_keys):
+            raise ValueError('Applied plan no longer matches current data; generate a new plan')
+        return {'status':'already_applied', 'updated_editions':0, 'after':current}
+    if current != before:
+        raise ValueError('Event identity plan is stale; generate a new plan')
+    if not current['event_column']:
+        if getattr(c, 'postgres', False):
+            constraints = c.execute("SELECT conname,pg_get_constraintdef(oid) FROM pg_constraint WHERE conrelid='editions'::regclass AND contype='u'").fetchall()
+            matches = [name for name,definition in constraints if definition == 'UNIQUE (venue_id, year, track)']
+            if len(matches) != 1 or len(constraints) != 1:
+                raise ValueError('Unexpected legacy edition uniqueness')
+            c.execute("ALTER TABLE editions ADD COLUMN event_key TEXT COLLATE \"C\" NOT NULL DEFAULT ''")
+            c.execute('ALTER TABLE editions DROP CONSTRAINT '+quote(matches[0]))
+            c.execute('ALTER TABLE editions ADD CONSTRAINT editions_event_identity_unique UNIQUE(venue_id,year,track,event_key)')
+        else:
+            unique = [tuple(r[2] for r in c.execute('PRAGMA index_info('+quote(index[1])+')'))
+                      for index in c.execute('PRAGMA index_list(editions)') if index[2]]
+            if unique != [('venue_id','year','track')]:
+                raise ValueError('Unexpected legacy edition uniqueness')
+            c.execute("CREATE TABLE editions_event_upgrade(id INTEGER PRIMARY KEY,venue_id INTEGER NOT NULL REFERENCES venues(id),year INTEGER NOT NULL,track TEXT NOT NULL DEFAULT 'main',event_key TEXT NOT NULL DEFAULT '',UNIQUE(venue_id,year,track,event_key))")
+            c.execute('INSERT INTO editions_event_upgrade(id,venue_id,year,track) SELECT id,venue_id,year,track FROM editions')
+            c.execute('DROP TABLE editions')
+            c.execute('ALTER TABLE editions_event_upgrade RENAME TO editions')
+    for item in before['assignments']:
+        result = c.execute("UPDATE editions SET event_key=? WHERE id=? AND event_key=''", (item['event_key'],item['edition_id']))
+        if result.rowcount != 1:
+            raise ValueError('Edition assignment changed during upgrade')
+    c.execute('INSERT INTO schema_migrations(name) VALUES(?)', (marker,))
+    after = inspect(c, progress=progress)
+    expected_keys = dict(before['event_keys'])
+    expected_keys.update({a['edition_id']:a['event_key'] for a in before['assignments']})
+    if (after['editions_sha256'] != before['editions_sha256'] or after['protected'] != before['protected']
+            or after['counts'] != before['counts'] or dict(after['event_keys']) != expected_keys):
+        raise ValueError('Event upgrade changed protected data')
+    if not getattr(c, 'postgres', False) and c.execute('PRAGMA foreign_key_check').fetchall():
+        raise ValueError('Foreign key violation after event upgrade')
+    return {'status':'applied', 'updated_editions':len(before['assignments']), 'after':after}
+
+
+def upgrade(proposal, db=None, *, pg_service=None, pg_schema=None, progress=None):
+    if pg_service:
+        from paper_atlas.postgres.writer import WriteConnection
+        with closing(WriteConnection(pg_service, pg_schema)) as c:
+            if proposal['database'] != database_identity(c):
+                raise ValueError('Plan targets a different database')
+            try:
+                result = apply_plan(c, proposal, progress=progress); c.commit(); return result
+            except BaseException:
+                c.rollback(); raise
+    require_sqlite_writable(db)
+    if not Path(db).is_file():
+        raise ValueError('Existing SQLite sample required')
+    with closing(sqlite3.connect(db, timeout=30)) as c:
+        if proposal['database'] != database_identity(c, db):
+            raise ValueError('Plan targets a different database')
+        c.execute('PRAGMA foreign_keys=OFF')  # Outside the transaction; no cascading deletes.
+        try:
+            c.execute('BEGIN IMMEDIATE')
+            result = apply_plan(c, proposal, progress=progress); c.commit(); return result
+        except BaseException:
+            c.rollback(); raise
+        finally:
+            c.execute('PRAGMA foreign_keys=ON')
+
+
+def main(argv=None, *, prog=None):
+    p = argparse.ArgumentParser(prog=prog); database_arguments(p)
+    p.add_argument('--out', required=True)
+    p.add_argument('--apply-plan'); p.add_argument('--plan-sha256')
+    args = p.parse_args(argv)
+    if bool(args.apply_plan) != bool(args.plan_sha256):
+        p.error('--apply-plan and --plan-sha256 must be supplied together')
+    target = Path(args.out)
+    if target.exists():
+        raise ValueError('Refusing to overwrite an existing plan/report')
+    progress = lambda event: print(json.dumps({'phase':'exact_row_count', **event}), file=sys.stderr, flush=True)
+    if args.apply_plan:
+        raw = Path(args.apply_plan).read_bytes()
+        if hashlib.sha256(raw).hexdigest() != args.plan_sha256:
+            raise ValueError('Plan file SHA256 differs from approved bytes')
+        result = upgrade(json.loads(raw), args.db, pg_service=args.pg_service, pg_schema=args.pg_schema, progress=progress)
+    else:
+        result = plan(args.db, pg_service=args.pg_service, pg_schema=args.pg_schema, progress=progress)
+    target.write_text(json.dumps(result, ensure_ascii=False, indent=2)+'\n')
+    print(json.dumps({'out':str(target), 'sha256':hashlib.sha256(target.read_bytes()).hexdigest(),
+                      'status':result.get('status','planned')}), flush=True)
@@ -0,0 +1,204 @@
+"""Evidence-bound repair of two existing IJCAI/ECAI edition memberships."""
+import argparse
+from contextlib import closing
+import hashlib
+import json
+from pathlib import Path
+
+from paper_atlas.db.backend import database_arguments, open_read_connection, open_store
+from paper_atlas.db.submissions import timestamp
+from paper_atlas.collectors.dblp import XML_SHA
+
+YEARS = (2018, 2022)
+TARGET = 'ECAI+IJCAI'
+MEMBERS = {'ECAI', 'IJCAI'}
+EVIDENCE = 'https://www.eurai.org/ecai/history'
+MARKER = 'joint_ijcai_ecai_2018_2022_v1'
+
+
+def _digest(c, sql, params=()):
+    sha = hashlib.sha256(); count = 0
+    for row in c.execute(sql, params):
+        sha.update((json.dumps([row[i] for i in range(len(row))], ensure_ascii=False,
+                              separators=(',', ':')) + '\n').encode())
+        count += 1
+        if count > 100000:
+            raise ValueError('Joint repair evidence scope exceeded bounded row limit')
+    return {'rows': count, 'sha256': sha.hexdigest()}
+
+
+def fingerprints(c, ids):
+    marks = ','.join('?' for _ in ids)
+    submissions = 'SELECT id FROM submissions WHERE edition_id IN (' + marks + ')'
+    papers = 'SELECT paper_id FROM submissions WHERE edition_id IN (' + marks + ')'
+    decisions = 'SELECT id FROM decisions WHERE submission_id IN (' + submissions + ')'
+    checks = {
+        'papers': ('id IN (' + papers + ')', 'id'),
+        'identifiers': ('paper_id IN (' + papers + ')', 'scheme,value'),
+        'source_records': ('paper_id IN (' + papers + ')', 'id'),
+        'paper_tags': ('paper_id IN (' + papers + ')', 'paper_id,tag_id,evidence_key'),
+        'submissions': ('edition_id IN (' + marks + ')', 'id'),
+        'decisions': ('submission_id IN (' + submissions + ')', 'id'),
+        'submission_sources': ('submission_id IN (' + submissions + ')', 'submission_id,source_record_id,source_submission_id'),
+        'submission_identifiers': ('edition_id IN (' + marks + ')', 'edition_id,scheme,value'),
+        'decision_sources': ('decision_id IN (' + decisions + ')', 'decision_id,source_record_id,source_decision_id'),
+        'edition_sources': ('edition_id IN (' + marks + ')', 'edition_id,source_id,list_url'),
+    }
+    return {table: _digest(c, 'SELECT * FROM ' + table + ' WHERE ' + where + ' ORDER BY ' + order, ids)
+            for table, (where, order) in checks.items()}
+
+
+def inspect(c):
+    target = c.execute('SELECT id FROM venues WHERE acronym=?', (TARGET,)).fetchall()
+    if len(target) != 1:
+        raise ValueError('Exactly one existing canonical joint venue required')
+    target = target[0][0]
+    aliases = {r[0] for r in c.execute('SELECT alias FROM venue_aliases WHERE venue_id=?', (target,))}
+    if aliases != MEMBERS:
+        raise ValueError('Joint target must already have exactly ECAI and IJCAI aliases')
+    editions = []
+    for year in YEARS:
+        rows = c.execute('''SELECT e.id,e.venue_id,v.acronym FROM editions e JOIN venues v ON v.id=e.venue_id
+            WHERE v.acronym IN ('IJCAI','ECAI+IJCAI') AND e.year=? AND e.track='main' ''', (year,)).fetchall()
+        if len(rows) != 1:
+            raise ValueError('Expected one existing edition per year; missing or colliding editions require separate review')
+        edition, venue, acronym = (rows[0][i] for i in range(3))
+        count = c.execute('SELECT count(*) FROM submissions WHERE edition_id=?', (edition,)).fetchone()[0]
+        if not 0 < count <= 5000:
+            raise ValueError('Existing edition must have a nonempty bounded submission scope')
+        # Every existing submission must be supported by its own pinned DBLP
+        # volume record. No title/author matching, new attempts or text writes.
+        evidence = c.execute('''SELECT s.id,r.external_id,r.metadata_json FROM submissions s
+            JOIN submission_sources ss ON ss.submission_id=s.id
+            JOIN source_records r ON r.id=ss.source_record_id JOIN sources src ON src.id=r.source_id
+            WHERE s.edition_id=? AND src.name='dblp' ORDER BY s.id,r.id''', (edition,)).fetchall()
+        seen = set()
+        for row in evidence:
+            sid, external, metadata = (row[i] for i in range(3))
+            meta = json.loads(metadata)
+            bibliography = meta.get('bibliography') or {}
+            if (meta.get('snapshot_sha256') != XML_SHA
+                    or meta.get('proceedings_key') != 'conf/ijcai/' + str(year)
+                    or meta.get('bibliographic_year') != year
+                    or bibliography.get('booktitle') not in (['IJCAI'], ['IJCAI/ECAI'])
+                    or not external.startswith('conf/ijcai/')):
+                raise ValueError('Source evidence outside the exact verified IJCAI/ECAI volume')
+            seen.add(sid)
+        if len(seen) != count:
+            raise ValueError('Every submission must have matching original volume evidence')
+        editions.append({'id': edition, 'year': year, 'track': 'main', 'from_venue_id': venue,
+                         'from_venue': acronym, 'target_venue_id': target, 'submissions': count,
+                         'evidence_url': EVIDENCE, 'proceedings_key': 'conf/ijcai/' + str(year)})
+    ids = tuple(e['id'] for e in editions)
+    return {'format_version': 1, 'kind': MARKER, 'checked_at': timestamp(), 'editions': editions,
+            'content_fingerprints': fingerprints(c, ids), 'target_aliases': sorted(aliases),
+            'status': 'already_joint' if all(e['from_venue_id'] == target for e in editions) else 'ready',
+            'scope': 'Only these two existing edition venue references; no source text, paper, submission, decision, track, identifier or tag change.'}
+
+
+def validate_plan(expected):
+    if not isinstance(expected, dict):
+        raise ValueError('Repair plan must be a JSON object')
+    if set(expected) != {'format_version','kind','checked_at','editions','content_fingerprints','target_aliases','status','scope','database'}:
+        raise ValueError('Unexpected repair plan fields')
+    if (type(expected['format_version']) is not int or expected['format_version'] != 1
+            or expected['kind'] != MARKER or expected['status'] not in ('ready','already_joint')):
+        raise ValueError('Unsupported repair plan')
+    if (not isinstance(expected['database'],dict) or not isinstance(expected['content_fingerprints'],dict)
+            or not isinstance(expected['editions'],list) or len(expected['editions']) != 2
+            or expected['target_aliases'] != sorted(MEMBERS)):
+        raise ValueError('Invalid repair plan structure')
+    for edition, year in zip(expected['editions'], YEARS):
+        if not isinstance(edition,dict) or edition.get('year') != year:
+            raise ValueError('Repair plan must name the two exact ordered years')
+        for key in ('id','year','from_venue_id','target_venue_id','submissions'):
+            if type(edition.get(key)) is not int or edition[key] <= 0:
+                raise ValueError('Repair plan IDs/counts must be positive integers')
+
+
+def apply_plan(c, expected):
+    validate_plan(expected)
+    actual = inspect(c)
+    if actual['content_fingerprints'] != expected['content_fingerprints'] or actual['target_aliases'] != expected['target_aliases']:
+        raise ValueError('Stale repair plan: protected content or aliases changed')
+    if len(expected['editions']) != 2:
+        raise ValueError('Exactly two editions required')
+    for old, now in zip(expected['editions'], actual['editions']):
+        if set(old) != set(now):
+            raise ValueError('Unexpected edition fields')
+        for key in ('id','year','track','target_venue_id','submissions','evidence_url','proceedings_key'):
+            if old[key] != now[key]:
+                raise ValueError('Stale repair plan: edition differs')
+        if now['from_venue_id'] != old['from_venue_id'] and now['from_venue_id'] != now['target_venue_id']:
+            raise ValueError('Edition membership differs from plan')
+    if actual['status'] == 'already_joint':
+        return {**actual, 'status':'already_joint', 'updated_editions':0}
+    for edition in actual['editions']:
+        if edition['from_venue_id'] == edition['target_venue_id']:
+            continue
+        changed = c.execute('''UPDATE editions SET venue_id=? WHERE id=? AND venue_id=? AND year=? AND track=?''',
+                            (edition['target_venue_id'],edition['id'],edition['from_venue_id'],edition['year'],edition['track']))
+        if changed.rowcount != 1:
+            raise ValueError('Concurrent edition change; entire repair must roll back')
+    after = inspect(c)
+    if after['status'] != 'already_joint' or after['content_fingerprints'] != actual['content_fingerprints']:
+        raise ValueError('Postcheck changed protected content; entire repair must roll back')
+    c.execute('INSERT INTO schema_migrations(name) VALUES(?) ON CONFLICT DO NOTHING', (MARKER,))
+    return {**after, 'status':'applied', 'updated_editions':sum(e['from_venue_id'] != e['target_venue_id'] for e in actual['editions'])}
+
+
+def database_identity(c, db):
+    if getattr(c, 'postgres', False):
+        row = c.execute('SELECT current_database(),current_schema()').fetchone()
+        return {'engine':'postgresql','database':row[0],'schema':row[1]}
+    return {'engine':'sqlite','path':str(Path(db).resolve())}
+
+
+def run(db, out, *, pg_service=None, pg_schema=None, plan=None, plan_sha256=None):
+    out = Path(out).resolve()
+    if not out.parent.is_dir():
+        raise ValueError('Report parent directory must already exist')
+    if out.exists():
+        raise ValueError('Preserve existing evidence report; choose a new output path')
+    expected = None
+    if plan:
+        raw = Path(plan).read_bytes()
+        if hashlib.sha256(raw).hexdigest() != plan_sha256:
+            raise ValueError('Repair plan hash differs before opening database')
+        expected = json.loads(raw)
+        validate_plan(expected)
+    elif plan_sha256:
+        raise ValueError('Plan hash requires an existing plan')
+    if db and out == Path(db).resolve():
+        raise ValueError('Report must not overwrite database')
+    writer = open_store(db, pg_service=pg_service, pg_schema=pg_schema) if expected is not None else None
+    c = writer.conn if writer else open_read_connection(db, pg_service=pg_service, pg_schema=pg_schema)
+    with closing(c):
+        try:
+            if expected is not None and not getattr(c, 'postgres', False):
+                c.commit(); c.execute('BEGIN IMMEDIATE')
+            identity = database_identity(c, db)
+            if expected is not None and expected['database'] != identity:
+                raise ValueError('Plan belongs to another database/schema')
+            report = apply_plan(c, expected) if expected is not None else inspect(c)
+            report['database'] = identity
+            if expected is not None:
+                report['plan_sha256'] = plan_sha256
+            if expected is not None:
+                c.commit()
+        except BaseException:
+            if expected is not None: c.rollback()
+            raise
+    out.write_text(json.dumps(report,ensure_ascii=False,indent=2)+'\n')
+    print(json.dumps({'status':report['status'],'editions':len(report['editions']),
+                      'updated_editions':report.get('updated_editions',0),'report':str(out)}))
+    return report
+
+
+def main(argv=None, *, prog=None):
+    parser = argparse.ArgumentParser(prog=prog); database_arguments(parser)
+    parser.add_argument('--out', required=True)
+    parser.add_argument('--plan', help='Apply an already reviewed plan; omitted means read-only preflight')
+    parser.add_argument('--plan-sha256', help='Required exact plan SHA256 when applying')
+    args = parser.parse_args(argv)
+    run(args.db,args.out,pg_service=args.pg_service,pg_schema=args.pg_schema,plan=args.plan,plan_sha256=args.plan_sha256)
@@ -42,9 +42,23 @@ def source_record_count(c, source, edition):


 def require_incremental_parent(c, source, manifest, options):
-    edition = c.execute('''SELECT e.id FROM editions e JOIN venues v ON v.id=e.venue_id
-        WHERE lower(v.acronym)=lower(?) AND e.year=? AND e.track=?''',
-        (manifest['venue'], manifest['year'], manifest['track'])).fetchone()
+    from paper_atlas.db.events import has_event_key, validate_event_key
+    key = validate_event_key(manifest.get('event_key'))
+    enabled = has_event_key(c)
+    if key and not enabled:
+        raise ValueError('Event identity migration required for incremental coverage')
+    field = 'e.event_key' if enabled else "''"
+    rows = c.execute('SELECT e.id,'+field+""" FROM editions e JOIN venues v ON v.id=e.venue_id
+        WHERE lower(v.acronym)=lower(?) AND e.year=? AND e.track=?""",
+        (manifest['venue'], manifest['year'], manifest['track'])).fetchall()
+    if key is None:
+        if len(rows) > 1 or any(r[1] for r in rows) or (manifest['venue'] == 'WWW' and manifest['year'] in (1994,1995)):
+            raise ValueError('Explicit manifest event_key required for incremental coverage')
+    else:
+        rows = [r for r in rows if r[1] == key]
+    if len(rows) > 1:
+        raise ValueError('Ambiguous incremental coverage event')
+    edition = rows[0] if rows else None
    entries = c.execute('''SELECT list_url,status,expected_count,imported_count
        FROM edition_sources WHERE edition_id=? AND source_id=?''',
        (edition[0], source)).fetchall() if edition else []
@@ -94,9 +108,11 @@ def ingest_file(db,path, *, pg_service=None, pg_schema=None):
                row = json.loads(line)
                if row['source'] != source_name:
                    raise ValueError('Source differs from manifest')
-                if any(key in manifest and manifest[key]!=row[key] for key in ('venue','year','track')):
+                if any(key in manifest and manifest[key]!=row.get(key) for key in ('venue','year','track','event_key')):
                    raise ValueError('Conference edition differs from manifest')
                require_track_record(row, manifest)
+                from paper_atlas.db.events import validate_event_key
+                validate_event_key(row.get('event_key'))
                external = row['external_id']
                if external in seen:
                    raise ValueError('Duplicate external ID in one collected file: '+external)
@@ -117,7 +133,13 @@ def ingest_file(db,path, *, pg_service=None, pg_schema=None):
                        status=event['status']
                        if events and status is None:raise ValueError('Explicit decision event requires a status')
                        if status is not None and status not in ('accepted','rejected','desk_rejected','withdrawn','under_review','unknown'):raise ValueError('Unsupported decision event')
-                        edition=store.decision(paper,record,row['venue'],row['year'],row['track'],external,event.get('evidence_url',row['url']),status,event.get('raw_value',''),row.get('venue_aliases'),identities=identities,observed_at=event.get('observed_at') or row_observed,decision_date=event.get('decision_date'),source_decision_id=event.get('source_decision_id',''),submitted_at=row.get('submitted_at'),guard_status=source_name in (PUBLIC_SOURCE,ARCHIVE_SOURCE))
+                        edition=store.decision(paper,record,row['venue'],row['year'],row['track'],external,event.get('evidence_url',row['url']),status,event.get('raw_value',''),row.get('venue_aliases'),identities=identities,observed_at=event.get('observed_at') or row_observed,decision_date=event.get('decision_date'),source_decision_id=event.get('source_decision_id',''),submitted_at=row.get('submitted_at'),guard_status=source_name in (PUBLIC_SOURCE,ARCHIVE_SOURCE),event_key=row.get('event_key'))
+                    from paper_atlas.db.edition_scopes import KEY
+                    scope_metadata=json.loads(c.execute('SELECT metadata_json FROM source_records WHERE id=?',(record,)).fetchone()[0])
+                    if scope_metadata.get(KEY):
+                        actual_track=c.execute('SELECT track FROM editions WHERE id=?',(edition,)).fetchone()[0]
+                        if row['track']!=actual_track:
+                            raise ValueError('Recollect this whole-volume source with reviewed per-record tracks before refresh')
                    editions.add(edition)
                else:
                    raise ValueError('This importer requires an explicit supported decision status')
@@ -143,7 +143,7 @@ def migrate(db, service, out, *, schema='research', storage_path=None, min_free_
    free_space(storage_path, min_free_gib)
    control = schema + '_migration'
    report = {'status': 'preflight', 'source': str(db), 'service': service, 'schema': schema,
-              'started_at': timestamp(), 'tables': {}, 'scope': 'All 21 business tables; FTS5 internals rebuilt as native PostgreSQL GIN.'}
+              'started_at': timestamp(), 'tables': {}, 'scope': 'All baseline business tables and recognized installed extensions; FTS5 rebuilt as native PostgreSQL GIN.'}
    with Path(str(db) + '.maintenance.lock').open('a') as lock:
        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
        if Path(str(db) + '-wal').exists() and Path(str(db) + '-wal').stat().st_size:
@@ -240,7 +240,7 @@ def migrate(db, service, out, *, schema='research', storage_path=None, min_free_
                    JOIN pg_am am ON am.oid=ix.relam WHERE ns.nspname=%s AND ix.relname='papers_search_gin' ''', (stage,)).fetchone()
                if search != ('gin', True, True, 'papers'):
                    raise ValueError('Native full-text index is not valid and ready')
-                for table in TABLES:
+                for table in plan:
                    pg.execute('ANALYZE ' + qualify(stage, table))
                invalid = pg.execute('''SELECT count(*) FROM pg_constraint co JOIN pg_class cl ON cl.oid=co.conrelid
                    JOIN pg_namespace ns ON ns.oid=cl.relnamespace WHERE ns.nspname=%s AND NOT co.convalidated''', (stage,)).fetchone()[0]
@@ -8,7 +8,9 @@ TABLES = ('sources', 'papers', 'identifiers', 'source_records', 'venues', 'editi
          'submission_sources', 'submission_identifiers', 'decision_sources',
          'submission_merges', 'decision_merges', 'schema_migrations', 'tags',
          'paper_tags', 'match_candidates', 'paper_merges', 'ingest_runs')
+OPTIONAL_TABLES = ('annotation_events',)
 CHECKS = {
+    'annotation_events': ["kind IN ('tag','research_type')", 'retracts_id IS NULL OR retracts_id<>id'],
    'venues': ["venue_type IN ('conference','journal','review_platform')"],
    'edition_sources': ["status IN ('pending','running','complete','partial','blocked','unavailable','not_yet_published')"],
    'decisions': ["status IN ('accepted','rejected','desk_rejected','withdrawn','under_review','unknown')"],
@@ -50,10 +52,10 @@ def quote(name):
 def inspect(connection):
    business = {name for schema, name, kind, *_ in connection.execute('PRAGMA table_list')
                if schema == 'main' and kind == 'table' and not name.startswith('sqlite_')}
-    if business != set(TABLES):
+    if not set(TABLES) <= business or business - set(TABLES) - set(OPTIONAL_TABLES):
        raise ValueError('Unexpected business tables: ' + repr(sorted(business ^ set(TABLES))))
    result = {}
-    for table in TABLES:
+    for table in (*TABLES, *(name for name in OPTIONAL_TABLES if name in business)):
        columns = [{'name': r[1], 'type': r[2].upper(), 'notnull': bool(r[3]),
                    'default': r[4], 'pk': r[5]}
                   for r in connection.execute('PRAGMA table_info(' + quote(table) + ')')]
@@ -85,3 +85,5 @@ class WriteConnection:
 class PostgresStore(Store):
    def __init__(self, service, schema=None):
        self.conn = WriteConnection(service, schema)
+        from paper_atlas.db.events import has_event_key
+        self.event_identity = has_event_key(self.conn)
@@ -14,7 +14,9 @@ ACCEPTED_PAPERS = "SELECT s.paper_id FROM submissions s JOIN decisions d ON d.su


 def known_acceptances(conn,paper):
-    return [dict(row) for row in conn.execute('''SELECT s.id AS submission_id,v.acronym AS venue,e.year,e.track,
+    from paper_atlas.db.events import has_event_key
+    event = 'e.event_key' if has_event_key(conn) else "''"
+    return [dict(row) for row in conn.execute('''SELECT s.id AS submission_id,v.acronym AS venue,e.year,e.track,'''+event+''' AS event_key,
        d.id AS decision_id,d.decision_date,d.observed_at,d.evidence_url
        FROM submissions s JOIN editions e ON e.id=s.edition_id JOIN venues v ON v.id=e.venue_id
        JOIN decisions d ON d.submission_id=s.id WHERE s.paper_id=? AND d.status='accepted' AND '''+LATEST_DECISION+
@@ -29,10 +31,13 @@ def main(argv=None, *, prog=None):
    parser.add_argument('--pg-schema', help='Optional PostgreSQL schema override; otherwise use the configured search_path')
    parser.add_argument('--query', help='Title/abstract search: FTS5 for SQLite, web-search syntax for PostgreSQL')
    parser.add_argument('--paper',type=int,help='Paper ID; include sources, tags and submission history')
+    parser.add_argument('--research-type', help='Independent type filter as namespace=value; no type inferred from track')
+    parser.add_argument('--annotation-history', action='store_true', help='Include retraction evidence for --paper')
    parser.add_argument('--tag', help='Filter as namespace=value, e.g. arxiv:category=cs.AI')
    parser.add_argument('--venue', help='Conference acronym')
    parser.add_argument('--year', type=int)
    parser.add_argument('--track',help='Exact track, e.g. main, findings, workshop')
+    parser.add_argument('--event-key',help='Exact event within a venue/year/track')
    parser.add_argument('--status', choices=['accepted','rejected','desk_rejected','withdrawn','under_review','unknown'])
    parser.add_argument('--outcome',choices=['accepted','no_known_acceptance'],help='跨会议的已知录用情况；未查到录用不等于从未录用')
    parser.add_argument('--limit', type=int, default=20)
@@ -47,6 +52,13 @@ def main(argv=None, *, prog=None):
        conn = sqlite3.connect(Path(args.db).resolve().as_uri()+'?mode=ro', uri=True)
        conn.row_factory = sqlite3.Row
        conn.execute('BEGIN')  # One consistent read snapshot while ingestion continues.
+    from paper_atlas.db.events import has_event_key
+    event = 'e.event_key' if has_event_key(conn) else "''"
+    if args.event_key is not None and event == "''":
+        conn.close()
+        raise ValueError('Event identity migration required for event-key queries')
+    from paper_atlas.curation.annotations import available, observations, ACTIVE
+    has_annotations = available(conn)
    if args.stats:
        result = {name:conn.execute('SELECT count(*) FROM '+name).fetchone()[0] for name in ('papers','source_records','submissions','decisions','tags','match_candidates')}
        result['records_by_source'] = [dict(r) for r in conn.execute('SELECT s.name,count(r.id) AS imported_records FROM sources s LEFT JOIN source_records r ON r.source_id=s.id GROUP BY s.id ORDER BY s.name')]
@@ -69,17 +81,35 @@ def main(argv=None, *, prog=None):
                where.append('p.id IN (SELECT rowid FROM papers_fts WHERE papers_fts MATCH ?)')
            params.append(args.query)
        if args.tag:
+            if '=' not in args.tag:
+                parser.error('--tag requires namespace=value')
            namespace,value = args.tag.split('=',1)
-            where.append('EXISTS(SELECT 1 FROM paper_tags pt JOIN tags t ON t.id=pt.tag_id WHERE pt.paper_id=p.id AND t.namespace=? AND t.value=?)'); params.extend([namespace,value])
+            platform = 'EXISTS(SELECT 1 FROM paper_tags pt JOIN tags t ON t.id=pt.tag_id WHERE pt.paper_id=p.id AND t.namespace=? AND t.value=?)'
+            params.extend([namespace,value])
+            if has_annotations:
+                platform = '(' + platform + ' OR EXISTS(SELECT 1 FROM annotation_events a WHERE a.paper_id=p.id AND a.kind=\'tag\' AND a.namespace=? AND a.value=? AND ' + ACTIVE + '))'
+                params.extend([namespace,value])
+            where.append(platform)
+        if args.research_type:
+            if '=' not in args.research_type:
+                parser.error('--research-type requires namespace=value')
+            namespace,value = args.research_type.split('=',1)
+            if has_annotations:
+                where.append('EXISTS(SELECT 1 FROM annotation_events a WHERE a.paper_id=p.id AND a.kind=\'research_type\' AND a.namespace=? AND a.value=? AND ' + ACTIVE + ')')
+                params.extend([namespace,value])
+            else:
+                where.append('1=0')
        if args.outcome:
            where.append('p.id '+('IN' if args.outcome=='accepted' else 'NOT IN')+' ('+ACCEPTED_PAPERS+')')
-        if args.venue or args.year or args.status or args.track:
+        if args.venue or args.year or args.status or args.track or args.event_key is not None:
            clause = ['1=1']
            if args.venue:
                if conn.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='venue_aliases'").fetchone():
                    clause.append('(lower(v.acronym)=lower(?) OR EXISTS(SELECT 1 FROM venue_aliases va WHERE va.venue_id=v.id AND lower(va.alias)=lower(?)))'); params.extend([args.venue,args.venue])
                else:
                    clause.append('lower(v.acronym)=lower(?)');params.append(args.venue)
+            if args.event_key is not None:
+                clause.append('e.event_key=?');params.append(args.event_key)
            if args.track:
                clause.append('e.track=?');params.append(args.track)
            if args.year:
@@ -98,10 +128,14 @@ def main(argv=None, *, prog=None):
            paper['known_acceptances']=known_acceptances(conn,row['id'])
            paper['publication_outcome']='accepted' if paper['known_acceptances'] else 'no_known_acceptance'
            if args.paper is not None:
+                paper['research_types'] = observations(conn, row['id'], kind='research_type')
+                paper['annotation_tags'] = observations(conn, row['id'], kind='tag')
+                if args.annotation_history:
+                    paper['annotation_history'] = observations(conn, row['id'], history=True)
                paper['tags'] = [dict(r) for r in conn.execute('SELECT t.namespace,t.value,pt.evidence_key FROM paper_tags pt JOIN tags t ON t.id=pt.tag_id WHERE pt.paper_id=?',(row['id'],))]
                paper['sources'] = [dict(r) for r in conn.execute('SELECT s.name,r.external_id,r.url,r.title,r.abstract,r.retrieved_at FROM source_records r JOIN sources s ON s.id=r.source_id WHERE r.paper_id=?',(row['id'],))]
                submissions = []
-                for sub in conn.execute('SELECT s.id,s.source_submission_id,s.submitted_at,v.acronym,e.year,e.track FROM submissions s JOIN editions e ON e.id=s.edition_id JOIN venues v ON v.id=e.venue_id WHERE s.paper_id=? ORDER BY e.year,s.id',(row['id'],)):
+                for sub in conn.execute('SELECT s.id,s.source_submission_id,s.submitted_at,v.acronym,e.year,e.track,'+event+' AS event_key FROM submissions s JOIN editions e ON e.id=s.edition_id JOIN venues v ON v.id=e.venue_id WHERE s.paper_id=? ORDER BY e.year,s.id',(row['id'],)):
                    submission = dict(sub)
                    submission['decisions'] = []
                    for d in conn.execute('SELECT id,status,raw_value,evidence_url,observed_at,decision_date FROM decisions WHERE submission_id=? ORDER BY observed_at,COALESCE(decision_date,observed_at),id',(sub['id'],)):
@@ -21,5 +21,5 @@ include = ["paper_atlas*"]
 exclude = ["tests*"]

 [tool.setuptools.package-data]
-"paper_atlas.db" = ["schema.sql"]
+"paper_atlas.db" = ["schema.sql", "annotations.sql"]
 "paper_atlas.resources" = ["venues.json"]
@@ -0,0 +1,54 @@
+<HTML><HEAD><TITLE>AAMAS 2025: Proceedings of the 2025 International Conference on Autonomous Agents and Multiagent Systems</TITLE>
+<META http-equiv=Content-Type content="text/html; charset=utf-8"><LINK 
+href="forms/index_files/factemplate.css" type=text/css rel=stylesheet>
+<META content="MSHTML 6.00.2900.3562" name=GENERATOR></HEAD>
+<BODY bgcolor="#010101" bgproperties="fixed"><DIV style="TEXT-ALIGN: center" >
+<table width="724" border="0" align="center" cellpadding="0" cellspacing="0" valign="top">
+  <td colspan="2" align="center" valign="top" bgcolor="#FFFFFF"><img src="forms/index_files/aamas25.png" width="750" height="300" alt=""/></td>
+  </tr>
+  <tr bgcolor="#FFFFFF"> 
+    <td width="125" align="center" valign="top" bgcolor="#FFFFFF"><table width="125" border="1" align="center" cellpadding="1" cellspacing="1" bordercolor="#444444" style="margin-bottom: 2">
+        <tr> 
+          <td bgcolor="#FFFFFF"><p style="text-indent: 0; margin-left: 6; margin-right: 6; margin-top: 5; margin-bottom: 4" align="left"><A href="forms/index.htm">Main 
+              Page</A></p></td>
+        </tr>
+        <tr> 
+          <td bgcolor="#FFFFFF"><p style="text-indent: 0; margin-left: 6; margin-right: 6; margin-top: 5; margin-bottom: 4" align="left"><A href="forms/contents.htm">Table 
+              of Contents</A></p></td>
+        </tr>
+      </table></td>
+    <td width="599"><p style="text-indent: 0; margin-left: 12; margin-right: 14; margin-top: 12; margin-bottom: 12" align="left"><font color="#010101" size="4" face="Arial, Helvetica, sans-serif"><strong>Welcome 
+        to the Proceedings of AAMAS-2025</strong></font></p>
+      <p style="text-indent: 0; margin-left: 12; margin-right: 14; margin-top: 12; margin-bottom: 12;" align="left"><font color="#333333" size="2" face="Times New Roman, Times, serif">These 
+        are the proceedings of the 24th International Conference on Autonomous 
+        Agents and Multiagent Systems (AAMAS-2025). They are published by the 
+        International Foundation for Autonomous Agents and Multiagent Systems 
+    (IFAAMAS).</font></p></td>
+  </tr>
+  <tr bgcolor="#FFFFFF"> 
+    <td align="center" valign="middle" bgcolor="#FFFFFF">&nbsp;</td>
+    <td><table width="96%" border="0" cellspacing="2" cellpadding="2">
+        <tr align="left" valign="top"> 
+          <td> <p style="text-indent: 0; margin-left: 12; margin-right: 6; margin-top: 0; margin-bottom: 6;" align="left"><font color="#333333" face="Times New Roman, Times, serif"><font size="2"><strong>ISBN: 979-8-4007-1426-9</strong></font></font></p></td>
+          <td> <p style="text-indent: 0; margin-left: 12; margin-right: 6; margin-top: 0; margin-bottom: 6;" align="left"><font color="#333333" face="Times New Roman, Times, serif"></font></p></td>
+        </tr>
+        <tr> 
+          <td width="42%"><div align="left"><img src="forms/index_files/ifaamas.jpg" width="256" height="104"></div></td>
+          <td width="58%"><div align="center"><img src="forms/index_files/ACM-In-Cooperation_medium.jpg" width="285" height="86"></div></td>
+        </tr>
+      </table>
+      <p style="text-indent: 0; margin-left: 12; margin-right: 14; margin-top: 12; margin-bottom: 12;" align="left"><font color="#333333" size="2" face="Times New Roman, Times, serif">Copyright 
+        &copy; 2025 by International Foundation for Autonomous Agents and Multiagent 
+        Systems (IFAAMAS). Permission to make digital or hard copies of portions 
+        of this work for personal or classroom use is granted without fee provided 
+        that copies are not made or distributed for profit or commercial advantage 
+        and that copies bear this notice and the full citation on the first page. 
+        Copyright for components of this work owned by others than IFAAMAS must 
+        be honored. Abstracting with credit is permitted. To copy otherwise, to 
+        republish, to post on servers or to redistribute to lists, requires prior 
+    specific permission and/or a fee. </font></p></td>
+  </tr>
+</table>
+  <p>&nbsp;</p>
+
+</BODY></HTML>
@@ -0,0 +1,38 @@
+{
+  "status": "two_successful_official_metadata_pages_recovered_third403_not_retried",
+  "receipts": [
+    {
+      "file": "index.html",
+      "url": "https://www.ifaamas.org/Proceedings/aamas2025/",
+      "bytes": 4107,
+      "sha256": "850b7825c66d0147ac8a8bbf03a554590e4a9e8f4b5c576e043999bbd43317f4",
+      "at": "2026-11-09T12:31:49.347577+00:00",
+      "at_precision": "filesystem_write_time_recovered",
+      "http_status": 200,
+      "content_type": "text/html",
+      "receipt_recovered": true,
+      "scope": "Collectorasserted200/htmlbeforewrite;request3acceptedprogram403;noheaders/finalredirectURLpersisted;no refetch or rawbytesmutation."
+    },
+    {
+      "file": "contents.html",
+      "url": "https://www.ifaamas.org/Proceedings/aamas2025/forms/contents.htm",
+      "bytes": 370650,
+      "sha256": "732847b51972f34c721a49d8bd963a80a029a48f3ec08022c9a0d5ddc2945549",
+      "at": "2026-11-09T12:31:52.006642+00:00",
+      "at_precision": "filesystem_write_time_recovered",
+      "http_status": 200,
+      "content_type": "text/html",
+      "receipt_recovered": true,
+      "scope": "Collectorasserted200/htmlbeforewrite;request3acceptedprogram403;noheaders/finalredirectURLpersisted;no refetch or rawbytesmutation."
+    }
+  ],
+  "failed_url": "https://aamas2025.org/index.php/conference/program/accepted-papers/",
+  "not_attempted_url": "https://aamas2025.org/index.php/conference/calls/submission-instructions-main-technical-track/",
+  "original_error": {
+    "error": "HTTP Error 403: Forbidden",
+    "type": "HTTPError",
+    "downloaded": 2
+  },
+  "research_fulltext_downloaded": false,
+  "database_written": false
+}
@@ -0,0 +1,263 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<collection id="1963.earlymt">
+  <volume id="1" ingest-date="2021-11-14" type="proceedings">
+    <!-- https://aclanthology.org/1963.earlymt-1/ -->
+    <meta>
+      <booktitle>Proceedings of the Annual meeting of the Association for Machine Translation and Computational Linguistics</booktitle>
+      <address>Denver, Colorado</address>
+      <month>25-26 August</month>
+      <year>1963</year>
+      <pdf hash="2ff28cb1"/>
+      <venue>earlymt</venue>
+    </meta>
+    <paper id="1">
+      <!-- https://aclanthology.org/1963.earlymt-1.1/ -->
+      <title>Necessity of introducing some information provided by transformational analysis into <fixed-case>MT</fixed-case> algorithms</title>
+      <author><first>Irena</first><last>Bellert</last></author>
+      <abstract>A few examples of ambiguous English constructions and their Polish equivalents are discussed in terms of the correlation between their respective phrase-marker representations and transformational analyses. It is shown by these examples that such an investigation can reveal interesting facts for MT, and therefore should be carried out for any pair of languages for which a given MT program is being constructed. If the phrase-marker of the English construction is set into one-to-one correspondence with the phrasemarker of the Polish equivalent construction, whatever particular transformational analysis of this construction is to be taken into account, then the ambiguous phrasemarker representation can be used as a syntactical model for MT algorithms with good results. If the phrase-marker of the English construction is set into one-to-many correspondence with the phrasemarkers of the Polish equivalents, according to the transformational analyses of this construction, then the ambiguous phrase-structure representation has to be resolved in terms of transformational analysis, for only then is it possible to assign the corresponding phrase structure representation to the Polish equivalents. A tentative scheme of syntactical recognition is provided for the multiply ambiguous adjectival construction in English1 (which proved to belong to the latter case) by means of introducing some information obtained from the transformational analysis of this construction.</abstract>
+      <bibkey>bellert-1963-necessity</bibkey>
+    </paper>
+    <paper id="2">
+      <!-- https://aclanthology.org/1963.earlymt-1.2/ -->
+      <title>The use of a random access device for dictionary lookup</title>
+      <author><first>Robert S.</first><last>Betz</last></author>
+      <author><first>Walter</first><last>Hoffman</last></author>
+      <abstract>The purpose of this paper will be to present a scheme to locate for single textual items and idioms in textual order their corresponding dictionary entries stored in an IBM 1301 random access mechanism. Textual items are considered to be 24 characters in length (left justified with following blanks). A dictionary entry consists of a 24 character Russian form, grammar information for the form and a set of translations for that form. Dictionary entries are packed into sequential tracks of the 1301. This paper will cover the method used for dictionary storage. The lookup for a textual item I first consists of a search for the first track that the dictionary entry E (if one exists) for I could be stored in. Once a track has been determined its contents are searched in core by a bisection convergence technique to find E. If E cannot be found, a “no entry” indication is made. If E is found a further search is made of the dictionary to find the longest sequence of text, starting with the first item I, that has a dictionary entry. The last such entry found is picked up. Included in the presentation will be examples of the dictionary lookup output for actual text.</abstract>
+      <bibkey>betz-hoffman-1963-use</bibkey>
+    </paper>
+    <paper id="3">
+      <!-- https://aclanthology.org/1963.earlymt-1.3/ -->
+      <title>Generative processes for <fixed-case>R</fixed-case>ussian impersonal sentences</title>
+      <author><first>C. G.</first><last>Borkowski</last></author>
+      <author><first>L. R.</first><last>Micklesen</last></author>
+      <abstract>Impersonal sentences of Russian are those traditionally construed to consist of predicates only. Ever since the first Russian grammar was compiled, they have continued to pose a problem for grammarians. This paper is intended to be a review and evaluation of all types of the so-called impersonal sentences in the Russian language. The investigation of these sentences has been conducted in terms of their relationships to basic (kernel) sentences. Our paper attempts to define the origin for such impersonal sentences, i.e., how such sentences might be derived within the framework of a generative grammar from a set of rules possessing maximal simplicity and maximal generative power. The long-range aim of this investigation involves the most efficient manipulation of such sentences in a recognition device for Russian-English MT.</abstract>
+      <bibkey>borkowski-micklesen-1963-generative</bibkey>
+    </paper>
+    <paper id="4">
+      <!-- https://aclanthology.org/1963.earlymt-1.4/ -->
+      <title>Concerning the role of sub-grammars in machine translation</title>
+      <author><first>Joyce M.</first><last>Brady</last></author>
+      <author><first>William B.</first><last>Estes</last></author>
+      <abstract>The comprehensive grammars being developed at the Linguistics Research Center of the University of Texas will be too large for easy access and manipulation in either experimental programs or practical translation. It is necessary, therefore, to devise some reliable method for selecting subsets of the grammar rules which will be reasonably adequate for a given purpose. Since the majority of the rules are dictionary rules, this problem is closely related both to the problem of constructing microglossaries and to the subsequent problem of choosing a particular microglossary suitable to a given text. Our current approach to this problem entails the construction of key word lists in the first stage of analysis which guide the computer in its choice of a previously constructed microglossary. Work to date indicates adaptations of this technique may not only contribute to the solution of storage and access problems but also facilitate analysis and simplify problems of semantic resolution.</abstract>
+      <bibkey>brady-estes-1963-concerning</bibkey>
+    </paper>
+    <paper id="5">
+      <!-- https://aclanthology.org/1963.earlymt-1.5/ -->
+      <title>Word-meaning and sentence-meaning</title>
+      <author><first>Elinor K.</first><last>Charney</last></author>
+      <abstract>A theory of semantics is presented which (1) defines the meanings of the most frequently occurring semantic morphemes (‘all’, ‘unless’, ‘only’, ‘if’, ‘not’, etc.), (2) explains their role, as semantically interdependent structural-constants, in giving rise to sentence-meanings, (3) suggests a possible approach to a sentenceby-sentence recognition program, and (4) offers a feasible method of coordinating among different language systems synonymous sentences whose grammatical features and structural-constants do not bear a one-to-one correspondence to one another. The theory applies only to morphemes that function as structural-constants and their interlocking relationships, denotative terms being treated as variables whose ranges alone have structural significance in sentencemeaning. The basic views underlying the theory are: In any given sentence, it is the particular configuration of structural-constants in combination with specific grammatical features which produces the sentencemeaning; the defined meaning of each individual structural-constant remains constant. The word-meanings of this type of morpheme, thus, must be carefully distinguished from the sentence-meanings that configuration of these morphemes produce. Sentence-synonymy is not based upon word-synonymy alone. Contrary to the popular view that the meanings of all of the individual words must be known before the sentencemeaning can be known, it is shown that one must comprehend the total configuration of structural-constants and syntactical features in a sentence in order to comprehend the correct sentence-meaning and that this understanding of the sentence as a whole must precede the determination of the correct semantic interpretation of these critical morphemes. In fact, the structural features that produce the sentence-meanings may restrict the possible meanings of even the denotative terms since a structural feature may demand, for example, a verbal rather than a noun phrase as an indispensable feature of the configuration. Two or more synonymous sentences whose denotative terms are everywhere the same but whose structural configurations are not isomorphic express the same fundamental sentence-meaning. The fundamental sentence-meanings can be explicitly formulated, and serve as the mapping functions to co-ordinate morphemically-unlike synonymous sentences within a language system or from one system to another. The research goal of the author is to establish empirically these translation rules that state formally the structural characteristics of the sentence configurations whose sentence-meanings, as wholes, are related as synonymous.</abstract>
+      <bibkey>charney-1963-word</bibkey>
+    </paper>
+    <paper id="6">
+      <!-- https://aclanthology.org/1963.earlymt-1.6/ -->
+      <title>Translating ordinary language into symbolic logic</title>
+      <author><first>Jared L.</first><last>Darlington</last></author>
+      <abstract>The paper describes a computer program, written in COMIT, for translating ordinary English into the notation of propositional logic and first-order functional logic. The program is designed to provide an ordinary language input to a COMIT program for the David-Putnam proof-procedure algorithm. The entire set of operations which are performed on an input sentence or argument are divided into three stages. In Stage I, an input sentence ‘S’, such as “The composer who wrote ‘Alcina’ wrote some operas in English,” is rewritten in a quasi-logical notation, “The X/A such that X/A is a composer and X/A wrote Alcina wrote some X/B such that X/B is an opera and X/B is in English.” The quasi-logical notation serves as an intermediate language between logic and ordinary English. In Stage II, S is translated into the logical notation of propositional functions and quantifiers, or of propositional logic, whichever is appropriate. In Stage III, S is run through the proof-procedure program and evaluated. (The sample sentence quoted is of course ‘invalid’, i.e. nontautological.) The COMIT program for Stage III is complete, that for Stage II is almost complete, and that for Stage I is incomplete. The paper describes the work done to date on the programs for Stages I and II.</abstract>
+      <bibkey>darlington-1963-translating</bibkey>
+    </paper>
+    <paper id="7">
+      <!-- https://aclanthology.org/1963.earlymt-1.7/ -->
+      <title>The graphic structure of word-breaking</title>
+      <author><first>J. L.</first><last>Dolby</last></author>
+      <author><first>H. L.</first><last>Resnikoff</last></author>
+      <abstract>In a recent paper1 the authors have shown that it is possible to determine the possible parts of speech of English words from an analysis of the written form. This determination depends upon the ability to determine the number of graphic syllables in the word. It is natural, then, to speculate as to the nature of graphic syllabification and the relation of this phenomenon to the practice of word-breaking in dictionaries and style manuals. It is not at all clear at the start that dictionary wordbreaking is subject to any fixed structure. In fact, certain forms cannot be broken uniquely in isolation since the dictionary provides different forms depending upon whether the word is used as a noun or a verb. However, it is shown in this paper that letter strings can be decomposed into 3 sets of roughly the same size in the following manner: in the first, strings are never broken in English words; in the second, the strings are always broken in English words; and in the third, both situations occur. Rules for breaking vowel strings are obtained by a study of the CVC forms. Breaks involving consonants can be determined by noting whether or not the consonant string occurs in penultimate position with the final c. The final e in compounds also serves to identify the forms that are generally split off from the rest of the word. A thorough analysis is made of the accuracy of the rules given when applied to the 12,000 words of the Government Printing Office Style Manual Supplement on word-breaking. Comparisons are also drawn between this source and several American dictionaries on the basis of a random sample of 500 words.</abstract>
+      <bibkey>dolby-resnikoff-1963-graphic</bibkey>
+    </paper>
+    <paper id="8">
+      <!-- https://aclanthology.org/1963.earlymt-1.8/ -->
+      <title>Writing of <fixed-case>C</fixed-case>hinese recognition grammar for machine translation</title>
+      <author><first>Ching-yi</first><last>Dougherty</last></author>
+      <abstract>Our approach to this problem is based on the stratificational grammar outlined and the procedures proposed by Dr. Sydney Lamb. How the theory and the procedures can be applied to written Chinese is briefly discussed. For the time being our research is limited to the particular kind of written Chinese found in chemical and biochemical journals. First the Chinese lexes are classified by detailed syntactical analysis, then binary grammar rules are constructed for joining two primary or constitute classes. How a more and more refined classification can eliminate one by one the ambiguity resulting from all possible constructions arising from juxtaposition of two distributional classes is discussed in detail.</abstract>
+      <bibkey>dougherty-1963-writing</bibkey>
+    </paper>
+    <paper id="9">
+      <!-- https://aclanthology.org/1963.earlymt-1.9/ -->
+      <title>The behavior of <fixed-case>E</fixed-case>nglish articles</title>
+      <author><first>H. P.</first><last>Edmundson</last></author>
+      <abstract>Machine translation has often been conceived as consisting of three steps: analysis of source-language sentence, transformation of analyzed pieces, and synthesis of target-language sentence. This paper is concerned with one aspect of the last step, namely, the rules of behavior of English articles. Since the classical definitions of definite and indefinite articles are operationally imprecise, proper mechanistic rules must be formulated in order to permit the automatic insertion or non-insertion of English articles. The rules discussed are of syntactic origin; however, note is also taken of their semantic aspects. This paper describes the methods used to derive these rules and offers ideas for further research.</abstract>
+      <bibkey>edmundson-1963-behavior</bibkey>
+    </paper>
+    <paper id="10">
+      <!-- https://aclanthology.org/1963.earlymt-1.10/ -->
+      <title>On representing syntactic structure</title>
+      <author><first>E. R.</first><last>Gammon</last></author>
+      <abstract>The idea of sentence depth of Yngve (A Model and an Hypothesis for Language Structure, Proc. Am. Phil. Soc., Vol. 104, No. 5, Oct. 1960) is extended to the notion of “distance” between constituents of a construction. The distance between constituents is defined as a weighted sum of the number of IC cuts separating them. Yngve’s depth is then a maximum distance from a sentence to any of its words. Various systems of weighting cuts are investigated. For example, in endocentric structures we may require that the distance from an attribute to the structure exceeds the distance from the head to the structure, and in exocentric structures that the distances from each constituent to the structure are equal. Representations of constructions are considered which preserve the distance between constituents. It is shown that it is impossible to represent some sentences in Euclidean space with exact distances, but a representation may be found if only relative order is preserved. If more general spaces are used then exact distances may be represented. It follows that for a wide class of sentence types, there is a weighting, and a space, in which the distance preserving representations are identical with the diagrams of traditional grammar.</abstract>
+      <bibkey>gammon-1963-representing</bibkey>
+    </paper>
+    <paper id="11">
+      <!-- https://aclanthology.org/1963.earlymt-1.11/ -->
+      <title>La traduction automatique et l’enseignement du russe</title>
+      <author><first>Yves</first><last>Gentilhomme</last></author>
+      <abstract>Les recherches effectuées depuis quelques années en vue de la Traduction Automatique ont conduit à des méthodes de travail et à des résultats intéressant la pédagogie des langues. Une expérience d’enseignement du russe a l’usage des scientifiques fondée sur ces données a été poursuivie pendant deux ans à Paris (Centre National de la Recherche Scientifique et Faculté des Sciences), et a abouti à la publication d’un manuel. Le present compte-rendu a pour objet de préciser les principes généraux utilisés, la réaction des étudiants et le rendement pédagogique obtenu. 1. Graphes morphologiques: Les mots d’une même famille. Notion de base. La double ramification. Les graphes abstraits. Les néologismes scientifiques. 2. Graphes syntaxiques: La double structure d’une phrase. Multiplicité des modèles. Point de vue psychologique. Notion de fonction. Continuité et discontinuité. 3. Les séparateurs: La segmentation d’une phrase. Le vocabulaire prioritaire. 4. Théorie de la valence: macro et microcontexte. Qu’est-ce-que “connaître un mot”? 5. Point de vue de l’étudiant; point de vue du traducteur humain; et point de vue de l’Enseignant.</abstract>
+      <bibkey>gentilhomme-1963-la</bibkey>
+    </paper>
+    <paper id="12">
+      <!-- https://aclanthology.org/1963.earlymt-1.12/ -->
+      <title>Word and context association by means of linear networks</title>
+      <author><first>Vincent E.</first><last>Giuliano</last></author>
+      <abstract>This paper is concerned with the use of electrical networks for the automatic recognition of statistical associations among words and contexts present in written text. A general mathematical theory is proposed for association by means of linear transformations, and it is shown that this theory can be realized through use of passive linear electrical networks. Several smallscale experimental associative networks have been built, and are briefly described in the paper; one such device will be demonstrated in the course of the oral presentation of the paper. Some of the devices generate measures of association among index terms used to characterize a document collection, and between the index terms and the documents themselves. Another uses syntactic proximity within sentences as a criterion for the generation of word association measures. Examples are given of associations produced by these network devices. It is conjectured that the networkproduced association measures reflect two distinct types of linguistic association—“synonymy” association which reflects similarity of meaning, and “contiguity” association which reflects real-world relationships among designata.</abstract>
+      <bibkey>giuliano-1963-word</bibkey>
+    </paper>
+    <paper id="13">
+      <!-- https://aclanthology.org/1963.earlymt-1.13/ -->
+      <title>A study of the combinatorial properties of <fixed-case>R</fixed-case>ussian nouns</title>
+      <author><first>Kenneth E.</first><last>Harper</last></author>
+      <abstract>A statistical study was made of the extent to which Russian nouns enter into certain kinds of syntactic combination. The basis of the study was a corpus of 180,000 running words of Russian physics text prepared for analysis by the Automatic Language Data Processing group at The Rand Corporation; for each sentence of text the syntactic dependency of each word had been previously coded. A data retrieval program was applied, showing for each noun in text the number of occurrences (a) with at least one genitive noun dependent, (b) with at least one adjective dependent, and (c) with either type of dependent. A listing of all nouns in text (64,026 occurrences of 2,993 nouns) was prepared, ordered by frequency, and showing counts for a, b, and c above. Separate listings were prepared, showing for each noun that occurred 50 times or more the probability P that it would be modified in each of these three ways; these listings were ordered on P. The data suggests, among others, the following conclusions: there is statistical significance in the variability with which nouns enter into the given combinations; the partial interchangeability of adjective and genitive noun modification is supported; a general correspondence exists between combinatorial groupings of nouns and morphological or semantic groupings (concrete nouns have low P for genitive complementation, abstract nouns have high P, etc); the use of words in a given field of discourse can be determined empirically (e.g., the use of deverbative nouns either to indicate a process or the result of a process). It is suggested that the distributional approach is a useful supplement to traditional syntactic and semantic classification schemes, and that it is of direct utility in automatic parsing programs.</abstract>
+      <bibkey>harper-1963-study</bibkey>
+    </paper>
+    <paper id="14">
+      <!-- https://aclanthology.org/1963.earlymt-1.14/ -->
+      <title>Connectability calculations, syntactic functions, and <fixed-case>R</fixed-case>ussian syntax</title>
+      <author><first>David G.</first><last>Hays</last></author>
+      <abstract>A program for sentence-structure determination can be divided into routines for analysis of word order and for testing the grammatical connectability of pairs of sentence members. The present paper describes a connectability-test routine that uses the technique called code matching. This technique requires elaborate descriptions of individual items, say the words or morphemes listed in a dictionary, but it avoids the use of large tables or complicated programs for testing connectability. Development of the technique also leads to a certain clarification of the linguistic concepts of function, exocentrism, and homography. In the present paper, a format for the description of Russian items is offered and a program for testing the connectability of pairs of Russian items is sketched. This system recognizes nine dominative functions: subjective; first, second, and third complementary; first, second, and third auxiliary; modifying; and predicative. The nature of a program for testing connectability with respect to coordinative functions (coordination, apposition, etc.) is suggested.</abstract>
+      <bibkey>hays-1963-connectability</bibkey>
+    </paper>
+    <paper id="15">
+      <!-- https://aclanthology.org/1963.earlymt-1.15/ -->
+      <title>Punctuation and automatic syntactic analysis</title>
+      <author><first>Lydia</first><last>Hirschberg</last></author>
+      <abstract>In this paper we discuss how algorithms for automatic analysis can take advantage of information carried by the punctuation marks. We neglect stylistic aspects of punctuation because they lack universality of usage and we restrict ourselves to those rules which any punctuation must observe in order to be intelligible. This involves a concept we call “coherence” of punctuation. In order to define “coherence”, we introduce two characteristics, which we prove to be mutually independent, namely “separating power” and “syntactic function”. The separating power is defined by three experimental laws expressing the fact that two punctuation marks of different separating power prevent to a different extent syntactic links from crossing them. These laws are defined independently of any particular grammatical character of the punctuation marks or of the attached grammatical syntagms. On the other hand, whichever grammatical system we choose, we may assimilate the punctuation marks to the ordinary words, to the extent that we can assign to them a known grammatical character and function, well defined in any particular context. They differ however from the other words by their large number of homographs and synonyms i.e. by the fact that almost every punctuation mark can occur with almost every grammatical value in each particular case, and in quite similar contexts. The syntactic functions, in general, and in particular those of the punctuation marks, can be ordered according to an arbitrary scale of decreasing “value” of syntactic links, where the “value” of a link is directly related to the number of syntactic conditions the links must satisfy. The law of coherence, then, shows that in a given context, a particular punctuation mark cannot indistinctly represent all its homographs, so that a certain number of assumptions about its syntactic nature and function can be discarded. This law can be stated as follows: “When moving from a punctuation mark to its immediate (left or right) neighbor in any text, the separating power cannot increase if the value of the syntactic function increases and vice-versa”. In addition we review two related topics, namely the stylistic character of punctuation and the necessity and existence of intrinsic criteria of grammatically, i.e. independent of punctuation. We propose such a criterion, and suggest a formalism related to the parenthesis free notation of logic.</abstract>
+      <bibkey>hirschberg-1963-punctuation</bibkey>
+    </paper>
+    <paper id="16">
+      <!-- https://aclanthology.org/1963.earlymt-1.16/ -->
+      <title>Application of decision tables to syntactic analysis</title>
+      <author><first>Walter</first><last>Hoffman</last></author>
+      <author><first>Amelia</first><last>Janiotis</last></author>
+      <author><first>Sidney</first><last>Simon</last></author>
+      <abstract>Decision tables have recently become an object of investigation as a possible means of improving problem formulation of data processing procedures. The initial emphasis for this new tool came from systems analysts who were primarily concerned with business data processing problems. The purpose of this paper is to investigate the suitability of decision tables as a means of expressing syntactic relations as an alternative to customary flow charting techniques. The history of decision tables will be briefly reviewed and several kinds of decision tables will be defined. As an example, parts of the predicative blocking routine developed at Wayne State University will be presented as formulated with the aid of decision tables. The aim of the predicative blocking routine is to group a predicative form together with its modal and temporal auxiliaries, infinitive complements, and negative particle, if any of these exist. The object of the search is to define such a syntactic block, but it may turn out instead that an infinitive phrase is defined or that a possible predicative form turns out to be an adverb.</abstract>
+      <bibkey>hoffman-etal-1963-application</bibkey>
+    </paper>
+    <paper id="17">
+      <!-- https://aclanthology.org/1963.earlymt-1.17/ -->
+      <title>Simultaneous computation of lexical and extralinguistic information measures in dialogue</title>
+      <author><first>Joseph</first><last>Jaffe</last></author>
+      <abstract>An approach to the study of information processing in verbal interaction is described. It compares patterns of two indices of dispersion in recorded dialogue. The lexical measure is the mean segmental type—token ratio, based on 25-word segments of the running conversation. It is computed from a key punched transcript of the dialogue without regard to the speaker of the words. The extralinguistic measure is the H statistic, computed from the temporal pattern of the interaction. The latter is prepared from a two-channel tape recording by a special analogue to digital converter (AVTA system) which key punches the state of the vocal transaction 200 times per minute. Probabilities of the four possible states (either A or B speaking, neither speaking, both speaking) are the basis for the computation. All analyses are done on the IBM 7090. The methodology is part of an investigation of information processing in dyadic systems, aimed toward the reclassification of pathological communication.</abstract>
+      <bibkey>jaffe-1963-simultaneous</bibkey>
+    </paper>
+    <paper id="18">
+      <!-- https://aclanthology.org/1963.earlymt-1.18/ -->
+      <title>Design of a generalized information system</title>
+      <author><first>Ronald W.</first><last>Jonas</last></author>
+      <abstract>While mechanical translation research involves the design of a computer system which simulates language processes, there is the associated problem of collecting the language data which are to be used in translation. Because large quantities of information will be needed, the computer may be useful for data accumulation and verification. A generalized information system should be able to accept the many types of data which a linguist encodes. A suitable means of communication between the linguist and the system has to be established. This may be achieved with a central input, called Linguistic Requests, and a central output, called Information Displays. The requests should be coordinated so that all possible inputs to the system are compatible, and the displays should be composed by the system such that they are clearly understandable. An information system should be interpretive of the linguist’s needs by allowing him to program the data manipulation. The key to such a scheme is that the linguist be permitted to classify his data freely and to retrieve it as he chooses. He should have at his disposal selecting, sorting, and displaying functions with which he can verify data, select data for introduction to a mechanical translation system, and perform other activities necessary in his research. Such an information system has been designed at the Linguistics Research Center of The University of Texas.</abstract>
+      <bibkey>jonas-1963-design</bibkey>
+    </paper>
+    <paper id="19">
+      <!-- https://aclanthology.org/1963.earlymt-1.19/ -->
+      <title>Some experiments performed with an automatic paraphraser</title>
+      <author><first>Sheldon</first><last>Klein</last></author>
+      <abstract>The automatic paraphrasing system used in the experiments described herein consisted of a phrase structure, grammatically correct nonsense generator coupled with a monitoring system that required the dependency relations of the sentence in production to be in harmony with those of a source text. The output sentences also appeared to be logically consistent with the content of that source. Dependency was treated as a binary relation, transitive except across most verbs and prepositions. Five experiments in paraphrasing were performed with this basic system. The first attempted to paraphrase without the operation of the dependency monitoring system, yielding grammatically correct nonsense. The second experiment included the operation of the monitoring system and yielded logically consistent paraphrases of the source text. The third and fourth experiments demanded that the monitoring system permit the production of only those sentences whose dependency relations were non-existent in the source text. While these latter outputs were seemingly nonsensical, they bore a special logical relationship to the source. The fifth experiment demanded that the monitoring system permit the production of sentences whose dependency relations were the converse of those in the source. This restriction was equivalent to turning the dependency tree of the source text upside down. The output of this experiment consisted only of kernel type sentences which, if read backwards, were logically consistent with the source. The results of these experiments determine some formal properties of dependency and engender some comments about the role of dependency in phrase structure and transformational models of language.</abstract>
+      <bibkey>klein-1963-experiments</bibkey>
+    </paper>
+    <paper id="20">
+      <!-- https://aclanthology.org/1963.earlymt-1.20/ -->
+      <title>Interlingual correspondence at the syntactic level</title>
+      <author><first>Edward S.</first><last>Klima</last></author>
+      <abstract>The paper will investigate a few major construction types in several related European languages: relative clauses, attributive phrases, and certain instances of coordinate conjunction involving these constructions. In each of the languages independently, the constructions will be described as resulting from syntactic mechanisms further analyzable into chains of partially ordered operations on more basic structures. Pairs of sentences equivalent in two languages will be examined. Sentences will be considered equivalent if they are acceptable translations of one another. The examples used will, in fact, be drawn primarily from standard translations of scholarly and literary prose. Equivalence between whole sentences can be further analyzed, as will be shown, into general equivalence 1) between the chains of operations describing the constructions and 2) between certain elements (e.g., lexical items) in the more basic underlying structures. It will be seen that superficial differences in the ultimate shape of certain translation pairs can be accounted for as the result of minor differences in the particular operations involved or in the basic underlying structure. We shall examine two languages (e.g., French and German) in which attributive phrase formation and relative clause formation on the whole correspond and in which, in a more or less abstract way, the rules of relative clause formation are included as intermediate links in the chain of operations describing attributive phrases. The fact that in particular cases a relative clause in the one language corresponds to an attributive phrase in the other will be found to result from, e.g., differences in the choice of perfect auxiliary in the two languages.</abstract>
+      <bibkey>klima-1963-interlingual</bibkey>
+    </paper>
+    <paper id="21">
+      <!-- https://aclanthology.org/1963.earlymt-1.21/ -->
+      <title>Sentence structure diagrams</title>
+      <author><first>Susumu</first><last>Kuno</last></author>
+      <abstract>A system for automatically producing a sentence structure diagram for each analysis of a given sentence has been added to the program of the multiple-path syntactic analyzer. A structure code, consisting of a series of structure symbols or phrase markers that identify the successive higher-order structures to which the word in question belongs, is assigned to each word of the sentence. The set of structure codes for the words of a given sentence is equivalent to an explicit tree diagram of the sentence structure, but more compact and easier to lay out on conventional printers. The diagramming system makes some experimental assumptions about the dependencies of certain structures upon higher-level structures. All the major syntactic components of a sentence (i.e., subject, verb, object, complement, period, or question mark) are represented in the current system as occurring on the same level, all being dependent on the topmost level, “sentence”. A floating structure such as a prepositional phrase or adverbial phrase or clause, whose dependency is not determined in the analyzer, is represented as depending upon the nearest preceding structure modifiable by such a floating structure. Different assumptions as to structural dependencies would yield different diagrams without requiring modification on the main flow of the diagramming program. The diagrams thus obtained contribute greatly to the rapid and accurate evaluation of the analysis results, and they are also useful for obtaining basic syntactic patterns of analyzed structures, and for detecting the head of each identified structure.</abstract>
+      <bibkey>kuno-1963-sentence</bibkey>
+    </paper>
+    <paper id="22">
+      <!-- https://aclanthology.org/1963.earlymt-1.22/ -->
+      <title>Linguistic structure and machine translation</title>
+      <author><first>Sydney M.</first><last>Lamb</last></author>
+      <abstract>If one understands the nature of linguistic structure, one will know what design features an adequate machine translation system must have. To put it the other way around, it is futile to attempt the construction of a machine translation system without a knowledge of what the structure of language is like. This principle means that if someone wants to construct a machine translation system, the most important thing he must do is to understand the structure of language. Any MT system, whether by conscious intention on the part of its creators or not, is based upon some view of the nature of linguistic structure. By making explicit the underlying theory for various MT systems which have been proposed we can determine whether or not they are adequate. Similarly, by observing linguistic phenomena we can determine what properties an adequate theory of language must have, and such determination will show what features an MT system must have in order to be adequate. It can be shown that some of the approaches to MT now being pursued must necessarily fail because their underlying linguistic theories are inadequate to account for various well-known linguistic phenomena.</abstract>
+      <bibkey>lamb-1963-linguistic</bibkey>
+    </paper>
+    <paper id="23">
+      <!-- https://aclanthology.org/1963.earlymt-1.23/ -->
+      <title>On redundancy in artificial languages</title>
+      <author><first>W. P.</first><last>Lehmann</last></author>
+      <abstract>Artificial languages are one concern of work in computational linguistics, if only as a mnemonic device for interlinguas which will be developed. Even if it does not gain wider use, the structure of an artificial language is of general interest. In contrast to the artificial languages which have been widely proposed, linguistic principles underlying a welldesigned artificial language and its usefulness are wellestablished, particularly through Trubetzkoy’s article, TCLP 8.5-21. which indicates phonological limitations for such a language. Since Trubetzkoy’s specifications yield a total of approximately 11,000 morphemes, if an artificial language incorporated the degree of redundancy found in natural languages it would be severely handicapped by the size of its lexicon. The paper discusses the problem particularly with regard to suprasegmentals, which Trubetzkoy almost entirely ignored.</abstract>
+      <bibkey>lehmann-1963-redundancy</bibkey>
+    </paper>
+    <paper id="24">
+      <!-- https://aclanthology.org/1963.earlymt-1.24/ -->
+      <title>A procedure for automatic sentence structure analysis</title>
+      <author><first>D.</first><last>Lieberman</last></author>
+      <abstract>The two main considerations in the design of this procedure were the economical recognition and representation of multiple readings of syntactically ambiguous sentences, and general applicability to “all” languages (English, Russian, Chinese). The following features will be discussed: types of structural descriptions, form of linguistic rules, use of linguistic heuristics to achieve economical multiple analyses, application to linguistic research and application to production MT systems. Also, the relation between this procedure and other existing sentence analysis procedures will be discussed.</abstract>
+      <bibkey>lieberman-1963-procedure</bibkey>
+    </paper>
+    <paper id="25">
+      <!-- https://aclanthology.org/1963.earlymt-1.25/ -->
+      <title>An algorithm for the translation of <fixed-case>R</fixed-case>ussian inorganic-chemistry terms</title>
+      <author><first>L. R.</first><last>Micklesen</last></author>
+      <author><first>P. H.</first><last>Smith</last></author>
+      <abstract>An algorithm has been devised, and a computer program written, to translate certain recurring types of inorganic-chemistry terms from Russian to English. The terms arc all noun-phrases, and several different types of such phrases have been included in the program. Examples are: AZOTNONATRIEVA4 SOL6 sodium nitrate SOL6 ZAKISI/OKISI JELEZA ferrous/ferric salt ZAKISNA4 OKISNA4 SOL6 JELEZA GIDRAT ZAKISI/OKISI JELEZA ferrous/ferric salt etc., where the stems underlined may be replaced by any of a number of other stems (up to 65 in some positions) in the particular type. Translation of each type encounters problems common to almost all the types: (1) The Russian noun is translated as an English adjective, while the noun of the resulting English phrase is found among the modifiers of the Russian noun. (2) The Russian noun (English adjective) may be a metal with more than one valence state, the state indicated (if at all) by the modifiers. (3) The number of the resulting English noun-phrase is determined by some member of the Russian phrase other than the noun. (4) The phrase elements may occur compounded in the chemical phrase but free in other contexts, and dictionary storage must provide for this. The program permits translation of conjoined phrase elements as well. The paper also includes an investigation into the deeper grammatical implications of this type of chemical nomenclature, and some excursions into the semantic correlations involved.</abstract>
+      <bibkey>micklesen-smith-1963-algorithm</bibkey>
+    </paper>
+    <paper id="26">
+      <!-- https://aclanthology.org/1963.earlymt-1.26/ -->
+      <title>The application of table processing concepts to the Sakai translation technique</title>
+      <author><first>A.</first><last>Opler</last></author>
+      <author><first>R.</first><last>Silverstone</last></author>
+      <author><first>Y.</first><last>Saleh</last></author>
+      <author><first>M.</first><last>Hildebran</last></author>
+      <author><first>I.</first><last>Slutzky</last></author>
+      <abstract>In 1961, I. Sakai described a new technique for the mechanical translation of languages. The method utilizes large tables which contain the syntactic rules of the source and target languages. As part of a study of the AN/GSQ-16 Lexical Processing Machine, a modification of the Sakai method was developed. Five of six planned table scanning phases were implemented and tested. Our translation system (1) converts input text to syntactic and semantic codes with a dictionary scan, (2) clears syntactic ambiguities where resolution by adjacent words is effective, (3) resolves residual syntactic ambiguities by determining the longest meaningful semantic unit, (4) reorders word sequence according to the rules of the target language and (5) produces the final target language translation. French to English was the source-target pair selected for the study. An Input Dictionary of 3,000 French stems was prepared and 17,000 entries comprised the Input Product Table (allowable syntactic combinations ). Since Sakai was working with highly dissimilar languages, he found it necessary to use an intermediate language. Because of the structural similarity between French and English, we found an intermediate language was unnecessary. The method proved straightforward to implement using the table lookup logic of the Lexical Processor. The translation was actually performed on an IBM 1401 which we programmed to simulate the concept of the AN/GSQ-16 Lexical Processor. In our implementation magnetic tapes replaced the photoscopic storage disk.</abstract>
+      <bibkey>opler-etal-1963-application</bibkey>
+    </paper>
+    <paper id="27">
+      <!-- https://aclanthology.org/1963.earlymt-1.27/ -->
+      <title><fixed-case>S</fixed-case>lavic languages—comparative morphosyntactic research</title>
+      <author><first>Milos</first><last>Pacak</last></author>
+      <abstract>An appropriate goal for present-day linguistics is the development of a general theory of relations between languages. One necessary requirement in the development of such a theory is the identification and classification of inflected forms in terms of their morphosyntactic properties in a set of presumably related languages. According to Sapir, “all languages differ from one another, but certain ones differ far more than others”. As for the Slavic languages he might well have said that they are all alike, but some are more alike than others. The similarities stemming from their common origin and from subsequent parallel development enable us to group them into a number of more or less homogeneous types. The experimental comparative research at The Georgetown University was focused on a group of four Slavic languages, namely, Russian, Czech, Polish and Serbocroatian. The first step in the comparative procedure here described is the morphosyntactic analysis of each of the four languages individually. The analysis should be based on the complementary distribution of inflectional morphemes. The properties whose distribution must be determined are: 1) the graphemic shape of the inflectional morphemes, 2) the establishment of distributional classes and subclasses of stem morphemes and (on the basis of 1 and 2), 3) the morphosyntactic function of inflectional morphemes which is determined by the distributional subclass of the stem morpheme. f(x,y)-l, where x is the distributional subclass of the stem morpheme (which is a constant) and y is the given inflectional morpheme (which is a free variable). On the basis of this preliminary analysis the patterns of absolute equivalence, partial equivalence, and absolute difference can be established for each class of inflected forms in each language under study. Once this has been accomplished, the results can be used in order to determine the extent of distributional equivalences among the individual languages. The applicability of this procedure was tested on the class of adjectivals. Within the frame of adjectivals the following morphosyntactic properties were analyzed within each language languages: 1) the category of gender, 2) the category of animateness, 3) the category of case and murder. The product of this comparative analysis is a set of formation rules which embody a system for the identification of the inflected forms. The detailed result will be presented in an additional report.</abstract>
+      <bibkey>pacak-1963-slavic</bibkey>
+    </paper>
+    <paper id="28">
+      <!-- https://aclanthology.org/1963.earlymt-1.28/ -->
+      <title>Types of language hierarchy</title>
+      <author><first>E. D.</first><last>Pendergraft</last></author>
+      <abstract>Various relations lead to hierarchical systems of linguistic description. This paper considers briefly a typology of descriptive metalanguages based on such relations and sketches possible consequences for computational linguistics. Its scope is accordingly limited to metalanguages having operational interpretations which specify individual linguistic processes and structural interpretations which specify language data of individual languages. Immediate-constituent, context-free metalanguages are used to illustrate hierarchical types.</abstract>
+      <bibkey>pendergraft-1963-types</bibkey>
+    </paper>
+    <paper id="29">
+      <!-- https://aclanthology.org/1963.earlymt-1.29/ -->
+      <title>Path economization in exhaustive left-to-right syntactic analysis</title>
+      <author><first>Warren J.</first><last>Plath</last></author>
+      <abstract>In exhaustive left-to-right syntactic analysis using the predictive approach, each path of syntactic connection which originates at the beginning of a sentence must be followed until it is clear whether or not it will lead to the production of a well-formed analysis. The original scheme of following each path until it terminates either in an analysis or in a grammatical inconsistency has been considerably improved through the. incorporation of two path-testing techniques. Using the first technique, the program abandons a path as unproductive whenever a situation is detected where the prediction pool contains more predictions of a given type than can possibly be fulfilled by the remaining words in the sentence. Employment of the second technique, which is based on periodic comparison of the current prediction pool with pools formed on earlier productive paths, eliminates repeated analysis of identical right-hand segments which belong to distinct paths. Taken together, the two path-testing procedures frequently enable the program to terminate the processing of a path well before its end has been reached. For most sentences, this means a considerable reduction in the total path length traversed, accompanied by a corresponding increase in the speed of analysis. Comparison of runs performed using both versions of the program indicates that employment of the new techniques reduces the average running time per sentence to less than one-fifth of its former value.</abstract>
+      <bibkey>plath-1963-path</bibkey>
+    </paper>
+    <paper id="30">
+      <!-- https://aclanthology.org/1963.earlymt-1.30/ -->
+      <title>A computer representation for semantic information</title>
+      <author><first>Bertram</first><last>Raphael</last></author>
+      <abstract>This paper deals with the problem of representing in a useful form, within a digital computer, the information content of statements in natural language. The model proposed consists of words and list-structure associations between words. Statements in simple English are thought of as describing relations between objects in the real world. Sentences are analyzed by matching them against members of a list of formats, each of which determines a unique relation. These relations are stored on description-lists associated with those words which denote objects (or sets of objects). A LISP computer program uses this model in the context of a simple question-answering system. Functions are provided which may grow, search, and modify this model. Formats and functions dealing with set-relations, part-whole and numeric relations, and left-toright spatial relations have been included in the system, which is being expanded to handle other types of relations. All functions which operate on the model report information concerning their actions to the programmer, so that the applicability and limitations of this kind of model may more easily be evaluated.</abstract>
+      <bibkey>raphael-1963-computer</bibkey>
+    </paper>
+    <paper id="31">
+      <!-- https://aclanthology.org/1963.earlymt-1.31/ -->
+      <title>Specifications for generative grammars used in language data processing</title>
+      <author><first>Robert</first><last>Tabory</last></author>
+      <abstract>It becomes more and more evident that successful pragmatics (i.e. automatic recognition and production procedures for sentences) cannot be performed without previously written generative grammars for the languages involved, using an underlying meta-theoretical framework proposed by the present school of mathematical linguistics. Two aspects of grammar writing are examined: 1. A taxonomy over the non-terminal vocabulary, using a subscripting system for signs and fitting into the more general string taxonomy of phrase structure components. The resulting more complex lexical organization is studied. 2. A command syntax for phrase structure components limiting the full, not necessarily needed generative power of these grammars. The proposed restrictions correspond to a priori linguistic intuition. Applicational order and location of the rules is studied. Finally, the recognitional power and generative capacity of a computer are examined, the machine being structured according to a Newell-Shaw-Simon list system. It is well known that pushdown stores are particular cases of list structures, that context-free grammars are particular cases of phrase structure grammars and that pushdown stores are the generative devices for context-free grammars.</abstract>
+      <bibkey>tabory-1963-specifications</bibkey>
+    </paper>
+    <paper id="32">
+      <!-- https://aclanthology.org/1963.earlymt-1.32/ -->
+      <title>Collecting linguistic data for the grammar of a language</title>
+      <author><first>Wayne</first><last>Tosh</last></author>
+      <abstract>Establishing the grammatical description of a language is one of the major tasks facing the technician in machine translation. Another is that of creating the system of programs with which to carry out the translation process. The Linguistics Research Center of The University of Texas recognizes the advantages in maintaining the specialties of linguistic research and computer programming as two separate areas of endeavor. We regard the linguistic task as a problem in convergence. We do not expect ever to have a final description of a language (except theoretically for a given point in the history of that language). We do expect, however, to begin with almost immediate application of the very first grammatical description. We shall make repeated revisions of the grammar as we learn how to make it approximate better the language text fed into the computer. The grammatical description of any one language is based primarily on specific text evidence. We are not attempting to describe “the language”. We are, however, attempting to make descriptive decisions sufficiently general that new text evidence does not require extensive revision of earlier descriptions. Corpora selected for description are chosen so as to have similar texts within the same scientific discipline for the several languages. Tree diagrams are drawn for each sentence in detail. The diagrams are inspected for consistency before corresponding phrase-structure rules are compiled in the computer. The grammar is then verified in the computer system and revised as necessary.</abstract>
+      <bibkey>tosh-1963-collecting</bibkey>
+    </paper>
+    <paper id="33">
+      <!-- https://aclanthology.org/1963.earlymt-1.33/ -->
+      <title>Derivational suffixes in <fixed-case>R</fixed-case>ussian general vocabulary and in chemical nomenclature</title>
+      <author><first>John H.</first><last>Wahlgren</last></author>
+      <abstract>A grammar based upon a conventional morphemic analysis of Russian will have a rather large inventory of derivational suffixes. A relatively small number of these recur with sufficient generality to acquire lexemic status (i.e., to be what is usually termed “productive”). Names of chemical substances in Russian may likewise be analyzed as combinations of roots or stems with derivational affixes, in particular, suffixes. The number of productive suffixes in the chemical nomenclature is considerably larger than in the general vocabulary. These suffixes derive from adoption into Russian of an international system of chemical nomenclature. A grammar of this system is basically independent of any grammar of Russian. It must, however, be consistently incorporated into the grammar and dictionary which are to serve in a machine translation system for texts in the source language containing chemical names. Grammatical analysis of chemical suffixes and connected study of general Russian derivational suffixes has raised certain practical problems and theoretical questions concerning the nature of derivation. On the practical side, where a complex and highly productive system is involved, effective means of detecting and dealing with homography have required development. Theoretical consideration has been given to the question of grammaticality in chemical names and to problems of sememic analysis and classification of root and stem lexemes into tactic classes on the basis of cooccurrence with derivational suffixes.</abstract>
+      <bibkey>wahlgren-1963-derivational</bibkey>
+    </paper>
+    <paper id="34">
+      <!-- https://aclanthology.org/1963.earlymt-1.34/ -->
+      <title>On the order of clauses</title>
+      <author><first>Victor H.</first><last>Yngve</last></author>
+      <abstract>We used to think that the output of a translation machine would be stylistically inelegant, but this would be tolerable if only the message got across. We now find that getting the message across accurately is difficult, but we may be able to have stylistic elegance in the output since much of style reflects depth phenomena and thus is systematic. As an example, the order of the clauses in many twoclause sentences can be reversed without a change of meaning, but the same is not normally true of sentences with more than two clauses. The meaning usually changes when the clause order is changed. Equivalently, there appear to be severe restrictions on clause order for any given meaning. These restrictions appear to follow from depth considerations. The idea is being investigated that there is a normal depth-related clause order and any deviations from this order must be signalled by special syntactic or semantic devices. The nature of these devices is being explored. When translating multi-clause sentences, there may be trouble due to the fact that the clause types of the two languages are not exactly parallel. Therefore the list of allowed and preferred clause orders in the two languages will not be equivalent and the special syntactic and semantic devices available to signal deviations from the normal order will be different. Thus one would predict that multi-clause sentences in language A often have to be split into two or more sentences when translated into language B, while at the same time multi-clause sentences in language B will often have to be broken into two or more sentences when translating into language A.</abstract>
+      <bibkey>yngve-1963-order</bibkey>
+    </paper>
+  </volume>
+</collection>
@@ -0,0 +1,273 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<collection id="T78">
+  <volume id="1" type="proceedings">
+    <!-- https://aclanthology.org/T78-1/ -->
+    <meta>
+      <booktitle>Theoretical Issues in Natural Language <fixed-case>P</fixed-case>rocessing-2</booktitle>
+      <editor id="david-l-waltz"><first>David L.</first><last>Waltz</last></editor>
+      <venue>tinlap</venue>
+      <year>1978</year>
+    </meta>
+    <frontmatter>
+      <!-- https://aclanthology.org/T78-1000/ -->
+      <pdf hash="fb6164ad"/>
+      <bibkey>tinlap-1978-theoretical</bibkey>
+    </frontmatter>
+    <paper id="1">
+      <!-- https://aclanthology.org/T78-1001/ -->
+      <title>Testing The Psychological Reality of a Representational Model</title>
+      <author><first>Dedre</first><last>Gentner</last></author>
+      <pdf hash="f723a956"/>
+      <bibkey>gentner-1978-testing-psychological</bibkey>
+    </paper>
+    <paper id="2">
+      <!-- https://aclanthology.org/T78-1002/ -->
+      <title>What Makes Something “Ad Hoc”</title>
+      <author id="roger-c-schank"><first>Roger C.</first><last>Schank</last></author>
+      <pdf hash="636853f9"/>
+      <bibkey>schank-1978-makes-something</bibkey>
+    </paper>
+    <paper id="3">
+      <!-- https://aclanthology.org/T78-1003/ -->
+      <title>The Relation of Grammar to Cognition–a Synopsis</title>
+      <author><first>Leonard</first><last>Talmy</last></author>
+      <pdf hash="101c67dc"/>
+      <bibkey>talmy-1978-relation-grammar</bibkey>
+    </paper>
+    <paper id="4">
+      <!-- https://aclanthology.org/T78-1004/ -->
+      <title>On primitives, prototypes, and other semantic anomalies</title>
+      <author><first>Terry</first><last>Winograd</last></author>
+      <pdf hash="f8e47023"/>
+      <bibkey>winograd-1978-primitives-prototypes</bibkey>
+    </paper>
+    <paper id="5">
+      <!-- https://aclanthology.org/T78-1005/ -->
+      <title>Taxonomic Lattice Structures for Situation Recognition</title>
+      <author id="william-a-woods"><first>William A.</first><last>Woods</last></author>
+      <pdf hash="92957ddf"/>
+      <bibkey>woods-1978-taxonomic-lattice</bibkey>
+    </paper>
+    <paper id="6">
+      <!-- https://aclanthology.org/T78-1006/ -->
+      <title>Description Formation and Discourse Model Synthesis</title>
+      <author id="bonnie-webber"><first>Bonnie Lynn</first><last>Webber</last></author>
+      <pdf hash="ffded1d2"/>
+      <bibkey>webber-1978-description-formation</bibkey>
+    </paper>
+    <paper id="7">
+      <!-- https://aclanthology.org/T78-1007/ -->
+      <title>The Processing of Referring Expressions within a Semantic Network</title>
+      <author><first>John R.</first><last>Anderson</last></author>
+      <pdf hash="8bcc083a"/>
+      <bibkey>anderson-1978-processing-referring</bibkey>
+    </paper>
+    <paper id="8">
+      <!-- https://aclanthology.org/T78-1008/ -->
+      <title>Reference Diaries</title>
+      <author><first>Herbert H.</first><last>Clark</last></author>
+      <author><first>Catherine</first><last>Marshall</last></author>
+      <pdf hash="d06b7ea2"/>
+      <bibkey>clark-marshall-1978-reference-diaries</bibkey>
+    </paper>
+    <paper id="9">
+      <!-- https://aclanthology.org/T78-1009/ -->
+      <title>Subsequent Reference: Syntactic and Rhetorical Constraints</title>
+      <author id="david-d-mcdonald"><first>David D.</first><last>McDonald</last></author>
+      <pdf hash="2d424559"/>
+      <bibkey>mcdonald-1978-subsequent-reference</bibkey>
+    </paper>
+    <paper id="10">
+      <!-- https://aclanthology.org/T78-1010/ -->
+      <title>Some Psycholinguistic Constraints on the Construction and Interpretation of Definite Descriptions</title>
+      <author><first>Andrew</first><last>Ortony</last></author>
+      <pdf hash="69807727"/>
+      <bibkey>ortony-1978-psycholinguistic-constraints</bibkey>
+    </paper>
+    <paper id="11">
+      <!-- https://aclanthology.org/T78-1011/ -->
+      <title>Bound Variables and Other Anaphors</title>
+      <author id="barbara-h-partee"><first>Barbara H.</first><last>Partee</last></author>
+      <pdf hash="e8e6a510"/>
+      <bibkey>partee-1978-bound-variables</bibkey>
+    </paper>
+    <paper id="12">
+      <!-- https://aclanthology.org/T78-1012/ -->
+      <title>The Use of Focus as a Tool for Disambiguation of Definite Noun Phrases</title>
+      <author id="candace-l-sidner"><first>Candace L.</first><last>Sidner</last></author>
+      <pdf hash="7b96d2b7"/>
+      <bibkey>sidner-1978-use-focus</bibkey>
+    </paper>
+    <paper id="13">
+      <!-- https://aclanthology.org/T78-1013/ -->
+      <title>Focusing in Dialog</title>
+      <author id="barbara-j-grosz"><first>Barbara J.</first><last>Grosz</last></author>
+      <pdf hash="8c8d4c2e"/>
+      <bibkey>grosz-1978-focusing-dialog</bibkey>
+    </paper>
+    <paper id="14">
+      <!-- https://aclanthology.org/T78-1014/ -->
+      <title>Topic Levels</title>
+      <author><first>Joseph E.</first><last>Grimes</last></author>
+      <pdf hash="f485b2ba"/>
+      <bibkey>grimes-1978-topic-levels</bibkey>
+    </paper>
+    <paper id="15">
+      <!-- https://aclanthology.org/T78-1015/ -->
+      <title>Toward a Rational Model of Discourse Comprehension</title>
+      <author><first>Jerry L.</first><last>Morgan</last></author>
+      <pdf hash="5e12a597"/>
+      <bibkey>morgan-1978-toward-rational</bibkey>
+    </paper>
+    <paper id="16">
+      <!-- https://aclanthology.org/T78-1016/ -->
+      <title>Assent and Compliance in Children’s Language Comprehension</title>
+      <author><first>David R.</first><last>Olson</last></author>
+      <pdf hash="708bc4a0"/>
+      <bibkey>olson-1978-assent-compliance</bibkey>
+    </paper>
+    <paper id="17">
+      <!-- https://aclanthology.org/T78-1017/ -->
+      <title>Speech Acts as a Basis for Understanding Dialogue Coherence</title>
+      <author id="c-raymond-perrault"><first>C. Raymond</first><last>Perrault</last></author>
+      <author id="james-allen"><first>James F.</first><last>Allen</last></author>
+      <pdf hash="d111402b"/>
+      <bibkey>perrault-allen-1978-speech</bibkey>
+    </paper>
+    <paper id="18">
+      <!-- https://aclanthology.org/T78-1018/ -->
+      <title>A Framework for Comparing Language Experiences (with particular emphasis on: The Effect of Audience on Discourse Models)</title>
+      <author><first>Andee</first><last>Rubin</last></author>
+      <pdf hash="5d9a6150"/>
+      <bibkey>rubin-1978-framework-comparing</bibkey>
+    </paper>
+    <paper id="19">
+      <!-- https://aclanthology.org/T78-1019/ -->
+      <title>Intentlonallty and Human Conversations</title>
+      <author id="jaime-g-carbonell"><first>Jaime G.</first><last>Carbonell Jr</last></author>
+      <pdf hash="c50fc619"/>
+      <bibkey>carbonell-jr-1978-intentlonallty-human</bibkey>
+    </paper>
+    <paper id="20">
+      <!-- https://aclanthology.org/T78-1020/ -->
+      <title>On the Interdependence of Language and Perception</title>
+      <author id="david-l-waltz"><first>David L.</first><last>Waltz</last></author>
+      <pdf hash="3c708191"/>
+      <bibkey>waltz-1978-interdependence-language</bibkey>
+    </paper>
+    <paper id="21">
+      <!-- https://aclanthology.org/T78-1021/ -->
+      <title>The Problem of Naming Shapes: Vision-Language Interface</title>
+      <author id="ruzena-bajcsy"><first>R.</first><last>Bajcsy</last></author>
+      <author id="aravind-joshi"><first>A. K.</first><last>Joshi</last></author>
+      <pdf hash="50331b4e"/>
+      <bibkey>bajcsy-joshi-1978-problem-naming</bibkey>
+    </paper>
+    <paper id="22">
+      <!-- https://aclanthology.org/T78-1022/ -->
+      <title>An Argument about the Composition of Conceptual Structure</title>
+      <author><first>Ray</first><last>Jackendoff</last></author>
+      <pdf hash="57d001f8"/>
+      <bibkey>jackendoff-1978-argument-composition</bibkey>
+    </paper>
+    <paper id="23">
+      <!-- https://aclanthology.org/T78-1023/ -->
+      <title>On the Ontological Status of Visual Mental Images</title>
+      <author><first>Stephen Michael</first><last>Kosslyn</last></author>
+      <pdf hash="fd06e265"/>
+      <bibkey>kosslyn-1978-ontological-status</bibkey>
+    </paper>
+    <paper id="24">
+      <!-- https://aclanthology.org/T78-1024/ -->
+      <title>What has language to do with perception? Some speculations on the <i>Lingua Mentis</i></title>
+      <author><first>Zenon W.</first><last>Pylyshyn</last></author>
+      <pdf hash="a2f3a044"/>
+      <bibkey>pylyshyn-1978-language-perception</bibkey>
+    </paper>
+    <paper id="25">
+      <!-- https://aclanthology.org/T78-1025/ -->
+      <title>Semantic Primitives in Language and Vision</title>
+      <author id="yorick-wilks"><first>Yorick</first><last>Wilks</last></author>
+      <pdf hash="b4e13896"/>
+      <bibkey>wilks-1978-semantic-primitives</bibkey>
+    </paper>
+    <paper id="26">
+      <!-- https://aclanthology.org/T78-1026/ -->
+      <title>A Note on Partial Match of Descriptions. Can One Simultaneously Question (Retrieve) and Inform (Update)?</title>
+      <author id="aravind-joshi"><first>Aravind K.</first><last>Joshi</last></author>
+      <pdf hash="74969243"/>
+      <bibkey>joshi-1978-note-partial</bibkey>
+    </paper>
+    <paper id="27">
+      <!-- https://aclanthology.org/T78-1027/ -->
+      <title>With a Spoon in Hand This Must Be the Eating Frame</title>
+      <author><first>Eugene</first><last>Charniak</last></author>
+      <pdf hash="f1be68bb"/>
+      <bibkey>charniak-1978-spoon-hand</bibkey>
+    </paper>
+    <paper id="28">
+      <!-- https://aclanthology.org/T78-1028/ -->
+      <title>Fragments of a Theory of Human Plausible Reasoning</title>
+      <author><first>Allan</first><last>Collins</last></author>
+      <pdf hash="67b4bca2"/>
+      <bibkey>collins-1978-fragments-theory</bibkey>
+    </paper>
+    <paper id="29">
+      <!-- https://aclanthology.org/T78-1029/ -->
+      <title>Indirect Responses to Loaded Questions</title>
+      <author><first>S. Jerrold</first><last>Kaplan</last></author>
+      <pdf hash="135037f9"/>
+      <bibkey>kaplan-1978-indirect-responses</bibkey>
+    </paper>
+    <paper id="30">
+      <!-- https://aclanthology.org/T78-1030/ -->
+      <title>On Reasoning by Default</title>
+      <author><first>Raymond</first><last>Reiter</last></author>
+      <pdf hash="0de53d33"/>
+      <bibkey>reiter-1978-reasoning-default</bibkey>
+    </paper>
+    <paper id="31">
+      <!-- https://aclanthology.org/T78-1031/ -->
+      <title>Path-Based and Node-Based Inference in Semantic Networks</title>
+      <author id="stuart-c-shapiro"><first>Stuart C.</first><last>Shapiro</last></author>
+      <pdf hash="2ddc5535"/>
+      <bibkey>shapiro-1978-path-based</bibkey>
+    </paper>
+    <paper id="32">
+      <!-- https://aclanthology.org/T78-1032/ -->
+      <title>The Representation of Derivable Information in Memory: When What Might Have Been Left Unsaid Is Said</title>
+      <author><first>Rand J.</first><last>Spiro</last></author>
+      <author><first>Joseph</first><last>Esposito</last></author>
+      <author><first>Richard J.</first><last>Vondruska</last></author>
+      <pdf hash="7758fb45"/>
+      <bibkey>spiro-etal-1978-representation-derivable</bibkey>
+    </paper>
+    <paper id="33">
+      <!-- https://aclanthology.org/T78-1033/ -->
+      <title>A Heuristic for Paradigms</title>
+      <author><first>Joseph E.</first><last>Grimes</last></author>
+      <pdf hash="53b42c16"/>
+      <bibkey>grimes-1978-heuristic-paradigms</bibkey>
+    </paper>
+    <paper id="34">
+      <!-- https://aclanthology.org/T78-1034/ -->
+      <title>A Computational Account of Some Constraints on Language</title>
+      <author id="mitch-marcus"><first>Mitchell</first><last>Marcus</last></author>
+      <pdf hash="c9724c43"/>
+      <bibkey>marcus-1978-computational-account</bibkey>
+    </paper>
+    <paper id="35">
+      <!-- https://aclanthology.org/T78-1035/ -->
+      <title>Remarks on Processing, Constraints, and the Lexicon</title>
+      <author id="thomas-wasow"><first>Thomas</first><last>Wasow</last></author>
+      <pdf hash="8beed275"/>
+      <bibkey>wasow-1978-remarks-processing</bibkey>
+    </paper>
+    <paper id="36">
+      <!-- https://aclanthology.org/T78-1036/ -->
+      <title>List of questions suggested for consideration in each session</title>
+      <pdf hash="1950b908"/>
+      <bibkey>nn-1978-list-questions</bibkey>
+    </paper>
+  </volume>
+</collection>
@@ -0,0 +1,314 @@
+{
+  "source_snapshot_sha256": "0376ad019b216553faff0a14e1757b2d4c7a3b84c1beacf0511ef83695211b18",
+  "scope": "Pinned proceedings metadata, not authentic example paper records or evidence that all volumes contain indexed papers. Test papers are synthetic.",
+  "volumes": [
+    {
+      "key": "conf/ecml/1987",
+      "fields": {
+        "editor": [
+          "Ivan Bratko",
+          "Nada Lavrac"
+        ],
+        "title": [
+          "Progress in Machine Learning - Proceedings of EWSL 87: 2nd European Working Session on Learning, Bled, Yugoslavia, May 1987"
+        ],
+        "booktitle": [
+          "EWSL"
+        ],
+        "publisher": [
+          "Sigma Press, Wilmslow"
+        ],
+        "year": [
+          "1987"
+        ],
+        "isbn": [
+          "1-85058-088-X"
+        ],
+        "url": [
+          "db/conf/ecml/ewsl87.html"
+        ]
+      },
+      "bibliographic_counts": [
+        {
+          "year": "1987",
+          "booktitle": "EWSL",
+          "record_type": "inproceedings",
+          "count": 16
+        }
+      ],
+      "expected_original_series": "EWSL",
+      "expected_target_family": "ECML-PKDD"
+    },
+    {
+      "key": "conf/ecml/1988",
+      "fields": {
+        "editor": [
+          "Derek H. Sleeman"
+        ],
+        "title": [
+          "Proceedings of the Third European Working Session on Learning, EWSL 1988, Turing Institute, Glasgow, UK, October 3-5, 1988"
+        ],
+        "booktitle": [
+          "EWSL"
+        ],
+        "publisher": [
+          "Pitman Publishing"
+        ],
+        "year": [
+          "1988"
+        ],
+        "isbn": [
+          "0-273-08800-9"
+        ],
+        "url": [
+          "db/conf/ecml/ewsl88.html"
+        ]
+      },
+      "bibliographic_counts": [
+        {
+          "year": "1988",
+          "booktitle": "EWSL",
+          "record_type": "inproceedings",
+          "count": 21
+        }
+      ],
+      "expected_original_series": "EWSL",
+      "expected_target_family": "ECML-PKDD"
+    },
+    {
+      "key": "conf/ecml/1989",
+      "fields": {
+        "editor": [
+          "Katharina Morik"
+        ],
+        "title": [
+          "Proceedings of the 4th European Working Session on Learning, Montpellier, France, 4-6 December 1989"
+        ],
+        "booktitle": [
+          "EWSL"
+        ],
+        "publisher": [
+          "Pitman and Morgan Kaufman Publishers"
+        ],
+        "year": [
+          "1989"
+        ]
+      },
+      "bibliographic_counts": [],
+      "expected_original_series": "EWSL",
+      "expected_target_family": "ECML-PKDD"
+    },
+    {
+      "key": "conf/ecml/1991",
+      "fields": {
+        "editor": [
+          "Yves Kodratoff"
+        ],
+        "title": [
+          "Machine Learning - EWSL-91, European Working Session on Learning, Porto, Portugal, March 6-8, 1991, Proceedings"
+        ],
+        "booktitle": [
+          "EWSL"
+        ],
+        "series": [
+          "Lecture Notes in Computer Science"
+        ],
+        "volume": [
+          "482"
+        ],
+        "publisher": [
+          "Springer"
+        ],
+        "year": [
+          "1991"
+        ],
+        "isbn": [
+          "3-540-53816-X"
+        ],
+        "ee": [
+          "https://doi.org/10.1007/BFb0016999"
+        ],
+        "url": [
+          "db/conf/ecml/ewsl91.html"
+        ]
+      },
+      "bibliographic_counts": [
+        {
+          "year": "1991",
+          "booktitle": "EWSL",
+          "record_type": "inproceedings",
+          "count": 44
+        }
+      ],
+      "expected_original_series": "EWSL",
+      "expected_target_family": "ECML-PKDD"
+    },
+    {
+      "key": "conf/ecp/1997",
+      "fields": {
+        "editor": [
+          "Sam Steel",
+          "Rachid Alami 0001"
+        ],
+        "title": [
+          "Recent Advances in AI Planning, 4th European Conference on Planning, ECP'97, Toulouse, France, September 24-26, 1997, Proceedings"
+        ],
+        "booktitle": [
+          "ECP"
+        ],
+        "series": [
+          "Lecture Notes in Computer Science"
+        ],
+        "volume": [
+          "1348"
+        ],
+        "publisher": [
+          "Springer"
+        ],
+        "year": [
+          "1997"
+        ],
+        "isbn": [
+          "3-540-63912-8"
+        ],
+        "ee": [
+          "https://doi.org/10.1007/3-540-63912-8"
+        ],
+        "url": [
+          "db/conf/ecp/ecp1997.html"
+        ]
+      },
+      "bibliographic_counts": [
+        {
+          "year": "1997",
+          "booktitle": "ECP",
+          "record_type": "inproceedings",
+          "count": 35
+        }
+      ],
+      "expected_original_series": "ECP",
+      "expected_target_family": "ICAPS"
+    },
+    {
+      "key": "conf/ecp/1999",
+      "fields": {
+        "editor": [
+          "Susanne Biundo",
+          "Maria Fox 0001"
+        ],
+        "title": [
+          "Recent Advances in AI Planning, 5th European Conference on Planning, ECP'99, Durham, UK, September 8-10, 1999, Proceedings"
+        ],
+        "booktitle": [
+          "ECP"
+        ],
+        "series": [
+          "Lecture Notes in Computer Science"
+        ],
+        "volume": [
+          "1809"
+        ],
+        "publisher": [
+          "Springer"
+        ],
+        "year": [
+          "2000"
+        ],
+        "isbn": [
+          "3-540-67866-2"
+        ],
+        "ee": [
+          "https://doi.org/10.1007/10720246"
+        ],
+        "url": [
+          "db/conf/ecp/ecp1999.html"
+        ]
+      },
+      "bibliographic_counts": [
+        {
+          "year": "1999",
+          "booktitle": "ECP",
+          "record_type": "inproceedings",
+          "count": 28
+        }
+      ],
+      "expected_original_series": "ECP",
+      "expected_target_family": "ICAPS"
+    },
+    {
+      "key": "conf/ewsp/1991",
+      "fields": {
+        "editor": [
+          "Joachim Hertzberg"
+        ],
+        "title": [
+          "European Workshop on Planning, EWSP '91, Sankt Augustin, Germany, March 18-19, 1991, Proceedings"
+        ],
+        "booktitle": [
+          "EWSP"
+        ],
+        "series": [
+          "Lecture Notes in Computer Science"
+        ],
+        "volume": [
+          "522"
+        ],
+        "publisher": [
+          "Springer"
+        ],
+        "year": [
+          "1991"
+        ],
+        "isbn": [
+          "3-540-54364-3"
+        ],
+        "ee": [
+          "https://doi.org/10.1007/BFb0052944"
+        ],
+        "url": [
+          "db/conf/ewsp/ewsp1991.html"
+        ]
+      },
+      "bibliographic_counts": [
+        {
+          "year": "1991",
+          "booktitle": "EWSP",
+          "record_type": "inproceedings",
+          "count": 10
+        }
+      ],
+      "expected_original_series": "EWSP",
+      "expected_target_family": "ICAPS"
+    },
+    {
+      "key": "conf/aips/1990",
+      "fields": {
+        "title": [
+          "Proceedings of the First International Conference on Expert Planning Systems, Brighton, UK, June 27-29, 1990"
+        ],
+        "booktitle": [
+          "Expert Planning Systems"
+        ],
+        "publisher": [
+          "AAAI"
+        ],
+        "year": [
+          "1990"
+        ],
+        "url": [
+          "db/conf/aips/aips1990.html"
+        ]
+      },
+      "bibliographic_counts": [
+        {
+          "year": "1990",
+          "booktitle": "Expert Planning Systems",
+          "record_type": "inproceedings",
+          "count": 48
+        }
+      ],
+      "expected_original_series": "EPS",
+      "expected_target_family": "ICAPS"
+    }
+  ]
+}
@@ -0,0 +1,15 @@
+{
+  "receipts": [
+    {
+      "url": "https://neurips.cc/static/virtual/data/neurips-2026-orals-posters.json",
+      "final_url": "https://neurips.cc/static/virtual/data/neurips-2026-orals-posters.json",
+      "status": 200,
+      "content_type": "application/json",
+      "file": "program-json.response",
+      "bytes": 20447021,
+      "sha256": "879293a863057fa05370443b3b5ddee12a10eeb37c810abc6c1d53f71f545997",
+      "started_at": "2026-11-09T17:57:23.825509+00:00",
+      "finished_at": "2026-11-09T17:57:40.125580+00:00"
+    }
+  ]
+}
@@ -0,0 +1,85 @@
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from paper_atlas.collectors import aamas, aamas2025
+
+
+FIXTURE = Path(__file__).parent/'fixtures/aamas2025'
+
+
+class Aamas2025Tests(unittest.TestCase):
+    def parse(self, html=None):
+        return aamas2025.parse_contents(html or (FIXTURE/'contents.html').read_text(),
+            {'observed_at': '2026-11-09T12:31:50+00:00', 'url': aamas2025.URLS['contents']})
+
+    def test_real_toc_preserves_every_title_author_and_affiliation(self):
+        expected = json.loads((FIXTURE/'expected-authors.json').read_text())
+        self.assertEqual(hashlib.sha256((FIXTURE/'contents.html').read_bytes()).hexdigest(), expected['source_sha256'])
+        rows, excluded = self.parse()
+        self.assertEqual((len(rows), len(excluded)), (476, 3))
+        by_url = {r['paper_url']: r for r in expected['entries']}
+        for row in rows:
+            original = by_url[row['metadata']['paper_url']]
+            self.assertEqual(row['title'], original['title'])
+            self.assertEqual(row['authors'], [a['name'] for a in original['authors']])
+            self.assertEqual(row['metadata']['author_affiliations'], [a['affiliation'] for a in original['authors']])
+            self.assertIsNone(row['abstract'])
+            self.assertEqual(row['identifiers'], {})
+            self.assertEqual(row['status'], 'accepted')
+            self.assertNotIn('decision_date', row)
+            self.assertTrue(all(t['namespace'] == 'aamas_proceedings:publication_format' for t in row['tags']))
+
+    def test_publication_format_and_track_are_separate(self):
+        rows, excluded = self.parse()
+        groups = {k: sum(r['track'] == k for r in rows) for k in {r['track'] for r in rows}}
+        self.assertEqual(groups, {'proceedings_unspecified': 409, 'blue_sky': 12, 'doctoral': 25, 'demo': 21, 'jaamas': 9})
+        competition = next(r for r in rows if r['external_id'] == '2025/p3000')
+        self.assertEqual(competition['year'], 2025)
+        self.assertEqual(competition['metadata']['publication_format'], 'competition_report')
+        self.assertEqual(competition['metadata']['section_heading'], 'Demo Track')
+        self.assertEqual(competition['track'], 'proceedings_unspecified')
+        self.assertEqual(len({r['external_id'] for r in rows}), 476)
+        self.assertEqual([r['publisher_page'] for r in excluded], [1, 3, 4])
+
+    def test_refuses_changed_edition_inventory_or_author_markup(self):
+        original = (FIXTURE/'contents.html').read_text()
+        for html in [original.replace('AAMAS 2025:', 'AAMAS 2026:', 1),
+                     original.replace('../pdfs/p5.pdf', '../pdfs/p14.pdf', 1),
+                     original.replace('Paper Track</font>', 'Workshop Track</font>'),
+                     original.replace('Amir Abolfazli', '', 1),
+                     original.replace('[COMP24]', '[CHANGED]', 1)]:
+            with self.subTest(change=html[:60]):
+                with self.assertRaises(ValueError): self.parse(html)
+
+    def test_frozen_collection_is_partial_and_never_fetches_pdfs(self):
+        with tempfile.TemporaryDirectory() as tmp, patch.object(aamas2025, 'fetch', side_effect=AssertionError('No HTTP in frozen mode')):
+            out = Path(tmp)/'out'
+            report = aamas.collect(2025, out, snapshots=FIXTURE)
+            self.assertEqual(report['records'], 476)
+            self.assertFalse(report['database_written'])
+            self.assertFalse(report['pdfs_downloaded'])
+            self.assertEqual(len(report['files']), 5)
+            for m in report['files']:
+                self.assertEqual(m['status'], 'partial')
+                self.assertEqual(m['missing_abstract_count'], m['count'])
+                self.assertEqual(hashlib.sha256(Path(m['file']).read_bytes()).hexdigest(), m['file_sha256'])
+            receipt = report['source_receipts'][0]['response_receipt']
+            self.assertEqual(receipt['at_precision'], 'filesystem_write_time_recovered')
+            self.assertTrue((out/'aamas-proceedings-2025.json').is_file())
+
+    def test_rejects_tampered_or_unsafe_frozen_response(self):
+        import shutil
+        for mode in ['tamper', 'path', 'status']:
+            with self.subTest(mode=mode), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp); source = root/'source'; shutil.copytree(FIXTURE, source)
+                p = source/'receipts.json'; r = json.loads(p.read_text())
+                if mode == 'tamper': (source/'contents.html').write_text('bad')
+                elif mode == 'path': r['receipts'][0]['file'] = '../index.html'
+                else: r['receipts'][0]['http_status'] = 403
+                p.write_text(json.dumps(r))
+                with self.assertRaises(ValueError): aamas.collect(2025, root/'out', snapshots=source)
+                self.assertFalse((root/'out/aamas-proceedings-2025.json').exists())
@@ -0,0 +1,167 @@
+import gzip
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import sqlite3
+import unittest
+from unittest.mock import patch
+
+from paper_atlas.collectors import aamas, aamas2026
+from paper_atlas.ingestion.records import ingest_file
+
+
+FIXTURE = json.loads(gzip.decompress((Path(__file__).parent/'fixtures/aamas2026-fixture.json.gz').read_bytes()))
+EVIDENCE = {'url': aamas2026.URL, 'observed_at': FIXTURE['receipts']['receipts'][0]['finished_at']}
+
+
+class Aamas2026Tests(unittest.TestCase):
+    def parse(self, html=None):
+        return aamas2026.parse_contents(FIXTURE['contents'] if html is None else html, EVIDENCE)
+
+    def snapshots(self, folder):
+        folder.mkdir()
+        (folder/'contents.html').write_text(FIXTURE['contents'])
+        (folder/'receipts.json').write_text(json.dumps(FIXTURE['receipts']))
+        return folder
+
+    def test_every_publisher_title_author_affiliation_and_page_preserved(self):
+        rows, excluded, held = self.parse()
+        self.assertEqual((len(rows), len(excluded), len(held)), (639, 3, 1))
+        expected = {r['publisher_page']: r for r in FIXTURE['expected_entries']}
+        self.assertEqual(len(expected), 643)
+        all_rows = rows+excluded+held
+        self.assertEqual({r['metadata']['publisher_page'] for r in all_rows}, set(expected))
+        for r in all_rows:
+            e = expected[r['metadata']['publisher_page']]
+            self.assertEqual(r['title'], e['title'])
+            self.assertEqual(r['authors'], e['authors'])
+            self.assertEqual(r['metadata']['author_affiliations'], e['affiliations'])
+            self.assertEqual(r['metadata']['section_heading'], e['section'])
+        for r in rows:
+            self.assertIsNone(r['abstract'])
+            self.assertEqual(r['identifiers'], {})
+            if r['external_id'] != '2026/p3178':
+                self.assertEqual(r['status'], 'accepted')
+                self.assertNotIn('decision_date', r)
+
+    def test_explicit_withdrawal_preserves_status_date_and_no_pdf(self):
+        rows, _, _ = self.parse()
+        row, = [r for r in rows if r['external_id'] == '2026/p3178']
+        self.assertEqual(row['status'], 'withdrawn')
+        self.assertEqual(row['metadata']['withdrawal_date'], '2026-06-08')
+        self.assertNotIn('decision_date', row)
+        self.assertEqual(row['raw_decision'], 'Withdrawn June 8, 2026')
+        self.assertNotIn('paper_url', row['metadata'])
+        self.assertEqual(row['metadata']['publication_state'], 'withdrawn')
+        self.assertEqual(sum(r['status'] == 'accepted' for r in rows), 638)
+
+    def test_withdrawal_ingestion_retains_date_precision_without_invented_acceptance(self):
+        rows, _, _ = self.parse()
+        row, = [r for r in rows if r['external_id'] == '2026/p3178']
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp); path = root/'withdrawn.jsonl'; db = root/'sample.sqlite'
+            path.write_text(json.dumps(row, ensure_ascii=False)+'\n')
+            path.with_suffix('.manifest.json').write_text(json.dumps({
+                'source': 'aamas_proceedings', 'list_url': aamas2026.URL,
+                'venue': 'AAMAS', 'year': 2026, 'track': row['track'],
+                'count': 1, 'status': 'partial', 'missing_abstract_count': 1,
+                'file_sha256': hashlib.sha256(path.read_bytes()).hexdigest()}))
+            ingest_file(db, path)
+            with sqlite3.connect(db) as c:
+                self.assertEqual(c.execute('SELECT status,raw_value,decision_date FROM decisions').fetchall(),
+                                 [('withdrawn', 'Withdrawn June 8, 2026', None)])
+                metadata = json.loads(c.execute('SELECT metadata_json FROM source_records').fetchone()[0])
+                self.assertEqual(metadata['withdrawal_date'], '2026-06-08')
+                self.assertEqual(metadata['decision_date_precision'], 'day')
+                self.assertEqual(c.execute('PRAGMA foreign_key_check').fetchall(), [])
+
+    def test_retraction_is_not_accepted_or_withdrawn_and_retains_date(self):
+        rows, _, held = self.parse()
+        self.assertNotIn('2026/p238', {r['external_id'] for r in rows})
+        h, = held
+        self.assertEqual(h['publication_state'], 'retracted')
+        self.assertEqual(h['retraction_date'], '2026-06-08')
+        self.assertEqual(h['raw_publication_state'], 'Retracted June 8, 2026')
+        self.assertNotIn('status', h)
+        self.assertNotIn('paper_url', h['metadata'])
+        self.assertEqual(h['metadata']['source_evidence'], EVIDENCE)
+
+    def test_tracks_formats_and_prior_decisions_are_not_conflated(self):
+        rows, _, _ = self.parse()
+        counts = {t: sum(r['track'] == t for r in rows) for t in {r['track'] for r in rows}}
+        self.assertEqual(counts, {'proceedings_unspecified': 522, 'aaai_transfer': 19,
+                                 'blue_sky': 17, 'doctoral': 34, 'demo': 44, 'jaamas': 3})
+        for row in rows:
+            self.assertEqual(row['tags'][0]['namespace'], 'aamas_proceedings:publication_format')
+            if row['track'] == 'aaai_transfer':
+                self.assertIn('none inferred', row['metadata']['prior_submission_note'])
+                self.assertNotIn('decision_events', row)
+            if row['track'] == 'jaamas':
+                self.assertEqual(row['metadata']['publication_format'], 'journal_presentation')
+                self.assertIn('not another independent', row['metadata']['track_scope_note'])
+
+    def test_refuses_changed_year_section_page_link_author_and_retraction(self):
+        html = FIXTURE['contents']
+        replacements = [('AAMAS 2026:', 'AAMAS 2027:'),
+                        ('name="R" id="R"></a><font color="#010101">Research Paper Track',
+                         'name="R" id="R"></a><font color="#010101">Workshop Track'),
+                        ('(Page 4)', '(Page 1)'),
+                        ('../pdfs/HQQZ1937.pdf', 'https://other.example/paper.pdf'),
+                        ('Michael Wooldridge <i>', '<i>'),
+                        ('Retracted June 8, 2026', 'Withdrawn June 8, 2026')]
+        for old, new in replacements:
+            self.assertIn(old, html)
+            with self.subTest(change=old), self.assertRaises(ValueError):
+                self.parse(html.replace(old, new, 1))
+
+    def test_frozen_collection_is_partial_with_full_held_evidence(self):
+        with tempfile.TemporaryDirectory() as tmp, patch.object(aamas2026, 'fetch', side_effect=AssertionError('No HTTP')):
+            root = Path(tmp)
+            report = aamas.collect(2026, root/'out', snapshots=self.snapshots(root/'source'))
+            self.assertEqual(report['records'], 639)
+            self.assertEqual(report['status_counts'], {'accepted': 638, 'withdrawn': 1})
+            self.assertEqual(len(report['files']), 6)
+            self.assertEqual(len(report['held_publications']), 1)
+            self.assertFalse(report['database_written'])
+            self.assertFalse(report['pdfs_downloaded'])
+            for m in report['files']:
+                self.assertEqual(m['status'], 'partial')
+                self.assertEqual(m['missing_abstract_count'], m['count'])
+                self.assertEqual(hashlib.sha256(Path(m['file']).read_bytes()).hexdigest(), m['file_sha256'])
+            self.assertTrue((root/'out/aamas-proceedings-2026.json').is_file())
+
+    def test_frozen_response_rejects_tamper_unsafe_path_status_and_symlink(self):
+        for mode in ('tamper', 'path', 'status', 'symlink'):
+            with self.subTest(mode=mode), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp); source = self.snapshots(root/'source')
+                r = json.loads((source/'receipts.json').read_text())
+                if mode == 'tamper':
+                    (source/'contents.html').write_text('bad')
+                elif mode == 'path':
+                    r['receipts'][0]['file'] = '../outside.html'
+                elif mode == 'status':
+                    r['receipts'][0]['status'] = 403
+                else:
+                    (root/'outside.html').write_text(FIXTURE['contents'])
+                    (source/'contents.html').unlink()
+                    (source/'contents.html').symlink_to(root/'outside.html')
+                (source/'receipts.json').write_text(json.dumps(r))
+                with self.assertRaises(ValueError):
+                    aamas.collect(2026, root/'out', snapshots=source)
+                self.assertFalse((root/'out/aamas-proceedings-2026.json').exists())
+
+    def test_live_mode_fetches_only_html_and_preserves_receipt(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp); cache = root/'cache'; cache.mkdir()
+            receipt = {'retrieved_at': EVIDENCE['observed_at'], 'url': aamas2026.URL}
+            (cache/hashlib.sha256(aamas2026.URL.encode()).hexdigest()).with_suffix('.json').write_text(json.dumps(receipt))
+            with patch.object(aamas2026, 'fetch', return_value=FIXTURE['contents'].encode()) as fetch:
+                report = aamas.collect(2026, root/'out', cache=cache)
+            fetch.assert_called_once_with(aamas2026.URL, cache, 8*1024**2, delay=1)
+            self.assertEqual(report['source_receipts'][0]['response_receipt'], receipt)
+
+    def test_frozen_fixture_is_original_hashed_response(self):
+        r, = FIXTURE['receipts']['receipts']
+        self.assertEqual(hashlib.sha256(FIXTURE['contents'].encode()).hexdigest(), r['sha256'])
+        self.assertEqual(r['bytes'], len(FIXTURE['contents'].encode()))
@@ -0,0 +1,151 @@
+"""Publisher evidence, section boundaries and native-ingestion regression checks."""
+import hashlib
+import json
+import re
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from paper_atlas.collectors import aamas
+from paper_atlas.ingestion.records import ingest_file
+
+
+def paper(pid, abstract=True):
+    summary = '<span class="abstract">Research with <i>evidence</i>.<br>More detail.</span>' if abstract else ''
+    return f'''<div class="paper" id="{pid}"><span class="id">{pid}</span>
+    <p class="paper"><span class="title"><a href="../papers/{pid}.pdf">{summary}
+    A structured &amp; auditable paper {pid}</a></span><span class="authors">
+    <a href="authors.html#Jane">Jane Doe<span class="amount">has 7 papers</span></a>, Bob Smith
+    </span></p></div>'''
+
+
+def page(section, pid, abstract=True):
+    heading = aamas.SECTIONS[section][0]
+    return (f'<html><head><title>{heading} - AAMAS 2012</title></head><body>'
+            f'<h1>{heading}</h1><h2 class="section" id="s-1A">Session 1A – Robotics I</h2>'
+            +paper(pid, abstract)+'</body></html>')
+
+
+class AamasProceedingsTests(unittest.TestCase):
+    def snapshots(self, root):
+        root.mkdir()
+        receipts = []
+        items = {'introduction': ('<title>AAMAS 2012</title><p>Aggregate withdrawals do not identify papers.</p>', aamas.ROOT)}
+        for index, section in enumerate(aamas.SECTIONS):
+            items[section] = (page(section, f'P{index}_1', section != 'extabstracts'), aamas.ROOT+'resources/'+section+'.html')
+        for key, (html, url) in items.items():
+            data = html.encode()
+            (root/(key+'.html')).write_bytes(data)
+            receipts.append({'url': url, 'status': 200, 'file': key+'.html', 'bytes': len(data),
+                             'sha256': hashlib.sha256(data).hexdigest(), 'finished_at': '2026-11-09T00:00:00+00:00'})
+        (root/'receipts.json').write_text(json.dumps({'receipts': receipts}))
+        return root
+
+    def test_hidden_abstract_and_author_badges_are_not_title_or_authors(self):
+        rows = aamas.parse_section(page('fullpapers', '1A_1'), 'fullpapers', '2026-11-09T00:00:00Z', {'sha256': 'proof'})
+        row, = rows
+        self.assertEqual(row['title'], 'A structured & auditable paper 1A_1')
+        self.assertEqual(row['abstract'], 'Research with evidence. More detail.')
+        self.assertEqual(row['authors'], ['Jane Doe', 'Bob Smith'])
+        self.assertEqual(row['metadata']['authors_display'], 'Jane Doe, Bob Smith')
+        self.assertEqual(row['url'], aamas.ROOT+'resources/fullpapers.html#1A_1')
+        self.assertEqual(row['metadata']['paper_url'], aamas.ROOT+'papers/1A_1.pdf')
+        self.assertEqual(row['metadata']['source_evidence'], {'sha256': 'proof'})
+
+    def test_publication_formats_and_session_topics_do_not_invent_submission_tracks(self):
+        for section, (_, fmt, track, _) in aamas.SECTIONS.items():
+            row, = aamas.parse_section(page(section, 'P_1', False), section, '2026-11-09T00:00:00Z', {})
+            self.assertEqual((row['track'], row['metadata']['publication_format']), (track, fmt))
+            self.assertIsNone(row['abstract'])
+            self.assertEqual(row['status'], 'accepted')
+            self.assertEqual(row['metadata']['decision_date_precision'], 'not_supplied')
+            self.assertEqual(row['metadata']['session']['title'], 'Session 1A – Robotics I')
+            self.assertIn({'namespace': 'aamas_proceedings:publication_format', 'value': fmt}, row['tags'])
+        self.assertEqual(aamas.SECTIONS['fullpapers'][2], 'proceedings_unspecified')
+        self.assertEqual(aamas.SECTIONS['extabstracts'][2], 'proceedings_unspecified')
+
+    def test_changed_edition_section_duplicate_id_or_pdf_link_is_rejected(self):
+        html = page('fullpapers', '1A_1')
+        for changed in [html.replace('AAMAS 2012', 'AAMAS 2025'),
+                        html.replace('<h1>Full Papers</h1>', '<h1>Rejected Papers</h1>'),
+                        html.replace('</body>', paper('1A_1')+'</body>'),
+                        html.replace('../papers/1A_1.pdf', 'https://example.org/1A_1.pdf'),
+                        html.replace('../papers/1A_1.pdf', '../papers/1A_2.pdf')]:
+            with self.subTest(changed=changed):
+                with self.assertRaises(ValueError):
+                    aamas.parse_section(changed, 'fullpapers', '2026-11-09T00:00:00Z', {})
+
+    def test_frozen_responses_require_checksums_success_and_safe_paths(self):
+        for failure in ['checksum', 'status', 'path']:
+            with self.subTest(failure=failure), tempfile.TemporaryDirectory() as temporary:
+                root = self.snapshots(Path(temporary)/'source')
+                path = root/'receipts.json'
+                receipts = json.loads(path.read_text())
+                item = receipts['receipts'][0]
+                if failure == 'checksum': item['sha256'] = '0'*64
+                elif failure == 'status': item['status'] = 404
+                else: item['file'] = '../outside.html'
+                path.write_text(json.dumps(receipts))
+                with self.assertRaises(ValueError):
+                    aamas.read_pages(snapshots=root)
+
+    def test_reviewed_section_counts_and_year_are_required(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            source = self.snapshots(root/'source')
+            with self.assertRaises(ValueError):
+                aamas.collect(2012, root/'out', snapshots=source)
+            self.assertFalse((root/'out/aamas-proceedings-2012.json').exists())
+            with self.assertRaises(ValueError):
+                aamas.collect(2027, root/'future', snapshots=source)
+            self.assertFalse((root/'future').exists())
+
+    def test_ids_colliding_across_sections_do_not_produce_a_completed_collection(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            source = self.snapshots(root/'source')
+            receipts_path = source/'receipts.json'
+            receipts = json.loads(receipts_path.read_text())
+            for item in receipts['receipts'][1:]:
+                path = source/item['file']
+                data = re.sub(r'P[0-9]_1', 'SAME_1', path.read_text()).encode()
+                path.write_bytes(data)
+                item.update(bytes=len(data), sha256=hashlib.sha256(data).hexdigest())
+            receipts_path.write_text(json.dumps(receipts))
+            small = {key: (*value[:3], 1) for key, value in aamas.SECTIONS.items()}
+            with patch.dict(aamas.SECTIONS, small, clear=True), self.assertRaises(ValueError):
+                aamas.collect(2012, root/'out', snapshots=source)
+            self.assertFalse((root/'out/aamas-proceedings-2012.json').exists())
+
+    def test_collection_and_native_ingestion_preserve_formats_evidence_and_missing_abstracts(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            source = self.snapshots(root/'source')
+            small = {key: (*value[:3], 1) for key, value in aamas.SECTIONS.items()}
+            with patch.dict(aamas.SECTIONS, small, clear=True):
+                result = aamas.collect(2012, root/'out', snapshots=source)
+            self.assertEqual(result['records'], 4)
+            self.assertEqual(len(result['files']), 3)
+            self.assertFalse(result['database_written'])
+            self.assertFalse(result['pdfs_downloaded'])
+            db = root/'sample.sqlite'
+            for manifest in result['files']:
+                path = Path(manifest['file'])
+                self.assertEqual(hashlib.sha256(path.read_bytes()).hexdigest(), manifest['file_sha256'])
+                for raw in path.read_text().splitlines():
+                    record = json.loads(raw)
+                    evidence = record['metadata']['source_evidence']
+                    self.assertEqual(hashlib.sha256((root/'out'/evidence['file']).read_bytes()).hexdigest(), evidence['sha256'])
+                ingest_file(db, path)
+            with sqlite3.connect(db) as connection:
+                self.assertEqual(connection.execute('SELECT count(*) FROM papers').fetchone()[0], 4)
+                self.assertEqual(connection.execute('SELECT count(*) FROM submissions').fetchone()[0], 4)
+                self.assertEqual(connection.execute("SELECT count(*) FROM decisions WHERE status='accepted'").fetchone()[0], 4)
+                self.assertEqual(connection.execute('SELECT count(*) FROM papers WHERE abstract IS NULL').fetchone()[0], 1)
+                metadata = [json.loads(r[0]) for r in connection.execute('SELECT metadata_json FROM source_records')]
+                self.assertEqual({r['publication_format'] for r in metadata}, {'full_paper','extended_abstract','demo','doctoral_abstract'})
+                namespaces = {r[0] for r in connection.execute('SELECT DISTINCT namespace FROM tags')}
+                self.assertEqual(namespaces, {'aamas_proceedings:publication_format', 'aamas_proceedings:session'})
+                self.assertEqual(connection.execute('PRAGMA foreign_key_check').fetchall(), [])
@@ -0,0 +1,89 @@
+"""Cross-source publisher identities must preserve attempts and decision history."""
+import hashlib
+import json
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+
+from paper_atlas.db.submissions import identities_for_row
+from paper_atlas.ingestion.records import ingest_file
+
+
+DOI = '10.1234/aamas.identity.example'
+
+
+def row(source, external_id, *, venue='AAMAS', year=2012, track='demo', status='accepted', identifiers=None):
+    return {'source': source, 'external_id': external_id,
+            'url': 'https://example.org/'+source+'/'+external_id,
+            'title': 'A shared publication with independently recorded evidence',
+            'abstract': 'An independently recorded source abstract.',
+            'authors': ['Jane Doe', 'Bob Smith'],
+            'identifiers': identifiers if identifiers is not None else {'doi': DOI},
+            'venue': venue, 'year': year, 'track': track, 'status': status,
+            'observed_at': '2026-11-09T00:00:00Z',
+            'raw_decision': source+' observed '+status,
+            'metadata': {'original_source': source}, 'tags': []}
+
+
+def ingest(db, root, record):
+    path = root/(record['source']+'-'+record['external_id'].replace('/', '-')+'.jsonl')
+    path.write_text(json.dumps(record)+'\n')
+    path.with_suffix('.manifest.json').write_text(json.dumps({
+        'source': record['source'], 'parser_version': 1, 'venue': record['venue'],
+        'year': record['year'], 'track': record['track'], 'count': 1,
+        'list_url': 'https://example.org/'+record['source'], 'status': 'partial',
+        'file_sha256': hashlib.sha256(path.read_bytes()).hexdigest(),
+        'missing_abstract_count': 0}))
+    ingest_file(db, path)
+
+
+class AamasPublicationIdentityTests(unittest.TestCase):
+    def test_only_accepted_known_publisher_rows_supply_publication_doi_identity(self):
+        record = row('aamas_proceedings', '2012/D1_1', identifiers={'doi': 'https://doi.org/'+DOI.upper()})
+        self.assertEqual(identities_for_row(record), [('publication_doi', DOI)])
+        for status in ['rejected', 'desk_rejected', 'withdrawn', 'under_review', 'unknown']:
+            with self.subTest(status=status):
+                self.assertEqual(identities_for_row({**record, 'status': status}), [])
+        self.assertEqual(identities_for_row({**record, 'source': 'unverified_source'}), [])
+
+    def test_same_edition_doi_joins_sources_in_both_orders_without_duplicate_attempts(self):
+        publisher = row('aamas_proceedings', '2012/D1_1')
+        bibliography = row('dblp', 'conf/atal/Example12')
+        for order in [(publisher, bibliography), (bibliography, publisher)]:
+            with self.subTest(first=order[0]['source']), tempfile.TemporaryDirectory() as temporary:
+                root = Path(temporary)
+                db = root/'sample.sqlite'
+                for record in order:
+                    ingest(db, root, record)
+                ingest(db, root, publisher)
+                with sqlite3.connect(db) as connection:
+                    self.assertEqual(connection.execute('SELECT count(*) FROM papers').fetchone()[0], 1)
+                    self.assertEqual(connection.execute('SELECT count(*) FROM source_records').fetchone()[0], 2)
+                    self.assertEqual(connection.execute('SELECT count(*) FROM submissions').fetchone()[0], 1)
+                    self.assertEqual(connection.execute('SELECT count(*) FROM submission_sources').fetchone()[0], 2)
+                    self.assertEqual(connection.execute('SELECT count(*) FROM decision_sources').fetchone()[0], 2)
+                    self.assertEqual(connection.execute('SELECT scheme,value FROM submission_identifiers').fetchall(), [('publication_doi', DOI)])
+                    metadata = [json.loads(r[0]) for r in connection.execute('SELECT metadata_json FROM source_records')]
+                    self.assertEqual({r['original_source'] for r in metadata}, {'aamas_proceedings', 'dblp'})
+                    self.assertEqual(connection.execute('PRAGMA foreign_key_check').fetchall(), [])
+
+    def test_cross_venue_rejection_and_distinct_tracks_remain_separate_attempts(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            db = root/'sample.sqlite'
+            rejected = row('openreview_snapshot', 'original-forum', venue='AAAI', year=2011,
+                           track='main', status='rejected', identifiers={'arxiv': '1101.00001', 'openreview': 'original-forum'})
+            accepted = row('aamas_proceedings', '2012/D1_1', identifiers={'arxiv': '1101.00001', 'doi': DOI})
+            another_track = row('aamas_proceedings', '2012/F1_1', track='proceedings_unspecified', identifiers={'doi': DOI})
+            for record in [rejected, accepted, another_track]:
+                ingest(db, root, record)
+            with sqlite3.connect(db) as connection:
+                self.assertEqual(connection.execute('SELECT count(*) FROM papers').fetchone()[0], 1)
+                self.assertEqual(connection.execute('SELECT count(*) FROM submissions').fetchone()[0], 3)
+                history = connection.execute('''SELECT v.acronym,e.year,e.track,d.status FROM decisions d
+                    JOIN submissions s ON s.id=d.submission_id JOIN editions e ON e.id=s.edition_id
+                    JOIN venues v ON v.id=e.venue_id ORDER BY v.acronym,e.track''').fetchall()
+                self.assertEqual(set(history), {('AAAI',2011,'main','rejected'),('AAMAS',2012,'demo','accepted'),('AAMAS',2012,'proceedings_unspecified','accepted')})
+                self.assertEqual(connection.execute('SELECT count(*) FROM decision_sources').fetchone()[0], 3)
+                self.assertEqual(connection.execute('PRAGMA foreign_key_check').fetchall(), [])
@@ -0,0 +1,81 @@
+"""Exact AMTCL volume provenance and native metadata/history preservation."""
+import copy
+import hashlib
+import json
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+import xml.etree.ElementTree as ET
+
+from paper_atlas.collectors.acl import collect_xml, volume_scope, text
+from paper_atlas.collectors.acl_historical import event_scope
+from paper_atlas.ingestion.records import ingest_file
+
+FIXTURE = Path(__file__).parent/'fixtures/acl-1963-earlymt.xml'
+COMMIT = 'a7be623d01c48c61405dec31c871121cdbed5a01'
+
+
+class Acl1963Tests(unittest.TestCase):
+    def setUp(self):
+        self.volume = ET.parse(FIXTURE).getroot().find('volume')
+        self.meta = self.volume.find('meta')
+
+    def test_official_snapshot_and_exact_scope(self):
+        self.assertEqual(hashlib.sha256(FIXTURE.read_bytes()).hexdigest(), '4a4626d792ac507de0281cb358769f7246f4a0d6b6a9176ac02e61545c1635fc')
+        self.assertEqual(len(self.volume.findall('paper')), 34)
+        self.assertEqual(volume_scope(self.meta, '1', '1963.earlymt'), ('ACL', ['ACL', 'AMTCL'], 'proceedings_unspecified'))
+        scope = event_scope(self.meta, '1', '1963.earlymt')
+        self.assertEqual(scope['original_venue'], 'EarlyMT')
+        self.assertEqual(scope['publication_format'], 'published_abstract')
+        self.assertEqual(scope['event_dates'], ['1963-08-25', '1963-08-26'])
+
+    def test_other_earlymt_collections_and_volumes_stay_excluded(self):
+        for collection, volume in [('1962.earlymt', '1'), ('1971.earlymt', '1'), ('1963.earlymt', '2'), ('1963.other', '1')]:
+            with self.subTest(collection=collection, volume=volume):
+                self.assertIsNone(volume_scope(self.meta, volume, collection))
+        self.assertIsNone(volume_scope(self.meta, '1'))
+
+    def test_scope_metadata_drift_and_duplicates_are_rejected(self):
+        for field in ['venue', 'year', 'booktitle', 'address', 'month']:
+            for duplicate in [False, True]:
+                meta = copy.deepcopy(self.meta)
+                if duplicate:
+                    ET.SubElement(meta, field).text = text(meta.find(field))
+                else:
+                    meta.find(field).text = 'changed'
+                with self.subTest(field=field, duplicate=duplicate), self.assertRaises(ValueError):
+                    volume_scope(meta, '1', '1963.earlymt')
+
+    def test_every_original_contribution_survives_collection(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest, = collect_xml(FIXTURE, tmp, COMMIT)
+            rows = [json.loads(raw) for raw in Path(manifest['file']).read_text().splitlines()]
+        self.assertEqual(manifest['count'], 34)
+        self.assertEqual(manifest['missing_abstract_count'], 0)
+        self.assertEqual(manifest['excluded_materials'], [])
+        for paper, row in zip(self.volume.findall('paper'), rows):
+            self.assertEqual(row['external_id'], '1963.earlymt-1.'+paper.attrib['id'])
+            self.assertEqual(row['title'], text(paper.find('title')))
+            self.assertEqual(row['abstract'], text(paper.find('abstract')))
+            self.assertEqual(row['authors'], [{'given':text(a.find('first')), 'family':text(a.find('last'))} for a in paper.findall('author')])
+            self.assertEqual(row['metadata']['venue_codes'], ['earlymt'])
+            self.assertEqual(row['metadata']['publication_format'], 'published_abstract')
+            self.assertEqual(row['tags'], [{'namespace':'acl_anthology:publication_format','value':'published_abstract'}])
+            self.assertEqual((row['venue'], row['track'], row['status']), ('ACL', 'proceedings_unspecified', 'accepted'))
+
+    def test_native_ingestion_is_idempotent_and_preserves_abstracts_and_history(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            manifest, = collect_xml(FIXTURE, root/'source', COMMIT)
+            db = root/'sample.sqlite'
+            ingest_file(db, manifest['file'])
+            ingest_file(db, manifest['file'])
+            with sqlite3.connect(db) as c:
+                for table in ['papers', 'source_records', 'submissions', 'decisions']:
+                    self.assertEqual(c.execute('SELECT count(*) FROM '+table).fetchone()[0], 34)
+                self.assertEqual(c.execute("SELECT count(*) FROM papers WHERE abstract IS NOT NULL AND abstract!=''").fetchone()[0], 34)
+                self.assertEqual(c.execute("SELECT DISTINCT status FROM decisions").fetchall(), [('accepted',)])
+                self.assertEqual(c.execute("SELECT v.acronym,e.year,e.track FROM editions e JOIN venues v ON v.id=e.venue_id").fetchall(), [('ACL',1963,'proceedings_unspecified')])
+                self.assertIsNone(c.execute("SELECT 1 FROM venue_aliases WHERE alias='EarlyMT'").fetchone())
+                self.assertEqual(c.execute("SELECT count(*) FROM paper_tags pt JOIN tags t ON t.id=pt.tag_id WHERE t.namespace='acl_anthology:publication_format' AND t.value='published_abstract'").fetchone()[0], 34)
@@ -0,0 +1,114 @@
+"""Pinned T78 evidence, edition-local aliases and an explicitly identified material."""
+import copy
+import hashlib
+import json
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+import xml.etree.ElementTree as ET
+
+from paper_atlas.collectors.acl import collect_xml, volume_scope
+from paper_atlas.collectors.acl_historical import event_scope, material_reason
+from paper_atlas.db.store import Store
+from paper_atlas.ingestion.records import ingest_file
+
+FIXTURE = Path(__file__).parent/'fixtures/acl-t78.xml'
+COMMIT = 'a7be623d01c48c61405dec31c871121cdbed5a01'
+
+
+class AclHistoricalTests(unittest.TestCase):
+    def setUp(self):
+        self.root = ET.parse(FIXTURE).getroot()
+        self.volume = self.root.find('volume')
+        self.meta = self.volume.find('meta')
+
+    def test_frozen_volume_matches_official_snapshot(self):
+        self.assertEqual(hashlib.sha256(FIXTURE.read_bytes()).hexdigest(), 'f712f94cff0cba05f786b7ac31dad2ea9408fde2a17a04531130df623f57dd84')
+        self.assertEqual(len(self.volume.findall('paper')), 36)
+        self.assertEqual(volume_scope(self.meta, '1', 'T78'), ('ACL+TINLAP', ['ACL', 'TINLAP'], 'proceedings_unspecified'))
+
+    def test_unknown_year_collection_or_volume_is_not_globally_aliased(self):
+        for collection, volume in [('T75', '1'), ('T87', '1'), ('T78', '2'), ('C65', '1')]:
+            with self.subTest(collection=collection, volume=volume):
+                self.assertIsNone(event_scope(self.meta, volume, collection))
+                self.assertIsNone(volume_scope(self.meta, volume, collection))
+        self.assertIsNone(volume_scope(self.meta, '1'))
+
+    def test_known_volume_scope_rejects_critical_metadata_drift(self):
+        for field, replacement in [('venue', 'acl'), ('year', '1979'), ('booktitle', 'Another TINLAP'), ('editor/first', 'Another')]:
+            changed = copy.deepcopy(self.meta)
+            changed.find(field).text = replacement
+            with self.subTest(field=field), self.assertRaises(ValueError):
+                event_scope(changed, '1', 'T78')
+        changed = copy.deepcopy(self.meta)
+        ET.SubElement(changed, 'year').text = '1978'
+        with self.assertRaises(ValueError):
+            event_scope(changed, '1', 'T78')
+
+    def test_evidence_retains_original_series_dates_and_role_boundary(self):
+        scope = event_scope(self.meta, '1', 'T78')
+        self.assertEqual(scope['original_venue'], 'TINLAP')
+        self.assertEqual(scope['event_dates'], ['1978-07-25', '1978-07-27'])
+        self.assertEqual([e['pdf_pages'] for e in scope['evidence']], [[9, 10], [3]])
+        self.assertIn('not identified', scope['track_scope_note'])
+        self.assertIn('pending', scope['evidence'][0]['scope'])
+
+    def test_only_exact_session_questions_material_is_excluded(self):
+        paper = copy.deepcopy(self.volume.findall('paper')[-1])
+        self.assertIn('Session question list', material_reason('T78', '1', paper))
+        self.assertIsNone(material_reason('C65', '1', paper))
+        self.assertIsNone(material_reason('T78', '2', paper))
+        paper.set('id', '37')
+        self.assertIsNone(material_reason('T78', '1', paper))
+        paper.set('id', '36')
+        ET.SubElement(paper, 'author')
+        with self.assertRaises(ValueError):
+            material_reason('T78', '1', paper)
+
+    def test_all_authored_source_fields_and_material_receipt_survive_collection(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            manifest, = collect_xml(FIXTURE, temporary, COMMIT)
+            rows = [json.loads(raw) for raw in Path(manifest['file']).read_text().splitlines()]
+        self.assertEqual(manifest['count'], 35)
+        self.assertEqual(manifest['xml_paper_elements'], 36)
+        self.assertEqual(manifest['missing_abstract_count'], 35)
+        self.assertEqual(manifest['excluded_materials'][0]['external_id'], 'T78-1036')
+        for number, row in enumerate(rows, 1):
+            paper = self.volume.findall('paper')[number-1]
+            self.assertEqual(row['external_id'], f'T78-1{number:03d}')
+            self.assertEqual(row['title'], ' '.join(''.join(paper.find('title').itertext()).split()))
+            self.assertEqual(row['metadata']['venue_codes'], ['tinlap'])
+            self.assertEqual(row['metadata']['historical_event_scope']['original_venue'], 'TINLAP')
+            self.assertEqual(row['metadata']['metadata_commit'], COMMIT)
+            self.assertEqual((row['status'], row['track'], row['abstract']), ('accepted', 'proceedings_unspecified', None))
+
+    def test_old_coling_scope_is_unchanged_by_calendar_replacement_evidence(self):
+        meta = ET.fromstring('<meta><venue>coling</venue><year>1965</year><booktitle>COLING 1965</booktitle></meta>')
+        self.assertEqual(volume_scope(meta, '1', 'C65'), ('COLING', ['COLING'], 'main'))
+        self.assertIsNone(event_scope(meta, '1', 'C65'))
+
+    def test_native_ingestion_does_not_alias_other_tinlap_years_or_infer_negative_status(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            manifest, = collect_xml(FIXTURE, root/'source', COMMIT)
+            db = root/'sample.sqlite'
+            store = Store(db)
+            pid, rid = store.record('test_control', 'tinlap1975', 'https://example.org/tinlap1975',
+                                    'An earlier TINLAP contribution', None, ['Jane Doe'])
+            store.decision(pid, rid, 'TINLAP', 1975, 'main', 'tinlap1975', 'https://example.org/tinlap1975', 'accepted', 'test control')
+            store.conn.commit()
+            store.conn.close()
+            ingest_file(db, manifest['file'])
+            ingest_file(db, manifest['file'])
+            with sqlite3.connect(db) as c:
+                self.assertEqual(c.execute('SELECT count(*) FROM papers').fetchone()[0], 36)
+                self.assertEqual(c.execute('SELECT count(*) FROM submissions').fetchone()[0], 36)
+                self.assertEqual(c.execute('SELECT count(*) FROM decisions').fetchone()[0], 36)
+                self.assertEqual(c.execute("SELECT count(*) FROM decisions WHERE status!='accepted'").fetchone()[0], 0)
+                self.assertIsNone(c.execute("SELECT 1 FROM source_records WHERE external_id='T78-1036'").fetchone())
+                aliases = c.execute('SELECT v.acronym,a.alias FROM venue_aliases a JOIN venues v ON v.id=a.venue_id ORDER BY a.alias').fetchall()
+                self.assertEqual(aliases, [('ACL+TINLAP', 'ACL'), ('ACL+TINLAP', 'TINLAP')])
+                metadata = json.loads(c.execute("SELECT metadata_json FROM source_records WHERE external_id='T78-1001'").fetchone()[0])
+                self.assertEqual(metadata['historical_event_scope']['event_year'], 1978)
+                self.assertEqual(c.execute('PRAGMA foreign_key_check').fetchall(), [])
@@ -0,0 +1,227 @@
+from contextlib import closing, redirect_stdout
+import io
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+import uuid
+
+from paper_atlas import querying
+from paper_atlas.curation.annotations import (assert_annotation, available, initialize, main,
+                                             observations, retract_annotation)
+from paper_atlas.db.backend import open_store
+from paper_atlas.db.store import Store
+from paper_atlas.postgres import schema
+from paper_atlas.postgres.client import connect
+from paper_atlas.postgres.migration import migrate
+
+
+class AnnotationTests(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)
+        self.c = self.store.conn
+        self.paper, self.record = self.store.record('fixture', 'one', 'https://example.org/one', 'First research', None, [])
+        self.other, self.other_record = self.store.record('fixture', 'two', 'https://example.org/two', 'Other research', None, [])
+        self.store.record_tags(self.paper, self.record, 'fixture', [{'namespace':'fixture:topic','value':'original'}])
+        self.c.commit()
+
+    def add(self, **changes):
+        args = dict(paper=self.paper, kind='tag', namespace='custom:topic', value='reading',
+                    request_id='request-one', evidence_key='manual:reading', reason='Reviewed metadata', actor='reviewer')
+        args.update(changes)
+        return assert_annotation(self.c, **args)
+
+    def query(self, *args):
+        self.c.commit()
+        with redirect_stdout(io.StringIO()) as output:
+            querying.main(['--db', str(self.db), *map(str, args)])
+        return json.loads(output.getvalue())
+
+    def test_read_does_not_install_extension_and_write_requires_explicit_init(self):
+        self.assertFalse(available(self.c))
+        self.assertEqual(observations(self.c, self.paper), [])
+        with self.assertRaisesRegex(RuntimeError, 'init explicitly'):
+            self.add()
+        self.assertEqual(self.query('--research-type', 'custom:method=empirical'), [])
+        self.assertFalse(available(self.c))
+        self.assertEqual(len(schema.inspect(self.c)), 21)
+
+    def test_schema_upgrade_is_transactional_and_marker_mismatch_fails_closed(self):
+        self.assertTrue(initialize(self.c)); self.c.rollback()
+        self.assertFalse(available(self.c))
+        self.c.execute("INSERT INTO schema_migrations(name) VALUES('annotation_events_v1')")
+        with self.assertRaisesRegex(RuntimeError, 'mismatch'):
+            initialize(self.c)
+        self.c.rollback()
+        self.assertTrue(initialize(self.c)); self.assertFalse(initialize(self.c))
+        self.assertEqual(len(schema.inspect(self.c)), 22)
+
+    def test_unmarked_table_cannot_receive_assertions(self):
+        initialize(self.c)
+        self.c.execute("DELETE FROM schema_migrations WHERE name='annotation_events_v1'")
+        with self.assertRaisesRegex(RuntimeError, 'init explicitly'):
+            self.add()
+        self.assertEqual(self.c.execute('SELECT count(*) FROM annotation_events').fetchone()[0], 0)
+
+    def test_types_tags_and_platform_labels_are_independent_and_queryable(self):
+        initialize(self.c)
+        self.add()
+        self.add(kind='research_type', namespace='custom:topic', request_id='type', value='reading')
+        self.assertEqual(len(self.query('--tag', 'custom:topic=reading')), 1)
+        self.assertEqual(len(self.query('--research-type', 'custom:topic=reading')), 1)
+        self.assertEqual(len(self.query('--tag', 'fixture:topic=original')), 1)
+        detail = self.query('--paper', self.paper)[0]
+        self.assertEqual(len(detail['annotation_tags']), 1)
+        self.assertEqual(len(detail['research_types']), 1)
+        self.assertNotIn('annotation_history', detail)
+        self.assertEqual(detail['tags'][0]['namespace'], 'fixture:topic')
+
+    def test_repeated_request_is_idempotent_and_changed_content_fails(self):
+        initialize(self.c); event = self.add()
+        self.assertEqual(self.add(), event)
+        for change in ({'value':'different'}, {'kind':'research_type'}, {'reason':'changed'}, {'paper':self.other}):
+            with self.assertRaisesRegex(ValueError, 'different annotation'):
+                self.add(**change)
+        self.assertEqual(self.c.execute('SELECT count(*) FROM annotation_events').fetchone()[0], 1)
+
+    def test_retraction_keeps_original_and_other_assertions_of_same_label(self):
+        initialize(self.c); first = self.add(); second = self.add(request_id='second', evidence_key='independent')
+        kwargs = dict(request_id='retract', reason='No longer relevant', actor='reviewer')
+        removed = retract_annotation(self.c, first, **kwargs)
+        self.assertEqual(retract_annotation(self.c, first, **kwargs), removed)
+        self.assertEqual([r['id'] for r in observations(self.c, self.paper)], [second])
+        self.assertEqual(len(self.query('--paper', self.paper, '--annotation-history')[0]['annotation_history']), 3)
+        with self.assertRaisesRegex(ValueError, 'already retracted'):
+            retract_annotation(self.c, first, **{**kwargs,'request_id':'duplicate'})
+        with self.assertRaisesRegex(ValueError, 'existing assertion'):
+            retract_annotation(self.c, removed, **{**kwargs,'request_id':'nested'})
+
+    def test_source_assertions_require_matching_paper_and_platform(self):
+        initialize(self.c)
+        for change in ({'namespace':'fixture:type'}, {'namespace':'other:type','source_record_id':self.record},
+                       {'namespace':'fixture:type','source_record_id':self.other_record}):
+            with self.assertRaises(ValueError):
+                self.add(**change)
+        event = self.add(kind='research_type', namespace='fixture:declared_type', source_record_id=self.record)
+        with self.assertRaisesRegex(ValueError, 'Manual CLI'):
+            retract_annotation(self.c, event, request_id='cannot', reason='x', actor='y', custom_only=True)
+        self.assertEqual(observations(self.c, self.paper)[0]['source_record_id'], self.record)
+
+    def test_platform_tag_refresh_preserves_both_custom_kinds(self):
+        initialize(self.c); self.add(); self.add(kind='research_type', request_id='type')
+        self.store.record_tags(self.paper, self.record, 'fixture', [{'namespace':'fixture:topic','value':'refreshed'}])
+        self.assertEqual(len(observations(self.c, self.paper)), 2)
+        self.assertEqual(len(self.query('--tag','fixture:topic=refreshed')), 1)
+        self.assertEqual(self.query('--tag','fixture:topic=original'), [])
+
+    def test_merge_preserves_retractions_evidence_and_original_paper_ids(self):
+        initialize(self.c); event = self.add(source_record_id=self.record)
+        removed = retract_annotation(self.c, event, request_id='withdraw', reason='corrected', actor='reviewer')
+        active = self.add(request_id='active', kind='research_type', value='survey')
+        self.store.merge(self.other, self.paper, 'Independently reviewed identity')
+        rows = observations(self.c, self.other, history=True)
+        self.assertEqual([r['id'] for r in rows], [event, removed, active])
+        self.assertEqual({r['original_paper_id'] for r in rows}, {self.paper})
+        self.assertEqual({r['paper_id'] for r in rows}, {self.other})
+        self.assertEqual([r['id'] for r in observations(self.c, self.other)], [active])
+        self.assertEqual(self.add(source_record_id=self.record), event)  # exact retry survives canonical merge
+        self.assertEqual(self.c.execute('PRAGMA foreign_key_check').fetchall(), [])
+
+    def test_invalid_input_does_not_create_events(self):
+        initialize(self.c)
+        for change in ({'paper':True}, {'paper':999999}, {'kind':'main'}, {'namespace':'arxiv'},
+                       {'namespace':'custom:topic;DROP'}, {'value':' '}, {'reason':''},
+                       {'actor':''}, {'request_id':''}, {'evidence_key':''}, {'source_record_id':True},
+                       {'evidence_url':'file:///etc/passwd'}, {'evidence_url':'https://user:secret@example.org/'}):
+            with self.subTest(change=change), self.assertRaises(ValueError):
+                self.add(**change)
+        self.assertEqual(self.c.execute('SELECT count(*) FROM annotation_events').fetchone()[0], 0)
+
+    def test_cli_manual_scope_and_complete_assert_retract_lifecycle(self):
+        with redirect_stdout(io.StringIO()):
+            main(['init','--db',str(self.db)])
+            main(['assert','--db',str(self.db),'--paper',str(self.paper),'--kind','research_type',
+                  '--namespace','custom:method','--value','empirical','--evidence-key','manual:review',
+                  '--request-id','cli-one','--reason','Read abstract','--actor','reviewer'])
+        self.assertEqual(len(self.query('--research-type','custom:method=empirical')), 1)
+        event = observations(self.c, self.paper)[0]['id']
+        with redirect_stdout(io.StringIO()):
+            main(['retract','--db',str(self.db),'--event',str(event),'--request-id','cli-two',
+                  '--reason','Corrected classification','--actor','reviewer'])
+        self.assertEqual(self.query('--research-type','custom:method=empirical'), [])
+        with redirect_stdout(io.StringIO()) as out:
+            main(['list','--db',str(self.db),'--paper',str(self.paper),'--history'])
+        self.assertEqual(len(json.loads(out.getvalue())), 2)
+
+
+@unittest.skipUnless(os.environ.get('PAPER_ATLAS_TEST_PG_SERVICE'), 'Requires approved remote PostgreSQL service')
+class PostgreSQLAnnotationTests(unittest.TestCase):
+    def setUp(self):
+        self.service = os.environ['PAPER_ATLAS_TEST_PG_SERVICE']
+        self.target = 'pa_anno_' + uuid.uuid4().hex[:12]
+        self.tmp = tempfile.TemporaryDirectory(); self.addCleanup(self.tmp.cleanup)
+        self.db = Path(self.tmp.name) / 'source.sqlite'
+        self.s = Store(self.db)
+        self.paper, self.record = self.s.record('fixture','one','https://example.org','Paper',None,[])
+        self.s.conn.commit()
+        self.addCleanup(self.s.conn.close); self.addCleanup(self.cleanup)
+
+    def cleanup(self):
+        with connect(self.service) as c:
+            for name, in c.execute('SELECT nspname FROM pg_namespace WHERE starts_with(nspname,%s)', (self.target,)):
+                c.execute('DROP SCHEMA ' + schema.quote(name) + ' CASCADE')
+
+    def migrate(self):
+        self.s.conn.commit()
+        self.s.conn.close()  # Freeze/checkpoint the fixture, just like a real source migration.
+        with redirect_stdout(io.StringIO()):
+            return migrate(self.db, self.service, Path(self.tmp.name)/'report.json', schema=self.target, min_free_gib=0)
+
+    def args(self, **changes):
+        a = dict(paper=self.paper,kind='research_type',namespace='custom:method',value='survey\x00and\x01',
+                 request_id='native',evidence_key='manual',reason='Reviewed\x00evidence',actor='reviewer')
+        a.update(changes); return a
+
+    def test_native_schema_upgrade_roundtrip_retraction_and_queries(self):
+        self.migrate()
+        with closing(open_store(pg_service=self.service, pg_schema=self.target).conn) as c:
+            self.assertTrue(initialize(c)); self.assertFalse(initialize(c))
+            event = assert_annotation(c, **self.args()); c.commit()
+            self.assertEqual(assert_annotation(c, **self.args()), event)
+            self.assertEqual(observations(c,self.paper)[0]['value'], 'survey\x00and\x01')
+            c.commit()
+        with redirect_stdout(io.StringIO()) as out:
+            querying.main(['--pg-service',self.service,'--pg-schema',self.target,'--paper',str(self.paper)])
+        self.assertEqual(json.loads(out.getvalue())[0]['research_types'][0]['id'], event)
+        with closing(open_store(pg_service=self.service,pg_schema=self.target).conn) as c:
+            retract_annotation(c,event,request_id='removed',reason='Changed',actor='reviewer');c.commit()
+            self.assertEqual(observations(c,self.paper), [])
+            self.assertEqual(len(observations(c,self.paper,history=True)), 2)
+
+    def test_initialized_sqlite_extension_migrates_all_rows_hashes_and_identity(self):
+        initialize(self.s.conn)
+        event = assert_annotation(self.s.conn, **self.args())
+        retract_annotation(self.s.conn,event,request_id='retracted',reason='Corrected',actor='reviewer')
+        report = self.migrate()
+        self.assertEqual(len(report['tables']),22)
+        self.assertEqual(report['tables']['annotation_events']['source_rows'],2)
+        self.assertEqual(report['tables']['annotation_events']['source_sha256'],report['tables']['annotation_events']['target_sha256'])
+        with closing(open_store(pg_service=self.service,pg_schema=self.target).conn) as c:
+            new = assert_annotation(c, **self.args(request_id='after-migration'))
+            self.assertGreater(new,2); c.commit()
+            self.assertEqual(len(observations(c,self.paper,history=True)),3)
+
+    def test_native_upgrade_rollback_keeps_legacy_schema_usable(self):
+        self.migrate()
+        with closing(open_store(pg_service=self.service,pg_schema=self.target).conn) as c:
+            initialize(c); c.rollback()
+            self.assertFalse(available(c))
+            self.assertEqual(c.execute('SELECT count(*) FROM papers').fetchone()[0],1)
+            self.assertTrue(initialize(c))
+            with self.assertRaises(ValueError):
+                assert_annotation(c, **self.args(namespace='wrong:type',source_record_id=self.record))
+            self.assertEqual(c.execute('SELECT count(*) FROM annotation_events').fetchone()[0],0)
+            c.rollback()
@@ -0,0 +1,141 @@
+import gzip
+import hashlib
+import json
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from paper_atlas.collectors.dblp import catalogue
+from paper_atlas.collectors.dblp_recovery import recover
+from paper_atlas.collectors.dblp_scope import scope
+from paper_atlas.ingestion.records import ingest_file
+
+
+class DblpRecoveryTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.root = Path(self.tmp.name)
+        self.dtd = self.root / 'dblp.dtd'
+        self.dtd.write_bytes(b'<!ENTITY eacute "&#233;">')
+        self.archive = self.root / 'dblp.xml.gz'
+        # These include a keynote and a workshop, neither a main-paper inference.
+        body = '''<proceedings key="conf/ifaamas/2025"><title>AAMAS 2025</title><year>2025</year></proceedings>
+<inproceedings key="conf/ifaamas/keynote"><author>Ren&eacute;</author><title>Keynote: Agents</title><year>2025</year><booktitle>AAMAS</booktitle><crossref>conf/ifaamas/2025</crossref></inproceedings>
+<inproceedings key="conf/ifaamas/paper"><author>Alice Doe</author><title>Research <i>agents</i></title><year>2025</year><booktitle>AAMAS</booktitle><crossref>conf/ifaamas/2025</crossref><ee>https://dl.acm.org/doi/10.5555/3709347.123</ee></inproceedings>
+<proceedings key="conf/ifaamas/2025w"><title>AAMAS Workshop</title><year>2025</year></proceedings>
+<inproceedings key="conf/ifaamas/workshop"><title>Workshop paper</title><year>2025</year><booktitle>AAMAS Workshop</booktitle><crossref>conf/ifaamas/2025w</crossref></inproceedings>
+<inproceedings key="conf/unrelated/other"><title>Other family</title><year>2025</year></inproceedings>'''
+        with gzip.open(self.archive, 'wb') as stream:
+            stream.write(('<?xml version="1.0"?><!DOCTYPE dblp SYSTEM "dblp.dtd"><dblp>'
+                          + body + '</dblp>').encode())
+        self.sha = hashlib.sha256(self.archive.read_bytes()).hexdigest()
+        self.md5 = hashlib.md5(self.dtd.read_bytes()).hexdigest()
+        self.manifest = catalogue(self.archive, self.dtd, self.root / 'catalogue',
+                                  self.sha, self.md5)
+        self.catalogue = Path(self.manifest['catalogue'])
+        self.manifest_path = self.catalogue.with_name('dblp-ai-candidates.manifest.json')
+
+    def run_recovery(self, **kwargs):
+        options = dict(expected_sha=self.sha, expected_dtd_md5=self.md5)
+        options.update(kwargs)
+        return recover(self.archive, self.dtd, self.catalogue, self.root / 'recovered',
+                       ['ifaamas'], **options)
+
+    def test_fresh_discovery_and_recovery_from_old_candidate_omission(self):
+        self.assertEqual(self.manifest['candidate_family_counts']['ifaamas'], 3)
+        # Simulate an older filter without altering its complete catalogue.
+        manifest = dict(self.manifest)
+        manifest['candidate_family_counts'] = {}
+        self.manifest_path.write_text(json.dumps(manifest))
+        candidate = Path(manifest['file'])
+        candidate.write_text('old incomplete candidate file\n')
+        before = {p: p.read_bytes() for p in [self.archive, self.dtd, self.catalogue,
+                                             self.manifest_path, candidate]}
+        with patch('urllib.request.urlopen', side_effect=AssertionError('No network')):
+            report = self.run_recovery()
+        rows = [json.loads(line) for line in Path(report['file']).read_text().splitlines()]
+        self.assertEqual(report['recovered_publications'], 3)
+        self.assertEqual(report['recovered_volumes'], 2)
+        self.assertEqual(report['recovered_records'], 5)
+        self.assertEqual(report['records_scanned'], 6)
+        self.assertEqual(report['old_candidate_family_counts'], {'ifaamas': 0})
+        self.assertFalse(report['database_written'])
+        self.assertEqual(next(r for r in rows if r['key'].endswith('/keynote'))['fields']['author'], ['René'])
+        self.assertTrue(any(r['key'].endswith('/workshop') for r in rows))
+        self.assertTrue(all(not ({'source', 'status', 'venue', 'track'} & r.keys()) for r in rows))
+        publication = next(r for r in rows if r['key'].endswith('/paper'))
+        volume = next(r for r in rows if r['key'] == 'conf/ifaamas/2025')
+        self.assertEqual(scope(publication, volume), (None, 'outside_target_family'))
+        self.assertEqual({p: p.read_bytes() for p in before}, before)
+        self.assertEqual(hashlib.sha256(Path(report['file']).read_bytes()).hexdigest(),
+                         report['file_sha256'])
+        # Raw recovery files cannot accidentally enter the normalized writer.
+        with patch('paper_atlas.ingestion.records.open_store') as writer:
+            with self.assertRaisesRegex(ValueError, 'source manifest'):
+                ingest_file(self.root / 'never.sqlite', report['file'])
+            writer.assert_not_called()
+        self.assertFalse((self.root / 'never.sqlite').exists())
+
+    def test_checksum_mismatch_does_not_publish(self):
+        for options in [{'expected_sha': '0' * 64}, {'expected_dtd_md5': '0' * 32}]:
+            with self.subTest(options=options), self.assertRaisesRegex(ValueError, 'checksum'):
+                self.run_recovery(**options)
+            self.assertFalse((self.root / 'recovered').exists())
+
+    def test_wrong_catalogue_snapshot_and_incomplete_totals_are_rejected(self):
+        for changes in [{'snapshot_sha256': '0' * 64}, {'dtd_md5': '0' * 32},
+                        {'records_scanned': 99}, {'record_types': {'proceedings': 2}}]:
+            manifest = {**self.manifest, **changes}
+            self.manifest_path.write_text(json.dumps(manifest))
+            with self.subTest(changes=changes), self.assertRaises(ValueError):
+                self.run_recovery()
+            self.assertFalse((self.root / 'recovered').exists())
+
+    def test_changed_family_count_does_not_publish_partial_result(self):
+        with sqlite3.connect(self.catalogue) as c:
+            c.execute("UPDATE family_counts SET count=count+1 WHERE family='ifaamas' AND record_type='inproceedings'")
+        with self.assertRaisesRegex(ValueError, 'family totals'):
+            self.run_recovery()
+        self.assertFalse((self.root / 'recovered').exists())
+
+    def test_changed_volume_metadata_is_detected(self):
+        with sqlite3.connect(self.catalogue) as c:
+            row = json.loads(c.execute("SELECT metadata_json FROM proceedings WHERE key='conf/ifaamas/2025'").fetchone()[0])
+            row['fields']['title'] = ['Wrong volume']
+            c.execute("UPDATE proceedings SET metadata_json=? WHERE key='conf/ifaamas/2025'", (json.dumps(row),))
+        with self.assertRaisesRegex(ValueError, 'proceedings differs'):
+            self.run_recovery()
+        self.assertFalse((self.root / 'recovered').exists())
+
+    def test_truncated_gzip_never_publishes(self):
+        self.archive.write_bytes(self.archive.read_bytes()[:-8])
+        revised_sha = hashlib.sha256(self.archive.read_bytes()).hexdigest()
+        self.manifest_path.write_text(json.dumps({**self.manifest, 'snapshot_sha256': revised_sha}))
+        with self.assertRaises((EOFError, OSError)):
+            self.run_recovery(expected_sha=revised_sha)
+        self.assertFalse((self.root / 'recovered').exists())
+
+    def test_existing_output_is_preserved_and_unknown_family_is_rejected(self):
+        out = self.root / 'recovered'
+        out.mkdir()
+        sentinel = out / 'keep'
+        sentinel.write_text('existing')
+        with self.assertRaisesRegex(ValueError, 'already exist'):
+            self.run_recovery()
+        self.assertEqual(sentinel.read_text(), 'existing')
+        for names in [[], ['../ifaamas'], ['not-a-supported-family'], [None]]:
+            with self.subTest(names=names), self.assertRaises(ValueError):
+                recover(self.archive, self.dtd, self.catalogue, self.root / 'other', names)
+
+    def test_requested_family_missing_from_catalogue_is_explicit(self):
+        with self.assertRaisesRegex(ValueError, 'absent from complete catalogue'):
+            recover(self.archive, self.dtd, self.catalogue, self.root / 'recovered',
+                    ['ifaamas', 'icml'], expected_sha=self.sha, expected_dtd_md5=self.md5)
+        self.assertFalse((self.root / 'recovered').exists())
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,159 @@
+"""Stable-attempt correction, rollback and stale whole-volume refresh on both engines."""
+from contextlib import closing, redirect_stdout
+import copy
+import hashlib
+import io
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+import uuid
+
+from paper_atlas.db.backend import open_store
+from paper_atlas.db.edition_scopes import KEY
+from paper_atlas.db.store import Store
+from paper_atlas.ingestion.edition_tracks import proposal,apply_plan,verify,validate,run
+from paper_atlas.ingestion.event_identity import database_identity,values
+from paper_atlas.ingestion.records import ingest_file
+from paper_atlas.postgres.client import connect
+from paper_atlas.postgres.migration import migrate
+from paper_atlas.postgres.schema import quote
+
+
+def seed(db):
+    s=Store(db); rows=[]
+    for i,track in enumerate(['main','survey','doctoral_consortium','proceedings_unspecified'],1):
+        external='entry'+str(i);doi='10.1234/entry'+str(i)
+        p,r=s.record('fixture',external,'https://example.org/'+external,'Publication '+external,
+                     'Abstract with NUL\x00 and SOH\x01',[],{'doi':doi})
+        eid=s.decision(p,r,'JOINT',2022,'main',external,'https://example.org/'+external,'accepted','published',identities=[('doi',doi)],observed_at='2022-01-01T00:00:00Z')
+        sid=s.conn.execute('SELECT id FROM submissions WHERE source_record_id=?',(r,)).fetchone()[0]
+        s.record_tags(p,r,'fixture',[{'namespace':'fixture:subject','value':'Original'}])
+        rows.append(dict(submission_id=sid,source_record_id=r,external_id=external,source='fixture',doi=doi,
+                         from_edition_id=eid,year=2022,venue='JOINT',venue_names=['JOINT'],track=track,
+                         section=track,evidence_url='https://example.org/proceedings/2022/',evidence_sha256='a'*64))
+    source=s.conn.execute("SELECT id FROM sources WHERE name='fixture'").fetchone()[0]
+    s.conn.execute("INSERT INTO edition_sources VALUES(?,?,?,'complete',4,4,'checkpoint','2022-01-01T00:00:00Z',NULL)",(eid,source,'https://example.org/volume'))
+    s.conn.commit();s.conn.close();return {'format':1,'records':rows}
+
+
+class TrackCases:
+    def store(self):return open_store(**self.target)
+
+    def plan(self,c):return proposal(c,self.inventory,database_identity(c,self.target.get('db')))
+
+    def test_move_preserves_all_history_tags_text_and_stable_identities(self):
+        with closing(self.store().conn)as c:
+            plan=self.plan(c);before=plan['before']['protected'];r=apply_plan(c,plan);c.commit()
+            self.assertEqual((r['events_moved'],r['records_verified']),(3,4))
+            self.assertEqual(r['protected'],before)
+            self.assertEqual(apply_plan(c,plan)['status'],'already_applied')
+            self.assertEqual(values(c.execute('SELECT status,expected_count,imported_count FROM edition_sources ORDER BY edition_id')),[['partial',1,1]]*4)
+            self.assertEqual(c.execute('SELECT count(*) FROM submissions').fetchone()[0],4)
+            self.assertEqual(c.execute('SELECT count(*) FROM decisions').fetchone()[0],4)
+            self.assertEqual(c.execute('SELECT count(*) FROM paper_merges').fetchone()[0],0)
+
+    def test_source_record_refresh_keeps_scope_and_original_attempt(self):
+        with closing(self.store().conn)as c:
+            plan=self.plan(c);apply_plan(c,plan);c.commit()
+        with closing(self.store().conn)as c:
+            # Use Store methods with the same writer connection as production.
+            s=object.__new__(Store);s.conn=c;s.event_identity=True
+            r=self.inventory['records'][1];metadata=json.loads(c.execute('SELECT metadata_json FROM source_records WHERE id=?',(r['source_record_id'],)).fetchone()[0]);saved=metadata[KEY]
+            p,record=s.record('fixture',r['external_id'],'https://example.org/new','Refreshed title',None,[],{'doi':r['doi']},{'new_source_field':True})
+            eid=s.decision(p,record,'JOINT',2022,'main',r['external_id'],'https://example.org/entry2','accepted','published',identities=[('doi',r['doi'])],observed_at='2022-01-01T00:00:00Z')
+            self.assertEqual(c.execute('SELECT track FROM editions WHERE id=?',(eid,)).fetchone()[0],'survey')
+            self.assertEqual(c.execute('SELECT count(*) FROM submissions').fetchone()[0],4)
+            self.assertEqual(json.loads(c.execute('SELECT metadata_json FROM source_records WHERE id=?',(record,)).fetchone()[0])[KEY],saved)
+            with self.assertRaisesRegex(ValueError,'cannot supply'):
+                s.record('fixture',r['external_id'],'https://example.org/new','Forged',None,[],metadata={KEY:[]})
+            c.rollback()
+
+    def test_stale_snapshot_and_partial_inventory_are_rejected(self):
+        with closing(self.store().conn)as c:
+            plan=self.plan(c)
+            c.execute("UPDATE papers SET title='Changed' WHERE id=(SELECT paper_id FROM submissions WHERE id=?)",(self.inventory['records'][0]['submission_id'],))
+            with self.assertRaisesRegex(ValueError,'Stale'):apply_plan(c,plan)
+            c.rollback()
+            bad=copy.deepcopy(self.inventory);bad['records'].pop()
+            with self.assertRaisesRegex(ValueError,'every attempt'):proposal(c,bad,database_identity(c,self.target.get('db')))
+            bad=copy.deepcopy(self.inventory);bad['records'][0]['doi']='10.1234/wrong'
+            with self.assertRaisesRegex(ValueError,'DOI'):proposal(c,bad,database_identity(c,self.target.get('db')))
+
+    def test_failure_after_updates_rolls_back_all_scope_and_metadata_changes(self):
+        with closing(self.store().conn)as c:
+            plan=self.plan(c)
+            # A late coverage failure must roll back earlier moved attempts.
+            source=c.execute("SELECT id FROM sources WHERE name='fixture'").fetchone()[0]
+            c.execute("INSERT INTO sources(name,homepage) VALUES('other','https://example.org')")
+            other=c.execute("SELECT id FROM sources WHERE name='other'").fetchone()[0]
+            c.execute('UPDATE edition_sources SET source_id=? WHERE source_id=?',(other,source));c.commit()
+            plan=self.plan(c)
+            try:
+                with self.assertRaisesRegex(ValueError,'outside'):apply_plan(c,plan)
+            finally:c.rollback()
+            self.assertEqual(self.plan(c)['before'],plan['before'])
+            self.assertEqual(c.execute('SELECT count(*) FROM editions').fetchone()[0],1)
+
+    def test_import_old_whole_volume_fails_without_corrupting_coverage(self):
+        with closing(self.store().conn)as c:
+            plan=self.plan(c);apply_plan(c,plan);c.commit()
+        r=self.inventory['records'][1];path=self.root/'old.jsonl'
+        row=dict(source='fixture',external_id=r['external_id'],url='https://example.org/entry2',title='Old title',authors=[],identifiers={'doi':r['doi']},venue='JOINT',year=2022,track='main',status='accepted')
+        path.write_text(json.dumps(row)+'\n');path.with_suffix('.manifest.json').write_text(json.dumps(dict(source='fixture',venue='JOINT',year=2022,track='main',count=1,list_url='https://example.org/volume',status='complete')))
+        with self.assertRaisesRegex(ValueError,'Recollect'):ingest_file(self.target.get('db'),path,**{k:v for k,v in self.target.items()if k!='db'})
+        with closing(self.store().conn)as c:verify(c,plan)
+
+    def test_nonempty_target_and_alias_drift_fail_before_moving(self):
+        with closing(self.store().conn)as c:
+            c.execute("INSERT INTO venue_aliases VALUES((SELECT id FROM venues WHERE acronym='JOINT'),'ADDED')")
+            with self.assertRaisesRegex(ValueError,'aliases'):self.plan(c)
+            c.rollback()
+            s=object.__new__(Store);s.conn=c;s.event_identity=True
+            p,r=s.record('fixture','collision','https://example.org/collision','Distinct contribution',None,[],{'doi':'10.1234/collision'})
+            s.decision(p,r,'JOINT',2022,'survey','collision','https://example.org/collision','accepted','published')
+            with self.assertRaisesRegex(ValueError,'Nonempty target'):self.plan(c)
+            c.rollback()
+            self.assertEqual(c.execute('SELECT count(*) FROM submissions').fetchone()[0],4)
+
+    def test_repeated_plan_detects_coverage_or_scope_evidence_drift(self):
+        with closing(self.store().conn)as c:
+            plan=self.plan(c);apply_plan(c,plan);c.commit()
+            c.execute("UPDATE edition_sources SET imported_count=99")
+            with self.assertRaisesRegex(ValueError,'coverage'):apply_plan(c,plan)
+            c.rollback()
+            record=self.inventory['records'][0]['source_record_id']
+            m=json.loads(c.execute('SELECT metadata_json FROM source_records WHERE id=?',(record,)).fetchone()[0]);m[KEY]=[]
+            c.execute('UPDATE source_records SET metadata_json=? WHERE id=?',(json.dumps(m),record))
+            with self.assertRaisesRegex(ValueError,'unchanged track'):apply_plan(c,plan)
+            c.rollback()
+
+    def test_cli_hash_binding_preflight_and_duplicate_inventory(self):
+        inventory=self.root/'inventory.json';inventory.write_text(json.dumps(self.inventory))
+        planfile=self.root/'plan.json';p=run(self.target.get('db'),planfile,inventory=inventory,**{k:v for k,v in self.target.items()if k!='db'})
+        with self.assertRaisesRegex(ValueError,'hash'):run(self.target.get('db'),self.root/'bad.json',plan=planfile,plan_sha256='0'*64,**{k:v for k,v in self.target.items()if k!='db'})
+        report=run(self.target.get('db'),self.root/'applied.json',plan=planfile,plan_sha256=hashlib.sha256(planfile.read_bytes()).hexdigest(),**{k:v for k,v in self.target.items()if k!='db'})
+        self.assertEqual(report['events_moved'],3)
+        bad=copy.deepcopy(self.inventory);bad['records'].append(bad['records'][0])
+        with self.assertRaisesRegex(ValueError,'Repeated'):validate(bad)
+
+
+class SQLiteTrackTests(TrackCases,unittest.TestCase):
+    def setUp(self):
+        t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name);db=self.root/'source.sqlite'
+        self.inventory=seed(db);self.target={'db':db}
+
+
+@unittest.skipUnless(os.environ.get('PAPER_ATLAS_TEST_PG_SERVICE'),'Requires approved remote PostgreSQL service')
+class PostgreSQLTrackTests(TrackCases,unittest.TestCase):
+    def setUp(self):
+        t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name);db=self.root/'source.sqlite';self.inventory=seed(db)
+        self.service=os.environ['PAPER_ATLAS_TEST_PG_SERVICE'];self.schema='pa_tracks_'+uuid.uuid4().hex[:12];self.addCleanup(self.cleanup)
+        with redirect_stdout(io.StringIO()):migrate(db,self.service,self.root/'migration.json',schema=self.schema,min_free_gib=0)
+        self.target={'pg_service':self.service,'pg_schema':self.schema}
+
+    def cleanup(self):
+        with connect(self.service)as c:
+            for name, in c.execute('SELECT nspname FROM pg_namespace WHERE starts_with(nspname,%s)',(self.schema,)):
+                c.execute('DROP SCHEMA '+quote(name)+' CASCADE')
@@ -0,0 +1,202 @@
+from contextlib import closing, redirect_stdout, contextmanager
+import io
+import json
+import os
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+import uuid
+from importlib.resources import files
+
+from paper_atlas.db.store import Store
+from paper_atlas.db.backend import open_store
+from paper_atlas.db.events import has_event_key
+from paper_atlas.collectors.dblp import XML_SHA
+from paper_atlas.ingestion.event_identity import plan, upgrade, exact_counts
+from paper_atlas.ingestion.records import ingest_file
+from paper_atlas.ingestion.backfill import backfill
+from paper_atlas.postgres.client import connect
+from paper_atlas.postgres.schema import quote
+from paper_atlas.postgres.migration import migrate
+from paper_atlas import querying
+
+
+@contextmanager
+def opened_store(**kwargs):
+    store=open_store(**kwargs)
+    try:
+        yield store
+    finally:
+        store.conn.close()
+
+
+def legacy(db):
+    sql = files('paper_atlas.db').joinpath('schema.sql').read_text().replace(" event_key TEXT NOT NULL DEFAULT '',\n", '').replace('UNIQUE(venue_id,year,track,event_key)', 'UNIQUE(venue_id,year,track)')
+    c = sqlite3.connect(db); c.executescript(sql); c.close()
+    s = Store(db)
+    p,r = s.record('dblp','conf/www/Fall95','https://example.org/fall','Same paper in two events',
+                    'Abstract\x00with\x01text',['A Person'],{'arxiv':'2501.00001'})
+    s.record_tags(p,r,'dblp',[{'namespace':'dblp:booktitle','value':'WWW (Fall)'}])
+    s.decision(p,r,'Legacy',1995,'main','conf/www/Fall95','https://example.org/accept','accepted','Accept')
+    s.conn.execute("UPDATE venues SET acronym='WWW',name='WWW'")
+    meta={'snapshot_sha256':XML_SHA,'proceedings_key':'conf/www/1995f','bibliographic_year':1995,
+          'bibliography':{'booktitle':['WWW (Fall)'],'url':['db/conf/www/www1995f.html#Fall95']}}
+    s.conn.execute('UPDATE source_records SET metadata_json=?',(json.dumps(meta),));s.conn.commit();s.conn.close()
+    return p,r
+
+
+def add(store, external, event=None, status='accepted', venue='WWW', year=1995):
+    p,r = store.record('fixture',external,'https://example.org/'+external,'Same paper in two events',
+                       'Abstract\x00with\x01text',['A Person'],{'arxiv':'2501.00001'})
+    edition = store.decision(p,r,venue,year,'main',external,'https://example.org/'+status,status,status,event_key=event)
+    return p,r,edition
+
+
+def file(root, name, rows, event=None):
+    p=root/(name+'.jsonl');p.write_text(''.join(json.dumps(r)+'\n'for r in rows))
+    manifest={'source':'fixture','venue':'WWW','year':1995,'track':'main','count':len(rows),'list_url':'https://example.org/'+name}
+    if event is not None:manifest['event_key']=event
+    p.with_suffix('.manifest.json').write_text(json.dumps(manifest));return p
+
+
+class EventIdentityTests(unittest.TestCase):
+    def setUp(self):
+        t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name);self.db=self.root/'sample.sqlite'
+
+    def test_same_paper_distinct_events_keep_both_attempts_and_decisions(self):
+        s=Store(self.db);self.addCleanup(s.conn.close)
+        paper,_,spring=add(s,'spring','www-1995-spring','rejected');_,_,fall=add(s,'fall','www-1995-fall')
+        s.conn.commit();self.assertNotEqual(spring,fall)
+        with redirect_stdout(io.StringIO())as out:querying.main(['--db',str(self.db),'--paper',str(paper)])
+        row=json.loads(out.getvalue())[0];self.assertEqual({a['event_key']for a in row['submissions']},{'www-1995-spring','www-1995-fall'})
+        self.assertEqual([a['event_key']for a in row['known_acceptances']],['www-1995-fall'])
+        self.assertEqual({a['latest_status']for a in row['submissions']},{'rejected','accepted'})
+        with redirect_stdout(io.StringIO())as out:querying.main(['--db',str(self.db),'--venue','WWW','--event-key','www-1995-spring','--status','rejected'])
+        self.assertEqual(len(json.loads(out.getvalue())),1)
+
+    def test_explicit_migration_preserves_ids_history_and_source_bytes(self):
+        paper,record=legacy(self.db);proposal=plan(self.db);self.assertFalse(proposal['before']['event_column'])
+        result=upgrade(proposal,self.db);self.assertEqual(result['updated_editions'],1)
+        self.assertEqual(result['after']['protected'],proposal['before']['protected'])
+        self.assertEqual(result['after']['editions_sha256'],proposal['before']['editions_sha256'])
+        self.assertEqual(upgrade(proposal,self.db)['status'],'already_applied')
+        s=Store(self.db);self.addCleanup(s.conn.close)
+        self.assertEqual(s.conn.execute('SELECT id,event_key FROM editions').fetchall(),[(1,'www-1995-fall')])
+        # An old file without event_key still has its original source anchor.
+        self.assertEqual(s.decision(paper,record,'WWW',1995,'main','conf/www/Fall95','https://example.org/accept','accepted','Accept'),1)
+        self.assertEqual(s.conn.execute('SELECT count(*) FROM submissions').fetchone()[0],1)
+        self.assertEqual(s.conn.execute('PRAGMA foreign_key_check').fetchall(),[])
+
+    def test_unverified_legacy_volume_is_not_automatically_labelled(self):
+        legacy(self.db)
+        with sqlite3.connect(self.db)as c:c.execute("UPDATE source_records SET metadata_json='{}'")
+        with self.assertRaisesRegex(ValueError,'complete pinned Fall'):plan(self.db)
+        with sqlite3.connect(self.db)as c:self.assertFalse(has_event_key(c))
+
+    def test_stale_plan_rolls_back_before_schema_change(self):
+        legacy(self.db);proposal=plan(self.db)
+        with sqlite3.connect(self.db)as c:c.execute("UPDATE editions SET track='unspecified'")
+        with self.assertRaisesRegex(ValueError,'stale'):upgrade(proposal,self.db)
+        with sqlite3.connect(self.db)as c:self.assertFalse(has_event_key(c));self.assertEqual(c.execute('SELECT track FROM editions').fetchone()[0],'unspecified')
+
+    def test_unscoped_source_and_wrong_refresh_event_fail(self):
+        s=Store(self.db);self.addCleanup(s.conn.close);_,r,e=add(s,'first','www-1995-fall');s.conn.commit()
+        p,r2=s.record('fixture','unscoped','https://example.org/u','Other work',None,[])
+        with self.assertRaisesRegex(ValueError,'event_key'):s.decision(p,r2,'WWW',1995,'main','unscoped','https://example.org/u','accepted','Accept')
+        with self.assertRaisesRegex(ValueError,'Cannot move'):s.decision(p,r,'WWW',1995,'main','first','https://example.org/u','accepted','Accept',event_key='www-1995-spring')
+        self.assertEqual(s.conn.execute('SELECT count(*) FROM editions').fetchone()[0],1)
+
+    def test_pinned_fall_cannot_claim_spring(self):
+        p,r=legacy(self.db);upgrade(plan(self.db),self.db);s=Store(self.db);self.addCleanup(s.conn.close)
+        with self.assertRaisesRegex(ValueError,'pinned WWW Fall'):s.decision(p,r,'WWW',1995,'main','conf/www/Fall95','https://example.org/u','accepted','Accept',event_key='www-1995-spring')
+
+    def test_manifest_event_mismatch_rolls_back_the_whole_file(self):
+        s=Store(self.db);s.conn.close()
+        base={'source':'fixture','venue':'WWW','year':1995,'track':'main','status':'accepted','title':'Input work','url':'https://example.org/p','authors':[]}
+        path=file(self.root,'bad',[dict(base,external_id='a',event_key='www-1995-spring'),dict(base,external_id='b',event_key='www-1995-fall')],'www-1995-spring')
+        with self.assertRaisesRegex(ValueError,'edition differs'):ingest_file(self.db,path)
+        with sqlite3.connect(self.db)as c:
+            self.assertEqual(c.execute('SELECT count(*) FROM papers').fetchone()[0],0)
+            self.assertEqual(c.execute('SELECT count(*) FROM editions').fetchone()[0],0)
+
+    def test_backfill_selects_the_explicit_event_and_preserves_attempts(self):
+        s=Store(self.db);add(s,'spring','www-1995-spring','rejected');add(s,'fall','www-1995-fall');s.conn.commit();s.conn.close()
+        row={'source':'fixture','external_id':'fall','venue':'WWW','year':1995,'track':'main','event_key':'www-1995-fall','status':'accepted','identifiers':{'openreview':'forumFall'}}
+        path=file(self.root,'backfill',[row],'www-1995-fall')
+        with redirect_stdout(io.StringIO()):result=backfill(self.db,[path])
+        self.assertEqual(result['submissions_after'],2)
+        with sqlite3.connect(self.db)as c:
+            self.assertEqual(c.execute("SELECT e.event_key FROM submission_identifiers si JOIN submissions s ON s.id=si.submission_id JOIN editions e ON e.id=s.edition_id WHERE si.scheme='openreview' AND si.value='forumFall'").fetchone()[0],'www-1995-fall')
+
+    def test_exact_paged_counts_cover_composite_key_boundaries(self):
+        s=Store(self.db);self.addCleanup(s.conn.close)
+        for i in range(7):add(s,'entry'+str(i),'www-1995-fall')
+        s.conn.commit();events=[];counts=exact_counts(s.conn,page_size=2,progress=events.append)
+        self.assertEqual(counts['source_records'],7)
+        self.assertEqual(counts['identifiers'],8)
+        self.assertEqual(counts['submission_sources'],7)
+        self.assertEqual([e['rows_counted']for e in events if e['table']=='identifiers'and e['complete']],[8])
+
+    def test_legacy_single_event_writes_and_reads_remain_available(self):
+        legacy(self.db);s=Store(self.db);self.addCleanup(s.conn.close)
+        add(s,'ordinary',venue='COLM',year=2025);s.conn.commit()
+        with redirect_stdout(io.StringIO())as out:querying.main(['--db',str(self.db),'--venue','COLM'])
+        self.assertEqual(json.loads(out.getvalue())[0]['known_acceptances'][-1]['event_key'],'')
+        with self.assertRaisesRegex(ValueError,'migration required'):
+            querying.main(['--db',str(self.db),'--event-key','www-1995-fall'])
+
+    def test_unexpected_extra_edition_column_requires_review(self):
+        legacy(self.db)
+        with sqlite3.connect(self.db)as c:c.execute('ALTER TABLE editions ADD COLUMN custom_data TEXT')
+        with self.assertRaisesRegex(ValueError,'Unexpected edition schema'):plan(self.db)
+
+    def test_file_spanning_two_events_without_manifest_key_rolls_back(self):
+        Store(self.db).conn.close()
+        base={'source':'fixture','venue':'WWW','year':1995,'track':'main','status':'accepted','title':'Input work','url':'https://example.org/p','authors':[]}
+        path=file(self.root,'two',[dict(base,external_id='a',event_key='www-1995-spring'),dict(base,external_id='b',event_key='www-1995-fall')])
+        with self.assertRaisesRegex(ValueError,'exactly one'):ingest_file(self.db,path)
+        with sqlite3.connect(self.db)as c:self.assertEqual(c.execute('SELECT count(*) FROM submissions').fetchone()[0],0)
+
+    def test_cutover_sqlite_backup_remains_protected(self):
+        legacy(self.db);proposal=plan(self.db);Path(str(self.db.resolve())+'.postgresql-cutover.json').write_text('{}')
+        with self.assertRaisesRegex(RuntimeError,'cut over'):upgrade(proposal,self.db)
+
+
+@unittest.skipUnless(os.environ.get('PAPER_ATLAS_TEST_PG_SERVICE'),'Requires approved remote PostgreSQL test service')
+class PostgreSQLEventIdentityTests(unittest.TestCase):
+    def setUp(self):
+        self.service=os.environ['PAPER_ATLAS_TEST_PG_SERVICE'];self.schema='pa_event_'+uuid.uuid4().hex[:12]
+        t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name);self.db=self.root/'seed.sqlite';legacy(self.db)
+        self.addCleanup(self.cleanup)
+        with redirect_stdout(io.StringIO()):migrate(self.db,self.service,self.root/'migrate.json',schema=self.schema,min_free_gib=0)
+
+    def cleanup(self):
+        with connect(self.service)as c:
+            for (name,)in c.execute('SELECT nspname FROM pg_namespace WHERE starts_with(nspname,%s)',(self.schema,)).fetchall():c.execute('DROP SCHEMA '+quote(name)+' CASCADE')
+
+    def test_native_upgrade_preserves_ids_and_codec_then_accepts_separate_event(self):
+        proposal=plan(pg_service=self.service,pg_schema=self.schema)
+        result=upgrade(proposal,pg_service=self.service,pg_schema=self.schema)
+        self.assertEqual(result['after']['protected'],proposal['before']['protected'])
+        self.assertEqual(upgrade(proposal,pg_service=self.service,pg_schema=self.schema)['status'],'already_applied')
+        with opened_store(pg_service=self.service,pg_schema=self.schema)as s:
+            paper,_,spring=add(s,'spring','www-1995-spring','rejected');s.conn.commit()
+            self.assertNotEqual(spring,1)
+            self.assertEqual(s.conn.execute('SELECT abstract FROM papers WHERE id=?',(paper,)).fetchone()[0],'Abstract\x00with\x01text')
+        with redirect_stdout(io.StringIO())as out:querying.main(['--pg-service',self.service,'--pg-schema',self.schema,'--paper',str(paper)])
+        row=json.loads(out.getvalue())[0];self.assertEqual(len(row['submissions']),2);self.assertEqual(len(row['known_acceptances']),1)
+
+    def test_native_paged_counts_preserve_encoded_composite_key_order(self):
+        with opened_store(pg_service=self.service,pg_schema=self.schema)as s:
+            for value in ['a\x00b','a\x01b','a\x02b','z']:
+                s.conn.execute('INSERT INTO identifiers(scheme,value,paper_id) VALUES(?,?,?)',('custom',value,1))
+            s.conn.commit();counts=exact_counts(s.conn,page_size=2)
+            self.assertEqual(counts['identifiers'],6)
+            self.assertEqual(counts['submissions'],1)
+
+    def test_stale_native_plan_is_rejected_and_lock_released(self):
+        proposal=plan(pg_service=self.service,pg_schema=self.schema)
+        with opened_store(pg_service=self.service,pg_schema=self.schema)as s:s.conn.execute("UPDATE editions SET track='unspecified'");s.conn.commit()
+        with self.assertRaisesRegex(ValueError,'stale'):upgrade(proposal,pg_service=self.service,pg_schema=self.schema)
+        with opened_store(pg_service=self.service,pg_schema=self.schema)as s:self.assertFalse(has_event_key(s.conn))
@@ -0,0 +1,151 @@
+"""Original series, exact edition boundaries, and complete candidate discovery."""
+from contextlib import closing
+from copy import deepcopy
+import gzip
+import hashlib
+import json
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from paper_atlas.collectors.dblp import catalogue, XML_SHA
+from paper_atlas.collectors.dblp_records import collect, normalize_row
+from paper_atlas.ingestion.records import ingest_file
+
+FIXTURE = json.loads((Path(__file__).parent/'fixtures/historical_predecessors.json').read_text())
+EXAMPLES = {row['key']: row for row in FIXTURE['volumes']}
+
+
+def example(key, *, bibliographic_year=None):
+    fixed = EXAMPLES[key]
+    family = key.split('/')[1]
+    year = int(key.split('/')[-1])
+    volume = {'record_type': 'proceedings', 'key': key, 'fields': deepcopy(fixed['fields'])}
+    row = {'record_type': 'inproceedings', 'key': f'conf/{family}/SyntheticExample{year}', 'publtype': None,
+           'fields': {'title': [f'Synthetic historical research example {family} {year}'],
+                      'author': ['Jane Doe 0001', 'John Smith'], 'booktitle': fixed['fields']['booktitle'],
+                      'year': [str(bibliographic_year or year)], 'crossref': [key],
+                      'ee': [f'https://doi.org/10.1234/synthetic.{family}.{year}']}}
+    return row, volume
+
+
+class HistoricalPredecessorTests(unittest.TestCase):
+    def normalize(self, key, **kwargs):
+        row, volume = example(key, **kwargs)
+        fixed = EXAMPLES[key]
+        result, reason = normalize_row(row, {key: volume}, {fixed['expected_target_family']})
+        self.assertIsNone(reason)
+        self.assertIsNotNone(result)
+        return result
+
+    def test_ewsl_primary_series_retains_original_name_and_family_alias(self):
+        for year in [1987, 1988, 1989, 1991]:
+            with self.subTest(year=year):
+                record = self.normalize(f'conf/ecml/{year}')
+                self.assertEqual((record['venue'],record['venue_aliases'],record['year'],record['track']), ('EWSL',['ECML-PKDD'],year,'main'))
+                proof = record['metadata']['historical_predecessor_evidence']
+                self.assertEqual(proof['original_series'], 'EWSL')
+                self.assertEqual(proof['history_url'], 'https://ecmlpkdd2011.org/pastConferences.php')
+                self.assertEqual(record['metadata']['bibliography']['booktitle'], ['EWSL'])
+                self.assertEqual(record['metadata']['author_names_raw'], ['Jane Doe 0001','John Smith'])
+                self.assertEqual(record['authors'], ['Jane Doe','John Smith'])
+        self.assertEqual(EXAMPLES['conf/ecml/1989']['bibliographic_counts'], [])
+
+    def test_eps_ecp_ewsp_keep_original_series_instead_of_renaming_to_icaps(self):
+        for key in ['conf/aips/1990','conf/ecp/1997','conf/ecp/1999','conf/ewsp/1991']:
+            with self.subTest(key=key):
+                record = self.normalize(key)
+                fixed = EXAMPLES[key]
+                self.assertEqual(record['venue'], fixed['expected_original_series'])
+                self.assertEqual(record['venue_aliases'], ['ICAPS'])
+                self.assertEqual(record['track'], 'main')
+                proof = record['metadata']['historical_predecessor_evidence']
+                self.assertEqual(proof['history_url'], 'https://www.icaps-conference.org/conference-series/')
+                self.assertEqual(proof['proceedings_title'], fixed['fields']['title'][0])
+                self.assertEqual(proof['proceedings_year_fields'], fixed['fields']['year'])
+
+    def test_altered_titles_keys_suffixes_publication_years_and_unreviewed_editions_stay_held(self):
+        for key in ['conf/ecml/1988','conf/aips/1990','conf/ecp/1997','conf/ewsp/1991']:
+            row, volume = example(key)
+            for changed in ['title','key','suffix','publication_year']:
+                with self.subTest(key=key, changed=changed):
+                    r, v = deepcopy(row), deepcopy(volume)
+                    if changed == 'title': v['fields']['title'][0] += ', Affiliated Workshop'
+                    elif changed == 'key': v['key'] += 'w'; r['fields']['crossref'] = [v['key']]
+                    elif changed == 'suffix': r['fields']['booktitle'][0] += ' (Workshop)'
+                    else: v['fields']['year'] = ['2001']
+                    result, _ = normalize_row(r, {v['key']: v}, {EXAMPLES[key]['expected_target_family']})
+                    self.assertIsNone(result)
+        row, volume = example('conf/ecp/1997')
+        row['fields']['year'] = ['2001']; row['fields']['crossref'] = ['conf/ecp/2001']
+        volume['key'] = 'conf/ecp/2001'; volume['fields']['year'] = ['2001']
+        self.assertIsNone(normalize_row(row, {volume['key']:volume}, {'ICAPS'})[0])
+
+    def test_ecp1999_event_and_bibliographic_years_are_independently_retained(self):
+        record = self.normalize('conf/ecp/1999', bibliographic_year=2000)
+        self.assertEqual(record['year'], 1999)
+        self.assertEqual(record['metadata']['bibliographic_year'], 2000)
+        self.assertEqual(record['metadata']['bibliography']['year'], ['2000'])
+        self.assertEqual(record['metadata']['historical_predecessor_evidence']['proceedings_year_fields'], ['2000'])
+        self.assertEqual(record['metadata']['historical_predecessor_evidence']['event_year'], 1999)
+
+    def test_old_candidates_require_new_families_only_when_requested_years_need_them(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary); row, volume = example('conf/aips/1990')
+            db = root/'dblp-catalogue.sqlite'
+            with closing(sqlite3.connect(db)) as connection, connection:
+                connection.execute('CREATE TABLE proceedings(key TEXT PRIMARY KEY,metadata_json TEXT)')
+                connection.execute('INSERT INTO proceedings VALUES(?,?)', (volume['key'],json.dumps(volume)))
+            candidate = root/'candidate.jsonl'; candidate.write_text(json.dumps(row)+'\n')
+            db.with_name('dblp-ai-candidates.manifest.json').write_text(json.dumps({
+                'snapshot_sha256': XML_SHA, 'candidate_sha256': hashlib.sha256(candidate.read_bytes()).hexdigest(),
+                'candidate_records': 1, 'candidate_family_counts': {'aips':1},
+                'record_types': {'proceedings':1,'inproceedings':1}}))
+            # Tiny CI fixtures may live on tmpfs; production reserve is tested separately.
+            with patch('paper_atlas.collectors.dblp_records.shutil.disk_usage', return_value=SimpleNamespace(free=16*1024**3)):
+                result = collect(db, root/'early', ['ICAPS'], candidates=candidate, through_year=1990)
+            self.assertEqual((result['normalized_records'],result['files'][0]['venue']), (1,'EPS'))
+            for year, missing in [(1991,'ICAPS/ewsp'),(1997,'ICAPS/ecp')]:
+                out = root/str(year); out.mkdir(); sentinel=out/'previous.txt';sentinel.write_text('accepted previous output')
+                with self.subTest(year=year), self.assertRaisesRegex(ValueError, missing):
+                    collect(db, out, ['ICAPS'], candidates=candidate, through_year=year)
+                self.assertEqual(sentinel.read_text(), 'accepted previous output')
+                self.assertFalse((out/'dblp-normalization.json').exists())
+
+    def test_new_catalogue_includes_previously_missing_families_without_decision_inference(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary);dtd=root/'dblp.dtd';dtd.write_bytes(b'<!ENTITY eacute "&#233;">')
+            archive=root/'dblp.xml.gz'
+            body=''.join(f'<inproceedings key="conf/{family}/Synthetic"><title>Synthetic example</title><year>{year}</year><booktitle>{book}</booktitle><crossref>conf/{family}/{year}</crossref></inproceedings>' for family,year,book in [('ecp',1997,'ECP'),('ewsp',1991,'EWSP')])
+            with gzip.open(archive,'wb') as stream:stream.write(('<?xml version="1.0"?><!DOCTYPE dblp SYSTEM "dblp.dtd"><dblp>'+body+'</dblp>').encode())
+            result=catalogue(archive,dtd,root/'out',hashlib.sha256(archive.read_bytes()).hexdigest(),hashlib.md5(dtd.read_bytes()).hexdigest())
+            rows=[json.loads(line)for line in Path(result['file']).read_text().splitlines()]
+            self.assertEqual({r['key'] for r in rows}, {'conf/ecp/Synthetic','conf/ewsp/Synthetic'})
+            self.assertEqual(result['candidate_records'], 2)
+            self.assertTrue(all('status' not in r and 'venue' not in r for r in rows))
+
+    def test_native_import_keeps_original_series_aliases_and_full_source_evidence(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root=Path(temporary);db=root/'sample.sqlite'
+            for key in ['conf/ecml/1988','conf/ecp/1999']:
+                record=self.normalize(key);path=root/(key.replace('/','-')+'.jsonl')
+                path.write_text(json.dumps(record,ensure_ascii=False)+'\n')
+                path.with_suffix('.manifest.json').write_text(json.dumps({'source':'dblp','venue':record['venue'],'year':record['year'],'track':'main','count':1,'list_url':'https://doi.org/10.4230/dblp.xml.2026-11-01','file_sha256':hashlib.sha256(path.read_bytes()).hexdigest(),'status':'partial','missing_abstract_count':1}))
+                ingest_file(db,path)
+            with closing(sqlite3.connect(db)) as connection:
+                rows=connection.execute('SELECT v.acronym,a.alias,e.year FROM editions e JOIN venues v ON v.id=e.venue_id JOIN venue_aliases a ON a.venue_id=v.id ORDER BY v.acronym').fetchall()
+                self.assertEqual(rows,[('ECP','ICAPS',1999),('EWSL','ECML-PKDD',1988)])
+                metadata=[json.loads(r[0])for r in connection.execute('SELECT metadata_json FROM source_records')]
+                self.assertEqual({r['historical_predecessor_evidence']['original_series'] for r in metadata}, {'ECP','EWSL'})
+                self.assertEqual(connection.execute('SELECT count(*) FROM decisions WHERE status=?',('accepted',)).fetchone()[0],2)
+                self.assertEqual(connection.execute('PRAGMA foreign_key_check').fetchall(),[])
+
+    def test_existing_aips_normalization_remains_original_aips(self):
+        row, volume=example('conf/aips/1990');row['fields']['booktitle']=['AIPS'];row['fields']['year']=['1994'];row['fields']['crossref']=['conf/aips/1994']
+        volume['key']='conf/aips/1994';volume['fields']['title']=['AIPS 1994 Proceedings'];volume['fields']['year']=['1994']
+        record,reason=normalize_row(row,{volume['key']:volume},{'ICAPS'})
+        self.assertIsNone(reason);self.assertEqual((record['venue'],record['venue_aliases']),('AIPS',['ICAPS']))
+        self.assertNotIn('historical_predecessor_evidence',record['metadata'])
@@ -0,0 +1,115 @@
+"""Regression coverage for primary series once named Workshop, with strict scope boundaries."""
+from contextlib import closing
+import hashlib
+import json
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+
+from paper_atlas.collectors.dblp_records import normalize_row
+from paper_atlas.collectors.dblp_scope import scope
+from paper_atlas.ingestion.records import ingest_file
+
+ICML_HISTORY = 'https://icml.cc/Conferences/2008/past_icmls.shtml.html'
+IROS_HISTORY = 'https://www.ieee-ras.org/conferences-workshops/financially-co-sponsored/iros/iros-past-and-future-venues/'
+
+
+class HistoricalPrimarySeriesTests(unittest.TestCase):
+    def example(self, family, year, title, book=None, key=None):
+        key = key or f'conf/{family}/{year}'
+        book = book or ('ML' if family == 'icml' else 'IROS')
+        row = {'record_type':'inproceedings', 'key':f'conf/{family}/Paper{year}', 'publtype':None,
+               'fields':{'title':['An independently identified historical research paper'],
+                         'author':['Jane Doe'], 'booktitle':[book], 'year':[str(year)],
+                         'crossref':[key], 'ee':[f'https://doi.org/10.1234/{family}.{year}']}}
+        volume = {'record_type':'proceedings', 'key':key,
+                  'fields':{'title':[title], 'year':[str(year)]}}
+        return row, volume
+
+    def test_icml_workshop_primary_editions_are_not_silently_filtered(self):
+        examples = {
+            1989:'Proceedings of the Sixth International Workshop on Machine Learning (ML 1989), Cornell University, Ithaca, New York, USA, June 26-27, 1989',
+            1991:'Proceedings of the Eighth International Workshop (ML91), Northwestern University, Evanston, Illinois, USA',
+            1992:'Proceedings of the Ninth International Workshop on Machine Learning (ML 1992), Aberdeen, Scotland, UK, July 1-3, 1992',
+        }
+        for year, title in examples.items():
+            with self.subTest(year=year):
+                row, volume = self.example('icml', year, title)
+                record, reason = normalize_row(row, {volume['key']:volume}, {'ICML'})
+                self.assertIsNone(reason)
+                self.assertEqual((record['venue'],record['year'],record['track'],record['status']), ('ICML',year,'main','accepted'))
+                self.assertEqual(record['metadata']['proceedings_title'], title)
+                self.assertEqual(record['metadata']['track_scope_evidence_url'], ICML_HISTORY)
+                self.assertEqual(record['metadata']['bibliographic_year'], year)
+
+    def test_iros_first_three_editions_are_primary_series(self):
+        examples = {
+            1988:"IEEE International Workshop on Intelligent Robots and Systems '88, Proceedings. IROS 1988, Tokyo, Japan, October 31 - November 2, 1988",
+            1989:"IEEE International Workshop on Intelligent Robots and Systems '89, Proceedings. IROS 1989, September 4-6, 1989, Tsukuba, Japan",
+            1990:"IEEE International Workshop on Intelligent Robots and Systems '90, Towards a New Frontier of Applications, Proceedings. IROS 1990, July 3-6, 1990, Ibaraki, Japan",
+        }
+        for year, title in examples.items():
+            with self.subTest(year=year):
+                row, volume = self.example('iros', year, title)
+                record, reason = normalize_row(row, {volume['key']:volume}, {'IROS'})
+                self.assertIsNone(reason)
+                self.assertEqual((record['venue'],record['year'],record['track']), ('IROS',year,'main'))
+                self.assertEqual(record['metadata']['proceedings_title'], title)
+                self.assertEqual(record['metadata']['track_scope_evidence_url'], IROS_HISTORY)
+
+    def test_main_named_icml_predecessors_also_carry_primary_scope_provenance(self):
+        examples = {
+            1988:'Machine Learning, Proceedings of the Fifth International Conference on Machine Learning, Ann Arbor, Michigan, USA, June 12-14, 1988',
+            1990:'Machine Learning, Proceedings of the Seventh International Conference on Machine Learning, Austin, Texas, USA, June 21-23, 1990',
+        }
+        for year, title in examples.items():
+            row, volume = self.example('icml', year, title)
+            edition, reason = scope(row, volume)
+            self.assertIsNone(reason)
+            self.assertEqual(edition['track'], 'main')
+            self.assertEqual(edition['track_scope_evidence_url'], ICML_HISTORY)
+
+    def test_wrong_keys_titles_suffixes_and_unknown_years_keep_workshop_boundary(self):
+        title = 'Proceedings of the Eighth International Workshop (ML91), Northwestern University, Evanston, Illinois, USA'
+        for year, changed, book, key in [
+            (1991,title,'ML','conf/icml/1991w'),
+            (1991,title,'ML (Workshops)','conf/icml/1991'),
+            (1991,title.replace('Eighth','Ninth'),'ML','conf/icml/1991'),
+            (1991,title + ', Affiliated Workshop','ML','conf/icml/1991'),
+            (1987,'Machine Learning Workshop 1987, Irvine','ML','conf/icml/1987'),
+        ]:
+            with self.subTest(year=year, book=book, key=key, title=changed):
+                row, volume = self.example('icml',year,changed,book,key)
+                record, reason = normalize_row(row,{volume['key']:volume},{'ICML'})
+                self.assertIsNone(record)
+                self.assertEqual(reason,'separate_workshop')
+                self.assertNotIn('track_scope_evidence_url',scope(row,volume)[0])
+        title = "IEEE International Workshop on Intelligent Robots and Systems '88, Proceedings. IROS 1988, Tokyo, Japan, October 31 - November 2, 1988"
+        for changed, book, key in [
+            (title,'IROS','conf/iros/1988w'),
+            (title,'IROS (Workshops)','conf/iros/1988'),
+            (title.replace('Tokyo','Another city'),'IROS','conf/iros/1988'),
+        ]:
+            row, volume = self.example('iros',1988,changed,book,key)
+            self.assertEqual(normalize_row(row,{volume['key']:volume},{'IROS'})[1],'separate_workshop')
+
+    def test_primary_scope_proof_survives_native_file_ingestion(self):
+        title = 'Proceedings of the Eighth International Workshop (ML91), Northwestern University, Evanston, Illinois, USA'
+        row, volume = self.example('icml',1991,title)
+        record, reason = normalize_row(row,{volume['key']:volume},{'ICML'})
+        self.assertIsNone(reason)
+        with tempfile.TemporaryDirectory() as temporary:
+            root=Path(temporary);path=root/'records.jsonl';path.write_text(json.dumps(record)+'\n')
+            path.with_suffix('.manifest.json').write_text(json.dumps({'source':'dblp','count':1,'list_url':ICML_HISTORY,'file_sha256':hashlib.sha256(path.read_bytes()).hexdigest()}))
+            ingest_file(root/'test.sqlite',path)
+            with closing(sqlite3.connect(root/'test.sqlite')) as connection:
+                self.assertEqual(connection.execute('SELECT track FROM editions').fetchone()[0],'main')
+                self.assertEqual(connection.execute('SELECT status FROM decisions').fetchone()[0],'accepted')
+                metadata=json.loads(connection.execute('SELECT metadata_json FROM source_records').fetchone()[0])
+                self.assertEqual(metadata['proceedings_title'],title)
+                self.assertEqual(metadata['track_scope_evidence_url'],ICML_HISTORY)
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,148 @@
+"""Historical accepted lists, repeated presentations and preserved work histories."""
+import hashlib
+import json
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from paper_atlas.collectors import iclr_archive as archive
+from paper_atlas.db.store import Store
+from paper_atlas.ingestion.records import ingest_file
+
+OBSERVED = '2026-11-09T00:00:00Z'
+
+
+def entry(identifier, title='A shared research paper', display='Jane Doe and Bob Smith'):
+    return f'<li><div><a href="http://arxiv.org/abs/{identifier}">{title}</a>, {display}</div></li>'
+
+
+def page2015():
+    return ('<h3>Main Conference - Oral Presentations</h3><ol>'+entry('1412.0001v2')+'</ol>'
+            '<h3>Main Conference - Poster Presentations</h3><ol>'+entry('1412.0001v2')+'</ol>'
+            '<h3>Workshop Papers</h3><ol>'+entry('1412.0002', 'A workshop paper')+'</ol>')
+
+
+class IclrArchiveTests(unittest.TestCase):
+    def frozen(self, root, year, html):
+        root.mkdir()
+        data = html.encode()
+        (root/'page.html').write_bytes(data)
+        receipt = {'url': archive.PAGES[year][0], 'file': 'page.html', 'status': 200,
+                   'bytes': len(data), 'sha256': hashlib.sha256(data).hexdigest(), 'finished_at': OBSERVED}
+        (root/'receipts.json').write_text(json.dumps({'receipts': [receipt]}))
+        return root
+
+    def test_oral_poster_repeat_is_one_attempt_with_all_source_variants(self):
+        rows = archive.parse_page(page2015(), 2015, {'observed_at': OBSERVED})
+        main, workshop = rows
+        self.assertEqual((main['track'], workshop['track']), ('main', 'workshop'))
+        self.assertEqual(main['identifiers'], {'arxiv': '1412.0001'})
+        self.assertEqual(main['external_id'], '2015/main/1412.0001')
+        self.assertEqual(main['metadata']['presentations'], ['oral', 'poster'])
+        self.assertEqual(len(main['metadata']['source_variants']), 2)
+        self.assertEqual(main['metadata']['source_variants'][0]['version'], 'v2')
+        self.assertEqual(main['authors'], ['Jane Doe', 'Bob Smith'])
+        self.assertTrue(all(r['status'] == 'accepted' and r['abstract'] is None for r in rows))
+
+    def test_2014_author_span_outside_paragraph_and_trailing_separator(self):
+        html = ('<h3>Conference Proceedings</h3><p>conference papers accepted</p>'
+                '<div><b><a href="http://arxiv.org/abs/1312.0001">A <i>research</i> title</a></b></div>'
+                '<p><span style="font-style: italic">Jane Doe; </span>'
+                '<span style="font-style:italic">Bob Smith; Carol Wu;</span></p>'
+                '<div><a href="http://arxiv.org/abs/1312.0002">Another title</a>'
+                '<div><i><span>First Author; </span><span>Second Author</span></i></div></div>')
+        row, unwrapped = archive.parse_page(html, 2014, {'observed_at': OBSERVED})
+        self.assertEqual(row['title'], 'A research title')
+        self.assertEqual(row['authors'], ['Jane Doe', 'Bob Smith', 'Carol Wu'])
+        self.assertEqual(row['metadata']['source_variants'][0]['authors_display'], 'Jane Doe; Bob Smith; Carol Wu;')
+        self.assertEqual(row['track'], 'main')
+        self.assertEqual(unwrapped['authors'], ['First Author', 'Second Author'])
+
+    def test_same_arxiv_in_different_tracks_keeps_separate_source_attempts(self):
+        html = page2015().replace('1412.0002', '1412.0001v3')
+        rows = archive.parse_page(html, 2015, {'observed_at': OBSERVED})
+        self.assertEqual(len(rows), 2)
+        self.assertEqual({r['external_id'] for r in rows}, {'2015/main/1412.0001', '2015/workshop/1412.0001'})
+        self.assertEqual(rows[1]['metadata']['source_variants'][0]['version'], 'v3')
+
+    def test_2016_code_links_and_breaks_do_not_become_authors(self):
+        html = ('<h1>Accepted Papers (Conference Track)</h1><h3>Oral Presentations</h3><ol>'
+                '<li><a href="http://arxiv.org/abs/1511.00001">A title</a>'
+                '<a href="https://example.org/code">[code]</a><br>Jane Doe, Bob Smith</li></ol>'
+                '<h3>Poster Presentations</h3>')
+        row, = archive.parse_page(html, 2016, {'observed_at': OBSERVED})
+        self.assertEqual(row['authors'], ['Jane Doe', 'Bob Smith'])
+        self.assertEqual(row['metadata']['presentations'], ['oral'])
+
+    def test_conflicting_repeat_unknown_sections_and_unparsed_links_fail(self):
+        variants = [page2015().replace('Poster Presentations', 'Other Presentations'),
+                    page2015().replace('</ol>', '</ol><a href="http://arxiv.org/abs/1412.0003">stray</a>', 1),
+                    page2015().replace('Jane Doe and Bob Smith', 'Different Author', 1)]
+        for html in variants:
+            with self.subTest(html=html), self.assertRaises(ValueError):
+                archive.parse_page(html, 2015, {'observed_at': OBSERVED})
+
+    def test_arxiv_versions_are_preserved_and_unsafe_links_rejected(self):
+        self.assertEqual(archive.arxiv_link('https://arxiv.org/pdf/1511.00001v3.pdf'), ('1511.00001', 'v3'))
+        self.assertIsNone(archive.arxiv_link('https://arxiv.org.example.org/abs/1511.00001'))
+        for url in ['https://arxiv.org/abs/1511.00001?other=1', 'ftp://arxiv.org/abs/1511.00001',
+                    'https://user@arxiv.org/abs/1511.00001', 'https://arxiv.org/abs/not-a-paper']:
+            with self.subTest(url=url), self.assertRaises(ValueError):
+                archive.arxiv_link(url)
+
+    def test_receipt_hash_status_path_and_symlink_cannot_escape_snapshot(self):
+        for failure in ['hash', 'status', 'path', 'symlink']:
+            with self.subTest(failure=failure), tempfile.TemporaryDirectory() as temporary:
+                root = Path(temporary)
+                source = self.frozen(root/'source', 2015, page2015())
+                file = source/'receipts.json'
+                data = json.loads(file.read_text())
+                receipt = data['receipts'][0]
+                if failure == 'hash': receipt['sha256'] = '0'*64
+                elif failure == 'status': receipt['status'] = 404
+                elif failure == 'path': receipt['file'] = '../outside.html'
+                else:
+                    (root/'outside.html').write_text(page2015())
+                    (source/'page.html').unlink()
+                    (source/'page.html').symlink_to(root/'outside.html')
+                file.write_text(json.dumps(data))
+                with self.assertRaises(ValueError):
+                    archive.read_page(2015, snapshots=source)
+
+    def test_changed_inventory_leaves_no_completed_output(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            source = self.frozen(root/'source', 2015, page2015())
+            with self.assertRaises(ValueError):
+                archive.collect(2015, root/'out', snapshots=source)
+            self.assertFalse((root/'out/iclr-archive-2015.json').exists())
+
+    def test_native_import_keeps_rejected_to_accepted_history_and_abstract(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            source = self.frozen(root/'source', 2015, page2015())
+            with patch.dict(archive.PAGES, {2015: (archive.PAGES[2015][0], {'main': 1, 'workshop': 1})}):
+                result = archive.collect(2015, root/'out', snapshots=source)
+                with self.assertRaises(FileExistsError):
+                    archive.collect(2015, root/'out', snapshots=source)
+            db = root/'sample.sqlite'
+            store = Store(db)
+            pid, rid = store.record('arxiv', '1412.0001', 'https://arxiv.org/abs/1412.0001',
+                                    'A shared research paper', 'Keep this canonical abstract.',
+                                    ['Jane Doe', 'Bob Smith'], {'arxiv': '1412.0001'}, {})
+            store.decision(pid, rid, 'Earlier Conference', 2014, 'main', 'original-attempt',
+                           'https://example.org/rejected', 'rejected', 'explicit earlier decision', observed_at=OBSERVED)
+            store.conn.commit()
+            store.conn.close()
+            for manifest in result['files']:
+                ingest_file(db, manifest['file'])
+                ingest_file(db, manifest['file'])
+            with sqlite3.connect(db) as c:
+                self.assertEqual(c.execute('SELECT count(*) FROM papers').fetchone()[0], 2)
+                self.assertEqual(c.execute('SELECT abstract FROM papers WHERE id=?', (pid,)).fetchone()[0], 'Keep this canonical abstract.')
+                history = c.execute('SELECT v.acronym,e.year,d.status FROM decisions d JOIN submissions s ON s.id=d.submission_id JOIN editions e ON e.id=s.edition_id JOIN venues v ON v.id=e.venue_id WHERE s.paper_id=? ORDER BY e.year', (pid,)).fetchall()
+                self.assertEqual(history, [('Earlier Conference', 2014, 'rejected'), ('ICLR', 2015, 'accepted')])
+                self.assertEqual(c.execute('SELECT count(*) FROM submissions').fetchone()[0], 3)
+                self.assertEqual(c.execute('PRAGMA foreign_key_check').fetchall(), [])
@@ -0,0 +1,187 @@
+from contextlib import closing, redirect_stdout
+import hashlib
+import io
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+import uuid
+
+from paper_atlas.collectors.dblp import XML_SHA
+from paper_atlas.collectors.dblp_scope import scope
+from paper_atlas.collectors.dblp_records import normalize_row
+from paper_atlas.db.store import Store
+from paper_atlas.db.backend import open_store
+from paper_atlas.ingestion.joint_editions import (TARGET, MARKER, inspect, apply_plan, run)
+from paper_atlas.postgres.client import connect
+from paper_atlas.postgres.migration import migrate
+from paper_atlas.postgres.schema import quote
+from paper_atlas import querying
+
+
+def seed(store):
+    c = store.conn
+    c.execute("INSERT INTO venues(acronym,name,field,venue_type) VALUES(?,?,'reasoning','conference')", (TARGET,TARGET))
+    target = c.execute('SELECT id FROM venues WHERE acronym=?',(TARGET,)).fetchone()[0]
+    for alias in ['ECAI','IJCAI']:
+        c.execute('INSERT INTO venue_aliases VALUES(?,?)',(target,alias))
+    for year in [2018,2019,2022]:
+        metadata = {'snapshot_sha256':XML_SHA,'proceedings_key':'conf/ijcai/'+str(year),
+                    'bibliographic_year':year,'bibliography':{'booktitle':['IJCAI']}}
+        p,r=store.record('dblp','conf/ijcai/fixture'+str(year),'https://dblp.org/rec/fixture',
+                         'Original publication '+str(year),'Abstract\x00with\x01data',[],
+                         {'doi':'10.24963/ijcai.'+str(year)+'/1'}, {})
+        store.record_tags(p,r,'dblp',[{'namespace':'dblp:booktitle','value':'IJCAI'}])
+        store.decision(p,r,'IJCAI',year,'main','fixture'+str(year),'https://example.org/decision','accepted','listed')
+        stored=json.loads(c.execute('SELECT metadata_json FROM source_records WHERE id=?',(r,)).fetchone()[0]);stored.update(metadata)
+        c.execute('UPDATE source_records SET metadata_json=? WHERE id=?',(json.dumps(stored),r))
+    c.commit()
+
+
+def plan(c):
+    return {**inspect(c),'database':{'engine':'sqlite','path':'fixture'}}
+
+
+class JointEditionTests(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)
+        seed(self.store); self.c=self.store.conn
+
+    def test_apply_preserves_every_protected_row_and_edition_id(self):
+        before=plan(self.c); ids=[r['id']for r in before['editions']]
+        result=apply_plan(self.c,before);self.c.commit()
+        self.assertEqual(result['updated_editions'],2)
+        self.assertEqual(result['content_fingerprints'],before['content_fingerprints'])
+        self.assertEqual([r['id']for r in result['editions']],ids)
+        untouched=self.c.execute('SELECT v.acronym FROM editions e JOIN venues v ON v.id=e.venue_id WHERE e.year=2019').fetchone()[0]
+        self.assertEqual(untouched,'IJCAI')
+        self.assertEqual(self.c.execute('PRAGMA foreign_key_check').fetchall(),[])
+        self.assertEqual(self.c.execute('SELECT count(*) FROM schema_migrations WHERE name=?',(MARKER,)).fetchone()[0],1)
+        with redirect_stdout(io.StringIO())as out:
+            querying.main(['--db',str(self.db),'--venue','ECAI'])
+        self.assertEqual(len(json.loads(out.getvalue())),2)
+        self.assertEqual(apply_plan(self.c,before)['updated_editions'],0)
+
+    def test_refresh_of_old_normalized_source_does_not_recreate_ordinary_edition(self):
+        before=plan(self.c);apply_plan(self.c,before)
+        for year in [2018,2022]:
+            row=self.c.execute('''SELECT r.paper_id,r.id,d.observed_at FROM source_records r
+                JOIN submissions s ON s.source_record_id=r.id JOIN decisions d ON d.submission_id=s.id
+                WHERE r.external_id=?''',('conf/ijcai/fixture'+str(year),)).fetchone()
+            self.store.decision(row[0],row[1],'IJCAI',year,'main','fixture'+str(year),
+                                'https://example.org/decision','accepted','listed',observed_at=row[2])
+        self.assertEqual(inspect(self.c)['content_fingerprints'],before['content_fingerprints'])
+        self.assertEqual(self.c.execute('SELECT count(*) FROM editions').fetchone()[0],3)
+
+    def test_any_changed_source_text_rejects_stale_plan_before_membership_updates(self):
+        before=plan(self.c)
+        self.c.execute("UPDATE source_records SET title='New evidence' WHERE external_id='conf/ijcai/fixture2018'")
+        with self.assertRaisesRegex(ValueError,'Stale repair plan'):
+            apply_plan(self.c,before)
+        self.assertEqual(inspect(self.c)['status'],'ready')
+
+    def test_conflicting_target_edition_is_never_merged_or_deleted(self):
+        target=self.c.execute('SELECT id FROM venues WHERE acronym=?',(TARGET,)).fetchone()[0]
+        self.c.execute("INSERT INTO editions(venue_id,year,track) VALUES(?,2018,'main')",(target,))
+        with self.assertRaisesRegex(ValueError,'colliding'):
+            inspect(self.c)
+        self.assertEqual(self.c.execute('SELECT count(*) FROM editions WHERE year=2018').fetchone()[0],2)
+
+    def test_wrong_source_volume_and_snapshot_fail_closed(self):
+        original=self.c.execute("SELECT metadata_json FROM source_records WHERE external_id='conf/ijcai/fixture2018'").fetchone()[0]
+        for key,value in [('proceedings_key','conf/ijcai/2018w'),('snapshot_sha256','wrong'),('bibliographic_year',2017),('bibliography',{'booktitle':['Other']})]:
+            m=json.loads(original);m[key]=value
+            self.c.execute("UPDATE source_records SET metadata_json=? WHERE external_id='conf/ijcai/fixture2018'",(json.dumps(m),))
+            with self.subTest(key=key),self.assertRaisesRegex(ValueError,'Source evidence'):
+                inspect(self.c)
+
+    def test_missing_source_support_and_wrong_aliases_are_not_guessed(self):
+        self.c.execute("DELETE FROM venue_aliases WHERE alias='ECAI'")
+        with self.assertRaisesRegex(ValueError,'aliases'):
+            inspect(self.c)
+        self.c.rollback()
+        self.c.execute('DELETE FROM submission_sources WHERE source_record_id=(SELECT id FROM source_records WHERE external_id=?)',('conf/ijcai/fixture2022',))
+        with self.assertRaisesRegex(ValueError,'Every submission'):
+            inspect(self.c)
+
+    def test_cli_plan_readonly_hash_binding_identity_and_repeat_apply(self):
+        out=Path(self.tmp.name)/'plan.json'
+        with redirect_stdout(io.StringIO()):run(self.db,out)
+        self.assertEqual(inspect(self.c)['status'],'ready')
+        raw=out.read_bytes();sha=hashlib.sha256(raw).hexdigest()
+        with patch('paper_atlas.ingestion.joint_editions.open_store')as writer:
+            with self.assertRaisesRegex(ValueError,'hash differs'):
+                run(self.db,Path(self.tmp.name)/'bad.json',plan=out,plan_sha256='0'*64)
+            writer.assert_not_called()
+        with redirect_stdout(io.StringIO()):
+            result=run(self.db,Path(self.tmp.name)/'applied.json',plan=out,plan_sha256=sha)
+            again=run(self.db,Path(self.tmp.name)/'retry.json',plan=out,plan_sha256=sha)
+        self.assertEqual(result['updated_editions'],2);self.assertEqual(again['updated_editions'],0)
+        self.assertEqual(result['plan_sha256'],sha);self.assertEqual(again['plan_sha256'],sha)
+        altered=json.loads(raw);altered['database']['path']='another.sqlite'
+        bad=Path(self.tmp.name)/'wrong-db.json';bad.write_text(json.dumps(altered))
+        with self.assertRaisesRegex(ValueError,'another database'):
+            run(self.db,Path(self.tmp.name)/'wrong-result.json',plan=bad,plan_sha256=hashlib.sha256(bad.read_bytes()).hexdigest())
+
+    def test_invalid_empty_plan_fails_before_opening_writer(self):
+        f=Path(self.tmp.name)/'empty.json';f.write_text('{}')
+        with patch('paper_atlas.ingestion.joint_editions.open_store')as writer:
+            with self.assertRaises(ValueError):
+                run(self.db,Path(self.tmp.name)/'empty-result.json',plan=f,plan_sha256=hashlib.sha256(f.read_bytes()).hexdigest())
+            writer.assert_not_called()
+
+    def test_collector_only_changes_the_two_exact_main_volume_keys(self):
+        for year in [2018,2019,2022]:
+            volume={'key':'conf/ijcai/'+str(year),'fields':{'title':['IJCAI '+str(year)],'year':[str(year)]}}
+            row={'record_type':'inproceedings','key':'conf/ijcai/One'+str(year),'fields':{'booktitle':['IJCAI'],
+                 'year':[str(year)],'crossref':[volume['key']],'title':['Original research title'],
+                 'author':['Jane Doe'],'ee':['https://doi.org/10.24963/ijcai.'+str(year)+'/1']}}
+            result,error=normalize_row(row,{volume['key']:volume},{'IJCAI','ECAI'})
+            self.assertIsNone(error)
+            self.assertEqual(result['venue'],TARGET if year in(2018,2022)else'IJCAI')
+            self.assertEqual(result['metadata']['bibliography']['booktitle'],['IJCAI'])
+            self.assertEqual(result['title'],'Original research title')
+            if year in(2018,2022):
+                self.assertIn('joint_edition_evidence',result['metadata'])
+                row['fields']['booktitle']=['IJCAI (Workshop)']
+                scoped,_=scope(row,volume)
+                self.assertEqual(scoped['venue'],'IJCAI')
+                self.assertEqual(scoped['track'],'workshop')
+
+
+@unittest.skipUnless(os.environ.get('PAPER_ATLAS_TEST_PG_SERVICE'),'Requires approved remote PostgreSQL service')
+class PostgreSQLJointTests(unittest.TestCase):
+    def setUp(self):
+        self.service=os.environ['PAPER_ATLAS_TEST_PG_SERVICE'];self.target='pa_joint_'+uuid.uuid4().hex[:12]
+        self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup)
+        self.db=Path(self.tmp.name)/'sample.sqlite';s=Store(self.db);seed(s);s.conn.close()
+        self.addCleanup(self.cleanup)
+        with redirect_stdout(io.StringIO()):migrate(self.db,self.service,Path(self.tmp.name)/'migration.json',schema=self.target,min_free_gib=0)
+
+    def cleanup(self):
+        with connect(self.service)as c:
+            for name, in c.execute('SELECT nspname FROM pg_namespace WHERE starts_with(nspname,%s)',(self.target,)).fetchall():
+                c.execute('DROP SCHEMA '+quote(name)+' CASCADE')
+
+    def test_native_repair_is_idempotent_keeps_codec_and_provenance(self):
+        p=Path(self.tmp.name)/'plan.json'
+        with redirect_stdout(io.StringIO()):
+            before=run(None,p,pg_service=self.service,pg_schema=self.target)
+            after=run(None,Path(self.tmp.name)/'applied.json',pg_service=self.service,pg_schema=self.target,plan=p,plan_sha256=hashlib.sha256(p.read_bytes()).hexdigest())
+        self.assertEqual(after['content_fingerprints'],before['content_fingerprints'])
+        with closing(open_store(pg_service=self.service,pg_schema=self.target).conn)as c:
+            self.assertEqual(apply_plan(c,before)['updated_editions'],0)
+            self.assertEqual(c.execute('SELECT abstract FROM papers ORDER BY id LIMIT 1').fetchone()[0],'Abstract\x00with\x01data')
+
+    def test_native_stale_source_plan_preserves_both_original_memberships(self):
+        with closing(open_store(pg_service=self.service,pg_schema=self.target).conn)as c:
+            before=plan(c)
+            c.execute("UPDATE source_records SET title='Changed' WHERE external_id=?",('conf/ijcai/fixture2022',));c.commit()
+            with self.assertRaisesRegex(ValueError,'Stale repair plan'):
+                apply_plan(c,before)
+            c.rollback()
+            self.assertEqual(inspect(c)['status'],'ready')
@@ -0,0 +1,174 @@
+import copy
+from collections import Counter
+import gzip
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+from urllib.parse import parse_qs, urlsplit
+
+from paper_atlas.collectors import neurips_program as program
+
+FIXTURES = Path(__file__).parent/'fixtures'
+RAW = gzip.decompress((FIXTURES/'neurips2026-program.json.gz').read_bytes())
+RECEIPTS = json.loads((FIXTURES/'neurips2026-receipts.json').read_text())
+EVIDENCE = {'url': program.URL, 'observed_at': RECEIPTS['receipts'][0]['finished_at']}
+
+
+class NeuripsProgramTests(unittest.TestCase):
+    def sample(self):
+        rows = json.loads(RAW)['results']
+        oral = next(r for r in rows if r['id'] == 154866)
+        poster = next(r for r in rows if r['paper_url'] == oral['paper_url'] and r['event_type'] == 'Poster')
+        return copy.deepcopy(poster), copy.deepcopy(oral)
+
+    def payload(self, rows):
+        return json.dumps({'count': len(rows), 'next': None, 'previous': None, 'results': rows})
+
+    def snapshots(self, folder):
+        folder.mkdir()
+        (folder/'program-json.response').write_bytes(RAW)
+        (folder/'receipts.json').write_text(json.dumps(RECEIPTS))
+        return folder
+
+    def test_full_snapshot_tracks_and_all_titles_authors_affiliations(self):
+        rows, held, duplicates, folded = program.parse_program(RAW, EVIDENCE)
+        self.assertEqual((len(rows), len(held), len(duplicates), folded), (9004, 139, 1, 132))
+        self.assertEqual(Counter(r['track'] for r in rows),
+                         {'main': 7896, 'evaluations_datasets': 971, 'position': 137})
+        expected = {}
+        for e in json.loads(RAW)['results']:
+            if e['sourceurl'] in program.GROUPS and e['event_type'] == 'Poster':
+                forum = parse_qs(urlsplit(e['paper_url']).query)['id'][0]
+                expected[forum] = e
+        self.assertEqual(len(expected), 9004)
+        for r in rows:
+            e = expected[r['identifiers']['openreview']]
+            self.assertEqual(r['title'], e['name'])
+            self.assertEqual(r['authors'], [a['fullname'] for a in e['authors']])
+            self.assertEqual(r['metadata']['author_affiliations'], [a.get('institution') for a in e['authors']])
+            self.assertEqual(r['raw_decision'], e['decision'])
+            self.assertEqual(r['status'], 'accepted')
+            self.assertNotIn('decision_date', r)
+            self.assertIsNone(r['abstract'])
+            self.assertEqual(r['year'], 2026)
+        self.assertEqual(duplicates[0]['event_id'], 154866)
+
+    def test_same_forum_folds_presentations_and_preserves_signed_source_ids(self):
+        poster, oral = self.sample()
+        rows, held, duplicates, folded = program.parse_program(self.payload([oral, poster, oral]), EVIDENCE)
+        row, = rows
+        self.assertEqual((len(held), len(duplicates), folded), (0, 1, 1))
+        self.assertEqual({p['sourceid'] for p in row['metadata']['presentations']},
+                         {poster['sourceid'], oral['sourceid']})
+        self.assertLess(oral['sourceid'], 0)
+        self.assertEqual({t['value'] for t in row['tags']}, {'Poster', 'Oral'})
+        self.assertTrue(all(t['namespace'] == 'neurips_program:presentation_format' for t in row['tags']))
+
+    def test_identical_title_and_authors_in_distinct_forums_remain_distinct(self):
+        poster, _ = self.sample(); other = copy.deepcopy(poster)
+        other.update(id=999999, uid='0'*32, sourceid=999999, paper_url='https://openreview.net/forum?id=otherForum7',
+                     virtualsite_url='/virtual/2026/poster/999999')
+        rows, _, _, _ = program.parse_program(self.payload([poster, other]), EVIDENCE)
+        self.assertEqual(len(rows), 2)
+        self.assertEqual(len({r['external_id'] for r in rows}), 2)
+
+    def test_conflicting_event_ids_or_same_forum_bibliography_are_rejected(self):
+        poster, oral = self.sample()
+        for field in ('name', 'authors', 'sourceurl', 'decision'):
+            changed = copy.deepcopy(oral)
+            if field == 'authors':
+                changed['authors'][0]['fullname'] = 'Different Author'
+            elif field == 'sourceurl':
+                changed[field] = 'https://openreview.net/group?id=NeurIPS.cc/2026/Position_Paper_Track'
+            elif field == 'decision':
+                changed[field] = 'Accept (poster)'
+            else:
+                changed[field] += ' changed'
+            with self.subTest(field=field), self.assertRaises(ValueError):
+                program.parse_program(self.payload([poster, changed]), EVIDENCE)
+        changed = copy.deepcopy(poster); changed['name'] += ' changed'
+        with self.assertRaises(ValueError):
+            program.parse_program(self.payload([poster, changed]), EVIDENCE)
+
+    def test_unreviewed_origin_decision_visibility_and_link_are_held(self):
+        poster, _ = self.sample()
+        mutations = [{'sourceurl': 'journal-track/NeurIPS_2026-Posters_TMLR.xlsx'},
+                     {'sourceurl': 'neurips2026-bridging-the-future'},
+                     {'sourceurl': None}, {'sourceurl': 'https://openreview.net/group?id=NeurIPS.cc/2027/Conference'},
+                     {'decision': 'Reject'}, {'visible': False},
+                     {'paper_url': 'https://other.example/forum?id=anotherID7'}]
+        for mutation in mutations:
+            changed = copy.deepcopy(poster); changed.update(id=999999, virtualsite_url='/virtual/2026/poster/999999')
+            changed.update(mutation)
+            rows, held, _, _ = program.parse_program(self.payload([poster, changed]), EVIDENCE)
+            self.assertEqual((len(rows), len(held)), (1, 1))
+            self.assertEqual(held[0]['raw_event'], changed)
+
+    def test_rejects_truncation_pagination_invalid_url_and_missing_authors(self):
+        poster, _ = self.sample()
+        raw = json.loads(self.payload([poster]))
+        bad = [dict(raw, count=2), dict(raw, next='https://example.com/next'),
+               {k: v for k, v in raw.items() if k != 'previous'}]
+        for payload in bad:
+            with self.assertRaises(ValueError):
+                program.parse_program(json.dumps(payload), EVIDENCE)
+        for mutation in [{'authors': []}, {'virtualsite_url': '/virtual/2025/poster/154865'}, {'id': True}]:
+            changed = copy.deepcopy(poster); changed.update(mutation)
+            with self.assertRaises(ValueError):
+                program.parse_program(self.payload([changed]), EVIDENCE)
+
+    def test_frozen_collection_is_partial_and_no_http_or_database_write(self):
+        with tempfile.TemporaryDirectory() as tmp, patch.object(program, 'fetch', side_effect=AssertionError('No HTTP')):
+            root = Path(tmp); source = self.snapshots(root/'source')
+            report = program.collect(root/'out', snapshots=source)
+            self.assertEqual(report['records'], 9004)
+            self.assertEqual(len(report['files']), 3)
+            self.assertFalse(report['database_written'])
+            self.assertFalse(report['pdfs_downloaded'])
+            for m in report['files']:
+                self.assertEqual(m['status'], 'partial')
+                self.assertEqual(m['missing_abstract_count'], m['count'])
+                self.assertEqual(hashlib.sha256(Path(m['file']).read_bytes()).hexdigest(), m['file_sha256'])
+            with self.assertRaises(ValueError):
+                program.collect(root/'out', snapshots=source)
+
+    def test_frozen_receipt_tamper_path_symlink_status_and_duplicate(self):
+        for mode in ('tamper', 'path', 'symlink', 'status', 'duplicate'):
+            with self.subTest(mode=mode), tempfile.TemporaryDirectory() as tmp:
+                root = Path(tmp); source = self.snapshots(root/'source')
+                receipts = copy.deepcopy(RECEIPTS)
+                if mode == 'tamper':
+                    (source/'program-json.response').write_text('bad')
+                elif mode == 'path':
+                    receipts['receipts'][0]['file'] = '../outside.json'
+                elif mode == 'symlink':
+                    (root/'outside.json').write_bytes(RAW)
+                    (source/'program-json.response').unlink()
+                    (source/'program-json.response').symlink_to(root/'outside.json')
+                elif mode == 'status':
+                    receipts['receipts'][0]['status'] = 403
+                else:
+                    receipts['receipts'].append(copy.deepcopy(receipts['receipts'][0]))
+                (source/'receipts.json').write_text(json.dumps(receipts))
+                with self.assertRaises(ValueError):
+                    program.collect(root/'out', snapshots=source)
+                self.assertFalse((root/'out/neurips-program-2026.json').exists())
+
+    def test_online_mode_only_requests_fixed_program_metadata(self):
+        poster, _ = self.sample(); raw = self.payload([poster]).encode()
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp); cache = root/'cache'; cache.mkdir()
+            receipt = {'retrieved_at': EVIDENCE['observed_at'], 'url': program.URL}
+            (cache/hashlib.sha256(program.URL.encode()).hexdigest()).with_suffix('.json').write_text(json.dumps(receipt))
+            with patch.object(program, 'fetch', return_value=raw) as fetch:
+                report = program.collect(root/'out', cache=cache)
+            fetch.assert_called_once_with(program.URL, cache, program.LIMIT, delay=1)
+            self.assertEqual(report['records'], 1)
+
+    def test_frozen_fixture_preserves_actual_response_bytes(self):
+        receipt, = RECEIPTS['receipts']
+        self.assertEqual(hashlib.sha256(RAW).hexdigest(), receipt['sha256'])
+        self.assertEqual(len(RAW), receipt['bytes'])
@@ -0,0 +1,172 @@
+"""Interactions between event identity and previously independent write safeguards."""
+from contextlib import contextmanager, redirect_stdout
+import hashlib
+import io
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+import uuid
+
+from paper_atlas import querying
+from paper_atlas.audits.coverage import report as coverage_report
+from paper_atlas.collectors.dblp import XML_SHA
+from paper_atlas.curation.annotations import initialize, assert_annotation, retract_annotation, observations
+from paper_atlas.db.backend import open_store
+from paper_atlas.ingestion.event_identity import plan, upgrade
+from paper_atlas.ingestion.records import ingest_file
+from paper_atlas.postgres.client import connect
+from paper_atlas.postgres.migration import migrate
+from paper_atlas.postgres.schema import quote
+from tests.test_event_identity import legacy, add
+
+
+class RuntimeCases:
+    @contextmanager
+    def store(self):
+        s = open_store(**self.target)
+        try:
+            yield s
+        finally:
+            s.conn.close()
+
+    def query(self, *args):
+        target = (['--db', str(self.target['db'])] if 'db' in self.target else
+                  ['--pg-service', self.target['pg_service'], '--pg-schema', self.target['pg_schema']])
+        with redirect_stdout(io.StringIO()) as out:
+            querying.main([*target, *map(str,args)])
+        return json.loads(out.getvalue())
+
+    def assertion(self, c, paper, request, **changes):
+        args = dict(paper=paper, kind='research_type', namespace='custom:method', value='empirical',
+                    request_id=request, evidence_key='review:'+request, actor='reviewer', reason='Reviewed metadata')
+        args.update(changes)
+        return assert_annotation(c, **args)
+
+    def test_event_upgrade_preserves_annotation_history_and_combined_queries(self):
+        with self.store() as s:
+            initialize(s.conn)
+            event = self.assertion(s.conn,1,'first')
+            retract_annotation(s.conn,event,request_id='retract',actor='reviewer',reason='Corrected')
+            self.assertion(s.conn,1,'second')
+            original = observations(s.conn,1,history=True)
+            s.conn.commit()
+        proposal = plan(**self.target)
+        self.assertEqual(proposal['before']['counts']['annotation_events'],3)
+        result = upgrade(proposal, **self.target)
+        self.assertEqual(result['after']['counts'],proposal['before']['counts'])
+        with self.store() as s:
+            self.assertEqual(observations(s.conn,1,history=True),original)
+            paper,_,_ = add(s,'spring','www-1995-spring','rejected')
+            self.assertEqual(paper,1)
+            s.conn.commit()
+        row = self.query('--venue','WWW','--event-key','www-1995-spring','--status','rejected',
+                         '--research-type','custom:method=empirical','--paper',1,'--annotation-history')[0]
+        self.assertEqual([a['event_key'] for a in row['known_acceptances']],['www-1995-fall'])
+        self.assertEqual({a['latest_status'] for a in row['submissions']},{'accepted','rejected'})
+        self.assertEqual(len(row['annotation_history']),3)
+        self.assertEqual(self.query('--event-key','www-1995-fall','--status','rejected'),[])
+
+    def collected(self, name, event, external, *, incremental=False, unscoped=False):
+        row = dict(source='fixture',external_id=external,url='https://example.org/'+external,
+                   title='Independent contribution '+external,authors=[],abstract='Known abstract',
+                   identifiers={'doi':'10.1234/'+external},venue='WWW',year=1995,track='main',
+                   event_key=event,status='accepted')
+        p = self.root/(name+'.jsonl');p.write_text(json.dumps(row)+'\n')
+        manifest = {k:row[k] for k in ('source','venue','year','track','event_key')}
+        manifest.update(list_url='https://example.org/'+event,count=1,status='partial',
+                        file_sha256=hashlib.sha256(p.read_bytes()).hexdigest())
+        if incremental:
+            manifest.update(coverage_mode='incremental',coverage_previous_count=1,
+                            coverage_previous_expected_count=1,coverage_expected_count=2)
+        if unscoped:
+            manifest.pop('event_key')
+        p.with_suffix('.manifest.json').write_text(json.dumps(manifest))
+        return p
+
+    def ingest(self, path):
+        with redirect_stdout(io.StringIO()):
+            ingest_file(self.target.get('db'),path,**{k:v for k,v in self.target.items() if k != 'db'})
+
+    def test_coverage_labels_both_same_year_events_and_keeps_legacy_readable(self):
+        registry=self.root/'registry.json'
+        registry.write_text(json.dumps({'scope_note':'Fixture only','venues':[{'acronym':'WWW','field':'web'}]}))
+        def snapshot():
+            return coverage_report(self.target.get('db'),registry,**{k:v for k,v in self.target.items() if k!='db'})['venues'][0]
+        self.assertEqual([e['event_key']for e in snapshot()['editions']],[''])
+        upgrade(plan(**self.target),**self.target)
+        with self.store() as s:
+            add(s,'spring','www-1995-spring','rejected');s.conn.commit()
+        result=snapshot();events={e['event_key']:e for e in result['editions']}
+        self.assertEqual(set(events),{'www-1995-fall','www-1995-spring'})
+        self.assertEqual((result['imported_submissions'],result['distinct_papers']),(2,1))
+        self.assertEqual(events['www-1995-fall']['latest_observed_status_counts']['accepted'],1)
+        self.assertEqual(events['www-1995-spring']['latest_observed_status_counts']['rejected'],1)
+        self.assertEqual(events['www-1995-fall']['source_record_counts'][0]['source'],'dblp')
+        self.assertEqual(events['www-1995-spring']['source_record_counts'][0]['source'],'fixture')
+
+    def test_incremental_parent_is_scoped_to_exact_event(self):
+        upgrade(plan(**self.target), **self.target)
+        self.ingest(self.collected('spring','www-1995-spring','spring-one'))
+        self.ingest(self.collected('fall','www-1995-fall','fall-one'))
+        self.ingest(self.collected('append','www-1995-fall','fall-two',incremental=True))
+        with self.store() as s:
+            rows = s.conn.execute('''SELECT e.event_key,es.expected_count,es.imported_count FROM edition_sources es
+                JOIN editions e ON e.id=es.edition_id JOIN sources src ON src.id=es.source_id
+                WHERE src.name='fixture' ORDER BY e.event_key''').fetchall()
+            self.assertEqual([tuple(r) for r in rows],[('www-1995-fall',2,2),('www-1995-spring',1,1)])
+        with self.assertRaisesRegex(ValueError,'event_key'):
+            self.ingest(self.collected('unscoped','www-1995-spring','unwanted',incremental=True,unscoped=True))
+        with self.assertRaisesRegex(ValueError,'parent changed'):
+            self.ingest(self.collected('stale','www-1995-fall','stale',incremental=True))
+        with self.store() as s:
+            self.assertEqual(s.conn.execute("SELECT count(*) FROM source_records r JOIN sources src ON src.id=r.source_id WHERE src.name='fixture'").fetchone()[0],3)
+
+    def test_joint_refresh_keeps_identity_annotations_and_event_query(self):
+        upgrade(plan(**self.target), **self.target)
+        metadata = dict(snapshot_sha256=XML_SHA,proceedings_key='conf/ijcai/2022',
+                        bibliographic_year=2022,bibliography={'booktitle':['IJCAI']})
+        with self.store() as s:
+            initialize(s.conn)
+            paper,record = s.record('dblp','conf/ijcai/Joint22','https://example.org/joint',
+                                   'Joint paper',None,[],{'doi':'10.1234/joint'},metadata)
+            eid = s.decision(paper,record,'IJCAI',2022,'main','conf/ijcai/Joint22','https://example.org/joint','accepted','Accept')
+            self.assertion(s.conn,paper,'joint')
+            s.conn.commit()
+        with self.store() as s:
+            again,r = s.record('dblp','conf/ijcai/Joint22','https://example.org/joint',
+                               'Corrected joint title',None,[],{'doi':'10.1234/joint'},metadata)
+            self.assertEqual(again,paper)
+            self.assertEqual(s.decision(again,r,'IJCAI',2022,'main','conf/ijcai/Joint22','https://example.org/joint','accepted','Accept'),eid)
+            self.assertEqual(s.conn.execute("SELECT count(*) FROM editions e JOIN venues v ON v.id=e.venue_id WHERE v.acronym='IJCAI' AND e.year=2022").fetchone()[0],0)
+            s.conn.commit()
+        for venue in ['IJCAI','ECAI']:
+            rows = self.query('--venue',venue,'--year',2022,'--event-key','',
+                              '--research-type','custom:method=empirical','--paper',paper)
+            self.assertEqual(len(rows),1)
+            self.assertEqual(len(rows[0]['submissions']),1)
+            self.assertEqual(rows[0]['submissions'][0]['acronym'],'ECAI+IJCAI')
+
+
+class SQLiteRuntimeTests(RuntimeCases, unittest.TestCase):
+    def setUp(self):
+        t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name)
+        db=self.root/'source.sqlite';legacy(db);self.target={'db':db}
+
+
+@unittest.skipUnless(os.environ.get('PAPER_ATLAS_TEST_PG_SERVICE'),'Requires approved remote PostgreSQL service')
+class PostgreSQLRuntimeTests(RuntimeCases, unittest.TestCase):
+    def setUp(self):
+        t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name)
+        db=self.root/'source.sqlite';legacy(db)
+        self.service=os.environ['PAPER_ATLAS_TEST_PG_SERVICE'];self.schema='pa_runtime_'+uuid.uuid4().hex[:12]
+        self.addCleanup(self.cleanup)
+        with redirect_stdout(io.StringIO()):
+            migrate(db,self.service,self.root/'migration.json',schema=self.schema,min_free_gib=0)
+        self.target={'pg_service':self.service,'pg_schema':self.schema}
+
+    def cleanup(self):
+        with connect(self.service) as c:
+            for name, in c.execute('SELECT nspname FROM pg_namespace WHERE starts_with(nspname,%s)',(self.schema,)):
+                c.execute('DROP SCHEMA '+quote(name)+' CASCADE')
@@ -0,0 +1,148 @@
+import gzip
+import hashlib
+import json
+import os
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from paper_atlas.audits.source_identity import audit, classify, load_inputs
+from paper_atlas.postgres.client import ReadConnection
+
+
+def record(**updates):
+    row = dict(source='reviewed_program', external_id='2026/forum-a',
+               title='A sufficiently specific scientific paper title', authors=['Jane Doe', 'John Smith'],
+               venue='NeurIPS', year=2026, track='main', status='accepted', identifiers={},
+               source_record_hits=[], identifier_hits=[], title_candidate_ids=[])
+    row.update(updates)
+    return row
+
+
+def write_input(root, rows):
+    path = root / 'source.jsonl'
+    raw = b''.join((json.dumps(row) + '\n').encode() for row in rows)
+    path.write_bytes(raw)
+    manifest = {k: rows[0][k] for k in ('source', 'venue', 'year', 'track')}
+    manifest.update(count=len(rows), file_sha256=hashlib.sha256(raw).hexdigest(),
+                    file='/ignored/untrusted/location.jsonl', status='partial')
+    path.with_suffix('.manifest.json').write_text(json.dumps(manifest))
+    return path
+
+
+class CandidateTests(unittest.TestCase):
+    def test_duplicate_names_do_not_equal_distinct_author_multiset(self):
+        row = record(authors=['Jane Doe', 'Jane Doe'], title_candidate_ids=[7])
+        result = classify(row, {7: {'title': row['title'], 'authors': ['Jane Doe']}})
+        self.assertEqual(result['kind'], 'partial_author_overlap_requires_review')
+        self.assertIn('duplicate_normalized_author_names', result['flags'])
+        self.assertFalse(result['comparisons'][0]['nonempty_author_multiset_equal'])
+
+    def test_arxiv_author_representation_and_order_match_but_never_approve(self):
+        row = record(title_candidate_ids=[7])
+        result = classify(row, {7: {'title': row['title'], 'authors': [['Smith', 'John', ''], ['Doe', 'Jane', '']]}})
+        self.assertEqual(result['kind'], 'one_exact_title_author_multiset_requires_review')
+        self.assertEqual(result['decision'], 'not_approved_for_import')
+
+    def test_binding_conflict_overrides_existing_source(self):
+        row = record(source_record_hits=[{'paper_id': 7}], identifier_hits=[{'paper_id': 8}])
+        entities = {pid: {'title': row['title'], 'authors': row['authors']} for pid in (7, 8)}
+        self.assertEqual(classify(row, entities)['kind'], 'conflicting_existing_bindings_hold')
+
+    def test_wrong_doi_binding_retains_author_title_disagreement(self):
+        row = record(identifier_hits=[{'paper_id': 7}])
+        result = classify(row, {7: {'title': 'Completely different work', 'authors': ['Somebody Else']}})
+        self.assertEqual(result['kind'], 'existing_identifier_binding_requires_review')
+        self.assertFalse(result['comparisons'][0]['normalized_title_equal'])
+        self.assertEqual(result['comparisons'][0]['author_name_overlap'], [])
+
+    def test_no_hit_is_not_novelty_and_missing_authors_never_agree(self):
+        self.assertEqual(classify(record(), {})['kind'], 'no_exact_match_not_proof_of_novelty')
+        row = record(authors=[], title_candidate_ids=[7])
+        result = classify(row, {7: {'title': row['title'], 'authors': []}})
+        self.assertEqual(result['kind'], 'no_author_agreement_hold')
+
+    def test_title_candidate_cap_is_explicit(self):
+        row = record(title_candidate_ids=list(range(21)))
+        entities = {pid: {'title': row['title'], 'authors': row['authors']} for pid in range(21)}
+        self.assertTrue(classify(row, entities)['title_candidates_truncated'])
+        self.assertEqual(classify(row, entities)['kind'], 'title_candidate_limit_reached_hold')
+
+
+class InputTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+
+    def test_raw_line_hash_and_manifest_path_not_followed(self):
+        path = write_input(self.root, [record()])
+        rows, inputs = load_inputs([path])
+        self.assertEqual(rows[0]['raw_line_sha256'], hashlib.sha256(path.read_bytes()).hexdigest())
+        self.assertEqual(inputs[0]['count'], 1)
+
+    def test_hash_tamper_rejected_before_database_connection(self):
+        path = write_input(self.root, [record()])
+        path.write_bytes(path.read_bytes().replace(b'Jane Doe', b'Jane Roe'))
+        with patch('paper_atlas.audits.source_identity.ReadConnection') as connection:
+            with self.assertRaisesRegex(ValueError, 'hash mismatch'):
+                audit([path], self.root / 'out', pg_service='test', pg_schema='research')
+            connection.assert_not_called()
+
+    def test_manifest_scope_and_count_tamper_and_duplicate_sources(self):
+        path = write_input(self.root, [record()])
+        manifest_path = path.with_suffix('.manifest.json')
+        manifest = json.loads(manifest_path.read_text())
+        for key, value in [('year', 2025), ('count', 2)]:
+            altered = dict(manifest, **{key: value})
+            manifest_path.write_text(json.dumps(altered))
+            with self.assertRaises(ValueError):
+                load_inputs([path])
+        manifest_path.write_text(json.dumps(manifest))
+        with self.assertRaisesRegex(ValueError, 'Duplicate source'):
+            load_inputs([path, path])
+
+    def test_existing_output_never_replayed_and_failure_not_completion(self):
+        path = write_input(self.root, [record()])
+        out = self.root / 'out'
+        with patch('paper_atlas.audits.source_identity.ReadConnection', side_effect=RuntimeError('unavailable')):
+            with self.assertRaises(RuntimeError):
+                audit([path], out, pg_service='test', pg_schema='research')
+        self.assertTrue((out / 'failed.json').exists())
+        self.assertFalse((out / 'postgresql-preflight.json').exists())
+        with self.assertRaises(FileExistsError):
+            audit([path], out, pg_service='test', pg_schema='research')
+
+
+@unittest.skipUnless(os.environ.get('PAPER_ATLAS_TEST_PG_SERVICE'), 'Requires the authorized remote PostgreSQL service')
+class ReadOnlyIntegrationTests(unittest.TestCase):
+    def test_existing_binding_full_evidence_and_no_import_approval(self):
+        service = os.environ['PAPER_ATLAS_TEST_PG_SERVICE']
+        connection = ReadConnection(service, 'research')
+        try:
+            self.assertEqual(connection.execute('SHOW transaction_read_only').fetchone()[0], 'on')
+            hit = connection.execute("SELECT value,paper_id FROM identifiers WHERE scheme='arxiv' ORDER BY value LIMIT 1").fetchone()
+            self.assertIsNotNone(hit)
+            paper = connection.execute('SELECT title,authors_json FROM papers WHERE id=?', (hit['paper_id'],)).fetchone()
+        finally:
+            connection.close()
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            path = write_input(root, [record(title=paper['title'], authors=json.loads(paper['authors_json']),
+                                            identifiers={'arxiv': hit['value']})])
+            report = audit([path], root / 'out', pg_service=service, pg_schema='research')
+            self.assertTrue(report['transaction_read_only'])
+            self.assertFalse(report['database_written'])
+            self.assertEqual(report['approved_for_import'], 0)
+            row, = report['entries']
+            self.assertIn(hit['paper_id'], [r['paper_id'] for r in row['identifier_hits']])
+            shard = report['entities'][str(hit['paper_id'])]
+            raw = (root / 'out' / shard['file']).read_bytes()
+            self.assertEqual(hashlib.sha256(raw).hexdigest(), shard['sha256'])
+            packet = json.loads(gzip.decompress(raw))
+            self.assertEqual(packet['paper']['id'], hit['paper_id'])
+            self.assertEqual(packet['paper']['title'], paper['title'])
+            self.assertEqual(packet['paper']['authors_json'], paper['authors_json'])
+            self.assertIn('attempts', packet)
+            self.assertTrue((root / 'out/postgresql-preflight.json').is_file())
@@ -0,0 +1,160 @@
+"""Real 49-chapter snapshots compared with a separately frozen metadata audit."""
+import copy
+import gzip
+import hashlib
+import json
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+
+from paper_atlas.collectors.springer_selected import (
+    BOOK, SOURCE, collect, parse_chapter, parse_toc, read_page, snapshot_index,
+)
+from paper_atlas.db.store import Store
+from paper_atlas.ingestion.records import ingest_file
+
+FIXTURE = Path(__file__).parent/'fixtures/springer-aistats1993-fixture.json.gz'
+
+
+class SpringerSelectedTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        raw = FIXTURE.read_bytes()
+        if hashlib.sha256(raw).hexdigest() != '94028fd37080f9d8027e5790e379cc151ee6eab17ed0d1dcc0f59e6e75f9d4d0':
+            raise AssertionError('Fixed source fixture differs')
+        cls.fixture = json.loads(gzip.decompress(raw))
+
+    def snapshots(self, root):
+        for group in ['toc','chapters']:
+            folder = root/group
+            folder.mkdir()
+            for name, text in self.fixture[group].items():
+                (folder/name).write_text(text)
+        return {'toc_snapshots':root/'toc','chapter_snapshots':root/'chapters'}
+
+    def test_all49_original_fields_against_independent_audit(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            report = collect(root/'out', **self.snapshots(root))
+            manifest, = report['files']
+            rows = [json.loads(s) for s in Path(manifest['file']).read_text().splitlines()]
+            self.assertEqual(len(rows), 49)
+            self.assertEqual(manifest['status'], 'partial')
+            self.assertEqual(manifest['missing_abstract_count'], 0)
+            self.assertTrue(manifest['excluded_materials'])
+            self.assertTrue(all(x['title'] == 'Front Matter' for x in manifest['excluded_materials']))
+            for row, expected in zip(rows, self.fixture['expected']):
+                for field in ['title','abstract']:
+                    self.assertEqual(row[field], expected[field])
+                self.assertEqual(row['identifiers'], {'doi':expected['doi']})
+                self.assertEqual(row['submission_identifiers'], [{'scheme':'publication_doi','value':expected['doi']}])
+                self.assertEqual(row['external_id'], expected['doi'])
+                self.assertEqual(row['metadata']['authors_citation_raw'], expected['authors_citation_raw'])
+                self.assertEqual(row['authors'], [{'family':s.split(',',1)[0].strip(), 'given':s.split(',',1)[1].strip()} for s in expected['authors_citation_raw']])
+                self.assertEqual(row['metadata']['first_page'], expected['first_page'])
+                self.assertEqual(row['metadata']['last_page'], expected['last_page'])
+                self.assertEqual((row['year'],row['metadata']['bibliographic_year']), (1993,1994))
+                self.assertEqual(row['track'], 'selected_volume')
+                self.assertEqual(row['event_key'], 'aistats-1993-selected-volume-1994')
+                self.assertNotIn('decision_date', row)
+                self.assertIn('original 1993 review decision not supplied', row['raw_decision'])
+                for e in [row['metadata']['source_evidence'], *row['metadata']['scope_evidence']]:
+                    self.assertEqual(hashlib.sha256((root/'out'/e['file']).read_bytes()).hexdigest(), e['sha256'])
+            self.assertFalse(report['database_written'])
+            with self.assertRaises(FileExistsError):
+                collect(root/'out', toc_snapshots=root/'toc', chapter_snapshots=root/'chapters')
+
+    def test_native_history_namespaces_and_idempotent_import(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            report = collect(root/'out', **self.snapshots(root))
+            manifest, = report['files']
+            first = json.loads(Path(manifest['file']).read_text().splitlines()[0])
+            db = root/'sample.sqlite'
+            store = Store(db)
+            pid, rid = store.record('prior_public','earlier','https://example.org/earlier',first['title'],first['abstract'],first['authors'])
+            store.decision(pid,rid,'AISTATS',1993,'main','earlier','https://example.org/earlier','rejected','original public rejection')
+            # Explicitly verified work identity; the short title alone must not
+            # force a merge or attach this publication DOI to the old attempt.
+            store.conn.execute('INSERT INTO identifiers VALUES(?,?,?)', ('doi',first['identifiers']['doi'],pid))
+            store.conn.commit()
+            old = store.conn.execute('SELECT * FROM decisions').fetchall()
+            store.conn.close()
+            ingest_file(db, manifest['file'])
+            ingest_file(db, manifest['file'])
+            with sqlite3.connect(db) as c:
+                self.assertEqual(c.execute('SELECT * FROM decisions WHERE status=\'rejected\'').fetchall(), [tuple(r) for r in old])
+                self.assertEqual(c.execute('SELECT count(*) FROM papers').fetchone()[0], 49)
+                self.assertEqual(c.execute('SELECT count(*) FROM submissions').fetchone()[0], 50)
+                self.assertEqual(c.execute('SELECT count(*) FROM decisions').fetchone()[0], 50)
+                self.assertEqual(c.execute('SELECT e.year,e.track,e.event_key FROM editions e ORDER BY e.id').fetchall(), [(1993,'main',''),(1993,'selected_volume','aistats-1993-selected-volume-1994')])
+                self.assertEqual(c.execute('SELECT count(*) FROM paper_tags pt JOIN tags t ON t.id=pt.tag_id WHERE t.namespace=?', (SOURCE+':publication_format',)).fetchone()[0], 49)
+                self.assertEqual(c.execute('SELECT count(*) FROM submission_identifiers WHERE scheme=\'publication_doi\'').fetchone()[0], 49)
+                self.assertIsNone(c.execute("SELECT 1 FROM submission_identifiers si JOIN submissions s ON s.id=si.submission_id JOIN editions e ON e.id=s.edition_id WHERE e.track='main'").fetchone())
+
+    def test_short_unanchored_title_keeps_identity_unconfirmed(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = Store(Path(tmp)/'identity.sqlite')
+            title = 'Statistical strategy: step 1'
+            authors = [{'given':'D. J.','family':'Hand'}]
+            old, _ = store.record('prior_public','earlier','https://example.org/old',title,'Same abstract',authors)
+            new, _ = store.record(SOURCE,BOOK+'_1','https://link.springer.com/chapter/'+BOOK+'_1',title,'Same abstract',authors,{'doi':BOOK+'_1'})
+            self.assertNotEqual(old, new)
+            self.assertEqual(store.conn.execute('SELECT count(*) FROM match_candidates WHERE method=\'exact_title_unconfirmed\'').fetchone()[0], 1)
+            store.conn.close()
+
+    def test_receipt_hash_path_redirect_and_content_type_guards(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            self.snapshots(root)
+            index = snapshot_index(root/'chapters')
+            url = 'https://link.springer.com/chapter/'+BOOK+'_1'
+            self.assertTrue(read_page(index,url)[0])
+            for key, value in [('sha256','0'*64),('file','../escape.html'),('final_url','https://example.org/chapter'),('http_status',403),('headers',{'Content-Type':'application/pdf'})]:
+                changed = copy.deepcopy(index)
+                changed[url][1][key] = value
+                with self.subTest(key=key), self.assertRaises((ValueError,KeyError)):
+                    read_page(changed,url)
+            changed = copy.deepcopy(index)
+            changed[url][1]['final_url'] = url+'?page=2'
+            with self.assertRaises(ValueError):
+                read_page(changed,url)
+
+    def test_missing_or_duplicate_snapshot_stops_collection(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            args = self.snapshots(root)
+            path = root/'chapters/receipts.json'
+            d = json.loads(path.read_bytes())
+            original = copy.deepcopy(d)
+            d['responses'].pop()
+            path.write_text(json.dumps(d))
+            with self.assertRaises(ValueError):
+                collect(root/'out', **args)
+            self.assertFalse((root/'out').exists())
+            original['responses'].append(original['responses'][0])
+            path.write_text(json.dumps(original))
+            with self.assertRaises(ValueError):
+                snapshot_index(root/'chapters')
+
+    def test_book_doi_year_and_duplicate_citation_fields_reject_drift(self):
+        html = self.fixture['chapters']['chapter-01.html']
+        for key, value in [('citation_doi',BOOK+'_2'),('citation_inbook_title','Another Book'),('citation_publication_date','1993')]:
+            import re
+            changed, count = re.subn(r'(<meta[^>]*name="'+key+r'"[^>]*content=")[^"]*', lambda m:m[1]+value, html)
+            self.assertEqual(count, 1)
+            with self.subTest(key=key), self.assertRaises(ValueError):
+                parse_chapter(changed, BOOK+'_1')
+        with self.assertRaises(ValueError):
+            parse_chapter(html+'<meta name="citation_doi" content="'+BOOK+'_1">', BOOK+'_1')
+
+    def test_missing_abstract_is_explicit_and_does_not_use_other_page_text(self):
+        html = self.fixture['chapters']['chapter-01.html'].replace('id="Abs1-content"','id="not-an-abstract"')
+        self.assertIsNone(parse_chapter(html, BOOK+'_1')['abstract'])
+
+    def test_toc_ignores_frontmatter_but_rejects_duplicate_publications(self):
+        html = self.fixture['toc']['springer-toc1.html']
+        self.assertEqual(len(parse_toc(html)), 17)
+        with self.assertRaises(ValueError):
+            parse_toc(html+html)
@@ -133,7 +133,7 @@ class SubmissionTests(unittest.TestCase):
        c.execute("INSERT INTO papers(id,title,title_key) VALUES(1,'Paper','paper')")
        c.execute("INSERT INTO source_records VALUES(1,1,'paper',1,'https://example.org/p','Paper','Abstract','[]','{}',CURRENT_TIMESTAMP)")
        c.execute("INSERT INTO venues VALUES(1,'ICLR','ICLR','machine_learning','conference')")
-        c.execute("INSERT INTO editions VALUES(1,1,2026,'main')")
+        c.execute("INSERT INTO editions(id,venue_id,year,track) VALUES(1,1,2026,'main')")
        c.execute("INSERT INTO submissions VALUES(1,1,1,1,'paper',NULL)")
        c.execute("INSERT INTO decisions VALUES(1,1,'accepted','Accept','https://example.org/decision','2026-01-01T00:00:00Z',NULL)")
        c.commit();c.close()
@@ -0,0 +1,155 @@
+import hashlib
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+from paper_atlas.collectors.www_archive import (ROOT, SPRING, FALL, Sources, collect, decode,
+                                                early_review, spring_rows)
+
+
+class ArchiveTests(unittest.TestCase):
+    def setUp(self):
+        t=tempfile.TemporaryDirectory();self.addCleanup(t.cleanup);self.root=Path(t.name);self.cache=self.root/'cache';self.cache.mkdir()
+        self.pages={ROOT+'www1/PrelimProcs.html':'''<h1>Formal presentations</h1><ol><li><em>Keywords:</em> BUSINESS TRACK?<br><em>Title:</em><b> First contribution</b><br><em>Author:</em>Jane Doe &lt;jane@example.org&gt;<br><li><em>Title:</em><b>Unlinked contribution</b><br><em>Author:</em>John Roe<br></ol>''',
+                    FALL:'<h1>Conference Tracks</h1><ol><li><a href="Agents.html">Agents</a><li><a href="Tutor.html">Tutorials</a></ol>',
+                    ROOT+'www2/Proceedings/Agents.html':'<h3>Panel</h3><dl><dt><a href="a.html">Linked talk</a><dd>Jane Doe<dt>Unlinked talk</a><dd>John Roe</dl>',
+                    ROOT+'www2/Proceedings/Tutor.html':'<h1>Tutorials</h1><dl><dt>Training session<dd>Teacher</dl>'}
+        for track in ['papers','posters']:
+            self.pages[SPRING+track+'/author.html']='<b>Doe, Jane</b><ul><li><a href="01/paper.html">Same contribution</a></li></ul><b>Roe, John</b><a href="01/paper.html">Same contribution</a>'
+            self.pages[SPRING+track+'/abstract.html']='''<h1>Abstracts</h1><a href="#one">Same contribution</a><h3><a href="01/paper.html">Same contribution</a></h3><i>Author: Jane Doe, John Roe<br>Institute</i><p>Actual abstract with <i>inline emphasis</i> and a separator\u2028 preserved.</p><hr><h2>Another session</h2>'''
+        self.pages[SPRING+'papers/session.html']='<a href="01/paper.html">Same contribution</a>'
+
+    def sources(self):
+        rows=[]
+        for i,(url,html) in enumerate(sorted(self.pages.items())):
+            raw=html.encode()if isinstance(html,str)else html;name='source-'+str(i)+'.html';(self.cache/name).write_bytes(raw)
+            rows.append(dict(url=url,status=200,file=name,bytes=len(raw),sha256=hashlib.sha256(raw).hexdigest()))
+        p=self.cache/'manifest.json';p.write_text(json.dumps({'sources':rows}));sha=hashlib.sha256(p.read_bytes()).hexdigest()
+        return Sources(self.cache,sha),sha
+
+    def test_offline_batch_separates_tracks_review_and_importable_rows(self):
+        _,sha=self.sources();out=self.root/'batch';report=collect(self.cache,sha,out)
+        self.assertEqual(report['ready'],2);self.assertEqual(report['held'],5)
+        queue=json.loads((out/'import-queue.json').read_text())['files'];self.assertEqual(len(queue),2)
+        for name in queue:
+            p=Path(name);rows=[json.loads(l)for l in p.read_text().split('\n') if l];self.assertEqual(len(rows),1)
+            row=rows[0];self.assertEqual(row['event_key'],'www-1995-spring');self.assertEqual(row['authors'],['Jane Doe','John Roe'])
+            self.assertIn(row['track'],['main','poster']);self.assertIn('inline emphasis',row['abstract']);self.assertNotIn('Another session',row['abstract'])
+            self.assertIn('\u2028',row['abstract']);manifest=json.loads(p.with_suffix('.manifest.json').read_text());self.assertEqual(manifest['file_sha256'],hashlib.sha256(p.read_bytes()).hexdigest());self.assertEqual(manifest['status'],'partial')
+        held=[json.loads(l)for l in(out/'review-candidates.jsonl').read_text().split('\n') if l]
+        self.assertTrue(all('status'not in r and 'source_evidence'in r for r in held))
+        self.assertFalse(any('review-candidates'in p for p in queue))
+
+    def test_partial_manifest_preserves_full_listing_size_separately_from_ready_count(self):
+        self.pages[SPRING+'posters/abstract.html']+='<h3><a href="02/other.html">Unlinked poster</a></h3><i>Author: Other Person</i><p>Actual abstract</p>'
+        _,sha=self.sources();out=self.root/'batch';collect(self.cache,sha,out)
+        manifest=json.loads((out/'www-1995-spring-poster.manifest.json').read_text())
+        self.assertEqual((manifest['count'],manifest['source_listing_count'],manifest['held_entry_count']),(1,2,1))
+        self.assertNotIn('coverage_previous_count',manifest)  # Live parent must be independently preflighted.
+
+    def test_malformed_href_requires_exact_id_and_two_clean_index_anchors(self):
+        self.pages[SPRING+'papers/abstract.html']=self.pages[SPRING+'papers/abstract.html'].replace('01/paper.html','01/        paper.html')
+        sources,_=self.sources();rows,held,_=spring_rows(sources,'papers');self.assertEqual(held,[])
+        self.assertEqual(rows[0]['url'],SPRING+'papers/01/paper.html');self.assertTrue(rows[0]['metadata']['url_corroborated_by_author_and_session'])
+        self.assertIn('        ',rows[0]['metadata']['abstract_href_raw'])
+
+    def test_main_index_disagreement_fails_without_publishing_batch(self):
+        self.pages[SPRING+'papers/session.html']='<a href="02/other.html">Other work</a>';_,sha=self.sources();out=self.root/'batch'
+        with self.assertRaisesRegex(ValueError,'ID sets disagree'):collect(self.cache,sha,out)
+        self.assertFalse(out.exists())
+
+    def test_same_entry_id_with_conflicting_clean_url_is_rejected(self):
+        self.pages[SPRING+'papers/session.html']='<a href="01/other.html">Same contribution</a>';sources,_=self.sources()
+        with self.assertRaisesRegex(ValueError,'URLs disagree'):spring_rows(sources,'papers')
+
+    def test_poster_without_linked_author_entry_is_held_even_with_abstract(self):
+        self.pages[SPRING+'posters/author.html']='<b>Doe, Jane</b><a href="#">Same contribution</a>';sources,_=self.sources();rows,held,counts=spring_rows(sources,'posters')
+        self.assertEqual(rows,[]);self.assertEqual(counts['abstract_entries'],1);self.assertEqual(held[0]['reason'],'abstract_entry_missing_linked_author_index')
+
+    def test_unlinked_and_panel_entries_never_become_acceptance_or_rejection(self):
+        sources,_=self.sources();held,counts=early_review(sources);self.assertEqual(counts,{'first_conference_fields':2,'fall_categories':2,'fall_program_entries':3})
+        self.assertTrue(any(r['candidate']['title']=='Unlinked talk'for r in held));self.assertTrue(all('status'not in r for r in held))
+        self.assertEqual(held[0]['candidate']['authors_raw'],['Jane Doe'])
+
+    def test_title_disagreement_goes_to_review_with_source_claims(self):
+        self.pages[SPRING+'papers/abstract.html']=self.pages[SPRING+'papers/abstract.html'].replace('Same contribution','Different contribution');sources,_=self.sources();rows,held,_=spring_rows(sources,'papers')
+        self.assertEqual(rows,[]);self.assertEqual(held[0]['reason'],'abstract_and_author_index_titles_disagree')
+
+    def test_cache_tampering_and_manifest_hash_mismatch_fail_closed(self):
+        _,sha=self.sources()
+        with self.assertRaisesRegex(ValueError,'manifest checksum'):Sources(self.cache,'0'*64)
+        p=next(self.cache.glob('source-*.html'));p.write_bytes(p.read_bytes()+b'x')
+        with self.assertRaisesRegex(ValueError,'checksum or size'):Sources(self.cache,sha)
+
+    def test_cache_cannot_read_paths_outside_snapshot(self):
+        _,sha=self.sources();p=self.cache/'manifest.json';d=json.loads(p.read_text());d['sources'][0]['file']='../outside.html';p.write_text(json.dumps(d))
+        with self.assertRaisesRegex(ValueError,'plain files'):Sources(self.cache,hashlib.sha256(p.read_bytes()).hexdigest())
+
+    def test_keywords_only_is_missing_abstract_not_invented_summary(self):
+        self.pages[SPRING+'papers/abstract.html']='<h3><a href="01/paper.html">Same contribution</a></h3><i>Author: Jane Doe</i><p>Keywords: networking, hypertext</p>';sources,_=self.sources();rows,held,_=spring_rows(sources,'papers')
+        self.assertEqual(rows,[]);self.assertEqual(held[0]['reason'],'missing_abstract')
+
+    def test_old_encoding_and_duplicate_abstract_identity(self):
+        self.assertEqual(decode(b'M\xfcller')[0],'Müller')
+        self.pages[SPRING+'papers/abstract.html']*=2;sources,_=self.sources()
+        with self.assertRaisesRegex(ValueError,'Duplicate abstract'):spring_rows(sources,'papers')
+
+    def test_existing_output_is_never_overwritten(self):
+        _,sha=self.sources();out=self.root/'batch';out.mkdir();(out/'keep').write_text('original')
+        with self.assertRaisesRegex(ValueError,'overwrite'):collect(self.cache,sha,out)
+        self.assertEqual((out/'keep').read_text(),'original')
+
+    def review(self,*,authors=None,author_source='canonical_byline',missing='',page=None):
+        url=SPRING+'posters/01/paper.html'
+        self.pages[url]=page or '<h1>Canonical full title</h1><p>Jane Doe, John Roe</p><p>Keywords: web</p><h2>Abstract</h2><p>Body</p>'
+        _,sha=self.sources();raw=self.pages[url].encode()if isinstance(self.pages[url],str)else self.pages[url]
+        row=dict(entry_id='01',individual_url=url,individual_sha256=hashlib.sha256(raw).hexdigest(),
+                 title='Canonical full title',authors=authors or ['Jane Doe','John Roe'],author_source=author_source,
+                 reason='Reviewed exact canonical entry and its explicit authorship; retain original title variants',missing_abstract_reason=missing)
+        p=self.root/'review.json';p.write_text(json.dumps({'format':1,'source_cache_sha256':sha,'records':[row]}));return sha,p,hashlib.sha256(p.read_bytes()).hexdigest()
+
+    def test_reviewed_variant_keeps_primary_title_and_all_old_title_claims(self):
+        sha,p,h=self.review();out=self.root/'reviewed';r=collect(self.cache,sha,out,reviewed=p,reviewed_sha256=h)
+        row=json.loads((out/'www-1995-spring-poster.jsonl').read_text());self.assertEqual(row['title'],'Canonical full title')
+        self.assertEqual(row['metadata']['abstract_heading_title_raw'],'Same contribution');self.assertEqual(row['metadata']['author_index_titles_raw'],['Same contribution'])
+        self.assertEqual(len(row['metadata']['source_evidence']),3);self.assertEqual(r['reviewed_posters_sha256'],h)
+        self.assertEqual(row['external_id'],'www3:posters:01');self.assertEqual(row['status'],'accepted')
+
+    def test_canonical_byline_can_resolve_unlinked_author_index_without_guessing(self):
+        self.pages[SPRING+'posters/author.html']='<b>Doe, Jane</b><a href="#">Broken index link</a>'
+        sha,p,h=self.review();out=self.root/'reviewed';collect(self.cache,sha,out,reviewed=p,reviewed_sha256=h)
+        row=json.loads((out/'www-1995-spring-poster.jsonl').read_text());self.assertEqual(row['authors'],['Jane Doe','John Roe'])
+        self.assertEqual(row['metadata']['author_index_raw'],[]);self.assertEqual(row['metadata']['author_order'],'canonical_byline')
+
+    def test_reviewed_missing_abstract_is_explicit_partial_not_body_summary(self):
+        self.pages[SPRING+'posters/abstract.html']='<h3><a href="01/paper.html">Same contribution</a></h3><i>Author: Jane Doe</i><p>Keywords: web</p>'
+        sha,p,h=self.review(missing='Neither listing nor canonical page supplies an explicit abstract')
+        out=self.root/'reviewed';collect(self.cache,sha,out,reviewed=p,reviewed_sha256=h)
+        row=json.loads((out/'www-1995-spring-poster.jsonl').read_text());m=json.loads((out/'www-1995-spring-poster.manifest.json').read_text())
+        self.assertIsNone(row['abstract']);self.assertEqual((m['missing_abstract_count'],m['status']),(1,'partial'))
+        sha,p,h=self.review()
+        with self.assertRaisesRegex(ValueError,'Missing abstract'):collect(self.cache,sha,self.root/'bad',reviewed=p,reviewed_sha256=h)
+        self.assertFalse((self.root/'bad').exists())
+
+    def test_reviewed_names_must_be_in_byline_region_not_citations_or_contact_guess(self):
+        sha,p,h=self.review(authors=['Unrelated Person'],page='<h1>Canonical full title</h1><p>Jane Doe</p><h2>Abstract</h2><p>Unrelated Person cited here</p>')
+        with self.assertRaisesRegex(ValueError,'byline region'):collect(self.cache,sha,self.root/'bad',reviewed=p,reviewed_sha256=h)
+        sha,p,h=self.review(author_source='author_index',authors=['Contact Person'])
+        with self.assertRaisesRegex(ValueError,'author-index'):collect(self.cache,sha,self.root/'bad',reviewed=p,reviewed_sha256=h)
+
+    def test_review_hash_cache_binding_and_canonical_h1_are_all_required(self):
+        sha,p,h=self.review()
+        with self.assertRaisesRegex(ValueError,'checksum'):collect(self.cache,sha,self.root/'bad',reviewed=p,reviewed_sha256='0'*64)
+        d=json.loads(p.read_text());d['source_cache_sha256']='0'*64;p.write_text(json.dumps(d));h=hashlib.sha256(p.read_bytes()).hexdigest()
+        with self.assertRaisesRegex(ValueError,'binding'):collect(self.cache,sha,self.root/'bad',reviewed=p,reviewed_sha256=h)
+        d['source_cache_sha256']=sha;d['records'][0]['title']='Wrong title';p.write_text(json.dumps(d));h=hashlib.sha256(p.read_bytes()).hexdigest()
+        with self.assertRaisesRegex(ValueError,'canonical H1'):collect(self.cache,sha,self.root/'bad',reviewed=p,reviewed_sha256=h)
+
+    def test_unlisted_review_entry_and_changed_primary_digest_fail_closed(self):
+        sha,p,h=self.review();d=json.loads(p.read_text());d['records'][0]['individual_sha256']='0'*64;p.write_text(json.dumps(d));h=hashlib.sha256(p.read_bytes()).hexdigest()
+        with self.assertRaisesRegex(ValueError,'page checksum'):collect(self.cache,sha,self.root/'bad',reviewed=p,reviewed_sha256=h)
+        self.pages[SPRING+'posters/abstract.html']=self.pages[SPRING+'posters/abstract.html'].replace('01/paper.html','02/other.html')
+        self.pages[SPRING+'posters/author.html']=self.pages[SPRING+'posters/author.html'].replace('01/paper.html','02/other.html')
+        sha,p,h=self.review()
+        with self.assertRaisesRegex(ValueError,'outside abstract'):collect(self.cache,sha,self.root/'bad',reviewed=p,reviewed_sha256=h)
Author	SHA1	Message	Date
Zayden-Jung	891a63d982	Merge pull request '封装来源身份只读预检与投稿历史证据' (#51 ) from codex/source-identity-audit into main Metadata integrity checks / metadata (push) Successful in 2m49s Details Reviewed-on: #51	2026-11-10 06:55:25 +00:00
codex-bot	fe3e2502a5	Add read-only source identity candidate audit with evidence shards Metadata integrity checks / metadata (push) Successful in 2m42s Details	2026-11-10 02:55:27 +08:00
Zayden-Jung	b675a38b97	Merge pull request '适配AAMAS2026官方目录并保留撤稿与撤回证据' (#49 ) from codex/aamas2026 into main Metadata integrity checks / metadata (push) Successful in 2m45s Details Reviewed-on: #49	2026-11-09 18:49:37 +00:00
Zayden-Jung	cb875b8eef	Merge pull request '封装NeurIPS2026节目采集，分离投稿与重复展示' (#50 ) from codex/neurips-program into main Metadata integrity checks / metadata (push) Successful in 2m34s Details Reviewed-on: #50	2026-11-09 18:49:29 +00:00
codex-bot	6df904e6d8	Collect official NeurIPS 2026 program with forum-level presentation deduplication Metadata integrity checks / metadata (push) Successful in 2m40s Details	2026-11-10 02:18:38 +08:00
codex-bot	57a557c66b	Merge current main and preserve scope and AAMAS documentation entries Metadata integrity checks / metadata (push) Successful in 2m27s Details	2026-11-10 01:12:45 +08:00
codex-bot	5b5e606f0c	Correct independent affiliation inventory and target section heading mutation Metadata integrity checks / metadata (push) Successful in 2m22s Details	2026-11-10 01:09:25 +08:00
Zayden-Jung	3ff9ee9a94	Merge pull request '限定2020起补漏，保留2000年以来来源与恢复清单' (#48 ) from codex/coverage-handoff-2020 into main Metadata integrity checks / metadata (push) Successful in 2m18s Details Reviewed-on: #48	2026-11-09 17:05:50 +00:00
codex-bot	9f84fd7caf	Separate italic title content from publisher status notices Metadata integrity checks / metadata (push) Failing after 2m6s Details	2026-11-10 01:04:46 +08:00
codex-bot	bf05d3cdc8	Keep day-only withdrawal evidence through native ingestion Metadata integrity checks / metadata (push) Failing after 2m6s Details	2026-11-10 01:02:54 +08:00
codex-bot	930df2a4d5	Preserve explicit withdrawal and byte-exact AAMAS fixture evidence Metadata integrity checks / metadata (push) Failing after 2m4s Details	2026-11-10 01:00:58 +08:00
codex-bot	37380e1d3b	Collect reviewed AAMAS 2026 tracks and hold explicit retraction evidence Metadata integrity checks / metadata (push) Failing after 2m10s Details	2026-11-10 00:57:09 +08:00
codex-bot	25ed4559ca	docs: set 2020 backfill scope and preserve recovery inventory since 2000 Metadata integrity checks / metadata (push) Successful in 2m9s Details	2026-11-10 00:50:15 +08:00
Zayden-Jung	e0ac62464a	Merge pull request '封装有来源核验的 Springer 会后选集采集器' (#47 ) from codex/springer-selected into main Metadata integrity checks / metadata (push) Successful in 2m22s Details Reviewed-on: #47	2026-11-09 16:47:08 +00:00
Zayden-Jung	e37fa46e42	Merge pull request '补入精确的 ACL 1963 AMTCL 年会摘要卷' (#46 ) from codex/acl1963 into main Metadata integrity checks / metadata (push) Successful in 2m9s Details Reviewed-on: #46	2026-11-09 16:47:02 +00:00
Zayden-Jung	70463c0250	Merge pull request '修复DBLP family候选漏采并提供快照恢复命令' (#45 ) from codex/dblp-ifaamas-discovery into main Metadata integrity checks / metadata (push) Successful in 2m12s Details Reviewed-on: #45	2026-11-09 16:46:56 +00:00
codex-bot	5c78a36fd5	Scope chapter publication identities and test explicit work anchors Metadata integrity checks / metadata (push) Successful in 2m20s Details	2026-11-10 00:04:35 +08:00
codex-bot	7facde6c94	Handle section front matter and preserve abstract paragraph boundaries Metadata integrity checks / metadata (push) Failing after 2m3s Details	2026-11-10 00:00:30 +08:00
codex-bot	c06981b244	Collect reviewed Springer postconference selected volumes Metadata integrity checks / metadata (push) Failing after 2m4s Details	2026-11-09 23:51:25 +08:00
codex-bot	8b1e983e7d	Recognize the exact 1963 AMTCL annual meeting volume Metadata integrity checks / metadata (push) Successful in 2m10s Details	2026-11-09 23:21:53 +08:00
codex-bot	fe0f08a550	Recover omitted DBLP discovery families from pinned snapshots Metadata integrity checks / metadata (push) Successful in 2m11s Details	2026-11-09 22:28:50 +08:00
Zayden-Jung	b226b3b98b	Merge pull request '限定ACL1978与TINLAP卷的来源关系及非论文条目' (#42 ) from codex/acl-early into main Metadata integrity checks / metadata (push) Successful in 2m18s Details Reviewed-on: #42	2026-11-09 13:42:18 +00:00
Zayden-Jung	05ada8daf8	Merge pull request '支持 AAMAS 2025 官方出版目录元数据采集' (#44 ) from codex/aamas2025 into main Metadata integrity checks / metadata (push) Successful in 3m20s Details Reviewed-on: #44	2026-11-09 13:42:00 +00:00
codex-bot	13408869c2	Add reviewed AAMAS 2025 publisher metadata adapter Metadata integrity checks / metadata (push) Successful in 2m11s Details	2026-11-09 20:50:29 +08:00
codex-bot	443a79dce2	Preserve edition-specific ACL and TINLAP 1978 source evidence Metadata integrity checks / metadata (push) Successful in 2m6s Details	2026-11-09 17:20:27 +08:00
Zayden-Jung	ec9edd88d4	Merge pull request '保留ICLR历史录用档案的轨道与完整来源证据' (#41 ) from codex/iclr-archive into main Metadata integrity checks / metadata (push) Successful in 2m54s Details Reviewed-on: #41	2026-11-09 09:02:49 +00:00
codex-bot	b5c0618be5	Handle standalone italic author blocks in the historical archive Metadata integrity checks / metadata (push) Successful in 2m6s Details	2026-11-09 16:24:42 +08:00
codex-bot	81864e48ae	Preserve complete fragmented ICLR 2014 author paragraphs Metadata integrity checks / metadata (push) Successful in 2m9s Details	2026-11-09 16:19:19 +08:00
Zayden-Jung	8ad052f577	Merge pull request '核验学习与规划会议前身卷并补齐发现范围' (#40 ) from codex/historical-predecessors into main Metadata integrity checks / metadata (push) Successful in 2m12s Details Reviewed-on: #40	2026-11-09 08:13:52 +00:00
codex-bot	348ebe0695	Collect archived ICLR accepted lists with track and presentation evidence Metadata integrity checks / metadata (push) Successful in 2m15s Details	2026-11-09 16:09:13 +08:00
codex-bot	aa696bd7b5	Isolate tiny predecessor fixtures from production disk reserve Metadata integrity checks / metadata (push) Successful in 2m11s Details	2026-11-09 15:15:48 +08:00
codex-bot	90bd534edd	Preserve reviewed historical learning and planning predecessor series Metadata integrity checks / metadata (push) Failing after 2m0s Details	2026-11-09 15:01:12 +08:00
Zayden-Jung	02a408ba8f	Merge pull request '保留 AAMAS 发表来源的同届 DOI 投稿身份' (#39 ) from codex/aamas-publication-identity into main Metadata integrity checks / metadata (push) Successful in 2m15s Details Reviewed-on: #39	2026-11-09 06:43:15 +00:00
codex-bot	714f745bd5	Assert normalized identity tuples and exact negative-status boundaries Metadata integrity checks / metadata (push) Successful in 2m13s Details	2026-11-09 14:13:12 +08:00
Zayden-Jung	cc78e837d2	Merge pull request '按发表形式采集 AAMAS 官方论文集' (#38 ) from codex/aamas-proceedings into main Metadata integrity checks / metadata (push) Successful in 2m26s Details Reviewed-on: #38	2026-11-09 05:52:57 +00:00
codex-bot	c0b2146ae8	Recognize AAMAS publisher DOI identities within submission scopes Metadata integrity checks / metadata (push) Failing after 2m1s Details	2026-11-09 13:51:49 +08:00
codex-bot	ae88367fac	Scope AAMAS tags to their exact source namespace Metadata integrity checks / metadata (push) Successful in 8m56s Details	2026-11-09 13:31:46 +08:00
codex-bot	a305d00c75	Collect evidenced AAMAS proceedings metadata by publication format Metadata integrity checks / metadata (push) Failing after 2m2s Details	2026-11-09 13:27:23 +08:00
Zayden-Jung	57fcfc7693	Merge pull request '按官方证据识别早期 ICML 与 IROS 主系列' (#37 ) from codex/historical-primary-series into main Metadata integrity checks / metadata (push) Successful in 2m58s Details Reviewed-on: #37	2026-11-09 05:19:49 +00:00
Zayden-Jung	a07b1e42a8	Merge pull request '修正早期 ACL 来源误匹配并记录官方目录缺口' (#36 ) from codex/history-source-scope into main Metadata integrity checks / metadata (push) Successful in 2m48s Details Reviewed-on: #36	2026-11-09 05:19:43 +00:00
codex-bot	7c6f4c9f1d	Recognize evidenced early ICML and IROS primary editions Metadata integrity checks / metadata (push) Successful in 9m26s Details	2026-11-09 02:39:18 +08:00
codex-bot	3f0ac694a0	Correct early ACL source candidates and record official index limits Metadata integrity checks / metadata (push) Successful in 14m52s Details	2026-11-09 02:28:51 +08:00
Zayden-Jung	32c7edd0a5	Merge pull request '核对135个历史年度缺口与候选论文集来源' (#35 ) from codex/historical-gaps into main Metadata integrity checks / metadata (push) Successful in 2m26s Details Reviewed-on: #35	2026-11-08 17:37:12 +00:00
Zayden-Jung	658d799334	Merge pull request '封装早期WWW档案采集并核实逐条poster证据' (#32 ) from codex/www-archive into main Metadata integrity checks / metadata (push) Successful in 2m34s Details Reviewed-on: #32	2026-11-08 17:37:03 +00:00
codex-bot	53fbe9c75c	Record current historical year gaps and candidate source volumes Metadata integrity checks / metadata (push) Successful in 3m15s Details	2026-11-09 00:50:15 +08:00
codex-bot	dac6edbe1e	Merge remote-tracking branch 'origin/main' into codex/www-archive Metadata integrity checks / metadata (push) Successful in 3m10s Details # Conflicts: # README.md	2026-11-09 00:48:14 +08:00
Zayden-Jung	7a674ac797	Merge pull request '按证据修正投稿轨道并保护后续来源刷新' (#34 ) from codex/edition-tracks into main Metadata integrity checks / metadata (push) Successful in 2m5s Details Reviewed-on: #34	2026-11-08 16:23:37 +00:00
codex-bot	eacc1e3292	Resolve reviewed WWW poster entries with canonical page evidence Metadata integrity checks / metadata (push) Successful in 1m32s Details	2026-11-09 00:18:32 +08:00
codex-bot	2275bc7530	Merge remote-tracking branch 'origin/main' into codex/www-archive # Conflicts: # README.md	2026-11-09 00:13:37 +08:00
codex-bot	d2c016e309	Reject target conflicts and post-application scope evidence drift Metadata integrity checks / metadata (push) Successful in 2m3s Details	2026-11-08 23:48:40 +08:00
codex-bot	ea3393144d	Merge remote-tracking branch 'origin/main' into codex/edition-tracks	2026-11-08 23:48:02 +08:00
codex-bot	7035cf33b9	Correct existing attempt tracks with bound evidence and refresh guards Metadata integrity checks / metadata (push) Successful in 1m59s Details	2026-11-08 23:46:37 +08:00
Zayden-Jung	60726a8c6b	Merge pull request '核实 IJCAI 两届 345 条非 main 分类与唯一目录缺项' (#33 ) from codex/ijcai-sections into main Metadata integrity checks / metadata (push) Successful in 1m28s Details Reviewed-on: #33	2026-11-08 15:44:02 +00:00
codex-bot	a1bbd26a5c	Merge remote-tracking branch 'origin/main' into codex/edition-tracks	2026-11-08 23:41:10 +08:00
Zayden-Jung	90f3fb213e	Merge pull request '区分同年同轨道会议事件并显式迁移原有身份' (#30 ) from codex/event-identity into main Metadata integrity checks / metadata (push) Successful in 1m28s Details Reviewed-on: #30	2026-11-08 15:37:08 +00:00
codex-bot	f9f4d263af	Expose independent event keys in integrated coverage reports Metadata integrity checks / metadata (push) Successful in 1m48s Details	2026-11-08 23:17:55 +08:00
codex-bot	0049b6ba84	Keep runtime integration compatible with newly merged curation tools Metadata integrity checks / metadata (push) Successful in 1m46s Details # Conflicts: # paper_atlas/cli.py # paper_atlas/curation/__init__.py	2026-11-08 23:13:12 +08:00
codex-bot	0133ce99d6	Preserve new workshop labels and historical edition scope from main Metadata integrity checks / metadata (push) Successful in 1m45s Details # Conflicts: # paper_atlas/collectors/dblp_scope.py	2026-11-08 22:21:55 +08:00
codex-bot	3d279cd7d8	Integrate current main coverage and public decision safeguards Metadata integrity checks / metadata (push) Successful in 1m44s Details	2026-11-08 22:16:21 +08:00
codex-bot	9040649320	Preserve full source listing totals beside ready archive subsets Metadata integrity checks / metadata (push) Successful in 1m10s Details	2026-11-08 21:54:43 +08:00
codex-bot	64ced7af42	Package reproducible early WWW metadata collection with explicit review holds Metadata integrity checks / metadata (push) Successful in 1m10s Details	2026-11-08 21:41:02 +08:00
codex-bot	4182070e76	Scope incremental parents to events and verify integrated write safeguards Metadata integrity checks / metadata (push) Successful in 1m45s Details	2026-11-08 21:04:05 +08:00
codex-bot	3c974009be	Integrate optional provenance-backed paper annotations # Conflicts: # README.md # paper_atlas/querying.py	2026-11-08 21:01:26 +08:00
codex-bot	298d7c4564	Integrate independent same-year event identity # Conflicts: # .gitea/workflows/check.yml # README.md # paper_atlas/cli.py	2026-11-08 21:01:08 +08:00
codex-bot	c7591bca0f	Integrate verified joint-edition refresh protection	2026-11-08 21:00:45 +08:00
codex-bot	160137ee2d	Integrate stable identities and incremental source coverage	2026-11-08 21:00:45 +08:00
codex-bot	e044c63546	Bound exact event migration counts with primary-key pagination Metadata integrity checks / metadata (push) Successful in 1m20s Details	2026-11-08 20:52:49 +08:00
codex-bot	c3aeee6323	Add explicit conference event identity with guarded legacy migration Metadata integrity checks / metadata (push) Successful in 1m14s Details	2026-11-08 20:39:40 +08:00
codex-bot	88c2819edd	Keep legacy source refreshes in their verified joint editions Metadata integrity checks / metadata (push) Successful in 1m13s Details	2026-11-08 19:15:26 +08:00
codex-bot	866aeaf068	Read PostgreSQL mapping rows by position during joint preflight Metadata integrity checks / metadata (push) Successful in 1m13s Details	2026-11-08 19:10:10 +08:00
codex-bot	c05b979b01	Bind repair execution receipts to the reviewed plan hash	2026-11-08 19:09:27 +08:00
codex-bot	3f81734e69	Repair verified joint edition membership without reimporting papers Metadata integrity checks / metadata (push) Failing after 1m5s Details	2026-11-08 19:07:00 +08:00
codex-bot	adcbbb66a2	Freeze SQLite annotation fixtures before PostgreSQL migration Metadata integrity checks / metadata (push) Successful in 1m19s Details	2026-11-08 18:41:38 +08:00
codex-bot	a13c535919	Require completed annotation upgrade before accepting evidence Metadata integrity checks / metadata (push) Failing after 1m5s Details	2026-11-08 18:40:51 +08:00
codex-bot	27e336eee9	Add evidence-bearing research types and retractable custom annotations Metadata integrity checks / metadata (push) Failing after 1m2s Details	2026-11-08 18:38:48 +08:00