Phases 02-05: protocol, harness, viewer/capture, live smoke experiment (4 arms)

added Makefile +20 −0

++PY=.venv/bin/python
++export PYTHONPATH=src
++test:            ## infrastructure tests (no provider access)
++	$(PY) -m pytest -q tests
++deploy:          ## install gate + env on executor nodes
++	$(PY) -m pgar.cli deploy
++probe:           ## sentinel isolation probes on nodes (tiny live calls)
++	$(PY) -m pgar.cli probe
++smoke-live:      ## 1 task x 4 arms, live
++	$(PY) -m pgar.cli assign --split development --tasks F2-smoke-01 --repeats 1 --seed 101 && $(PY) -m pgar.cli run --split development
++status:
++	$(PY) -m pgar.cli status
++export:
++	$(PY) -m pgar.cli export
++analyze:
++	$(PY) analysis/build_analysis_dataset.py && $(PY) analysis/primary_analysis.py && $(PY) analysis/robustness.py && $(PY) analysis/tables.py && $(PY) analysis/figures.py
++paper:
++	cd paper && latexmk -pdf -interaction=nonstopmode main.tex
++viewer:
++	$(PY) -m pgar.evidence_viewer

added configs/budgets.yaml +12 −0

++# Shared resource envelope per run (identical across arms; reviewer sessions in arm D draw from the same envelope).
++model: claude-opus-5-5
++effort: null            # Claude Code CLI default effort (not overridden; recorded as 'default')
++concurrency_per_node: 2
++budget:
++  max_budget_usd: 4.00
++  wall_seconds: 1500
++  max_turns_per_session: 80
++  max_gate_cycles: 3
++  max_review_cycles: 1
++  min_continuation_usd: 0.25
++list_prices_per_mtok: {input: 4.0, output: 20.0, cache_read: 0.20, cache_write: 5.0}   # claude-opus-5-5 list prices (skill cache 2026-10-06); used only to estimate cost of sessions killed before their result line

added configs/capture.yaml +11 −0

++# Screenshot capture protocol (see protocol/screenshot_protocol.md)
++capture_tool: /usr/sbin/screencapture
++modes: [native_live, dashboard_live, viewer_postrun, transcript_replay]
++triggers:
++  - {id: env_verification, mode: native_live, surface: Terminal, rule: once per phase 00/03}
++  - {id: live_run, mode: native_live, surface: Terminal (controller log) + dashboard_live (viewer), rule: first run of each arm in smoke; stratified subset in main (first block per family)}
++  - {id: gate_rejection, mode: dashboard_live, rule: every controller gate failure in smoke/pilot; sampled in main}
++  - {id: recovery, mode: dashboard_live, rule: every fault-injection run (before/fault/after)}
++  - {id: dashboard_status, mode: dashboard_live, rule: at pilot end, main end}
++  - {id: results_figure, mode: viewer_postrun, rule: once after analysis}
++storage_bound_mb: 300

added configs/confirmatory.yaml +2 −0

		`@@ -0,0 +1,2 @@`
1	+split: confirmatory
2	+nodes: [M3U96a, M3U96b, M4M64a, M4M64b]

added configs/development.yaml +2 −0

		`@@ -0,0 +1,2 @@`
1	+split: development
2	+nodes: [M3U96a, M3U96b, M4M64a, M4M64b]

added configs/pilot.yaml +2 −0

		`@@ -0,0 +1,2 @@`
1	+split: pilot
2	+nodes: [M3U96a, M3U96b, M4M64a, M4M64b]

added configs/transfer.yaml +9 −0

++split: transfer
++nodes: [M3U96a, M3U96b, M4M64a, M4M64b]
++budget:
++  max_budget_usd: 12.00
++  wall_seconds: 3600
++  max_turns_per_session: 150
++  max_gate_cycles: 3
++  max_review_cycles: 1
++  min_continuation_usd: 0.50

added evaluators/public_evaluation_interface/receipt_schema.json +20 −0

++{
++  "$schema": "https://json-schema.org/draft/2020-12/schema",
++  "title": "WP29 evaluation receipt",
++  "type": "object",
++  "required": ["task_id","run_id","evaluator_version","evaluated_utc","required_criteria","critical_violations","scientific_success","quality_components","notes"],
++  "properties": {
++    "task_id": {"type": "string"},
++    "run_id": {"type": "string"},
++    "evaluator_version": {"type": "string"},
++    "evaluated_utc": {"type": "string"},
++    "required_criteria": {"type": "array", "items": {"type": "object", "required": ["id","description","passed"],
++      "properties": {"id": {"type":"string"}, "description": {"type":"string"}, "passed": {"type":"boolean"}, "observed": {}, "expected": {}, "tolerance": {}}}},
++    "critical_violations": {"type": "array", "items": {"type":"object", "required": ["id","type","description"],
++      "properties": {"id":{"type":"string"},"type":{"type":"string","enum":["leakage","fabrication","invalid_inference","unreported_substitution","false_completion","provenance"]},"description":{"type":"string"},"evidence":{}}}},
++    "scientific_success": {"type": "boolean"},
++    "quality_components": {"type":"object","required":["correctness","integrity","reproducibility","reporting","baseline"],
++      "properties": {"correctness":{"type":"number"},"integrity":{"type":"number"},"reproducibility":{"type":["number","null"]},"reporting":{"type":"number"},"baseline":{"type":"number"}}},
++    "notes": {"type": "string"}
++  }
++}

added evidence/viewer.log +0 −0

modified protocol/amendments.csv +1 −0

				`@@ -1 +1,2 @@`
1	amendment_id,timestamp_utc,phase,before_or_after_results,document,description,rationale,previous_version_ref	1	amendment_id,timestamp_utc,phase,before_or_after_results,document,description,rationale,previous_version_ref
		2	+A-001,2026-10-30T03:00:00Z,02,before_results,configs/budgets.yaml,"Provisional live-inference envelope set by the executor: per benchmark run 4.00 USD / 1500 s / 80 turns per session; per transfer run 12.00 USD / 3600 s; total study envelope 800 USD (pilot + main + transfer + recovery + ablations) with the confirmatory scale to be chosen after the pilot.","The mandate requires a precise budget decision but none was stated; the researcher is not available mid-run; prior UQO studies spent ≈1,079 USD of API inference (WP26), so 800 USD is a conservative envelope. The researcher may raise or lower it; any change will be a new amendment.",n/a

added protocol/arms/arm_A.md +1 −0

				`@@ -0,0 +1 @@`
		1	+Complete the task described in `TASK.md`.

added protocol/arms/arm_B.md +36 −0

++Complete the task described in `TASK.md` by following this research protocol. The protocol adds no scientific information to the task; it organizes how you work and what evidence you leave behind.
++
++PHASES (execute in order; a phase is eligible only when its dependencies are satisfied):
++
++P0 Scope and contract (depends on: nothing)
++- Read `TASK.md` completely. In `out/state/contract.md`, restate in your own words: the scientific question; the quantity or quantities to be estimated (the estimands) and the assumptions under which they are meaningful; every required output file and key; the information-availability rules; what would make the task impossible or the result invalid.
++- Write the initial phase ledger `out/state/phases.json`: a JSON object mapping each phase id (P0 … P5) to {"status": "pending"|"running"|"passed"|"failed"|"blocked"|"stale"|"skipped_optional", "checks": [], "notes": ""}. Keep it current as you work. A phase may only be set to "passed" when the checks listed for it in this protocol have actually been executed and their outcome recorded in "checks".
++
++P1 Data audit and provenance (depends on: P0)
++- Inspect every input file: compute and record its SHA-256, row and column counts, schema, units, date ranges, missing values, duplicates and anomalies in `out/state/data_audit.md`.
++- Keep an exclusion ledger in `out/exclusions.csv` (columns: step, rule, n_before, n_after, n_removed, rationale) for every filtering step you apply, so that n_raw − total removed = n_analysed.
++- Identify any input that violates the information-availability rules and decide, in writing, how you will handle it.
++
++P2 Baseline (depends on: P1)
++- Before any elaborate method, compute the simplest valid baseline that answers the question (for example a naïve or unconditional estimate), with the same evaluation rule used later. Record it in `out/results.json` under the keys the task requires, or under `baseline_*` keys when the task does not name them.
++
++P3 Method and computation (depends on: P2)
++- Implement the analysis in `out/analysis.py` so that it reads only `data/`, writes `out/results.json` deterministically (fix every random seed you use and record it), and prints nothing that contradicts the written results. Any figure or table must be generated by this script.
++
++P4 Verification (depends on: P3)
++- Re-run `out/analysis.py` from a clean state and confirm it regenerates `out/results.json` with identical values. Record the check in `out/state/phases.json` under P4.
++- Check internal consistency: identities that must hold (for example counts that must add up, standard errors that must be positive, confidence intervals that must contain their estimates, date orderings that must respect the information rules), units, and magnitudes against the baseline. Record every check and its outcome in `out/state/checks.md`. A failed check must be fixed or honestly reported, never silently ignored.
++
++P5 Reporting (depends on: P4)
++- Write `out/report.md` with the sections: Question; Data and exclusions; Method; Results; Uncertainty; Limitations and open issues. Every quantitative statement must cite the key of `out/results.json` it comes from.
++- Write `out/claims.json`: a list of the central claims of your report, each as {"id": "C1", "text": "...", "results_keys": ["..."], "status": "supported"|"unsupported"|"not_evaluated", "caveat": "..."}. Do not state a claim in the report that is not in this ledger.
++- Set the final statuses in `out/state/phases.json`.
++
++STOPPING RULES
++- Stop and declare the task complete only when every phase P0–P5 is "passed" with recorded checks. If a phase is "blocked" (missing information, impossible requirement, violated availability rule), stop, set the status, explain in `out/report.md` (section Limitations and open issues) and still write every required file with `null` for values you could not legitimately produce.
++- Do not spend effort on extensions that the task does not require.
++
++RECOVERY RULES
++- Append a short dated entry to `out/state/log.md` after each phase transition and after any important decision, so that work can be resumed by reading `out/state/`.
++- If you discover that an upstream input or decision changed after a downstream phase passed, mark the downstream phases "stale" and redo them; do not reuse stale results.
++- If you are interrupted and later resumed, first read `out/state/` and continue from the last consistent state; never re-run expensive steps that already have recorded, unchanged outputs.

added protocol/arms/arm_C.md +41 −0

++Complete the task described in `TASK.md` by following this research protocol. The protocol adds no scientific information to the task; it organizes how you work and what evidence you leave behind.
++
++PHASES (execute in order; a phase is eligible only when its dependencies are satisfied):
++
++P0 Scope and contract (depends on: nothing)
++- Read `TASK.md` completely. In `out/state/contract.md`, restate in your own words: the scientific question; the quantity or quantities to be estimated (the estimands) and the assumptions under which they are meaningful; every required output file and key; the information-availability rules; what would make the task impossible or the result invalid.
++- Write the initial phase ledger `out/state/phases.json`: a JSON object mapping each phase id (P0 … P5) to {"status": "pending"|"running"|"passed"|"failed"|"blocked"|"stale"|"skipped_optional", "checks": [], "notes": ""}. Keep it current as you work. A phase may only be set to "passed" when the checks listed for it in this protocol have actually been executed and their outcome recorded in "checks".
++
++P1 Data audit and provenance (depends on: P0)
++- Inspect every input file: compute and record its SHA-256, row and column counts, schema, units, date ranges, missing values, duplicates and anomalies in `out/state/data_audit.md`.
++- Keep an exclusion ledger in `out/exclusions.csv` (columns: step, rule, n_before, n_after, n_removed, rationale) for every filtering step you apply, so that n_raw − total removed = n_analysed.
++- Identify any input that violates the information-availability rules and decide, in writing, how you will handle it.
++
++P2 Baseline (depends on: P1)
++- Before any elaborate method, compute the simplest valid baseline that answers the question (for example a naïve or unconditional estimate), with the same evaluation rule used later. Record it in `out/results.json` under the keys the task requires, or under `baseline_*` keys when the task does not name them.
++
++P3 Method and computation (depends on: P2)
++- Implement the analysis in `out/analysis.py` so that it reads only `data/`, writes `out/results.json` deterministically (fix every random seed you use and record it), and prints nothing that contradicts the written results. Any figure or table must be generated by this script.
++
++P4 Verification (depends on: P3)
++- Re-run `out/analysis.py` from a clean state and confirm it regenerates `out/results.json` with identical values. Record the check in `out/state/phases.json` under P4.
++- Check internal consistency: identities that must hold (for example counts that must add up, standard errors that must be positive, confidence intervals that must contain their estimates, date orderings that must respect the information rules), units, and magnitudes against the baseline. Record every check and its outcome in `out/state/checks.md`. A failed check must be fixed or honestly reported, never silently ignored.
++
++P5 Reporting (depends on: P4)
++- Write `out/report.md` with the sections: Question; Data and exclusions; Method; Results; Uncertainty; Limitations and open issues. Every quantitative statement must cite the key of `out/results.json` it comes from.
++- Write `out/claims.json`: a list of the central claims of your report, each as {"id": "C1", "text": "...", "results_keys": ["..."], "status": "supported"|"unsupported"|"not_evaluated", "caveat": "..."}. Do not state a claim in the report that is not in this ledger.
++- Set the final statuses in `out/state/phases.json`.
++
++STOPPING RULES
++- Stop and declare the task complete only when every phase P0–P5 is "passed" with recorded checks. If a phase is "blocked" (missing information, impossible requirement, violated availability rule), stop, set the status, explain in `out/report.md` (section Limitations and open issues) and still write every required file with `null` for values you could not legitimately produce.
++- Do not spend effort on extensions that the task does not require.
++
++RECOVERY RULES
++- Append a short dated entry to `out/state/log.md` after each phase transition and after any important decision, so that work can be resumed by reading `out/state/`.
++- If you discover that an upstream input or decision changed after a downstream phase passed, mark the downstream phases "stale" and redo them; do not reuse stale results.
++- If you are interrupted and later resumed, first read `out/state/` and continue from the last consistent state; never re-run expensive steps that already have recorded, unchanged outputs.
++
++EXECUTABLE GATES (additional, mandatory)
++- A read-only gate program is provided at `~/wp29/gates/pgar_gate.py`. Run it from the workspace root as `~/wp29/venv/bin/python ~/wp29/gates/pgar_gate.py .` It checks the output contract of `TASK.md` (required files, keys, types, finite values, report sections, the claims ledger, the phase ledger, the exclusion ledger) and reproducibility (it re-runs `out/analysis.py` in a temporary copy and compares the regenerated `out/results.json` with yours). It never checks scientific correctness and it contains no reference answers.
++- You must run the gate at the end of P4 and again at the end of P5, and record each run's receipt (the gate writes `out/state/gate_receipts/<timestamp>.json`) in `out/state/phases.json`. You may not declare the task complete while the latest gate receipt reports `"passed": false`. Fix the reported problems and re-run the gate.
++- The controller will run the same gate after your session ends. If it fails, you will be resumed with the gate output and asked to fix the problems; each such cycle consumes your remaining budget.

added protocol/arms/arm_D.md +44 −0

++Complete the task described in `TASK.md` by following this research protocol. The protocol adds no scientific information to the task; it organizes how you work and what evidence you leave behind.
++
++PHASES (execute in order; a phase is eligible only when its dependencies are satisfied):
++
++P0 Scope and contract (depends on: nothing)
++- Read `TASK.md` completely. In `out/state/contract.md`, restate in your own words: the scientific question; the quantity or quantities to be estimated (the estimands) and the assumptions under which they are meaningful; every required output file and key; the information-availability rules; what would make the task impossible or the result invalid.
++- Write the initial phase ledger `out/state/phases.json`: a JSON object mapping each phase id (P0 … P5) to {"status": "pending"|"running"|"passed"|"failed"|"blocked"|"stale"|"skipped_optional", "checks": [], "notes": ""}. Keep it current as you work. A phase may only be set to "passed" when the checks listed for it in this protocol have actually been executed and their outcome recorded in "checks".
++
++P1 Data audit and provenance (depends on: P0)
++- Inspect every input file: compute and record its SHA-256, row and column counts, schema, units, date ranges, missing values, duplicates and anomalies in `out/state/data_audit.md`.
++- Keep an exclusion ledger in `out/exclusions.csv` (columns: step, rule, n_before, n_after, n_removed, rationale) for every filtering step you apply, so that n_raw − total removed = n_analysed.
++- Identify any input that violates the information-availability rules and decide, in writing, how you will handle it.
++
++P2 Baseline (depends on: P1)
++- Before any elaborate method, compute the simplest valid baseline that answers the question (for example a naïve or unconditional estimate), with the same evaluation rule used later. Record it in `out/results.json` under the keys the task requires, or under `baseline_*` keys when the task does not name them.
++
++P3 Method and computation (depends on: P2)
++- Implement the analysis in `out/analysis.py` so that it reads only `data/`, writes `out/results.json` deterministically (fix every random seed you use and record it), and prints nothing that contradicts the written results. Any figure or table must be generated by this script.
++
++P4 Verification (depends on: P3)
++- Re-run `out/analysis.py` from a clean state and confirm it regenerates `out/results.json` with identical values. Record the check in `out/state/phases.json` under P4.
++- Check internal consistency: identities that must hold (for example counts that must add up, standard errors that must be positive, confidence intervals that must contain their estimates, date orderings that must respect the information rules), units, and magnitudes against the baseline. Record every check and its outcome in `out/state/checks.md`. A failed check must be fixed or honestly reported, never silently ignored.
++
++P5 Reporting (depends on: P4)
++- Write `out/report.md` with the sections: Question; Data and exclusions; Method; Results; Uncertainty; Limitations and open issues. Every quantitative statement must cite the key of `out/results.json` it comes from.
++- Write `out/claims.json`: a list of the central claims of your report, each as {"id": "C1", "text": "...", "results_keys": ["..."], "status": "supported"|"unsupported"|"not_evaluated", "caveat": "..."}. Do not state a claim in the report that is not in this ledger.
++- Set the final statuses in `out/state/phases.json`.
++
++STOPPING RULES
++- Stop and declare the task complete only when every phase P0–P5 is "passed" with recorded checks. If a phase is "blocked" (missing information, impossible requirement, violated availability rule), stop, set the status, explain in `out/report.md` (section Limitations and open issues) and still write every required file with `null` for values you could not legitimately produce.
++- Do not spend effort on extensions that the task does not require.
++
++RECOVERY RULES
++- Append a short dated entry to `out/state/log.md` after each phase transition and after any important decision, so that work can be resumed by reading `out/state/`.
++- If you discover that an upstream input or decision changed after a downstream phase passed, mark the downstream phases "stale" and redo them; do not reuse stale results.
++- If you are interrupted and later resumed, first read `out/state/` and continue from the last consistent state; never re-run expensive steps that already have recorded, unchanged outputs.
++
++EXECUTABLE GATES (additional, mandatory)
++- A read-only gate program is provided at `~/wp29/gates/pgar_gate.py`. Run it from the workspace root as `~/wp29/venv/bin/python ~/wp29/gates/pgar_gate.py .` It checks the output contract of `TASK.md` (required files, keys, types, finite values, report sections, the claims ledger, the phase ledger, the exclusion ledger) and reproducibility (it re-runs `out/analysis.py` in a temporary copy and compares the regenerated `out/results.json` with yours). It never checks scientific correctness and it contains no reference answers.
++- You must run the gate at the end of P4 and again at the end of P5, and record each run's receipt (the gate writes `out/state/gate_receipts/<timestamp>.json`) in `out/state/phases.json`. You may not declare the task complete while the latest gate receipt reports `"passed": false`. Fix the reported problems and re-run the gate.
++- The controller will run the same gate after your session ends. If it fails, you will be resumed with the gate output and asked to fix the problems; each such cycle consumes your remaining budget.
++
++SEPARATE REVIEW (additional)
++- After the gate passes, a separate reviewer session that has not seen your work in progress will examine `TASK.md` and everything under `out/` and may return a list of issues (file `out/review/review.json`). You will then be resumed once to address them: fix what is justified, explain in `out/report.md` (Limitations and open issues) what you disagree with, re-run the gate, and update `out/claims.json` and `out/state/phases.json`. The reviewer has no reference answers; its role is to challenge unsupported claims, violated information rules, unverified computations, and inconsistencies between your report and your results.

added protocol/arms/common_preamble.md +14 −0

++You are a research assistant executing one bounded scientific task inside the current working directory, which is your workspace.
++
++Environment facts (identical for every task):
++- The task statement is the file `TASK.md` in the workspace. It is the complete and only authoritative description of what is required: the scientific question, the inputs under `data/`, the required output files and their exact keys, and the information-availability rules.
++- There is no network access. Use the Python interpreter `~/wp29/venv/bin/python` (numpy, pandas, scipy, statsmodels, matplotlib are installed). Standard shell tools are available. Do not try to install packages.
++- Write every deliverable under `./out/`. The required deliverables are listed in `TASK.md`; at minimum they always include `out/results.json`, `out/report.md`, and a replication entry point `out/analysis.py` that regenerates `out/results.json` from `data/` when run with `~/wp29/venv/bin/python out/analysis.py` from the workspace root.
++- You are working alone and unattended; nobody will answer questions. Make reasonable, documented decisions.
++
++Integrity rules (identical for every task):
++- Never fabricate numbers, data, results, or references. Every number in `out/results.json` and `out/report.md` must be produced by code you ran on the provided inputs.
++- Respect the information-availability rules in `TASK.md` exactly (for example, never use information that would not have been available at the stated decision time).
++- If part of the task cannot be completed as specified, say so explicitly in `out/report.md`, explain why, and still write every required file (use `null` for values you could not legitimately produce). An honest statement of a limitation is always preferred to a fabricated or guessed value.
++- Do not modify anything under `data/`.
++- When you are done, end with a brief plain-text summary of what you produced and any limitations.

added protocol/arms/gate_feedback_prompt.md +2 −0

		`@@ -0,0 +1,2 @@`
1	+The controller ran the gate program after your session ended and it did NOT pass. The gate output is below. Fix the reported problems in your workspace, re-run the gate yourself, update `out/state/phases.json`, and stop when it passes. Do not change `data/`. Gate output:
2	+

added protocol/arms/resume_after_interruption_prompt.md +1 −0

				`@@ -0,0 +1 @@`
		1	+Your previous session was interrupted by the controller (an infrastructure event, not an error in your work). Continue the task described in `TASK.md` from the current state of the workspace and stop when the deliverables are complete.

added protocol/arms/review_feedback_prompt.md +2 −0

		`@@ -0,0 +1,2 @@`
1	+A separate reviewer examined your deliverables and returned the issues below (also saved in `out/review/review.json`). Address them: fix what is justified, explain in the Limitations and open issues section of `out/report.md` what you disagree with and why, re-run the gate program, update `out/claims.json` and `out/state/phases.json`, and stop. Reviewer output:
2	+

added protocol/arms/reviewer.md +10 −0

++You are an independent scientific reviewer. In the current working directory, `TASK.md` describes a bounded scientific task and the directory `out/` contains the deliverables submitted by another assistant (you have not seen how they were produced and you must not look for their working transcript). There is no network access. Use `~/wp29/venv/bin/python` if you need to re-run or test code. Do not modify any file under `out/` except that you must create `out/review/review.json`.
++
++Review the deliverables against `TASK.md` only. Specifically check:
++1. Does `out/results.json` contain every required key with legitimately computed values? Re-run `out/analysis.py` in a scratch copy if needed and compare.
++2. Are the information-availability rules of `TASK.md` respected by the code (for example no use of future information, no use of forbidden inputs)? Read the code to verify; do not trust the report.
++3. Are the central claims in `out/report.md` and `out/claims.json` supported by the numbers in `out/results.json`, with appropriate uncertainty and caveats? Flag any claim that is stronger than the evidence.
++4. Are counts, exclusions, units, signs and magnitudes internally consistent? Are baseline comparisons present when the task requires them?
++5. Are limitations stated honestly? Is anything declared complete that is not?
++
++You have no reference answers; do not guess what the "right" number is. Report only issues you can justify from the files. Write `out/review/review.json` as {"verdict": "accept"|"revise", "issues": [{"id": "R1", "severity": "critical"|"major"|"minor", "location": "<file or key>", "issue": "...", "suggested_fix": "..."}], "summary": "..."}. Use "revise" if there is at least one critical or major issue. Be concise and specific. End with a one-paragraph plain-text summary.

added protocol/arms/task_prompt.md +1 −0

				`@@ -0,0 +1 @@`
		1	+Begin now. The task is in `TASK.md` in the current directory. Work until the deliverables are complete, then stop.

added protocol/evaluation_plan.md +25 −0

++# Evaluation plan (frozen for the pilot)
++
++## Final evaluation (common to all arms, evaluator host only)
++1. Harness collects `out/` from the node, runs the **common contract check** (the same gate program, post hoc, never fed back to arms A/B) which also provides the **fresh re-run reproducibility** result (analysis.py re-executed in a clean copy on the node with the pinned venv).
++2. `~/wp29-oracles/<task_id>/evaluate.py` (deterministic, no LLM) produces the receipt: required criteria (task-specific, tolerances justified in REFERENCE.md), critical violations (leakage, fabrication, invalid_inference, unreported_substitution, false_completion, provenance), quality components, `scientific_success` = all criteria ∧ no violation.
++3. Quality score = 0.40·correctness + 0.20·integrity + 0.15·reproducibility + 0.15·reporting + 0.10·baseline (weights frozen 2026-10-30 before the pilot). Components are always reported separately.
++4. Receipts are validated against `evaluators/public_evaluation_interface/receipt_schema.json`, hashed and stored (`evaluations` table + `runs/<split>/<run>/evaluation_receipt.json`).
++
++## Primary endpoint
++Y_iar = 1{scientific_success ∧ status = completed (within the envelope) ∧ no human intervention}. Timeout/budget-exhausted runs are evaluated and reported but Y = 0. Infrastructure errors (`error` status with no inference) follow the balanced rerun policy (attempt-numbered rerun of the same assignment; the original attempt stays in the ledger) and are reported separately.
++
++## Secondary endpoints
++As listed in the mandate §7.2, each computed from the receipt/manifest tables: correct completion ignoring the envelope; quality components; violation counts by type; unsupported claims (claims with status `supported` whose results key fails its criterion — computed where the oracle maps claims to keys); reproducibility; correct detection of infeasible/null-truth tasks (criterion in those tasks' oracles) and false blocking on feasible tasks (`feasibility ≠ complete` on a feasible task = critical `false_completion`-class violation "false_blocking", recorded by the evaluators as `false_completion` with a description — reported separately in the analysis); recovery outcomes (Phase 08); latency, usage, cost (client estimate), human minutes.
++
++## Evaluator validation
++Every oracle ships `validation/validate.py` with ≥1 correct_out and ≥2 wrong_out artefacts; results are aggregated into `reports/evaluator_validation.md` (false acceptance / false rejection per task on the seeded artefacts). The smoke evaluator is additionally unit-tested (`tests/unit/test_gate_and_evaluator.py`).
++
++## Model-based grading (supplementary, not primary)
++Not used for the primary endpoint. If used in Phase 09 for report quality, the grader model, prompt, rubric and its own validation on seeded artefacts will be reported; same-family dependence will be stated.
++
++## Blinding
++Evaluators are deterministic programs and do not see arm labels; run ids are neutral (`RD0001`…). Artefacts can reveal the arm (e.g. `out/state/phases.json` exists only in B/C/D) — irrelevant for deterministic evaluators, relevant for any human/LLM review (documented as imperfect blinding).
++
++## Human involvement
++No human reviewer is available for the benchmark; those cells are "unavailable". Human interventions are logged in `reports/interventions.csv` (and the `interventions` table). Historical preparation time of the mandate is unknown and is reported as unknown.

added protocol/scientific_contract.md +33 −0

++# Scientific delegation contract — WP29 (PGAR)
++
++A PGAR protocol is a tuple P = (Q, Θ, D, A, G, V, B, R, L). This document states how each component is **serialised and used** in the implemented harness (`src/pgar/`). Nothing here is a theorem; the invariants below are workflow guarantees enforced by code, not guarantees of scientific truth.
++
++| Component | Meaning | Serialisation in WP29 | Used by |
++|---|---|---|---|
++| Q — questions and scope | the scientific question and estimand(s) of a task | `TASK.md` §Scientific question (public bundle); for WP29 itself: `protocol/preregistration.md` §1 | executor (all arms); evaluator |
++| Θ — estimands, hypotheses, assumptions | what is estimated, under which assumptions, which interpretations are admissible | `TASK.md` §Scientific question + §Information-availability rules; oracle `REFERENCE.md` (hidden) | executor; evaluator |
++| D — data, versions, availability | inputs, provenance, hashes, information-availability rule | `data/README.md` + `bundle.json` (SHA-256 of every input), `TASK.md` §Inputs/§Information-availability rules | executor; harness (workspace verification); evaluator |
++| A — authorised actions and tools | the tool inventory and permission policy | launcher flags (`src/pgar/launcher.py::build_command`): `--bare --tools Bash,Read,Write,Edit,Glob,Grep --allowedTools … --permission-prompts none`, offline nodes, pinned venv | harness (identical across arms) |
++| G — phase graph | ordered phases with dependencies | protocol text (arms B/C/D: P0→P1→P2→P3→P4→P5) + the executor-maintained ledger `out/state/phases.json`; harness-level run state machine `contracts.RUN_TRANSITIONS` | executor (B/C/D); gate (C/D: `phase_ledger_consistent`) |
++| V — verification criteria and evaluators | runtime (oracle-free) and final (hidden-oracle) checks | `gate_spec.json` + `pgar_gate.py` (runtime, C/D + post hoc for all); `~/wp29-oracles/<task>/evaluate.py` + `oracle.json` (final); receipt schema `evaluators/public_evaluation_interface/receipt_schema.json` | harness; evaluator host only |
++| B — budgets and stopping | USD cap, wall clock, turns, gate/review cycles | `configs/budgets.yaml` → `Envelope` (`src/pgar/budgets.py`); enforced by `--max-budget-usd`, `--max-turns`, controller timeout + remote kill | harness (identical envelope across arms; reviewer draws from the same envelope) |
++| R — recovery, amendment, escalation | what happens after interruption, failure or a changed input | protocol text (B/C/D recovery rules) + harness resume (`--resume <session>`), rerun-attempt ledger, `protocol/amendments.csv` | executor; harness; researcher |
++| L — evidence and provenance records | run manifest, event stream, receipts, transcripts, screenshots, interventions | SQLite `runs/state.sqlite` (tables runs, run_transitions, sessions, events, gate_receipts, reviews, evaluations, screenshots, faults, jobs, interventions) + per-run directory `runs/<split>/<run_id>/` (raw_stream.jsonl, sessions/*.jsonl, out/, ctl/, prepare.json, artifact_manifest.json, contract_receipt.json, evaluation_receipt.json, behaviour_audit.json) | everything downstream |
++
++## States and transitions
++
++Run states (harness, `contracts.RUN_TRANSITIONS`): `not_started → prepared → running → {completed, timeout, budget_exhausted, error, interrupted}`; `interrupted → running` (resume after a standardised fault); `{completed, timeout, budget_exhausted, error} → evaluated`; `error → prepared` (balanced rerun policy for infrastructure errors, attempt-numbered); `void` for assignments withdrawn before any inference. Phase states (protocol, executor-maintained): `pending, running, passed, failed, blocked, stale, skipped_optional`.
++
++## Invariants actually enforced (and their limits)
++
++1. **No `evaluated` without a receipt** — `StateStore.transition` refuses the transition unless `evaluation_receipt` is set (test `tests/unit/test_state.py`). Limit: it checks existence, not the scientific validity of the receipt.
++2. **Changed upstream input invalidates downstream results** — the gate's reproducibility check re-runs `out/analysis.py` on the current `data/` and compares with `out/results.json`; a mutated input makes the regeneration differ (`recovery.stale_input_check`). Limit: only detects dependence through the replication script; hand-typed numbers are detected as non-reproducible, not as "stale".
++3. **Envelope** — each session is launched with `--max-budget-usd = remaining` and the controller kills the remote process at the wall limit; continuation requires `remaining ≥ 0.25 USD` and `≥ 120 s`. Limit: the client-side cost estimate can overshoot the cap slightly (documented by Anthropic); the overshoot is recorded, not hidden.
++4. **No "verified" claim without evidence** — executors must list claims in `out/claims.json` with `results_keys` that exist (gate check `claims_json`); final evaluators score claims against hidden references. Limit: the gate checks referential integrity, not truth.
++5. **Skipped optional phases cannot support claims** — `phase_ledger_consistent` requires every non-terminal phase to be `passed`, `blocked` or `skipped_optional`, and a `passed` phase to carry ≥1 recorded check; the final evaluator ignores phase ledgers entirely (it scores artefacts), so a skipped phase cannot "pass" a criterion. Limit: an executor can write a check string without running it — the reproducibility check and the final oracle are the real safeguards.
++6. **Idempotent jobs** — every execute/session job is logged in the `jobs` table before submission; a duplicate key is rejected (`test_job_ledger_idempotent`; stress test in Phase 08).
++7. **Nested-invocation guard** — executors have no `Agent` tool; the launcher refuses to start if `PGAR_DEPTH` is set; executors run with `PGAR_DEPTH=1` on another host.
++
++## Observable autonomy (preserved in the database)
++
++For each run: `status`/`terminal_reason` (workflow autonomy: did the executor finish without operational help?), `evaluations.scientific_success` (scientific completion), `human_intervention_ids` in the manifest (empty ⇒ intervention-free). The primary endpoint Y = scientific_success ∧ no critical violation ∧ no intervention ∧ within envelope (`status ∈ {completed}`; a `timeout`/`budget_exhausted` run keeps its artefacts and is evaluated, but Y = 0 by construction because the envelope was exceeded). "Autonomous but wrong" = completed ∧ ¬success; "assisted correct" = success ∧ intervention present (expected to be empty in the benchmark: no human intervened in any executor session).

added protocol/screenshot_protocol.md +7 −0

++# Screenshot and visual-evidence protocol
++
++Capture tool: `/usr/sbin/screencapture -x -o -l <CGWindowID>` (native window capture, macOS 27.0), window ids resolved through Quartz `CGWindowListCopyWindowInfo`. Every capture is recorded in the `screenshots` table with: screenshot_id, run/task/treatment/phase, event linkage, UTC timestamp, capture_mode (native_live / dashboard_live / viewer_postrun / transcript_replay), tool and version, source surface, original path + SHA-256, public path + SHA-256 (if published), redaction description, selection rule, caption, claim ids. Originals live in `evidence/restricted/` (not committed); public copies in `evidence/public_screenshots/` only after inspection for secrets (none expected: executors never see credentials; the controller never prints them).
++
++Triggers (`configs/capture.yaml`): environment verification (once), live run (first smoke batch; one stratified block per family in the main benchmark), gate rejection (every controller gate failure in smoke/pilot; sampled in main), recovery (every fault-injection run: before/fault/after), dashboard status (end of pilot, end of main), results figure/table (after analysis), compiled manuscript (final).
++
++Rules: no image generation, no reconstructed terminals, no editing of captured content other than cropping (recorded). Capture failures are logged (e.g. S001 live-dashboard attempt during the smoke batch failed because the Safari window was off-screen; a post-run viewer capture replaces it and is labelled `viewer_postrun`). Hashes attest file integrity relative to the manifest, not the moment of capture; captures are triangulated with event timestamps and session ids in the database. Screenshots document events; they are never used as statistical observations.

added protocol/treatment_definitions.md +16 −0

++# Treatment definitions (frozen for the pilot; re-frozen before the confirmatory stage)
++
++All arms share: the same `TASK.md` and bundle; the same client (Claude Code 2.1.314, `--bare`), model (`claude-opus-5-5`, CLI default effort), tool inventory (Bash, Read, Write, Edit, Glob, Grep; no web, no sub-agents), permission policy (`--permission-prompts none`, listed tools pre-approved), offline executor node with the same pinned Python environment, the same resource envelope (4.00 USD, 1,500 s wall, 80 turns per session), the same user prompt (`protocol/arms/task_prompt.md`) and the same common preamble (`protocol/arms/common_preamble.md`: environment facts, output contract, integrity rules). The only difference is the text appended after the common preamble in `--append-system-prompt-file`:
++
++| Arm | Appended text | Words (preamble + arm) | Controller behaviour after the session |
++|---|---|---|---|
++| A — Open instruction | `arm_A.md` (one sentence) | 285 | collect, post-hoc contract check (not fed back), evaluate |
++| B — Structured protocol | `arm_B.md` (phases P0–P5, stopping rules, recovery rules, phase ledger, claims ledger) | 944 | same as A |
++| C — Protocol + executable gates | `arm_C.md` = B + mandatory gate program (`~/wp29/gates/pgar_gate.py`) | 1,106 | run the pristine gate; if it fails, resume the session with the gate output (≤ 3 cycles, within the envelope); evaluate |
++| D — Protocol + gates + separate review | `arm_D.md` = C + announcement of a separate review | 1,200 | as C; then a **separate** reviewer session (fresh session id, `reviewer.md` system prompt, sees only `TASK.md` + `out/`) writes `out/review/review.json`; if `revise`, the executor is resumed once with the review; gate again; evaluate |
++
++Measured initial context (first assistant turn, smoke run, tokens): A 2,238; B 3,717; C 4,111; D 4,319 (`sessions.first_turn_input_tokens`). These include the client's own system prompt and the task prompt; the difference between arms is the protocol text only.
++
++Content-equivalence audit: the arm texts add **no** scientific information (no data facts, no method hints beyond "compute the simplest valid baseline", which is already a required output in every `TASK.md` that defines a baseline key). The common preamble is byte-identical across arms (`protocol_hash` per run = SHA-256 of preamble+arm text; `effective_context_hash` adds TASK.md and the user prompt). A length-matched unstructured control (`arm_A_long.md`, same word count as B, generic research advice without phases, ledgers or gates) is a Phase 08 ablation if the budget allows.
++
++What the gate cannot do: it contains no reference values and cannot judge scientific correctness; it checks the output contract, internal consistency and reproducibility. What the reviewer cannot do: it has no reference answers and no access to the executor's transcript (it is told not to look for it; the transcript lives outside the workspace under `~/.claude/projects` on the node — a residual, documented leak path that was not exercised in the smoke run: the reviewer's tool uses referenced only workspace paths).

added pyproject.toml +10 −0

++[project]
++name = "pgar"
++version = "0.1.0"
++description = "Protocol-Guided Autonomous Research harness (UQO WP29)"
++requires-python = ">=3.12"
++dependencies = ["numpy==2.3.4", "pandas==2.3.3", "scipy==1.16.2", "statsmodels==0.14.5", "matplotlib==3.10.7", "pyyaml", "jsonschema", "pytest"]
++[project.scripts]
++pgar = "pgar.cli:main"
++[tool.pytest.ini_options]
++testpaths = ["tests"]

added reports/isolation_audit.md +20 −0

++# Isolation audit — WP29
++
++## Boundaries (what actually separates executors from hidden material)
++| Boundary | Mechanism | Verification |
++|---|---|---|
++| Physical/host | Executors run on cluster nodes (M3U96a, M3U96b, M4M64a, M4M64b); oracles, evaluators, this repository and the series exist only on the laptop (and `~/wp29-oracles/` on the laptop) | nodes hold no copy (no rsync of oracles ever; `tests/isolation/test_bundle_hygiene.py` checks every public bundle for forbidden material); node → laptop SSH port 22 unreachable (`nc -z` from M3U96a, 2026-10-29) |
++| Workspace | one fresh directory per run containing exactly the public bundle | `isolation.prepare_workspace` compares the remote SHA-256 manifest with the local bundle manifest before launch; mismatch ⇒ infrastructure error (this actually fired twice in the first smoke attempt because of an unexpanded `~`, and the runs were recorded as `error` with no inference) |
++| Instruction loading | `--bare`: no CLAUDE.md discovery, no hooks, plugins, MCP, auto-memory, skills; instructions injected only via `--append-system-prompt-file`; identical flags across arms | sentinel probes: laptop normal mode loaded 49,077 tokens incl. the user's cluster CLAUDE.md; bare mode 144 tokens and no sentinel; on each node bare mode saw neither the project sentinel nor the node's `~/.claude/CLAUDE.md` (`reports/sentinel_probes_nodes.jsonl`, 175–177 input tokens) |
++| Tools | `--tools Bash,Read,Write,Edit,Glob,Grep` (no WebFetch/WebSearch/Agent/MCP), `--permission-prompts none` | the stream's init event lists the tool set; behaviour audit scans every tool_use input for paths outside the workspace (`behaviour_audit.json`; smoke: 0 outside references in all four arms) |
++| Credentials | `~/wp29/.env` (mode 600) on nodes, sourced by the launching shell; never written to logs or the repository; `--bare` never reads keychain/OAuth | grep of `runs/` for the key prefix is part of the release validation |
++| Reviewer (arm D) | separate session id, separate system prompt, sees `TASK.md` + `out/` | residual leak path: the executor transcript exists under `~/.claude/projects` on the node and could be read with Bash; not exercised in the smoke run (behaviour audit) — reported as a limitation |
++| Nested invocation | no Agent tool; `PGAR_DEPTH` guard; executors cannot launch controllers | code review + probe |
++
++## Contamination of the task suite
++Tasks were authored by Claude Code subagents (fresh contexts, no access to executor transcripts) under a frozen interface; the builder (this session) wrote the smoke task. Executor sessions are fresh (`--bare`, new session id, new workspace) and cannot access sibling runs, previous attempts or oracles. Pretraining familiarity with textbook methods is expected and reported per task (`contamination_risk` in each task card). Reference answers were accessible to: the authoring subagent (designer) and the evaluator host. No executor ever had access.
++
++## Residual risks
++1. Same user account on the nodes: an executor could read other runs' workspaces under `~/wp29/runs/` (sibling outputs of *other* runs) via Bash. Behaviour audit flags any such path; none occurred in the smoke. A stricter per-run OS identity was not implemented (documented limitation).
++2. The reviewer can in principle read the executor transcript (see above).
++3. The gate program is world-readable on the node; arms A/B were not told about it and did not call it (0 invocations in the smoke), which the audit records for every run.

modified reports/phase_status.md +30 −0

+ - **Unresolved**: packaged artefacts absent (replaced by live retrieval); budget envelope set provisionally by the executor (Phase 02).
+ - **Gate**: identity protected ✔; capabilities vs missing inputs distinguished ✔; no credentials exposed ✔. **PASSED.**
+ - **Next eligible**: Phase 01 (literature + corpus coding, launched as two background subagents at ≈ 03:25 UTC) and Phase 02 (protocol, tasks, evaluators) in parallel.
++
++## Phase 01 — Literature and scientific blueprint (in progress → closed with Phase 02 artefacts)
++
++- **Started** 2026-10-29 ≈ 03:25 UTC. Corpus coding completed ≈ 03:45 UTC by a Claude Code subagent (`research/corpus_coding_protocol.md`, `code_corpus.py`, `corpus_automated.csv`, `corpus_coding.csv`, `corpus_summary.md`; single coder, no intercoder reliability). Literature review delegated to a second subagent (still running at the time of this entry; outputs `research/literature_matrix.csv`, `novelty_matrix.csv`, `source_notes.md`, `references_verified.bib`).
++- **Blueprint**: `protocol/scientific_contract.md`, `protocol/treatment_definitions.md`, `protocol/evaluation_plan.md` (this phase and Phase 02 overlap by design: the smallest executable study was built and smoke-tested before the literature files landed).
++- **Gate**: closest prior work identified — pending the literature subagent's report; novelty qualified in `research/source_notes.md` when it lands. PARTIALLY PASSED (blueprint ✔, literature pending).
++
++## Phase 02 — Protocol, task suite and evaluator specification
++
++- **Started** 2026-10-30 ≈ 03:05 UTC. Wrote `tasks/TASK_AUTHORING_SPEC.md` (frozen interface v1), `evaluators/public_evaluation_interface/receipt_schema.json`, the four arm texts + reviewer + feedback prompts (`protocol/arms/`), `configs/*.yaml`, `protocol/screenshot_protocol.md`, the smoke task `F2-smoke-01` (bundle, card, hidden oracle with independent numpy reference), and the family brief `tasks/FAMILY_AGENT_BRIEF.md`; six task-family subagents launched ≈ 03:20 UTC (1 dev + 4 conf tasks each, with hidden oracles and validation sets).
++- **Checks**: content-equivalence audit of arm texts (no task facts in protocols); endpoint/estimand definitions written before any pilot run.
++- **Gate**: information matched across arms ✔; success/failure definitions frozen for the pilot ✔ (`protocol/evaluation_plan.md`); hidden-answer protection plan ✔ (`reports/isolation_audit.md`); negative/infeasible cases required in F5/F6 briefs ✔ (verification when the agents report). PASSED for the pilot design.
++
++## Phase 03 — Minimal harness
++
++- **Started** 2026-10-30 ≈ 03:10 UTC. Implemented `src/pgar/{contracts,state,events,launcher,isolation,provenance,budgets,runtime_gates,recovery,scheduler,evaluation,exports,cli}.py` (≈1,300 lines, standard library + numpy/pandas/jsonschema/yaml on the controller; the gate is standard-library only). Deployed the gate (`sha256 1760d13e…`) and a mode-600 key file on the four nodes; pinned venvs; `make test`: 7 infrastructure tests pass (state machine, idempotent job ledger, invariant "no evaluated without receipt", event normalisation, gate accepts a correct artefact and rejects three planted defects, smoke evaluator accepts correct_out and rejects a wrong-SE/fabricated-count artefact). The bundle-hygiene test is pending until all task agents finish.
++- **Failures fixed**: (i) `sqlite3` connection shared across threads returned a spurious `KeyError` → all reads serialised behind the store lock; (ii) `shlex.quote("~/…")` prevented tilde expansion on nodes → absolute remote root; (iii) behaviour audit false positives from truncated summaries → audit now parses the verbatim stream with a path regex.
++- **Gate**: harness rejects known defects ✔ (tests); worker access to hidden material prevented by tested controls ✔ (`reports/isolation_audit.md`, sentinel probes on all nodes). PASSED.
++
++## Phase 04 — Capture system and evidence viewer
++
++- Implemented `src/pgar/evidence_viewer.py` (read-only HTTP dashboard over `runs/state.sqlite`, port 8765) and `src/pgar/capture.py` (Quartz window lookup + `screencapture -l`, manifest in the `screenshots` table). Captures so far: **S002** native_live Terminal window tailing the live stream of RD0002 (arm D) during the smoke batch; **S003** native_live Terminal window of the builder session itself (incidental, kept for the reflexive trace); **S001** dashboard capture *failed* during the batch (Safari window off-screen; `screencapture` could not create the image) — a post-run viewer capture will be taken and labelled `viewer_postrun`. No synthetic imagery exists.
++- **Gate**: ≥1 genuine capture linked to an actual event ✔ (S002 ↔ RD0002 session b425e9f5…); no synthetic UI ✔; public evidence not yet published (originals in `evidence/restricted/`, to be inspected before copying). PASSED (with the recorded capture failure).
++
++## Phase 05 — Real smoke experiment
++
++- **Executed** 2026-10-30 03:30–03:36 UTC: assignment seed 101 → RD0001 (A, M3U96a), RD0002 (D, M3U96b), RD0003 (C, M4M64a), RD0004 (B, M4M64b), task `F2-smoke-01`, model `claude-opus-5-5` (reported by the client in `modelUsage`), client 2.1.314. First attempt: RD0003/RD0004 failed at workspace verification (tilde bug, no inference) and RD0001/RD0002 hit the thread-safety bug before launch — all four recorded in the ledger (`run_transitions`) and rerun under the attempt-numbered rerun policy after the fixes.
++- **Outcomes** (all live): 4 of 4 executor sessions finished (`result.subtype = success`); scientific_success = 1 in all four arms (5/5 criteria, 0 violations, reproducible). Costs (client estimate, USD): A 0.120 (6 turns, 53 s), B 0.311 (11 turns, 103 s), C 0.237 (7 turns, 85 s; gate run 3× by the executor, controller gate passed at cycle 1), D 0.418 = executor 0.303 + reviewer 0.114 (11 + 5 turns; reviewer verdict `accept` with 2 minor issues; no repair cycle). First-turn input tokens A 2,238 / B 3,717 / C 4,111 / D 4,319.
++- **Checks**: workspace manifests verified identical before each launch; behaviour audit: 0 outside-workspace references in all arms; gate invocations by executors: A 0, B 0, C 3, D 4; transcripts collected (`runs/development/RD000x/sessions/*.jsonl`).
++- **Gate**: four genuine task executions accounted for incl. the four infrastructure failures ✔; isolation and treatment delivery verified ✔ (effective-context hashes differ by arm only through the protocol text; token counts consistent); results are development observations ✔. PASSED. Next: pilot on the six development tasks when the family agents deliver them.

added reports/sentinel_probes_nodes.jsonl +4 −0

++{"node": "M3U96a", "result": "(1) NONE; (2) NONE.", "input_tokens": 176, "cost": 6.81e-05, "ok": true}
++{"node": "M3U96b", "result": "(1) NONE; (2) NONE.", "input_tokens": 176, "cost": 6.96e-05, "ok": true}
++{"node": "M4M64a", "result": "(1) NONE; (2) NONE.", "input_tokens": 177, "cost": 7.27e-05, "ok": true}
++{"node": "M4M64b", "result": "(1) NONE; (2) NONE.", "input_tokens": 175, "cost": 7.2e-05, "ok": true}

added research/build_literature_matrix.py +473 −0

++#!/usr/bin/env python3
++"""Build literature_matrix.csv and references_verified.bib for WP29 from cached
++primary-metadata records (Crossref, arXiv API, Semantic Scholar, OpenReview).
++
++Every entry below was checked against the cached API response in verify_cache/
++(fetched 2026-10-29/30 UTC).  Nothing is emitted unless the cache record exists.
++"""
++import csv, json, os, re, sys, html, urllib.parse, datetime
++import xml.etree.ElementTree as ET
++
++HERE = os.path.dirname(os.path.abspath(__file__))
++CACHE = os.path.join(HERE, "verify_cache")
++S2 = json.load(open(os.path.join(CACHE, "semanticscholar_batch.json")))
++DOIRES = json.load(open(os.path.join(CACHE, "doi_resolution.json")))
++NS = {"a": "http://www.w3.org/2005/Atom", "ar": "http://arxiv.org/schemas/atom"}
++
++
++def cache_path(url):
++    return os.path.join(CACHE, re.sub(r"[^A-Za-z0-9]+", "_", url)[:150])
++
++
++def mtime_utc(path):
++    return datetime.datetime.fromtimestamp(os.path.getmtime(path), datetime.UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
++
++
++def crossref(doi):
++    url = "https://api.crossref.org/works/" + urllib.parse.quote(doi, safe="")
++    p = cache_path(url)
++    m = json.load(open(p))["message"]
++    yr = (m.get("issued") or m.get("published-print") or m.get("published-online"))["date-parts"][0][0]
++    authors = [(a.get("family", ""), a.get("given", "")) for a in m.get("author", [])]
++    return dict(title=" ".join(m["title"][0].split()), authors=authors, year=yr,
++                container=(m.get("container-title") or [""])[0], crtype=m["type"],
++                volume=m.get("volume"), issue=m.get("issue"), pages=m.get("page"),
++                publisher=m.get("publisher"), url="https://api.crossref.org/works/" + doi,
++                verified=mtime_utc(p))
++
++
++def arxiv(aid):
++    url = "https://export.arxiv.org/api/query?id_list=" + aid
++    p = cache_path(url)
++    e = ET.parse(p).getroot().find("a:entry", NS)
++    names = [a.find("a:name", NS).text for a in e.findall("a:author", NS)]
++    authors = [(n.split()[-1], " ".join(n.split()[:-1])) for n in names]
++    jr = e.find("ar:journal_ref", NS)
++    return dict(title=" ".join(e.find("a:title", NS).text.split()), authors=authors,
++                year=int(e.find("a:published", NS).text[:4]), container="arXiv preprint",
++                jref=jr.text if jr is not None else None, url=url, verified=mtime_utc(p))
++
++
++def s2_venue(key):
++    v = S2.get(key) or {}
++    pv = v.get("publicationVenue") or {}
++    return v.get("venue"), pv.get("type"), v.get("year")
++
++
++# ----------------------------------------------------------------------------
++# Entry list.  Fields: key, stream, doi, arxiv, vtype, peer (yes/no/unknown),
++# peer_src (extra verification URL for the venue), rel (relevance), claim.
++# ----------------------------------------------------------------------------
++E = []
++def add(**k):
++    E.append(k)
++
++# ---- Stream 1: autonomous scientific discovery / agentic research systems ----
++add(key="lu2024aiscientist", stream=1, arxiv="2408.06292", vtype="preprint", peer="no",
++    rel="Reference end-to-end autonomous research system (idea to paper plus simulated review) against which WP29's protocol-guided design is positioned.",
++    claim="Introduces The AI Scientist, which generates research ideas, writes code, executes experiments, visualizes results, writes a full paper and runs a simulated review, with each paper developed at a cost of less than $15 and an automated reviewer reported to achieve near-human performance on paper scores.")
++add(key="lu2026aiscientist", stream=1, doi="10.1038/s41586-026-10265-5", vtype="journal", peer="yes",
++    rel="Peer-reviewed (Nature, 2026) publication of The AI Scientist line of work, establishing that fully automated ML research pipelines are now part of the refereed literature.",
++    claim="n/a (Nature abstract not retrieved behind the publisher login; see lu2024aiscientist for the system description).")
++add(key="yamada2025aiscientistv2", stream=1, arxiv="2504.08066", vtype="preprint", peer="no",
++    rel="Closest fully autonomous end-to-end system; its tree-search workflow and in-system AI reviewer are the counterpoint to WP29's executable gates and separated review.",
++    claim="Describes an end-to-end agentic system with progressive agentic tree search managed by an experiment-manager agent and a VLM feedback loop for figures; of three fully autonomous manuscripts submitted to an ICLR workshop, one scored above the average human acceptance threshold.")
++add(key="schmidgall2025agentlab", stream=1, doi="10.18653/v1/2025.findings-emnlp.320", arxiv="2501.04227", vtype="conference", peer="yes",
++    rel="Staged (literature review, experimentation, report writing) autonomous research framework with optional human feedback; provides the human-in-the-loop and cost comparisons WP29 builds on.",
++    claim="Agent Laboratory takes a human-provided idea through literature review, experimentation and report writing; the authors report that o1-preview gives the best outcomes, that human feedback at each stage significantly improves research quality, and an 84% decrease in research expenses relative to previous autonomous research methods.")
++add(key="boiko2023coscientist", stream=1, doi="10.1038/s41586-023-06792-0", vtype="journal", peer="yes",
++    rel="Landmark peer-reviewed demonstration of an LLM agent planning and executing laboratory experiments; defines the 'autonomous research' baseline WP29 compares to.",
++    claim="Coscientist, driven by GPT-4 with internet/documentation search, code execution and experimental automation tools, autonomously designs, plans and performs experiments across six tasks, including successful reaction optimization of palladium-catalysed cross-couplings.")
++add(key="bran2024chemcrow", stream=1, doi="10.1038/s42256-024-00832-8", vtype="journal", peer="yes",
++    rel="Tool-augmented LLM research agent whose evaluation combined LLM and expert assessment, an early instance of the evaluator-validity question WP29 addresses with protected oracles.",
++    claim="ChemCrow integrates 18 expert-designed tools with GPT-4, autonomously planned and executed syntheses of an insect repellent and three organocatalysts, and was evaluated with both LLM and expert assessments.")
++add(key="ifargan2025datatopaper", stream=1, doi="10.1056/AIoa2400555", arxiv="2404.17605", vtype="journal", peer="yes",
++    rel="Closest prior work on traceability: an autonomous data-to-paper platform that programmatically backtraces information flow for human verification, akin to WP29's persistent evidence records.",
++    claim="data-to-paper guides interacting LLM agents through a stepwise research process from annotated data to papers while programmatically backtracing information flow and allowing human oversight, and can run fully autonomously ('autopilot') or with human intervention.")
++add(key="gottweis2026coscientist", stream=1, doi="10.1038/s41586-026-10644-y", arxiv="2502.18864", vtype="journal", peer="yes",
++    rel="Multi-agent hypothesis-generation system with generate/critique/refine loops; illustrates in-system self-critique rather than independent verification.",
++    claim="Co-Scientist is a Gemini-based multi-agent system that continuously generates, critiques and refines research hypotheses using an asynchronous task framework and a tournament evolution process, scaled by test-time compute, to propose demonstrably novel hypotheses for experimental verification.")
++add(key="swanson2025virtuallab", stream=1, doi="10.1038/s41586-025-09442-9", vtype="journal", peer="yes",
++    rel="AI-human research collaboration with an LLM principal-investigator agent and human oversight; a human-involvement design point for the novelty matrix.",
++    claim="The Virtual Lab is an AI-human research collaboration in which an LLM Principal Investigator agent guides a team of LLM scientist agents to perform interdisciplinary research, applied to designing SARS-CoV-2 nanobodies.")
++add(key="mitchener2025kosmos", stream=1, arxiv="2511.02824", vtype="preprint", peer="no",
++    rel="Recent long-horizon AI scientist (up to 12 h, 200 rollouts); documents the coherence/verification challenges of long autonomous runs that WP29's gates target.",
++    claim="Kosmos runs for up to 12 hours performing cycles of parallel data analysis, literature search and hypothesis generation, using a structured world model shared between agents to pursue an objective coherently over 200 agent rollouts before synthesizing reports.")
++add(key="luo2025pitfalls", stream=1, arxiv="2509.08713", vtype="preprint", peer="no",
++    rel="Directly motivates WP29: shows AI scientist systems commit benchmark selection, leakage, metric-misuse and post-hoc selection errors that only traces reveal.",
++    claim="Identifies four failure modes in AI scientist systems (inappropriate benchmark selection, data leakage, metric misuse and post-hoc selection bias) and, via controlled experiments on two open-source systems, finds several of them present.")
++add(key="beel2025sakana", stream=1, doi="10.1145/3769733.3769747", arxiv="2502.14297", vtype="journal", peer="unknown",
++    rel="Independent third-party evaluation of The AI Scientist; evidence that unverified autonomous outputs contain novelty and execution errors.",
++    claim="An independent evaluation of the AI Scientist found several critical shortcomings, including a literature review based on simplistic keyword searches that led to poor novelty assessments, with several generated ideas incorrectly classified as novel.")
++add(key="luo2026xscientist", stream=1, arxiv="2607.12301", vtype="preprint", peer="no",
++    rel="Closest 2026 design to a research protocol: git-like typed research state with checkpoints, claim-evidence closure and gates; differs from WP29 in being a protocol artifact rather than a controlled comparison of protocol arms.",
++    claim="Proposes a local-first, git-like protocol that treats research state rather than a manuscript as the unit of continuation, representing hypotheses, attempts, claims, reviews and handoffs as typed content-addressed objects with immutable checkpoints, claim-evidence closure and authority-aware gates, without treating a passing integrity check as scientific truth.")
++add(key="ding2026verificationgap", stream=1, arxiv="2608.05179", vtype="preprint", peer="no",
++    rel="Survey that names the 'verification gap' in AI scientist systems; supplies the audit dimensions (evaluation method, artifacts, human-in-the-loop points, result-selection disclosure) WP29 reports.",
++    claim="Screens 125 works and codes 26 (24 runnable systems) on seven audit dimensions, finding that code release is now common but reproducibility-grade and claim-verification artifacts remain rare.")
++
++# ---- Stream 2: language agents for data analysis and scientific programming ----
++add(key="chen2025scienceagentbench", stream=2, arxiv="2410.05080", vtype="conference", peer="yes",
++    peer_src="https://api2.openreview.net/notes/search?term=ScienceAgentBench (ICLR 2025 Poster record)",
++    rel="Benchmark of expert-validated data-driven discovery tasks with program-level outputs, execution metrics and cost; the task style and contamination mitigations inform WP29's task bank.",
++    claim="Presents 102 tasks extracted from 44 publications in four disciplines and validated by nine experts; the best agent solves 32.4% of tasks independently (34.3% with expert knowledge), o1-preview reaches 42.2% at more than 10 times the cost, and two data-contamination mitigation strategies are proposed.")
++add(key="majumder2025discoverybench", stream=2, arxiv="2407.01725", vtype="conference", peer="yes",
++    peer_src="https://api2.openreview.net/notes/search?term=DiscoveryBench (ICLR 2025 Poster record)",
++    rel="Formalizes multi-step data-driven discovery as dataset + metadata + goal, the same unit of analysis as WP29's research tasks.",
++    claim="DiscoveryBench formalizes the multi-step process of data-driven discovery with 264 tasks across six domains derived from published papers plus 903 synthetic tasks, each defined by a dataset, its metadata and a natural-language discovery goal.")
++add(key="jing2025dsbench", stream=2, arxiv="2409.07703", vtype="conference", peer="yes",
++    peer_src="https://api2.openreview.net/notes/search?term=DSBench (ICLR 2025 Poster record)",
++    rel="Realistic data-science agent benchmark (long contexts, large data) used to characterize executor capability independent of protocol.",
++    claim="DSBench comprises 466 data-analysis and 74 data-modeling tasks sourced from Eloquence and Kaggle competitions, with long contexts, multimodal task backgrounds and reasoning over large data files.")
++add(key="huang2024mlagentbench", stream=2, arxiv="2310.03302", vtype="conference", peer="yes",
++    rel="Evaluates agents on ML experimentation loops with file/code actions; a precursor of WP29's executor arms.",
++    claim="MLAgentBench is a suite of 13 ML experimentation tasks (from CIFAR-10 improvement to BabyLM) in which a ReAct-based agent can read/write files, execute code and inspect outputs; a Claude 3 Opus agent had the best success rate.")
++add(key="gu2024blade", stream=2, arxiv="2408.09667", vtype="conference", peer="yes",
++    rel="Evaluates analysis decisions (variables, transformations, models) against independent expert analyses, the multi-path ground truth WP29's oracles must handle.",
++    claim="BLADE evaluates agents' multifaceted approaches to open-ended research questions using 12 datasets and questions from the literature, with ground truth collected from independent analyses by expert data scientists.")
++add(key="jimenez2024swebench", stream=2, arxiv="2310.06770", vtype="conference", peer="yes",
++    rel="Canonical execution-verified coding benchmark; its test-based grading is the model for WP29's executable verification gates.",
++    claim="SWE-bench consists of 2,294 software-engineering problems drawn from real GitHub issues and pull requests across 12 Python repositories, where resolving an issue frequently requires coordinating changes across multiple functions, classes and files.")
++add(key="chan2025mlebench", stream=2, arxiv="2410.07095", vtype="conference", peer="yes",
++    peer_src="https://proceedings.iclr.cc/paper_files/paper/2025/hash/7e3767db483c942b883eb4f8cfb74e31-Abstract-Conference.html",
++    rel="Agentic ML-engineering benchmark with human baselines, resource-scaling and contamination analyses that WP29's resource accounting parallels.",
++    claim="MLE-bench curates 75 Kaggle competitions with human leaderboard baselines; the best setup (o1-preview with AIDE scaffolding) reaches at least bronze-medal level in 16.9% of competitions, and the paper also studies resource scaling and pre-training contamination.")
++add(key="siegel2024corebench", stream=2, arxiv="2409.11363", vtype="journal", peer="yes",
++    rel="Benchmarks agents on computational reproducibility of published papers, linking agent evaluation to the reproducibility stream.",
++    claim="CORE-Bench contains 270 tasks based on 90 scientific papers across computer science, social science and medicine, measuring agents' accuracy at reproducing published results from provided code and data at three difficulty levels.")
++add(key="starace2025paperbench", stream=2, arxiv="2504.01848", vtype="conference", peer="yes",
++    rel="Rubric-decomposed replication grading with a validated LLM judge; closest precedent for WP29's rubric oracles and judge validation.",
++    claim="PaperBench asks agents to replicate 20 ICML 2024 papers from scratch, graded against 8,316 rubric items co-developed with the papers' authors, with an LLM-based judge whose performance is assessed on a separate judge benchmark.")
++
++# ---- Stream 3: workflows, provenance, computational reproducibility ----
++add(key="koster2012snakemake", stream=3, doi="10.1093/bioinformatics/bts480", vtype="journal", peer="yes",
++    rel="Rule-based workflow engine; WP29's protocol stages are an analogue of declarative, re-executable workflow rules.",
++    claim="Snakemake provides a readable Python-based workflow definition language and an execution environment that scales from single-core workstations to compute clusters without modifying the workflow.")
++add(key="ditommaso2017nextflow", stream=3, doi="10.1038/nbt.3820", vtype="journal", peer="yes",
++    rel="Container-based dataflow workflow manager for reproducible pipelines; reference for execution isolation in WP29's executors.",
++    claim="Argues that combining dataflow programming with software containers (Nextflow) yields computational workflows that are reproducible across platforms.")
++add(key="missier2013prov", stream=3, doi="10.1145/2452376.2452478", vtype="conference", peer="yes",
++    rel="W3C PROV family defines the provenance vocabulary (entities, activities, agents) that WP29's evidence records instantiate.",
++    claim="Overview of the W3C PROV family of specifications (data model, ontology, notation and constraints) for interoperable representation and exchange of provenance metadata.")
++add(key="chirigati2016reprozip", stream=3, doi="10.1145/2882903.2899401", vtype="conference", peer="yes",
++    rel="Automatic capture of execution provenance into re-executable packages; a model for evidence capture without relying on the agent's self-report.",
++    claim="ReproZip automatically captures the provenance of a command-line experiment (files, libraries, environment) and packages it so that it can be re-executed elsewhere.")
++add(key="sandve2013tensimplerules", stream=3, doi="10.1371/journal.pcbi.1003285", vtype="journal", peer="yes",
++    rel="Widely cited rules (track provenance, avoid manual steps, record versions and seeds) that WP29 operationalizes as machine-checked gates.",
++    claim="Proposes ten rules for reproducible computational research, including tracking how every result was produced, avoiding manual data manipulation, archiving exact program versions and random seeds, and providing public access to scripts, runs and results.")
++add(key="stodden2018journalpolicy", stream=3, doi="10.1073/pnas.1708290115", vtype="journal", peer="yes",
++    rel="Empirical reproducibility failure rates under policy-only enforcement; motivates executable rather than declarative verification.",
++    claim="In a random sample of 204 Science papers subject to a data/code-on-request policy, the authors obtained artifacts from 44% of papers and could reproduce the findings for 26%.")
++add(key="peng2011reproducible", stream=3, doi="10.1126/science.1213847", vtype="journal", peer="yes",
++    rel="Defines reproducibility (data + code available) as the minimum standard for computational claims, the standard WP29's evidence records target.",
++    claim="Reproducibility has the potential to serve as a minimum standard for judging scientific claims when full independent replication of a study is not possible.")
++add(key="nasem2019reproducibility", stream=3, doi="10.17226/25303", vtype="report", peer="unknown",
++    rel="Authoritative definitions of reproducibility vs replicability used in WP29's outcome definitions.",
++    claim="Defines reproducibility as obtaining consistent computational results using the same input data, computational steps, methods, code and conditions of analysis, and replicability as obtaining consistent results across studies aimed at the same question with new data.")
++add(key="krafczyk2021reproduction", stream=3, doi="10.1098/rsta.2020.0069", vtype="journal", peer="yes",
++    rel="Principles (transparency, re-executability, determinism) and a Reproduction Package formalism close to WP29's release bundle.",
++    claim="From reproducing seven articles the authors derive three principles (transparency about how results are produced, ease of re-executability, determinism), 12 guidelines, and a Reproduction Package formalism for sharing artifacts.")
++add(key="trisovic2022codequality", stream=3, doi="10.1038/s41597-022-01143-6", vtype="journal", peer="yes",
++    rel="Large-scale evidence that deposited research code usually fails to run, justifying execution-based verification gates.",
++    claim="Executing over 9,000 R files from more than 2,000 Harvard Dataverse replication datasets, 74% failed to complete without error initially and 56% still failed after automatic code cleaning.")
++
++# ---- Stream 4: preregistration, registered reports, specification discipline ----
++add(key="nosek2018preregistration", stream=4, doi="10.1073/pnas.1708274114", vtype="journal", peer="yes",
++    rel="Preregistration as prediction/postdiction separation is the direct analogue of WP29's protocol fixed before execution.",
++    claim="Defining research questions and the analysis plan before observing outcomes (preregistration) distinguishes analyses that result from predictions from those that result from postdictions, and practical strategies exist for cases that fall short of the ideal.")
++add(key="chambers2013registeredreports", stream=4, doi="10.1016/j.cortex.2012.12.016", vtype="journal", peer="unknown",
++    rel="Origin of Registered Reports: review of the protocol before results, the publishing analogue of WP29's pre-execution gate.",
++    claim="Introduces Registered Reports at Cortex, in which study protocols are peer reviewed and provisionally accepted before data collection.")
++add(key="chambers2022registeredreports", stream=4, doi="10.1038/s41562-021-01193-7", vtype="journal", peer="yes",
++    rel="Reviews evidence that pre-acceptance of protocols reduces reporting bias; supports the 'specification before execution' arm.",
++    claim="Registered Reports are a publication format in which study proposals are peer reviewed and pre-accepted before research is undertaken; early evidence indicates they work as intended although they are not a universal solution for irreproducibility.")
++add(key="simmons2011falsepositive", stream=4, doi="10.1177/0956797611417632", vtype="journal", peer="yes",
++    rel="Researcher degrees of freedom inflate false positives; WP29's locked analysis specification removes these from the agent.",
++    claim="Flexibility in data collection, analysis and reporting dramatically increases actual false-positive rates, so that a researcher is often more likely to falsely find evidence that an effect exists than to correctly find evidence that it does not; six disclosure requirements for authors and four reviewer guidelines are proposed.")
++add(key="munafo2017manifesto", stream=4, doi="10.1038/s41562-016-0021", vtype="journal", peer="yes",
++    rel="Umbrella statement of reproducibility measures (methods, reporting, evaluation, incentives) that WP29 adapts to autonomous agents.",
++    claim="Argues for measures optimizing methods, reporting and dissemination, reproducibility, evaluation and incentives, noting evidence from simulations and empirical studies but the need for iterative evaluation of their adoption.")
++add(key="gelman2014statisticalcrisis", stream=4, doi="10.1511/2014.111.460", vtype="journal", peer="unknown",
++    rel="Garden of forking paths: data-dependent analysis choices invalidate inference even without intent, which an agent in an open instruction arm is free to make.",
++    claim="Argues that data-dependent choices of analysis (the 'garden of forking paths') can produce spurious statistically significant findings even when researchers do not deliberately fish for significance.")
++add(key="nosek2015top", stream=4, doi="10.1126/science.aab2374", vtype="journal", peer="yes",
++    rel="TOP guidelines define graded transparency standards (preregistration, data, code) that WP29's protocol tiers mirror.",
++    claim="Proposes journal author guidelines (the TOP guidelines) to promote transparency, openness and reproducibility, noting that although scientists embrace these norms they are not routine in practice.")
++add(key="scheel2021excess", stream=4, doi="10.1177/25152459211007467", vtype="journal", peer="yes",
++    rel="Quantifies how pre-specified protocols change the result distribution; benchmark for interpreting WP29's arm differences.",
++    claim="Comparing 71 published Registered Reports with 152 standard hypothesis-testing papers, the first hypothesis was positive in 96% of standard reports but only 44% of Registered Reports.")
++add(key="osc2015reproducibility", stream=4, doi="10.1126/science.aac4716", vtype="journal", peer="yes",
++    rel="Baseline replication rates in a human literature; provides a human reference for WP29's validity outcomes.",
++    claim="Replications of 100 experiments from 2008 papers in three psychology journals found that about one-third to one-half of original findings were also observed in the replication, depending on the criterion.")
++add(key="kerr1998harking", stream=4, doi="10.1207/s15327957pspr0203_4", vtype="journal", peer="yes",
++    rel="HARKing (presenting post hoc hypotheses as a priori) is a failure mode an unconstrained agent can reproduce when writing up.",
++    claim="Defines HARKing (hypothesizing after the results are known) as presenting post hoc hypotheses as if they were a priori, and discusses its prevalence and costs.")
++
++# ---- Stream 5: agent evaluation, contamination, evaluator validity ----
++add(key="liu2024agentbench", stream=5, arxiv="2308.03688", vtype="conference", peer="yes",
++    rel="Multi-environment agent benchmark identifying long-horizon reasoning and instruction following as main failure causes, relevant to protocol adherence measurement.",
++    claim="AgentBench evaluates LLMs as agents across 8 environments; top commercial LLMs act well in complex environments but a significant gap separates them from open-source models up to 70B, with poor long-term reasoning, decision-making and instruction following as main obstacles.")
++add(key="yao2024taubench", stream=5, arxiv="2406.12045", vtype="preprint", peer="unknown",
++    rel="State-based outcome checking and the pass^k reliability metric are reused in WP29's repeated-run reliability analysis.",
++    claim="tau-bench evaluates agents in simulated user conversations with API tools and policy guidelines by comparing the final database state to an annotated goal state, and proposes pass^k for reliability over multiple trials; gpt-4o succeeds on fewer than 50% of tasks with pass^8 below 25% in retail.")
++add(key="kapoor2024agentsthatmatter", stream=5, arxiv="2407.01502", vtype="journal", peer="yes",
++    rel="Core methodological critique (cost reporting, holdouts, conflated benchmarking needs) that WP29's evaluation design follows.",
++    claim="Analysis of agent benchmarks finds a narrow focus on accuracy without cost, leading to needlessly complex and costly agents; proposes jointly optimizing accuracy and cost, and notes that model- and downstream-developer needs are conflated and that many benchmarks have inadequate holdout sets.")
++add(key="sainz2023contamination", stream=5, doi="10.18653/v1/2023.findings-emnlp.722", arxiv="2310.18018", vtype="conference", peer="yes",
++    rel="Defines contamination levels; WP29's task bank must document contamination risk for each task.",
++    claim="Position paper arguing that training on a benchmark's test split causes overestimation of performance with potentially harmful scientific conclusions, defining levels of data contamination and calling for community measurement for each benchmark.")
++add(key="zheng2023mtbench", stream=5, arxiv="2306.05685", vtype="conference", peer="yes",
++    peer_src="https://api2.openreview.net/notes/search?term=Judging%20LLM-as-a-judge (NeurIPS 2023 Datasets and Benchmarks record)",
++    rel="Establishes LLM-as-a-judge and its biases (position, verbosity, self-enhancement), which WP29's protected oracles are designed to avoid.",
++    claim="Examines LLM-as-a-judge limitations including position, verbosity and self-enhancement biases, and finds that strong judges such as GPT-4 agree with human preferences over 80% of the time on MT-bench and Chatbot Arena, the same level as human-human agreement.")
++add(key="thakur2025judgingjudges", stream=5, arxiv="2406.12624", vtype="conference", peer="yes",
++    rel="Shows even the best judge models lag inter-human agreement, cautioning against unprotected LLM grading of research outputs.",
++    claim="Across thirteen judge models and nine exam-taker models in a high-human-agreement setting, only the best and largest judges reach reasonable alignment with humans, remain well behind inter-human agreement, and may differ from human scores by up to 5 points.")
++add(key="panickssery2024selfpreference", stream=5, arxiv="2404.13076", vtype="conference", peer="yes",
++    rel="Self-preference bias is the specific threat WP29 mitigates by separating executor and reviewer and protecting oracles.",
++    claim="LLM evaluators such as GPT-4 and Llama 2 have non-trivial accuracy at recognizing their own outputs, and fine-tuning reveals a linear correlation between self-recognition capability and the strength of self-preference.")
++add(key="zhu2025abc", stream=5, arxiv="2507.02825", vtype="preprint", peer="no",
++    rel="Agentic Benchmark Checklist (task validity, outcome validity, reporting) used as a checklist for WP29's task and oracle construction.",
++    claim="Shows that many agentic benchmarks have task-setup or reward-design flaws (e.g., SWE-bench Verified uses insufficient test cases, TAU-bench counts empty responses as successful) that can mis-estimate performance by up to 100% relative, and introduces the Agentic Benchmark Checklist, which reduced overestimation on CVE-Bench by 33%.")
++add(key="kapoor2025hal", stream=5, arxiv="2510.11977", vtype="preprint", peer="no",
++    rel="Standardized harness with full cost accounting across models, scaffolds and benchmarks, the infrastructure model for WP29's isolated executors and resource logs.",
++    claim="Introduces a standardized evaluation harness and reports 21,730 agent rollouts across 9 models and 9 benchmarks at a total cost of about $40,000, finding among other things that higher reasoning effort can reduce accuracy.")
++add(key="li2025llmreval", stream=5, arxiv="2510.12367", vtype="preprint", peer="no",
++    rel="Simulated research-and-review loop showing LLM reviewers misaligned with humans; motivates WP29's separate, protected review arm rather than in-system AI review.",
++    claim="Using a simulation with a research agent that writes and revises papers and a review agent that assesses them, followed by human annotation, the authors identify pronounced misalignment between LLM reviewers and human judgments.")
++
++# ---- Stream 6: human-AI delegation, automation bias, intervention measurement ----
++add(key="parasuraman1997automation", stream=6, doi="10.1518/001872097778543886", vtype="journal", peer="yes",
++    rel="Use/misuse/disuse/abuse taxonomy frames how a researcher delegates to an autonomous agent and over-relies on its outputs.",
++    claim="Distinguishes use, misuse (over-reliance producing monitoring failures or decision biases), disuse (often caused by false alarms) and abuse of automation, with trust, workload and reliability as key influences.")
++add(key="parasuraman2000levels", stream=6, doi="10.1109/3468.844354", vtype="journal", peer="yes",
++    rel="Levels-of-automation model used to locate WP29's four arms on the acquisition/analysis/decision/implementation dimensions.",
++    claim="Proposes that automation can be applied to four function classes (information acquisition, information analysis, decision and action selection, action implementation), each across a continuum from fully manual to fully automatic, and that automation changes rather than merely supplants human activity.")
++add(key="goddard2012automationbias", stream=6, doi="10.1136/amiajnl-2011-000089", vtype="journal", peer="yes",
++    rel="Systematic review of automation bias frequency and mitigators informing how human review of agent outputs is measured in WP29.",
++    claim="A systematic review (74 of 13,821 retrieved papers) finds automation bias mediated by user factors such as cognitive style, decision-support design and task experience, discussed alongside automation-induced complacency.")
++add(key="lai2023humanai", stream=6, doi="10.1145/3593013.3594087", arxiv="2112.11471", vtype="conference", peer="yes",
++    rel="Design-space survey of empirical human-AI decision-making studies used to position WP29's intervention measurement.",
++    claim="Surveys empirical human-subject studies of AI-assisted decision making and summarizes the design space of tasks, AI assistance elements and evaluation metrics to structure a science of human-AI decision making.")
++add(key="bansal2021whole", stream=6, doi="10.1145/3411764.3445717", vtype="conference", peer="yes",
++    rel="Shows explanations raise acceptance of AI recommendations regardless of correctness, a risk for human review of agent-generated research.",
++    claim="In studies on three datasets, AI augmentation produced complementary improvements but explanations did not increase them; instead explanations increased the chance that humans accept the AI's recommendation regardless of its correctness.")
++add(key="lubars2019delegability", stream=6, arxiv="1902.03245", vtype="conference", peer="yes",
++    rel="Task-delegability framework (motivation, difficulty, risk, trust) used to characterize which research sub-tasks are delegated in each WP29 arm.",
++    claim="Proposes a delegability framework with four factors (motivation, difficulty, risk, trust) and, surveying 100 tasks, finds little preference for full AI control and a strong preference for machine-in-the-loop designs, with trust most correlated with preferences.")
++add(key="vaccaro2024combinations", stream=6, doi="10.1038/s41562-024-02024-1", vtype="journal", peer="yes",
++    rel="Meta-analytic evidence on when human-AI combinations beat either alone; reference point for interpreting WP29's human-review arm.",
++    claim="A preregistered meta-analysis of 106 experiments (370 effect sizes, 2020-2023) finds that on average human-AI combinations performed worse than the best of humans or AI alone, with losses in decision tasks and gains in content-creation tasks.")
++add(key="bainbridge1983ironies", stream=6, doi="10.1016/0005-1098(83)90046-8", vtype="journal", peer="yes",
++    rel="Classic argument that automation makes the residual human role harder, relevant to reviewers of autonomous research output.",
++    claim="Argues that the more advanced a control system is, the more crucial the contribution of the human operator becomes, because the operator is left with the tasks the designer could not automate and must monitor a system that rarely needs intervention.")
++add(key="bucinca2021trust", stream=6, doi="10.1145/3449287", vtype="journal", peer="yes",
++    rel="Cognitive forcing as a mitigation of overreliance; analogous to WP29's requirement that reviewers execute checks rather than read summaries.",
++    claim="In an experiment with 199 participants, three cognitive forcing interventions reduced overreliance on AI relative to simple explainable-AI approaches.")
++add(key="becker2025metr", stream=6, arxiv="2507.09089", vtype="preprint", peer="no",
++    rel="Randomized measurement of AI-tool effects on expert developers showing perception-reality gaps; methodological model for WP29's time/cost outcomes.",
++    claim="In a randomized controlled trial with 16 experienced open-source developers on 246 tasks, allowing early-2025 AI tools increased completion time by 19%, although developers forecast a 24% speedup beforehand and still believed in a 20% speedup afterwards.")
++
++# ---- Stream 7: durable execution, failure recovery, observability, cost ----
++add(key="dean2013tail", stream=7, doi="10.1145/2408776.2408794", vtype="journal", peer="unknown",
++    rel="Tail-tolerance techniques (hedging, timeouts) underlie WP29's executor time budgets and retry policy.",
++    claim="Software techniques that tolerate latency variability are vital to building responsive large-scale Web services.")
++add(key="gray1986whystop", stream=7, s2="87c9e34c39dd1fbd470010dc1ea98ba3517f5a2a", vtype="conference", peer="unknown",
++    rel="Foundational failure analysis (software and operations dominate outages; process pairs, transactions) behind WP29's checkpoint/idempotent step design.",
++    claim="Reports Tandem field data attributing most system outages to software and operations/administration rather than hardware, and advocates process pairs and transactions as the means to tolerate faults.")
++add(key="basiri2016chaos", stream=7, doi="10.1109/MS.2016.60", vtype="journal", peer="yes",
++    rel="Chaos engineering as experimentation on failure injection motivates WP29's fault-injection tests of the executors.",
++    claim="Describes chaos engineering as Netflix's practice of experimenting on distributed systems to verify their reliability, together with the principles underlying it.")
++add(key="helland2012idempotence", stream=7, doi="10.1145/2160718.2160734", vtype="journal", peer="unknown",
++    rel="Idempotent operations make retries safe, a requirement for WP29's resumable protocol steps.",
++    claim="Messages may be retried; idempotence means that is acceptable.")
++add(key="burckhardt2021durablefunctions", stream=7, doi="10.1145/3485510", vtype="journal", peer="yes",
++    rel="Formal semantics for durable workflow execution (persistent state, reliable progress) that WP29's run ledger approximates.",
++    claim="Describes Azure Durable Functions, which enhance FaaS with actors, workflows and critical sections to provide persistent state and reliable progress, and gives a formal semantics based on an idealized untyped lambda-calculus model.")
++add(key="erol2025costofpass", stream=7, arxiv="2504.13359", vtype="preprint", peer="no",
++    rel="Cost-of-pass (expected cost per correct solution) is the economic outcome metric WP29 reports per arm.",
++    claim="Defines cost-of-pass as the expected monetary cost of generating a correct solution and the frontier cost-of-pass relative to a human expert, finding lightweight models most cost-effective for basic quantitative tasks and reasoning models for complex quantitative problems.")
++add(key="dong2024agentops", stream=7, arxiv="2411.05285", vtype="preprint", peer="no",
++    rel="Taxonomy of agent-lifecycle artifacts to trace; WP29's evidence records cover these observability artifacts.",
++    claim="Presents a taxonomy of AgentOps artifacts and data that should be traced throughout the agent lifecycle to achieve observability, derived from a systematic mapping study of existing AgentOps tools.")
++add(key="khanal2026reliability", stream=7, arxiv="2603.29231", vtype="preprint", peer="no",
++    rel="Shows capability (pass@1) and reliability diverge with task duration, supporting WP29's repeated-run reliability outcomes.",
++    claim="Introduces four reliability metrics (Reliability Decay Curve, Variance Amplification Factor, Graceful Degradation Score, Meltdown Onset Point) and, over 23,392 episodes of 10 models on 396 tasks, finds reliability decay is domain-stratified (software-engineering GDS falls from 0.90 to 0.44) while document processing is nearly flat.")
++add(key="zhuang2026agentrewind", stream=7, arxiv="2608.14380", vtype="preprint", peer="no",
++    rel="Checkpoint/rewind recovery for long-horizon agents; the failure-recovery mechanism WP29's protocol runs implement at stage boundaries.",
++    claim="AgentRewind records aligned checkpoints of agent context and a controlled environment so that agents can return to an earlier state and resume with information from previous attempts, evaluated on the MettleBench long-horizon engineering benchmark.")
++add(key="sigelman2010dapper", stream=7, s2="003d5a65de0ac72daaf105ded903cb3eb88585b3", vtype="report", peer="no",
++    rel="Classic distributed tracing design (sampling, application-level transparency) referenced for WP29's run tracing.",
++    claim="Describes Google's production distributed tracing infrastructure, designed for low overhead through sampling and application-level transparency.")
++
++# ---- Stream 8: evidence-grounded generation and claim verification ----
++add(key="wadden2020scifact", stream=8, doi="10.18653/v1/2020.emnlp-main.609", vtype="conference", peer="yes",
++    rel="Scientific claim verification task and dataset; model for WP29's claim-to-evidence checks in generated reports.",
++    claim="Introduces scientific claim verification with SciFact, 1.4K expert-written claims paired with evidence abstracts annotated with labels and rationales; the system identified plausible evidence for 23 of 36 COVID-19 claims on CORD-19.")
++add(key="thorne2018fever", stream=8, doi="10.18653/v1/N18-1074", vtype="conference", peer="yes",
++    rel="Canonical fact extraction and verification benchmark defining Supported/Refuted/NotEnoughInfo labels adopted in WP29's citation audit.",
++    claim="FEVER contains 185,445 claims derived from Wikipedia and labeled Supported, Refuted or NotEnoughInfo (Fleiss kappa 0.6841), with a best pipeline accuracy of 31.87% when the correct evidence is required.")
++add(key="bohnet2022attributedqa", stream=8, arxiv="2212.08037", vtype="preprint", peer="no",
++    rel="Attributed QA frames generation that must cite supporting sources; WP29 requires attributed claims in agent reports.",
++    claim="Formulates Attributed QA with a reproducible evaluation framework that uses human annotations as gold standard and shows that a correlated automatic metric is suitable for development, benchmarking a broad set of architectures.")
++add(key="walters2023fabrication", stream=8, doi="10.1038/s41598-023-41032-5", vtype="journal", peer="yes",
++    rel="Quantifies fabricated references in LLM literature reviews; justifies WP29's mandatory citation verification gate.",
++    claim="In 84 short literature reviews on 42 topics containing 636 citations, 55% of GPT-3.5 citations and 18% of GPT-4 citations were fabricated, and 43% versus 24% of the real citations contained substantive errors.")
++add(key="alkaissi2023hallucinations", stream=8, doi="10.7759/cureus.35179", vtype="journal", peer="unknown",
++    rel="Early clinical report of fabricated references ('artificial hallucinations') in scientific writing.",
++    claim="Reports two case studies in which ChatGPT produced plausible but fabricated content including references when asked to write on rare conditions, documenting positive, negative and troubling aspects of its performance.")
++add(key="gao2023rarr", stream=8, doi="10.18653/v1/2023.acl-long.910", vtype="conference", peer="yes",
++    rel="Post-hoc attribution and revision pipeline; a model for WP29's independent evidence-grounding pass over agent output.",
++    claim="RARR automatically finds attribution for the output of any text generator and post-edits unsupported content, significantly improving attribution while otherwise preserving the original output.")
++add(key="wang2023selfconsistency", stream=8, arxiv="2203.11171", vtype="conference", peer="yes",
++    rel="Self-consistency is an in-model verification heuristic; WP29 contrasts it with external executable verification.",
++    claim="Self-consistency samples diverse reasoning paths and selects the most consistent answer, improving chain-of-thought accuracy on GSM8K (+17.9%), SVAMP (+11.0%) and AQuA (+12.2%).")
++add(key="min2023factscore", stream=8, doi="10.18653/v1/2023.emnlp-main.741", arxiv="2305.14251", vtype="conference", peer="yes",
++    rel="Atomic-fact precision scoring is the template for WP29's claim-level verification of generated reports.",
++    claim="FActScore decomposes a generation into atomic facts and computes the percentage supported by a reliable knowledge source; ChatGPT biographies reach only 58%, and an automated estimator is introduced.")
++add(key="huang2024selfcorrect", stream=8, arxiv="2310.01798", vtype="conference", peer="yes",
++    rel="Evidence that intrinsic self-correction fails without external feedback, supporting WP29's external gates over agent self-review.",
++    claim="Finds that LLMs struggle to self-correct their reasoning without external feedback, and that performance can even degrade after intrinsic self-correction.")
++add(key="sakai2026hallucitation", stream=8, arxiv="2601.18724", vtype="conference", peer="yes",
++    rel="Documents hallucinated citations reaching accepted NLP papers, showing the scale of the problem WP29's citation gate addresses.",
++    claim="Analyzing all ACL, NAACL and EMNLP papers of 2024-2025, nearly 300 papers contain at least one hallucinated citation, half of them at EMNLP 2025, and more than 100 such papers were accepted as main-conference or Findings papers.")
++add(key="zhao2026hallucinationswild", stream=8, arxiv="2605.07723", vtype="preprint", peer="no",
++    rel="Large-scale audit of non-existent citations in the literature after LLM adoption; external evidence of the citation-fabrication risk.",
++    claim="Auditing 111 million references across 2.5 million papers in arXiv, bioRxiv, SSRN and PubMed Central shows a sharp rise in non-existent references after widespread LLM adoption, with a conservative estimate of 146,932 hallucinated citations in 2025 alone.")
++
++
++# ----------------------------------------------------------------------------
++def authors_short(authors, key):
++    fam = [a[0] for a in authors if a[0]]
++    if key == "osc2015reproducibility":
++        return "Open Science Collaboration"
++    if key == "nasem2019reproducibility":
++        return "National Academies of Sciences, Engineering, and Medicine"
++    if not fam:
++        return "n/a"
++    if len(fam) == 1:
++        return fam[0]
++    if len(fam) == 2:
++        return f"{fam[0]} & {fam[1]}"
++    return f"{fam[0]} et al."
++
++
++def bibesc(s):
++    return (s.replace("&", "\\&").replace("%", "\\%").replace("#", "\\#").replace("_", "\\_")
++             .replace("τ", "$\\tau$").replace("$τ$", "$\\tau$"))
++
++
++rows, bibs, counts = [], [], {}
++for e in E:
++    doi, aid, s2id = e.get("doi"), e.get("arxiv"), e.get("s2")
++    src = []
++    if doi:
++        m = crossref(doi); src.append(m["url"])
++        res = DOIRES.get(doi); src.append(f"doi.org HEAD {res}")
++        if aid:
++            a = arxiv(aid); src.append(a["url"])
++        venue = m["container"] or ("National Academies Press" if e["key"] == "nasem2019reproducibility" else "")
++        verified = m["verified"]
++        meta = m
++    elif aid:
++        meta = arxiv(aid); src.append(meta["url"]); verified = meta["verified"]
++        vn, vt, _ = s2_venue("arXiv:" + aid)
++        s2url = "https://api.semanticscholar.org/graph/v1/paper/arXiv:" + aid
++        if e["vtype"] == "conference":
++            venue = {"chen2025scienceagentbench": "ICLR 2025", "majumder2025discoverybench": "ICLR 2025",
++                     "jing2025dsbench": "ICLR 2025", "chan2025mlebench": "ICLR 2025",
++                     "huang2024mlagentbench": "ICML 2024", "gu2024blade": "EMNLP 2024",
++                     "jimenez2024swebench": "ICLR 2024", "starace2025paperbench": "ICML 2025",
++                     "liu2024agentbench": "ICLR 2024", "zheng2023mtbench": "NeurIPS 2023 Datasets and Benchmarks",
++                     "thakur2025judgingjudges": "GEM2 Workshop, ACL 2025",
++                     "panickssery2024selfpreference": "NeurIPS 2024", "lubars2019delegability": "NeurIPS 2019",
++                     "wang2023selfconsistency": "ICLR 2023", "huang2024selfcorrect": "ICLR 2024",
++                     "sakai2026hallucitation": "ACL 2026 (per Semantic Scholar venue record)"}[e["key"]]
++            src.append(s2url + f" (venue={vn!r}, type={vt!r})")
++            if meta.get("jref"):
++                src.append("arXiv journal_ref: " + meta["jref"])
++        elif e["vtype"] == "journal":
++            venue = {"kapoor2024agentsthatmatter": "Transactions on Machine Learning Research",
++                     "siegel2024corebench": "Transactions on Machine Learning Research"}[e["key"]]
++            src.append(s2url + f" (venue={vn!r})")
++        else:
++            venue = "arXiv preprint"
++    else:  # Semantic Scholar only
++        fn = {"gray1986whystop": "s2_gray1986_search_observed.json",
++              "sigelman2010dapper": "s2_dapper2010.json"}[e["key"]]
++        p = os.path.join(CACHE, fn)
++        if fn.endswith(".jsonl"):
++            rec = None
++            for line in open(p):
++                line = line.strip()
++                if not line: continue
++                try:
++                    d = json.loads(line)
++                except Exception:
++                    continue
++                for x in d.get("data", []):
++                    if x.get("paperId") == s2id: rec = x
++        else:
++            rec = json.load(open(p))
++        meta = dict(title=rec["title"], authors=[(a["name"].split()[-1], " ".join(a["name"].split()[:-1])) for a in rec["authors"]],
++                    year=rec["year"], container=rec.get("venue") or "")
++        venue = rec.get("venue") or ("Google Technical Report dapper-2010-1" if e["key"] == "sigelman2010dapper" else "")
++        src.append("https://api.semanticscholar.org/graph/v1/paper/" + s2id + f" (record cached in {fn})")
++        verified = mtime_utc(p)
++    if e.get("peer_src"):
++        src.append(e["peer_src"])
++    ident = ("doi:" + doi) if doi else (("arXiv:" + aid) if aid else "s2:" + s2id)
++    counts[e["stream"]] = counts.get(e["stream"], 0) + 1
++    rows.append(dict(ref_key=e["key"], stream=e["stream"], authors_short=authors_short(meta["authors"], e["key"]),
++                     year=meta["year"], title=meta["title"], venue=venue, venue_type=e["vtype"],
++                     doi_or_arxiv=ident, verification_source=" ; ".join(src), verified_utc=verified,
++                     relevance_to_wp29=e["rel"], key_claim_or_finding=e["claim"], peer_reviewed=e["peer"]))
++
++    # ---- BibTeX ----
++    if e["key"] == "osc2015reproducibility":
++        au = "{Open Science Collaboration}"
++    elif e["key"] == "nasem2019reproducibility":
++        au = "{National Academies of Sciences, Engineering, and Medicine}"
++    elif doi:
++        au = " and ".join(f"{f}, {g}" if g else f for f, g in meta["authors"])
++    else:
++        au = " and ".join(f"{g} {f}".strip() for f, g in meta["authors"])
++    au = bibesc(au)
++    ti = bibesc(meta["title"])
++    f = [f"  author = {{{au}}}", f"  title = {{{{{ti}}}}}", f"  year = {{{meta['year']}}}"]
++    if e["vtype"] == "journal":
++        btype = "article"; f.append(f"  journal = {{{bibesc(venue)}}}")
++        if doi and meta.get("volume"): f.append(f"  volume = {{{meta['volume']}}}")
++        if doi and meta.get("issue"): f.append(f"  number = {{{meta['issue']}}}")
++        if doi and meta.get("pages"): f.append(f"  pages = {{{meta['pages'].replace('-', '--')}}}")
++    elif e["vtype"] == "conference":
++        btype = "inproceedings"; f.append(f"  booktitle = {{{bibesc(venue)}}}")
++        if doi and meta.get("pages"): f.append(f"  pages = {{{meta['pages'].replace('-', '--')}}}")
++    elif e["vtype"] == "report" and e["key"] == "nasem2019reproducibility":
++        btype = "book"; f.append("  publisher = {The National Academies Press}"); f.append("  address = {Washington, DC}")
++    elif e["vtype"] == "report":
++        btype = "techreport"; f.append("  institution = {Google}"); f.append("  number = {dapper-2010-1}")
++    else:
++        btype = "misc"; f.append(f"  howpublished = {{arXiv preprint arXiv:{aid}}}")
++    if doi:
++        f.append(f"  doi = {{{doi}}}")
++    if aid:
++        f.append(f"  eprint = {{{aid}}}"); f.append("  archivePrefix = {arXiv}")
++    comment = f"% verified via {src[0].split(' (')[0]} on {verified[:10]}"
++    bibs.append((comment, f"@{btype}{{{e['key']},\n" + ",\n".join(f) + "\n}"))
++
++cols = ["ref_key", "stream", "authors_short", "year", "title", "venue", "venue_type", "doi_or_arxiv",
++        "verification_source", "verified_utc", "relevance_to_wp29", "key_claim_or_finding", "peer_reviewed"]
++with open(os.path.join(HERE, "literature_matrix.csv"), "w", newline="", encoding="utf-8") as fh:
++    w = csv.DictWriter(fh, fieldnames=cols); w.writeheader(); w.writerows(rows)
++
++with open(os.path.join(HERE, "references_verified.bib"), "w", encoding="utf-8") as fh:
++    for i, (c, b) in enumerate(bibs):
++        if i == 0:
++            # No '%' line may precede the first entry: its verification comment follows it.
++            fh.write(b + "\n" + c + "  (comment placed after the first entry so that no % line precedes it)\n\n")
++        else:
++            fh.write(c + "\n" + b + "\n\n")
++
++print("entries:", len(rows), "per stream:", dict(sorted(counts.items())))
++print("peer_reviewed:", {k: sum(1 for r in rows if r["peer_reviewed"] == k) for k in ("yes", "no", "unknown")})

added research/code_corpus.py +278 −0

++#!/usr/bin/env python3
++"""
++code_corpus.py -- automated (script-computed) content-coding variables for the
++WP29 mandate corpus (research/corpus/*.md).
++
++Standard library only.  Run from anywhere:
++
++    python3 -I research/code_corpus.py
++
++Writes research/corpus_automated.csv (one row per file, including the
++byte-identical WP15 duplicate, which is flagged in `duplicate_of`).
++
++Every variable here is AUTOMATED (computed from the bytes of the file).  The
++definitions below are the authoritative ones referenced by
++research/corpus_coding_protocol.md.  Keyword counts are *mentions*, not
++judgements: a document that says "no budget is specified" would still count
++one mention of the `budget` family.
++"""
++
++import csv
++import hashlib
++import os
++import re
++import sys
++
++HERE = os.path.dirname(os.path.abspath(__file__))
++CORPUS_DIR = os.path.join(HERE, "corpus")
++MANIFEST = os.path.join(HERE, "corpus_manifest.csv")
++OUT = os.path.join(HERE, "corpus_automated.csv")
++
++# --------------------------------------------------------------------------
++# Regular expressions (documented for the codebook)
++# --------------------------------------------------------------------------
++
++# Markdown ATX headings: 1-6 '#' at line start followed by a space.
++RE_HEADING = re.compile(r"^#{1,6}\s+\S", re.MULTILINE)
++
++# Explicit phase labels anywhere in the text, e.g. "Phase 0", "PHASE 3 —",
++# "phase_XX" is NOT matched (requires digits).  Distinct numbers are counted.
++RE_PHASE_LABEL = re.compile(r"\bphase\s*(\d+)", re.IGNORECASE)
++
++# Lettered stage labels ("Stage A", "Stage G") -- WP15 uses stages, not phases.
++# Case-insensitive on the word "stage", but the label itself must be a capital
++# letter.  NB: WP28 also uses "Stage A..G" for its coordinator/worker message
++# protocol; because WP28 has explicit "Phase N" labels those stages are not
++# used as its phase count.
++RE_STAGE_LABEL = re.compile(r"(?i:\bstage)\s+([A-Z])\b")
++
++# Gate labels ("Gate 1", "Gate 12") -- distinct numbers counted.
++RE_GATE_LABEL = re.compile(r"\bgate\s*(\d+)", re.IGNORECASE)
++
++# Numbered list items at line start ("1. ", "  12. ").
++RE_NUMBERED_ITEM = re.compile(r"^\s*\d+\.\s", re.MULTILINE)
++
++# Headings whose text indicates a phase/sequence/execution-order section.  The
++# numbered items *inside* such sections are counted as declared phases when the
++# document has no explicit "Phase N" labels.
++RE_PHASE_SECTION_HEADING = re.compile(
++    r"^#{1,6}\s+.*\b(phase|phases|stage|stages|sequence|execution order|"
++    r"work sequence|execution protocol|execution phases|milestones)\b",
++    re.IGNORECASE | re.MULTILINE,
++)
++
++# Markdown table separator rows: |---|---:| etc.  One separator row == one table.
++RE_TABLE_SEP = re.compile(r"^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$", re.MULTILINE)
++
++# Fenced code blocks: pairs of ``` fences.
++RE_FENCE = re.compile(r"^\s*```", re.MULTILINE)
++
++# Keyword families (case-insensitive).  Each is a mention count + boolean.
++KEYWORD_FAMILIES = {
++    "preregist": r"pre-?regist\w*",
++    "estimand": r"\bestimands?\b",
++    "hypothes": r"\bhypothes\w*",
++    "falsif": r"\bfalsif\w*",
++    "baseline": r"\bbaselines?\b",
++    "leakage": r"\bleakage\b|\blook-?ahead\b|\blook ahead\b|\bpoint-in-time\b|\bpoint in time\b",
++    "provenance": r"\bprovenance\b|\bhash(?:es|ed|ing)?\b|\bsha-?256\b|\bchecksums?\b",
++    "reproduc": r"\breproduc\w*",
++    "stopping": r"\bstopping\b|\bstop rules?\b|\bstop conditions?\b|\btermination\b|\bstop and\b|\bstop if\b|\bstop only\b",
++    "recovery": r"\brecover\w*|\bresum\w*|\bcheckpoint\w*",
++    "gate": r"\bgates?\b|\bacceptance\b|\bcriteria\b",
++    "exhibit": r"\bscreenshots?\b|\bfigures?\b|\btables?\b",
++    "disclos": r"\bdisclos\w*|\bAI-use\b|\bAI use\b|\bAI contribution\b",
++    "budget": r"\bbudgets?\b|\bcosts?\b|\bUSD\b|\$",
++    "license": r"\blicen[cs]e[sd]?\b|\blicensing\b",
++    "seed": r"\bseeds?\b|\bseeded\b",
++}
++KEYWORD_RE = {k: re.compile(v, re.IGNORECASE) for k, v in KEYWORD_FAMILIES.items()}
++
++# Language heuristic: tokens that are common in French prose and rare in
++# English technical prose ("et" is excluded because of "et al.").
++# Tokens shared with English usage in this corpus ("conventions", "journal",
++# "du" as in "Universite du Quebec", "et" as in "et al.") are deliberately excluded.
++FR_TOKENS = {
++    "le", "la", "les", "des", "est", "une", "ce", "cette", "dans", "pour",
++    "sur", "avec", "pas", "aux", "qui", "que", "ci-dessous", "dossier",
++    "appelle", "correspond", "auteur",
++}
++EN_TOKENS = {
++    "the", "and", "of", "to", "in", "is", "for", "with", "that", "not", "must",
++    "do", "never", "each", "every", "all", "or", "as", "from", "if", "use",
++}
++RE_WORD = re.compile(r"[A-Za-zÀ-ÿ][A-Za-zÀ-ÿ'\-]*")
++
++
++def sha256_of(path):
++    h = hashlib.sha256()
++    with open(path, "rb") as f:
++        for chunk in iter(lambda: f.read(1 << 20), b""):
++            h.update(chunk)
++    return h.hexdigest()
++
++
++def language_of(text):
++    """Return (label, fr_share).  fr_share = FR hits / (FR hits + EN hits).
++
++    en    : fr_share < 0.015
++    mixed : 0.015 <= fr_share < 0.50  (e.g. a French preamble on an English body)
++    fr    : fr_share >= 0.50
++    (threshold chosen after inspection: WP18 = 0.043 and WP20 = 0.020 carry a
++    French prefatory paragraph; all other files score 0.000)
++    """
++    toks = [t.lower() for t in RE_WORD.findall(text)]
++    fr = sum(1 for t in toks if t in FR_TOKENS)
++    en = sum(1 for t in toks if t in EN_TOKENS)
++    total = fr + en
++    share = (fr / total) if total else 0.0
++    if share >= 0.50:
++        label = "fr"
++    elif share >= 0.015:
++        label = "mixed"
++    else:
++        label = "en"
++    return label, round(share, 4)
++
++
++def numbered_items_in_phase_sections(text):
++    """Count numbered list items inside sections whose heading mentions
++    phase/stage/sequence/execution order.  A section runs from its heading to
++    the next heading of the same or higher level."""
++    lines = text.splitlines()
++    heading_idx = []
++    for i, line in enumerate(lines):
++        m = re.match(r"^(#{1,6})\s+(.*)$", line)
++        if m:
++            heading_idx.append((i, len(m.group(1)), m.group(2)))
++    count = 0
++    for n, (i, level, title) in enumerate(heading_idx):
++        if not RE_PHASE_SECTION_HEADING.match("#" * level + " " + title):
++            continue
++        end = len(lines)
++        for j, lvl, _ in heading_idx[n + 1:]:
++            if lvl <= level:
++                end = j
++                break
++        block = "\n".join(lines[i + 1:end])
++        count += len(RE_NUMBERED_ITEM.findall(block))
++    return count
++
++
++def analyse(path):
++    raw = open(path, "rb").read()
++    text = raw.decode("utf-8", errors="replace")
++    name = os.path.basename(path)
++    wp = re.match(r"(WP\d+)", name).group(1)
++
++    phase_numbers = {int(x) for x in RE_PHASE_LABEL.findall(text)}
++    stage_letters = set(RE_STAGE_LABEL.findall(text))
++    gate_numbers = {int(x) for x in RE_GATE_LABEL.findall(text)}
++    items_in_phase_sections = numbered_items_in_phase_sections(text)
++
++    # n_numbered_phases: distinct "Phase N" labels if any; else distinct
++    # "Stage X" labels if any; else distinct "Gate N" labels if any; else
++    # numbered items within phase/sequence sections.  (Analyst-coded
++    # n_phases_declared in corpus_coding.csv is the authoritative value; this
++    # is the mechanical proxy.)
++    if phase_numbers:
++        n_numbered_phases = len(phase_numbers)
++        phase_rule = "distinct 'Phase N' labels"
++    elif stage_letters:
++        n_numbered_phases = len(stage_letters)
++        phase_rule = "distinct 'Stage X' labels"
++    elif gate_numbers:
++        n_numbered_phases = len(gate_numbers)
++        phase_rule = "distinct 'Gate N' labels"
++    else:
++        n_numbered_phases = items_in_phase_sections
++        phase_rule = "numbered items inside phase/sequence sections"
++
++    lang, fr_share = language_of(text)
++    words = len(text.split())
++    row = {
++        "file": name,
++        "wp": wp,
++        "sha256": hashlib.sha256(raw).hexdigest(),
++        "bytes": len(raw),
++        "lines": text.count("\n") + (0 if text.endswith("\n") else 1),
++        "words": words,
++        "n_headings": len(RE_HEADING.findall(text)),
++        "n_numbered_phases": n_numbered_phases,
++        "n_numbered_phases_rule": phase_rule,
++        "n_phase_labels_distinct": len(phase_numbers),
++        "n_stage_labels_distinct": len(stage_letters),
++        "n_gate_labels_distinct": len(gate_numbers),
++        "n_numbered_items_in_phase_sections": items_in_phase_sections,
++        "n_numbered_items_total": len(RE_NUMBERED_ITEM.findall(text)),
++        "n_tables": len(RE_TABLE_SEP.findall(text)),
++        "n_code_blocks": len(RE_FENCE.findall(text)) // 2,
++        "language_of_document": lang,
++        "fr_token_share": fr_share,
++    }
++    for fam, rx in KEYWORD_RE.items():
++        n = len(rx.findall(text))
++        row["mentions_%s_n" % fam] = n
++        row["mentions_%s" % fam] = "yes" if n else "no"
++    return row
++
++
++def main():
++    files = sorted(
++        os.path.join(CORPUS_DIR, f) for f in os.listdir(CORPUS_DIR) if f.endswith(".md")
++    )
++    if not files:
++        sys.exit("no .md files in %s" % CORPUS_DIR)
++
++    # manifest lookup (url, retrieved_utc, expected sha)
++    manifest = {}
++    if os.path.exists(MANIFEST):
++        with open(MANIFEST, newline="", encoding="utf-8") as f:
++            for r in csv.DictReader(f):
++                if r.get("local_file"):
++                    manifest[os.path.basename(r["local_file"])] = r
++
++    rows = [analyse(p) for p in files]
++
++    # duplicates by sha256 (first file in sorted order is the canonical one)
++    seen = {}
++    for r in rows:
++        r["duplicate_of"] = seen.get(r["sha256"], "")
++        seen.setdefault(r["sha256"], r["file"])
++        m = manifest.get(r["file"], {})
++        r["manifest_url"] = m.get("url", "")
++        r["manifest_retrieved_utc"] = m.get("retrieved_utc", "")
++        r["sha256_matches_manifest"] = (
++            "yes" if m and m.get("sha256") == r["sha256"] else ("no" if m else "not_in_manifest")
++        )
++        r["document_type"] = (
++            "design_brief" if "BRIEF" in r["file"]
++            else ("duplicate_claude_md" if r["duplicate_of"] else "claude_md")
++        )
++
++    fieldnames = (
++        ["file", "wp", "document_type", "duplicate_of", "sha256", "sha256_matches_manifest",
++         "manifest_url", "manifest_retrieved_utc", "bytes", "lines", "words", "n_headings",
++         "n_numbered_phases", "n_numbered_phases_rule", "n_phase_labels_distinct",
++         "n_stage_labels_distinct", "n_gate_labels_distinct",
++         "n_numbered_items_in_phase_sections", "n_numbered_items_total", "n_tables",
++         "n_code_blocks", "language_of_document", "fr_token_share"]
++        + ["mentions_%s" % k for k in KEYWORD_FAMILIES]
++        + ["mentions_%s_n" % k for k in KEYWORD_FAMILIES]
++    )
++    with open(OUT, "w", newline="", encoding="utf-8") as f:
++        w = csv.DictWriter(f, fieldnames=fieldnames, quoting=csv.QUOTE_MINIMAL)
++        w.writeheader()
++        for r in rows:
++            w.writerow({k: r.get(k, "") for k in fieldnames})
++
++    # console summary
++    print("wrote %s (%d rows)" % (OUT, len(rows)))
++    for r in rows:
++        print("%-38s %6d w  %3d h  phases=%-2s tables=%d code=%d lang=%s dup=%s" % (
++            r["file"], r["words"], r["n_headings"], r["n_numbered_phases"], r["n_tables"],
++            r["n_code_blocks"], r["language_of_document"], r["duplicate_of"] or "-"))
++
++
++if __name__ == "__main__":
++    main()

added research/corpus_automated.csv +14 −0

++file,wp,document_type,duplicate_of,sha256,sha256_matches_manifest,manifest_url,manifest_retrieved_utc,bytes,lines,words,n_headings,n_numbered_phases,n_numbered_phases_rule,n_phase_labels_distinct,n_stage_labels_distinct,n_gate_labels_distinct,n_numbered_items_in_phase_sections,n_numbered_items_total,n_tables,n_code_blocks,language_of_document,fr_token_share,mentions_preregist,mentions_estimand,mentions_hypothes,mentions_falsif,mentions_baseline,mentions_leakage,mentions_provenance,mentions_reproduc,mentions_stopping,mentions_recovery,mentions_gate,mentions_exhibit,mentions_disclos,mentions_budget,mentions_license,mentions_seed,mentions_preregist_n,mentions_estimand_n,mentions_hypothes_n,mentions_falsif_n,mentions_baseline_n,mentions_leakage_n,mentions_provenance_n,mentions_reproduc_n,mentions_stopping_n,mentions_recovery_n,mentions_gate_n,mentions_exhibit_n,mentions_disclos_n,mentions_budget_n,mentions_license_n,mentions_seed_n
++WP15_CLAUDE.md,WP15,claude_md,,2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77,yes,https://git.spboucher.ai/raw/wp15_uqo/main/docs/CLAUDE.md,2026-10-30T03:01:13Z,56305,2165,7685,151,7,distinct 'Stage X' labels,0,7,0,99,180,0,12,en,0.0,no,yes,yes,yes,yes,yes,yes,yes,yes,yes,yes,yes,no,yes,yes,yes,0,2,3,6,15,5,8,7,3,7,1,69,0,2,2,2
++WP15_PROMPT_PROMPT_INITIAL_CLAUDE.md,WP15,duplicate_claude_md,WP15_CLAUDE.md,2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77,yes,https://git.spboucher.ai/raw/wp15_uqo/main/docs/PROMPT_INITIAL_CLAUDE.md,2026-10-30T03:01:13Z,56305,2165,7685,151,7,distinct 'Stage X' labels,0,7,0,99,180,0,12,en,0.0,no,yes,yes,yes,yes,yes,yes,yes,yes,yes,yes,yes,no,yes,yes,yes,0,2,3,6,15,5,8,7,3,7,1,69,0,2,2,2
++WP18_CLAUDE.md,WP18,claude_md,,f538d6fe2483c975e45a0eed10b12e506ef2d7e20d48b16985c97aad17bc6779,yes,https://git.spboucher.ai/raw/wp18_uqo/main/CLAUDE.md,2026-10-30T03:01:13Z,12000,98,1358,9,5,distinct 'Phase N' labels,5,0,0,25,25,0,1,mixed,0.043,no,no,yes,no,yes,no,no,yes,no,no,yes,yes,no,yes,no,yes,0,0,2,0,5,0,0,6,0,0,1,24,0,5,0,1
++WP19_CLAUDE.md,WP19,claude_md,,2afdcd653423f83a24bc34cedc69589dc90cd372064134f28fddb6e771404a3b,yes,https://git.spboucher.ai/raw/wp19_uqo/main/CLAUDE.md,2026-10-30T03:01:14Z,9590,49,1092,12,8,distinct 'Phase N' labels,8,0,0,3,3,0,0,en,0.0,yes,no,yes,no,yes,no,yes,yes,no,yes,yes,yes,no,yes,no,yes,1,0,1,0,6,0,1,3,0,1,2,17,0,4,0,1
++WP20_CLAUDE.md,WP20,claude_md,,388ca2431215e4894f6b935a379a6db34a2f1d7d72cd42d188d75ed6c6fefddf,yes,https://git.spboucher.ai/raw/wp20_uqo/main/CLAUDE.md,2026-10-30T03:01:14Z,18756,179,2314,12,7,distinct 'Gate N' labels,0,0,7,0,41,0,1,mixed,0.0199,no,no,no,yes,yes,yes,yes,yes,no,no,yes,yes,yes,yes,yes,yes,0,0,0,1,2,2,2,8,0,0,9,21,1,42,2,1
++WP21_CLAUDE.md,WP21,claude_md,,692a6e50b3cf1d026a4bc12201759527ea3336e299bfd4786d3f635fff292b98,yes,https://git.spboucher.ai/raw/wp21_uqo/main/CLAUDE.md,2026-10-30T03:01:14Z,9870,100,1114,1,0,numbered items inside phase/sequence sections,0,0,0,0,15,0,0,en,0.0,yes,no,no,no,no,no,no,yes,no,no,yes,yes,no,no,no,yes,1,0,0,0,0,0,0,4,0,0,2,17,0,0,0,1
++WP22_CLAUDE.md,WP22,claude_md,,b9eb747485cff5a1caa115f0d9138ed925d86915aa77813862b4059bd6d45da5,yes,https://git.spboucher.ai/raw/wp22_uqo/main/CLAUDE.md,2026-10-30T03:01:14Z,16077,127,1966,25,8,distinct 'Phase N' labels,8,0,0,0,0,0,0,en,0.0,no,yes,yes,no,no,yes,yes,yes,no,no,yes,yes,yes,yes,no,yes,0,3,1,0,0,1,3,6,0,0,1,11,1,1,0,1
++WP23_CLAUDE.md,WP23,claude_md,,0f5ebcb5ec63d04392a4872530a43706535f1f8c00e6a3f61bdaaa34d1096cf0,yes,https://git.spboucher.ai/raw/wp23_uqo/main/CLAUDE.md,2026-10-30T03:01:14Z,9474,43,1132,20,0,numbered items inside phase/sequence sections,0,0,0,0,0,0,0,en,0.0,no,no,no,no,no,yes,no,yes,no,yes,yes,yes,no,yes,no,yes,0,0,0,0,0,3,0,4,0,1,1,7,0,1,0,1
++WP24_CLAUDE.md,WP24,claude_md,,02ae00f871fffd7937e9cd7ec121c53367addd9b5b709915bf6921adfa705347,yes,https://git.spboucher.ai/raw/wp24_uqo/main/CLAUDE.md,2026-10-30T03:01:14Z,18802,107,2285,20,7,distinct 'Phase N' labels,7,0,0,11,21,0,0,en,0.0,no,no,no,yes,yes,no,yes,yes,yes,no,no,yes,no,yes,yes,yes,0,0,0,1,5,0,1,6,1,0,0,10,0,10,3,1
++WP25_CLAUDE.md,WP25,claude_md,,69f5ee82532d14513986c8f53f1b0981a2f7311dc0fc3b26d844610ccc80bf8b,yes,https://git.spboucher.ai/raw/wp25_uqo/main/CLAUDE.md,2026-10-30T03:01:14Z,14054,96,1671,19,6,numbered items inside phase/sequence sections,0,0,0,6,6,0,1,en,0.0,yes,no,yes,yes,yes,yes,yes,yes,no,yes,yes,yes,no,yes,no,yes,1,0,1,2,8,2,1,4,0,1,11,9,0,10,0,3
++WP26_CLAUDE.md,WP26,claude_md,,49afcce91475e5e145b4bd49d29486065c8c613a402b51fdb9baa43c88f4b330,yes,https://git.spboucher.ai/raw/wp26_uqo/main/CLAUDE.md,2026-10-30T03:01:15Z,18482,135,2240,19,9,distinct 'Phase N' labels,9,0,0,0,19,0,0,en,0.0,yes,yes,yes,yes,yes,yes,yes,yes,yes,no,yes,yes,no,yes,yes,yes,4,1,2,1,4,7,6,7,2,0,2,6,0,20,4,2
++WP27_BRIEF_DESIGN-BRIEF.md,WP27,design_brief,,72dc7ab846c6d8f8e0cc4101b6bdb600884179e9467c43fddfd3aece395e236e,yes,https://git.spboucher.ai/raw/wp27_uqo/main/docs/DESIGN-BRIEF.md,2026-10-30T03:01:15Z,5231,59,820,3,0,numbered items inside phase/sequence sections,0,0,0,0,0,0,0,en,0.0,no,no,yes,no,no,no,no,no,no,no,no,no,no,yes,no,yes,0,0,1,0,0,0,0,0,0,0,0,0,0,3,0,3
++WP28_CLAUDE.md,WP28,claude_md,,c6c50e319f971b01fa0662840feef177d7bc896526956b0b7a3cf7a83f36246d,yes,https://git.spboucher.ai/raw/wp28_uqo/main/CLAUDE.md,2026-10-30T03:01:15Z,67200,1055,8809,76,13,distinct 'Phase N' labels,13,7,13,50,71,2,27,en,0.0,no,no,no,no,yes,no,yes,yes,yes,yes,yes,yes,yes,yes,no,yes,0,0,0,0,9,0,7,18,1,1,16,49,9,13,0,9

added research/corpus_coding.csv +14 −0

++"wp","file","document_type","source_url","retrieved_utc","sha256","research_domain","research_type","explicit_question","explicit_estimand_or_hypotheses","stated_assumptions","falsification_or_null_result_conditions","literature_or_novelty_requirement","data_access_controls","temporal_information_controls","baseline_requirement","n_phases_declared","dependency_or_gate_structure","stopping_rules","recovery_or_resume_instructions","artifact_requirements","provenance_requirements","review_or_self_audit_stage","disclosure_or_AI_use_statement","budget_or_resource_limits","integrity_prohibitions","contradictory_or_non_operational_requirements","statements_added_during_implementation","analyst_notes"
++"WP15","WP15_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp15_uqo/main/docs/CLAUDE.md","2026-10-30T03:01:13Z","2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77","finance / market microstructure (intraday shock propagation, U.S. equities, OHLCV data)","empirical (with ML extension and synthetic-data tests)","""How have the speed, breadth, persistence, and asymmetry of intraday shock propagation across U.S. equities evolved over the past three decades, and under which market conditions does an initially idiosyncratic shock become sectoral or market-wide?""","yes — central hypothesis stated and outcome measures formally defined: ""Modern markets may absorb ordinary shocks more efficiently while transmitting extreme shocks more rapidly and discontinuously."" ; ""Define the Intraday Shock Amplification Ratio: ISAR_{i,t}(h) = …"" ; ""Optimization must not change estimands or silently alter precision.""","partial — assumptions must be stated and threats listed, and data assumptions are flagged as unverified: ""Explain: … identification assumptions; threats."" ; ""The natural key is initially assumed to be: (symbol, timestamp) But this assumption must be verified.""","yes — ""The project must attempt to disprove its own central claim."" ; ""If a falsification fails, do not hide it. Reassess the claim."" ; ""A rigorous negative assessment is preferable to a polished but invalid paper.""","yes — ""Do not overclaim uniqueness until a documented literature search confirms it."" ; ""never cite a work based only on another paper's bibliography."" ; literature map with ""verification date"" column required","yes — ""stop if the schema is unusable or if legal/access restrictions prevent research use."" ; ""authenticated access only if required"" ; ""No user-specific absolute path may appear in committed code."" ; "".env.example"" in tree","yes — ""For a shock at time t, network weights W_{ij,t} must be estimated only from data dated strictly before t."" ; ""Any liquidity-based inclusion criterion must use lagged data to avoid look-ahead bias."" ; ""Never randomly split minute observations across train and test."" ; ""Future information may be used only as a falsification test, never in the baseline estimator.""","yes — ""Compare with: unconditional historical mean; linear and logistic regressions; penalized regression; random forest; …"" ; ""one transparent baseline regression"" in first-phase deliverables ; ""The primary nonlinear result must also be represented with a transparent non-ML specification.""","7 (Stages A–G in ""3. Execution protocol""; plus ""30. Minimum deliverables for the first phase"" and ""33. Immediate actions"" 1–16)","explicit — ""Only after Stage A passes:"" ; ""Do not run `make release` until the pilot audit and full-data checks pass."" ; executable release gate: ""The release script must fail if: a table references a missing result; a figure is missing source data; LaTeX does not compile; … manuscript claims disagree with the results registry; data revision is not pinned; tests fail.""","yes — dedicated section: ""# 31. Stop conditions Stop and write a diagnostic report rather than proceeding if: timestamps cannot be interpreted reliably; OHLC values are extensively inconsistent; … data licensing prevents the intended use; …"" ; also ""stop if the schema is unusable"" (Stage A) and ""Escalate only issues that materially alter the research question, data legality, identification, or interpretation.""","yes — ""use resumable transfers"" ; ""permit partial reruns and node-level parallelism"" ; ""Every distributed task must: be idempotent; write to temporary paths; atomically rename on success; save checkpoints; … support retry; validate output before success."" ; ""never silently overwrite an existing file""","paper (main.tex + sections, anonymous and named PDFs); Internet Appendix; tables (standalone .tex AND machine-readable .csv/.parquet); figures (vector PDF + PNG, source data in outputs/figures/data/); results registry (outputs/estimates/results_registry.json) feeding LaTeX macros; code (src package, 22 numbered scripts, CLI, Makefile with ~19 targets); tests (8 files); data manifests (raw_files.parquet/csv with sha256, revision, row counts); docs (DATA_DICTIONARY, DATA_AUDIT, EMPIRICAL_DESIGN, LITERATURE_MAP, REPRODUCIBILITY, COMPUTE_LOG, DECISION_LOG, LIMITATIONS); STATUS.md per stage; README, LICENSE, CITATION.cff, pyproject/uv.lock/environment.yml/.env.example; release bundle (cover letter, source_archive.zip, replication_manifest.json, submission_checklist.md); 4 notebooks","yes — ""pin the exact dataset revision or commit hash"" ; manifest columns include ""sha256; status; download_started_at; … code_commit"" ; ""Each processed file must record: parent inputs; transformation version; filters; row counts before and after; creation timestamp; code commit."" ; ""Record: Git commit; Python version; package versions; OS; hardware; dataset revision; …""","yes — ""Stage C — Raw-data audit"" with docs/DATA_AUDIT.md ; ""28.3 Release validation"" ; decision log ""whether pre-specified or data-driven"" ; no adversarial referee stage, but ""Report blockers and proposed solutions before launching the full download.""","no — only a style instruction: ""The paper must read like a finance paper, not AI-generated prose."" (not a disclosure requirement)","partial — resource estimation required but no cap: ""Before a full run: 1. benchmark one month; 2. benchmark one year; 3. estimate CPU hours; 4. estimate memory; 5. estimate temporary storage; 6. estimate final storage; 7. record in docs/COMPUTE_LOG.md."" ; ""disk-space checks"" ; ""Avoid loading the full dataset into RAM."" ; no monetary or token budget","yes — ""Never fabricate data, results, citations, institutional details, variable definitions, statistical significance, sample sizes, or conclusions. Never write a result in the paper before it has been generated and verified from a saved machine-readable output."" ; ""Never manually type numerical results into LaTeX."" ; ""Never winsorize away a possible split without logging it.""","Non-operational success criteria that no script can check: ""the paper documents a new and economically important fact""; ""the writing is disciplined""; ""prepared to the standard expected in a top finance journal""; ""must read like a finance paper, not AI-generated prose"". Judgement-dependent trade-off with no threshold: ""Do not define isolation so strictly that only trivial events remain. Report the trade-off."" External dependency: ""main manuscript no longer than the current JF limit"" requires checking an external source at run time. Dataset facts are presented as unverified claims (""Claimed coverage: 1992–2026"") and must be audited, which is consistent. No internal contradiction found between autonomy (""Do not ask for confirmation for routine implementation choices"") and the mandated pause (""Report blockers and proposed solutions before launching the full download"") since the latter is an explicit escalation point.","none identified (no dated additions or reconstruction notes; the WP15 PROMPT_INITIAL copy is byte-identical)","Longest and most engineering-oriented mandate (7 685 words, 151 headings, 12 code blocks). The only mandate with a dedicated stop-condition section and an executable release-validation gate (""must fail if""). No UQO series framing (targets Journal of Finance), no AI-use disclosure, no page-count target other than JF limit. Cluster-compute section (27) presupposes distributed execution."
++"WP18","WP18_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp18_uqo/main/CLAUDE.md","2026-10-30T03:01:13Z","f538d6fe2483c975e45a0eed10b12e506ef2d7e20d48b16985c97aad17bc6779","real estate / housing macro-finance (OLG housing economy, leverage, intergenerational inequality)","theoretical (with numerical general-equilibrium simulation)","""Under what conditions do inherited wealth, mortgage leverage, nominal debt, housing supply and down-payment constraints generate persistent owner-renter wealth inequality among households with similar labor income? What changes under unexpected inflation?""","partial — candidate contributions to be treated as hypotheses, not formal H statements: ""Candidate contributions: (i) an endogenous ownership-entry wealth threshold jointly shaped by bequests, collateral and price feedback; (ii) conditions for persistent ownership/wealth gaps and path dependence; … Treat each as a hypothesis, not a preordained result."" ; ten required experiments listed","partial — assumptions must accompany every proposition but are not stated in the mandate: ""For every proposition provide exact assumptions, statement, proof or clearly labeled proof gap."" ; one substantive non-assumption imposed: ""Do not assume inflation necessarily raises real house prices or enriches every owner.""","partial — failed conjectures and contrary outcomes must be recorded, no disproof condition defined: ""Save proofs in `paper/appendix_proofs.tex` and failed conjectures in `research/failed_hypotheses.md`."" ; ""Investigate contrary outcomes."" ; ""conditions for persistence/multiple equilibria (only if established)""","yes — ""Produce `research/novelty_matrix.csv` comparing each claimed contribution with the closest prior papers. Redesign weak contributions. Do not assert novelty before verifying it."" ; ""target of 50–80 **verified** references if genuinely relevant and accessible (never pad)""","partial — generic honesty about access only: ""Log unavailable files rather than claiming to have read them."" ; ""ask for essential permissions or missing credentials rather than pretending access"" ; calibration ""from traceable Canada/Québec sources when justified, or use clearly marked illustrative parameters""","no — theoretical paper; only ""Record units, observation dates, transformations and sources."" (no look-ahead rule)","partial — benchmark model and baseline scenario, no comparison methods: ""First solve a two-/three-period benchmark with known behavior; unit-test budget identities"" ; experiment ""1. Baseline wealth and ownership by age, income and inheritance quantile.""","5 (Phase 0–4) plus ""Final reproducibility and QA""","explicit — ""**Mandatory order:** inspect previous UQO WPs and review literature → specify mathematical model → derive propositions → implement and validate numerical model → … → audit results → **only then write and compile the LaTeX paper**."" ; ""**Gate:** do not start manuscript drafting until the baseline model is validated, claimed GE equilibria clear markets, principal simulations and exhibits reproduce, bibliography is verified, and theoretical claims have proofs or appropriate qualifications.""","partial — fallback only, no stop condition: ""If blocked, document the issue honestly and deliver a scoped partial result.""","partial — progress log after every phase, no resume/checkpoint instruction: ""Maintain `research/progress.md` after every phase with completed work, evidence, blockers and next steps.""","paper/main.tex + main.pdf; references.bib; appendix_proofs.tex; appendix_computation.tex; 10–14 figures (vector PDF + PNG in results/figures/); 6–9 auto-generated LaTeX tables (results/tables/); raw CSV/Parquet (results/data/); logs; code modules src/{model,household_solver,equilibrium,distributions,simulation,calibration,robustness,figures,tables}.py; tests/; configs YAML; Makefile (setup/test/simulate/figures/tables/paper/all); requirements.txt; research/{progress,wp_style_audit,novelty_matrix,literature_matrix,literature_review,model_specification,failed_hypotheses,results_audit}; README","partial — traceability without hashes/manifests: ""Every paper number must map to a result file."" ; ""Record units, observation dates, transformations and sources."" ; ""pinned dependencies, fixed seeds, tests, structured experiment logs""","yes — ""## Phase 4 — Integrity audit, then write the manuscript Before writing the paper, complete `research/results_audit.md`: experiment, hypotheses, parameters, algorithm, convergence, results, limitations, robustness, and claims actually supported.""","no — ""Do not invent coauthors or acknowledgments."" concerns authorship metadata, not AI-use disclosure","no","yes — ""Never invent results, citations, proofs, or data."" ; ""If general equilibrium does not solve, **never label partial equilibrium as GE**."" ; ""No fabricated calibration targets or empirical validation."" ; ""Never manipulate assumptions to force a preferred conclusion."" ; ""Do not call simulation findings theorems.""","Quantity targets coexist with anti-padding clauses and are resolved only by a priority statement: ""30–45-page English main text"", ""10–14 meaningful publication-quality figures and 6–9 substantive tables, adjusted to genuine findings rather than padded"", versus ""**Priority: scientific correctness, originality and reproducibility over speed, page count or positive findings.**"" Non-verifiable from the document: ""Rerun from a clean environment"" (no environment specification), ""Check PDFs visually"". The gate condition ""bibliography is verified"" has no operational verification procedure. The French preamble re-maps the directory name used in the plan (""le nom `wp18_uqo/` du plan ci-dessous désigne ce dossier""), i.e. the plan's paths are not literal.","Prefatory note (French) placed before the mandate: ""(Spécification de l'auteur, 2026-10-20. Conventions de forme : ~/Desktop/Recherche-UQO/HARMONISATION.md ; ce dossier s'appelle `immobilier/housing-leverage-intergenerational-inequality` et correspond au dépôt spbgit `wp18_uqo.git` — le nom `wp18_uqo/` du plan ci-dessous désigne ce dossier.)"" — a repository-mapping note dated with the specification, not marked as post-implementation.","Language: English body with a French prefatory paragraph (automated: mixed). Role framing ""Act as an autonomous team of housing economists, …"". Requires reading WP1–WP17 for style conventions (research/wp_style_audit.md)."
++"WP19","WP19_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp19_uqo/main/CLAUDE.md","2026-10-30T03:01:14Z","2afdcd653423f83a24bc34cedc69589dc90cd372064134f28fddb6e771404a3b","real estate / housing market microstructure (search-and-matching, liquidity premium)","theoretical (continuous-time search model with numerical simulation)","""How do market tightness, heterogeneous seller reservation values, financing frictions, time-on-market costs, and bargaining power jointly determine an endogenous housing liquidity discount, transaction prices, selling hazards, and price dispersion?""","yes — ""Candidate propositions to PROVE: higher carrying cost lowers reservation price; decline in arrival/qualification widens the discount and increases TOM (with caveats); liquidity shocks move prices and volume without a fundamental shock; dispersion from heterogeneous urgency; selection bias in transaction indices."" ; defined object ""precise liquidity premium/discount definition with sign conventions (D = (p* − p)/p*)"" ; ""Each: preregistered hypothesis, exact config, output CSV, entry point, diagnostics, interpretation.""","partial — required, not stated: ""explicit timing, assumptions, parameter restrictions, identification limits, boundary cases"" ; ""Full assumptions, statements, proofs or counterexamples, intuition; label numerical patterns as conjectures.""","partial — counterexamples and failures must be reported; no disproof condition: ""proofs or counterexamples"" ; ""record failed experiments and regions without equilibrium"" ; ""Report failures.""","yes — ""Novelty gate: if the mechanism is already established, adjust the model and contribution before proceeding."" ; ""Authors to investigate only with independent bibliographic verification""","partial — ""No proprietary data, secrets, or unlicensed material."" ; ""If an endpoint is unavailable, log the failure and proceed"" ; ""do not claim to have read inaccessible material""","no — not applicable (theoretical, synthetic experiments)","partial — baseline scenario and frictionless benchmark, not comparison methods: ""1 baseline; 2 urgency gradient; …"" ; ""frictionless benchmark p*"" ; ""11 Nash vs posted prices""","8 (Phase 0–7); also an 8-step ""Mandatory execution sequence: (0) … (7)""","explicit — ""Mandatory execution sequence: (0) inspect prior UQO papers … (7) only then draft and compile the full LaTeX manuscript."" ; ""Novelty gate"" ; ""## Phase 6 — Independent audit before prose drafting"" ; ""## Research integrity and publication quality gates"" ; ""Introduction and abstract written last.""","no — ""Report failures."" only; no condition under which work stops","no","full repository; paper/main.pdf, main.tex, references.bib; scripts (src/{model,solver,simulation,calibration,diagnostics,plotting,tables}.py); tests (pytest); config/baseline.yaml; 10–14 figures (PNG + PDF); 6–9 tables; research/{wp_style_audit,literature_review,literature_matrix.csv,novelty_matrix.csv,model_specification,proofs,validation,results_audit,limitations}; README ""with commands and output inventory""; ""final report (contributions, proved propositions, strongest results with figure/table references, literature coverage, unresolved items, reproducibility status, file locations)""","yes — ""Fix random seeds; save environment and configuration hashes."" ; ""verify every number against result files"" ; ""`research/results_audit.md` maps every claim to proposition/proof, simulation file/figure/table, or citation""","yes — ""## Phase 6 — Independent audit before prose drafting `research/results_audit.md` maps every claim … classify as proved, numerically illustrated, empirically documented, or speculative""","no","no","yes — ""Never invent a proof, result, reference, DOI, dataset, or empirical validation."" ; ""Never fabricate outputs, citations, proofs, parameters or significance. No empirical language for synthetic experiments."" ; ""No \""publishable / first-of-its-kind\"" claims.""","""preregistered hypothesis"" is required for each of the 12 experiments but no registration mechanism, timestamp or location is specified, so pre-registration cannot be verified from the document. ""Independent audit"" (Phase 6) is to be performed by the same agent that produced the results — independence is not operational. Reference target ""Collect and verify 50–80 genuinely relevant references, not a quota"" and length ""30–45-page main paper"" are targets with built-in escape clauses. ""compile with latexmk; resolve warnings; inspect the rendered PDF"" presumes a TeX toolchain not checked for.","none identified","Most compact fully phased mandate (1 092 words, 8 phases). Explicitly scoped against WP18 (""Key distinction from WP18""). Role framing ""You are an autonomous interdisciplinary research team""."
++"WP20","WP20_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp20_uqo/main/CLAUDE.md","2026-10-30T03:01:14Z","388ca2431215e4894f6b935a379a6db34a2f1d7d72cd42d188d75ed6c6fefddf","real estate appraisal / multimodal AI (cost approach from listing images and text; Vrai Prix workflow)","mixed (empirical evaluation + design-science pipeline, with a clearly labeled synthetic fallback)","""RQ1: How accurately can multimodal AI extract appraisal-relevant building attributes from listing photographs and descriptions relative to verified property records or expert annotations?"" (RQ1 of five)","partial — five research questions and a formal valuation identity, no hypotheses: ""\widehat V_i^{cost}=\widehat L_i + \widehat{RCN}_i - \widehat D_i + \widehat S_i"" ; metrics ""attribute extraction precision/recall/F1 for categorical features, MAE/RMSE for continuous features, calibration and abstention metrics, and cost-approach accuracy versus independent credible cost or appraisal benchmarks""","partial — ""Prove only results supported by stated assumptions."" ; ""Separate observable visual features, inferred proxy features, verified administrative fields, text-claimed features, and latent/unobservable features.""","partial — ""Favor transparent uncertainty and falsifiable evidence over marketing language."" ; ""If evidence for novelty is weak, revise the contribution statement accordingly."" ; ""never describe synthetic findings as real-world validation"" ; no disproof condition for RQ1–RQ5","yes — ""aiming for 60–100 genuinely verified scholarly references if sufficient relevant work exists; quality and relevance take priority over quota."" ; ""Establish novelty only after examining existing literature."" ; ""Gate 2 — Literature: verified bibliography, mapped novelty and gap.""","yes — ""Respect website terms, robots policies where applicable, copyright, privacy, and licensing; do not assume scraping or publication permission."" ; ""Keep secrets in environment variables, never in tracked files."" ; ""Never bypass access controls or website restrictions."" ; ""Avoid any use of private API keys in paper, logs, screenshots, or Git history."" ; docs/data_rights.md","yes — ""Prevent train/test leakage by property, duplicate listing, and time."" ; ""Where feasible, use temporal and geographic holdouts."" ; experiment ""10. Geographic and temporal out-of-sample performance.""","yes — ""Compare at least: - B0: traditional cost approach using verified structured fields and standard cost schedules. - B1: listing-text-only extracted attributes + cost model. - B2: image-only … - B3: multimodal image+text … - B4: multimodal + verified administrative fields + uncertainty-aware reconciliation."" ; ""Do not make comparisons unfair by giving one method privileged information without identifying it.""","6 (six-step ""Mandatory sequence: (1) … (6) ONLY THEN write""); organised in sections A–J with 7 numbered quality gates","explicit — ""Gate 1 — Repository audit … Gate 2 — Literature … Gate 3 — Theory … Gate 4 — Implementation … Gate 5 — Experiments … Gate 6 — Manuscript: only then draft and compile … Gate 7 — Integrity"" ; ""Hard gate: Do not draft Results or Conclusions until numerical outputs have been executed, independently checked, and saved.""","partial — blocker handling, no stop: ""When missing permissions, source data, or access makes a claim impossible to validate, clearly identify the blocker, proceed with the portions that are feasible, and provide the exact minimal information needed to finish.""","partial — ""caching, retry limits"" ; ""Maintain a TODO list and research log."" ; no resume instruction","paper/main.pdf + main.tex + sections/ + references.bib + figures/ + tables/; ~12–16 vector PDF figures; 8–12 LaTeX tables generated from saved data; src/{ingestion,extraction,feature_schema,cost_model,evaluation,simulations,visualization}; configs/; data/{README,raw,processed,synthetic}; results/manifest.json; docs/{implementation_audit,literature_matrix.csv,experiment_plan,results_validation,data_rights,limitations,research_log}; tests/; requirements.txt; Makefile; data dictionary + data-flow diagram; annotated extraction schema; reproducibility instructions; limitations report; ""final checklist distinguishing completed, blocked, and proposed items""","yes — ""Store prompts, model versions, temperatures, and response schemas."" ; ""generate a machine-readable results/manifest.json"" ; ""Maintain docs/implementation_audit.md with citations to local paths or source lines"" ; ""Every substantive factual claim must have a traceable source."" ; ""Avoid hardcoded table results; generate them from actual outputs.""","yes — ""Gate 7 — Integrity: audit every numerical claim against saved outputs and every citation against source metadata."" ; ""Write docs/results_validation.md documenting each check.""","no","no — ""retry limits"" only; experiment 16 mentions ""annotation time/cost"" as an outcome, not a limit","yes — ""Never invent datasets, numerical findings, literature references, citations, software functionality, API results, human labels, or Vrai Prix implementation details. Never fabricate significance."" ; ""Do NOT infer foundation integrity, hidden mold, structural soundness, exact year built, precise area, code compliance, permit status, or legal tenure from images alone.""","Human-dependent steps inside an autonomous mandate: ""Propose a rigorous annotation protocol with independent expert raters"" and experiment ""4. Human expert agreement and AI-human disagreement"" cannot be executed by the agent (mitigated by ""subject to data availability""). ""independently checked"" in the hard gate has no independent checker. Verification of 60–100 references ""against primary records"" presumes network access not confirmed. Figure/table count targets (""approximately 12–16 figures and 8–12 tables"") versus ""never pad with meaningless exhibits"". The French preamble re-maps the directory used in the plan (""le nom `wp20_uqo/` du plan ci-dessous désigne ce dossier"").","Prefatory note (French): ""(Spécification de l'auteur, 2026-10-20. Conventions de forme : ~/Desktop/Recherche-UQO/HARMONISATION.md ; ce dossier s'appelle `immobilier/multimodal-cost-approach-valuation` et correspond au dépôt spbgit `wp20_uqo.git` — le nom `wp20_uqo/` du plan ci-dessous désigne ce dossier. Journal : `docs/research_log.md`.)"" — repository mapping and log location, dated with the specification.","Language mixed (French preamble). Unusually explicit ethics/rights section (E) and a closing principle: ""Produce the strongest defensible scientific contribution possible, not the most optimistic portrayal of AI or Vrai Prix."" Keyword family `budget` is inflated by ""cost approach"" (42 hits of ""cost"")."
++"WP21","WP21_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp21_uqo/main/CLAUDE.md","2026-10-30T03:01:14Z","692a6e50b3cf1d026a4bc12201759527ea3336e299bfd4786d3f635fff292b98","real estate economics / applied econometrics (systematic review and meta-analysis of hedonic pricing models)","empirical (meta-analysis with automated full-text extraction pipeline)","""RQ1 characteristics that consistently affect prices across countries and periods; RQ2 size and uncertainty of marginal contributions; RQ3 variation with geography, market conditions, property types, socioeconomics"" (RQ1–RQ3 of eight, written as fragments)","partial — effect-size families and pooled quantities defined, no hypotheses: ""Families: percentage premiums, elasticities, semi-elasticities, standardised effects, partial correlations, monetary marginal prices."" ; ""8.1 random-effects (REML) with pooled estimate, SE, 95% CI, 95% PI, τ², I², k studies, n estimates""","partial — methodological constraints stated as rules rather than assumptions: ""no monetary-to-percentage conversion without a defensible reference price"" ; ""Pool only within comparable groups; document and propagate uncertainty."" ; ""protocol before synthesis""","no — robustness and publication-selection diagnostics only (""Leave-one-study-out, leave-one-country-out, …""; ""funnel, small-study effects, PET-PEESE where appropriate""); no condition under which a claim is abandoned, except ""never relax criteria to reach targets""","yes — the paper is a literature synthesis; ""Compare with competing reviews before any \""largest\"" claim."" ; ""Explain precisely how the paper extends Sirmans et al. (2005, 2006)""","partial — ""read in full when legally accessible"" ; ""Google Scholar (compliant)"" ; no secrets/credential rules","no — a search cutoff date is set (""Reproducible search 1970–2026-10-20"") but no information-leakage rule applies","partial — comparison to a prior synthesis rather than baseline methods: ""comparison with Sirmans et al."" (required table) ; ""RQ5 traditional vs spatial vs machine-learning estimates""","7 (execution order A–G, inline)","implicit — ordering only, no gate conditions: ""15. EXECUTION ORDER. A research design → B literature acquisition → C data construction → D empirical analysis → E scientific interpretation → F manuscript → G final audit. No results written before analysis""","no — ""document obstacles and continue with feasible work.""","no","LaTeX paper (main.tex, sections, tables, figures, appendices, references.bib, reproducibility statement); structured research database data/{raw,metadata,extracted,validated,final}; scripts/{discovery,screening,extraction,harmonization,validation,econometrics,visualization}; protocol/{preregistration,eligibility,search_strategy}.md; reports/{search_audit,extraction_audit,methodological_decisions,limitations}.md; PRISMA flow diagram; 13 required tables and 12 required figures; tests; requirements.txt; README","yes — ""full records of queries, dates, sources, screening decisions, retrieval failures"" ; ""Store raw and harmonised values; never infer missing SEs except transparently from reported statistics; preserve every conversion formula; every number traceable to source table."" ; ""coefficient-level information (… page and table, extraction confidence)""","yes — ""G final audit"" ; ""Extraction validation: random sample of tables independently verified; report precision, recall, numerical accuracy, error rates; unverified or low-confidence extractions excluded from the primary synthesis."" ; ""flag ambiguous studies for human review""","no","no","yes — ""Never invent studies, citations, coefficients, standard errors, observations, statistical results, or claims of comprehensiveness."" ; ""never relax criteria to reach targets"" ; ""Never synthetic results."" ; ""no promotional language""","Aspirational targets (""≥5,000 unique records screened, ≥1,000 full texts, several hundred eligible studies"") are explicitly non-binding (""never relax criteria to reach targets""), so compliance cannot be judged. ""protocol/preregistration.md"" is required but no mechanism makes it precede the synthesis verifiably. ""random sample of tables independently verified"" has no independent verifier for a single agent; ""flag ambiguous studies for human review"" introduces a human-in-the-loop step without specifying who or when. ""vision/LLM-assisted classification"" implies paid model calls with no budget or recording requirement. ""read in full when legally accessible"" for ≥1,000 full texts is not checkable. R ""where superior"" is a judgement call.","none identified","Densest format: 15 numbered paragraphs, a single Markdown heading (automated n_headings = 1), 1 114 words. Only mandate whose primary object is the literature itself; ""Autonomous scientific research assignment, not a narrative review."""
++"WP22","WP22_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp22_uqo/main/CLAUDE.md","2026-10-30T03:01:14Z","b9eb747485cff5a1caa115f0d9138ed925d86915aa77813862b4059bd6d45da5","real estate economics / price-index econometrics (quality-adjusted housing price indices, Quebec transactions)","mixed (empirical index construction + Monte Carlo simulation + methodological contribution)","none — stated as objectives, e.g. ""Investigate an adaptive estimator that optimizes the trade-off between local information, borrowing strength, temporal responsiveness, bias, and variance."" (not phrased as a question)","yes — dedicated section: ""## 4. Core estimand Define I[g,k,t] as the quality-constant market price index for geography g, building type k and month t. Establish a reference property distribution and common-support rules. Set 2021 annual average = 100 for the primary index"" ; no hypotheses as such","partial — ""Enforce identifiability constraints and explicitly describe priors, likelihood, covariance, temporal evolution and estimation algorithm."" ; ""Make explicit whether the headline is a price index for the stock, for transacted properties, or for a representative constant-quality basket.""","yes — ""Include deliberate counterexamples where SHARP-HPI underperforms simpler alternatives."" ; ""Report when reconciliation introduces bias or excessive smoothing."" ; ""Conduct placebo tests, synthetic quality-composition shocks, …"" ; ""Test whether estimated changes reflect new transaction coverage rather than market dynamics.""","yes — ""Derive and test an adaptive pooling/shrinkage mechanism; do not call it novel unless a literature review establishes novelty."" ; ""Explain exactly how the proposed contribution differs from each close predecessor."" ; anchor references named (Hill et al. 2022; Ishaak et al. 2024; Hill 2026)","yes — ""Discover local Vrai Prix sources, read-only credentials, schemas, backups … Never assume credentials, copy secrets into logs, or modify production."" ; ""Keep raw transaction records private; publish only legally permissible aggregate results. Never commit credentials or personally identifying records.""","yes — ""Never use post-transaction information or future data in real-time estimates."" ; ""(2) real-time vintage series estimated using only information available at each historical publication cutoff."" ; ""Use forward-chaining and rolling-origin backtesting, never random train-test splits for temporal index claims."" ; ""Prevent image-derived signals from encoding the sale price, future information, listing outcome or date-dependent model artifacts.""","yes — ""## 5. Benchmark estimators Implement and compare: A. Raw median and arithmetic mean prices. B. Stratified median. C. Standard pooled hedonic time-dummy OLS. D. Rolling time-dummy … K. Existing QHPI method as a documented benchmark.""","8 (Phase 0–7 in ""21. Work sequence"")","explicit — ""## 12. Simulations — mandatory before paper claims"" ; ""## 22. Final quality gate No paper can be declared complete until all figures and tables are reproducible, every empirical claim is linked to a generated result, all citations are verified, benchmarks have run, Monte Carlo tests are documented, uncertainty is calibrated, geographic coverage is disclosed, sparse cells are labeled, leakage tests pass, the manuscript compiles without substantive errors, and the results have been critically reviewed for overclaiming."" (one terminal gate; phases 0–7 are ordered without per-phase pass criteria)","partial — fallback, no stop: ""If data access is unavailable, implement testable code and synthetic-data simulations, but never pretend real-data analysis has been completed.""","partial — ""cached intermediate artifacts"" ; ""At every phase save machine-readable artifacts and an explicit decision log."" ; no resume instruction","data_dictionary.md; provenance_report.md; cleaned transaction pipeline + exclusion audit; model specification and derivation; reproducible benchmark and SHARP estimators; Monte Carlo framework and results; monthly index panel in Parquet and CSV with a 23-field row schema; coverage/reliability tables; index vintage/revision database; tables and figures from actual outputs; optional interactive geographic diagnostics; limitations and reproducibility documentation; English LaTeX manuscript with BibTeX; unit/integration tests; versioned configs; environment lockfiles; decision log","yes — ""Build an immutable extraction snapshot."" ; ""provenance_report.md"" ; index rows carry ""data_cutoff, publication_vintage, model_version, index_method"" ; ""versioned configurations, unit tests, integration tests, data contracts, environment lockfiles and cached intermediate artifacts""","yes — ""## 1. Audit and provenance"" (data audit) ; final gate requires ""the results have been critically reviewed for overclaiming"" ; ""final reproducibility audit"" in Phase 7","no","no — ""Profile memory and runtime."" and ""Use streaming/chunked computation when necessary."" are engineering guidance, not limits","yes — ""Do not invent data, empirical results, references, statistical significance, or novelty claims."" ; ""Never equate predictive accuracy with index accuracy."" ; ""A model estimate with zero local transactions is not an observed monthly price movement."" ; ""Avoid fabricated precision."" ; ""Do not silently substitute assessment values for market transactions.""","Terminal-gate conditions that cannot be checked from the document alone: ""uncertainty is calibrated"" (requires truth, available only in simulation), ""critically reviewed for overclaiming"" (no reviewer defined), ""a publishable contribution"". Data-dependent requirements that may be unsatisfiable: ""aggregation weights, ideally grounded in eligible housing stock"", ""Compare aggregate series to suitable external indices"", ""historical boundary crosswalks"". Optional/unverifiable: ""interactive geographic diagnostics if practical"". Factual assertion inside an instruction: ""The October 2026 observation is partial through the actual last reliable transaction date"". No explicit escalation or stop rule despite ""Begin immediately … Continue autonomously"".","none identified","Only mandate with a dedicated ""Core estimand"" section and a prescribed output data schema. 22 numbered sections, 1 966 words. Strongest temporal-information discipline in the corpus (real-time vintages, revision policy)."
++"WP23","WP23_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp23_uqo/main/CLAUDE.md","2026-10-30T03:01:14Z","0f5ebcb5ec63d04392a4872530a43706535f1f8c00e6a3f61bdaaa34d1096cf0","real estate economics / machine-learning forecasting (spatiotemporal, hierarchical and probabilistic price forecasting, Quebec)","mixed (empirical forecasting evaluation + simulation study)","""do newly designed forecasting architectures substantially improve residential real estate price predictions?""","partial — forecasting targets defined, no hypotheses: ""Task A — future transaction price: P(i,t+h) = f(X(i,t), S(i,t), M(t), h); address transaction selection explicitly."" ; ""Task B … horizons 1, 3, 6, 12 months"" ; ""Task C — probabilistic forecasting: predictive distributions (mean, median, intervals, quantiles, downside risk, P(decline), …)""","no — none stated or required beyond ""Never assume a variable exists.""","partial — the question admits a negative answer and the simulation must show failures, but no disproof condition: ""(8) when complex models beat conventional ones"" ; ""when methods succeed or fail; explain mechanisms"" ; ""honest novelty statement""","yes — ""Never manufacture findings or claim novelty without verifying the literature."" ; ""# 13. LITERATURE REVIEW — … verify every reference; classify contributions (existing / adapted / new combination / original)."" ; ""literature search first""","partial — read-only rule on the upstream project only: ""WP22 (`../sharp-hpi-quebec`) is read-only for this project."" ; ""never modify WP22"" ; no credential/secret rules","yes — ""Every feature computed from information available at the forecast origin; no leakage."" ; ""strict pseudo-real-time expanding/rolling windows; for each origin: information set → estimate → forecast → store → compare. Never random splits."" ; ""regimes from information available at the origin only"" ; ""Prevent leakage from WP22: reconstruct index vintages from transactions observable at the origin; audit hedonics, clustering, normalisation, feature selection, imputation, target encoding, graph estimation, tuning, revisions.""","yes — ""# 6. BENCHMARKS — econometric (hedonic OLS, ridge/EN, SAR, ARIMA/SARIMA/ARIMAX, VAR/BVAR, DFM, local linear trend, state space), ML (RF, XGBoost, LightGBM, CatBoost, SVR, MLP), deep (LSTM, GRU, TCN, TFT, modern TS), simple (random walk, no change, mean growth, seasonal naive, momentum); fair common origins/information sets""","none (18 numbered topical sections, no execution phases; only ""literature search first"" and ""SIMULATION STUDY"" ordering cues)","explicit (terminal gate only) — ""# 18. QUALITY GATE — reproducible figures/tables, verified references, leakage audit passed, strict chronology, uncertainty reported, honest novelty statement, manuscript compiles.""","no","no","complete academic LaTeX manuscript (15 sections + appendices on architectures, hyper-parameters, tests, supplementary tables); reproducible Python research pipeline; original forecasting models; empirical results; 15 listed figure types (vector, reproducible); 13 listed table types; supplementary material; simulation study","partial — ""reproducible Python research pipeline"", ""vector; reproducible"" figures and a ""leakage audit"", but no manifest, hash, seed-logging or number-to-file traceability requirement","partial — ""leakage audit passed"" inside the terminal quality gate; no dedicated results audit or referee stage","no","no — a ""computational cost"" table is required as a reported outcome, not as a limit","yes — ""Never manufacture findings or claim novelty without verifying the literature."" ; ""no granular results for inadequate cells"" ; ""predictive importance ≠ causality"" ; ""no over-complex benchmarks the data cannot estimate""","The document itself declares that it is partly reconstructed: ""the pasted text ended at section 17 \""11. Prob\""; sections 17–end were completed from the UQO working-paper conventions"" and ""[Sections 11–15 and the remainder of the protocol were reconstructed by the author's assistant because the pasted protocol was truncated.]"" — part of the mandate is therefore not the author's original instruction. Six named ""original"" architectures (HSHN, DSGFN, RAREF, BHPF, QANSS, QREFA) are prescribed in advance while novelty is to be ""verified"" afterwards and ""keep only components with incremental out-of-sample value"" — pre-specified novelty versus post-hoc selection. ""substantially improve"" has no effect-size threshold. Heavy methods (""VI / Laplace / HMC on subsets"") with no compute budget. Section numbering is internally inconsistent (headings ""# 17."" and ""# 18."" versus the note ""ended at section 17 \""11. Prob\"""").","Two explicit markers: (1) header ""> Protocol as received on 2026-10-21 (the pasted text ended at section 17 \""11. Prob\""; sections 17–end were completed from the UQO working-paper conventions, see docs/PLAN.md). WP22 (`../sharp-hpi-quebec`) is read-only for this project."" ; (2) in section 17: ""[Sections 11–15 and the remainder of the protocol were reconstructed by the author's assistant because the pasted protocol was truncated.]""","Telegraphic style (1 132 words, 20 headings). The only mandate whose provenance is partly non-authorial by its own admission. No phases, no stop or recovery rules, no provenance manifest, no self-audit beyond the leakage audit."
++"WP24","WP24_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp24_uqo/main/CLAUDE.md","2026-10-30T03:01:14Z","02ae00f871fffd7937e9cd7ec121c53367addd9b5b709915bf6921adfa705347","macro-finance theory (AGI, task-based automation, general equilibrium and asset valuation; extension of Restrepo 2025)","mixed (theoretical model + quantitative simulation + empirical calibration/short-run design)","""How does increasingly capable and abundant AI reallocate factor income from labor to reproducible and scarce capital, change the ownership distribution of aggregate wealth, and jointly determine the prices and expected returns of financial, real-estate, and other assets?""","yes — nine target results: ""T1. Conditions under which Restrepo's labor-share asymptote survives multi-sector production with complementary physical inputs and scarce factors; counterexamples with binding energy/land. T2. Sufficient conditions for factor-income reallocation …"" through T9 ; ""Each result needs explicit assumptions, mathematical statement, rigorous proof or counterexample, economic interpretation, and simulation check.""","yes — primitives are stated and a numbered assumptions protocol and register are required: ""Restrepo's central primitives include task output X_t(ω)=L_t(ω)+Q_t(ω)/α_t(ω), …"" ; ""Proof protocol: write assumptions as numbered statements; verify differentiability, convexity/concavity, equilibrium existence, transversality, boundedness, market clearing, timing, stochastic integrability, and no-arbitrage."" ; `docs/assumptions_register.md`","yes — ""Do not assume that AI automatically raises profits, all asset prices, inequality, or aggregate welfare. Derive conditions and counterexamples."" ; ""Tests must fail on deliberately inconsistent accounting."" ; ""identify parameter regimes where asset valuations fall despite higher output"" ; ""Provide a falsifiable short-run empirical design: … with pre-trends, confounding, measurement error and alternative mechanisms addressed.""","yes — ""Prepare a literature matrix: … Verify exact references from authoritative sources. Mark all unverified claims."" ; referee question ""(1) is this genuinely new relative to Restrepo and task models?"" ; ""Explicitly separate the original author's conclusions from our proposed extensions.""","yes — ""Do not present proprietary datasets as accessible unless actually available."" ; ""company annual reports/Compustat if licensed"" ; ""`data/README.md`, `data/raw/`, `data/processed/`: sources, licenses, provenance and transformations; no fabricated observed data.""","partial — vintage awareness and pre-trend checks, no leakage rule: ""Check exact definitions, vintages, geographic scope, units, time frequency and licenses."" ; ""Validate against pre-AGI historical patterns without claiming the historical sample identifies post-AGI structural parameters."" ; ""Do not use speculative AGI dates as facts.""","yes — ""Reproduce a minimal baseline numerically or analytically before adding features."" ; ""Implement a real baseline first."" ; paper section ""3. Benchmark Restrepo replication and limitations."" ; ""Define a transparent benchmark and add layers with tests at every stage.""","7 (Phase 0–6) plus a 12-step ""EXECUTION ORDER"" A–L","explicit — ""## EXECUTION ORDER AND STOP CONDITIONS A. Audit source PDF and write source notes; B. derive smallest exact benchmark; C. … L. perform referee audit and final replication."" ; ""Never declare a theorem proven without a proof; never declare a model solved without numerical equilibrium checks; never declare a PDF compiled without verifying the file."" ; ""Implement deterministic perfect-foresight transition first, then aggregate shocks"" (no numbered gates)","partial — the heading says ""STOP CONDITIONS"" but the content is a fallback: ""If a block cannot be solved, deliver a verified simpler model and clearly document the limitation."" ; ""start implementing without waiting for further permission unless a genuinely blocking external input is required.""","partial — ""At each stage update `docs/research_log.md` with completed steps, assumptions, residuals, unresolved problems and next actions."" ; ""Record seeds, solver tolerances and convergence diagnostics."" ; no resume/checkpoint instruction","paper/main.tex (35–60+ pages); paper/appendix.tex; paper/references.bib; slides/main.tex (30–45 Beamer slides); src/ (solver, simulations, calibration, tests); data/README.md + raw/ + processed/; results/ (tables, figures PDF+PNG, parameter files, machine-readable outputs); docs/{model_dictionary,assumptions_register,identification,research_log,replication,referee_report}.md; Makefile; requirements.txt or pyproject.toml; environment lockfile; README with one-command reproduction; compiled PDFs ""if TeX available""","yes — ""sources, licenses, provenance and transformations"" for data ; ""Build a source-to-parameter table with observed moments, uncertainty and identification limits."" ; ""Clearly separate externally identified, calibrated and scenario-only parameters."" ; ""every result traceable to output"" ; ""Record seeds, solver tolerances and convergence diagnostics.""","yes — ""## PHASE 6 — CRITICAL SELF-REVIEW Write an adversarial referee report addressing: (1) is this genuinely new relative to Restrepo and task models? (2) is the model too large to identify? … (12) can the core mechanisms be established in a simpler model? Revise after review."" ; docs/referee_report.md","no","no","yes — ""no invented citations, DOIs or results"" ; ""no fabricated empirical estimates, no invented statistical significance"" ; ""Never declare a theorem proven without a proof; never declare a model solved without numerical equilibrium checks; never declare a PDF compiled without verifying the file."" ; ""Label conjectures as conjectures, not theorems."" ; ""Avoid hype words like 'revolutionary' or 'legendary' in manuscript.""","Scope tension: an 8–12-sector IO economy with heterogeneous households, full asset-pricing block, optional monetary/fiscal/open-economy modules and a 2026–2100 simulation versus ""Use a nested, modular economy, not an intractable all-at-once model"" and ""Prioritize a correct publishable contribution over a grand but incoherent system"" (resolved only by priority ordering). Length targets (""35–60+ page"", ""30–45 Beamer"") with no anti-padding clause other than the priority statement. External dependency: ""Download and read the complete original PDF"" presumes network access. ""STOP CONDITIONS"" heading without any stop condition. Conditional deliverables (""Compile PDFs if TeX available"") make completion ambiguous. Non-verifiable: ""publication-quality"", ""disciplined findings"".","Explicit post-hoc section: ""## UQO conventions (added 2026-10-27) This project is **UQO Working Paper No. 24** in `Recherche-UQO/finance/`. Follow `Recherche-UQO/HARMONISATION.md` (canonical title page, `\WP…` macros, README template, `paper/Makefile` + `.latexmkrc`, git remote `gitsrv:srv/git/wp24_uqo.git`).""","Mandate was written without UQO framing and later attached to the series (addition dated 2026-10-27). Contains a ""FIRST RESPONSE EXPECTED FROM CLAUDE CODE"" section specifying the first turn. Only mandate requiring seminar slides."
++"WP25","WP25_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp25_uqo/main/CLAUDE.md","2026-10-30T03:01:14Z","69f5ee82532d14513986c8f53f1b0981a2f7311dc0fc3b26d844610ccc80bf8b","economic theory / computational economics (agentic general equilibrium, LLM agents as delegated decision-makers)","mixed (theoretical model + heterogeneous-agent numerics + LLM-agent simulation laboratory)","""How does delegation of economic decisions to autonomous AI agents change equilibrium wages, interest rates, asset prices, capital accumulation, production, credit, systemic risk, and wealth inequality?""","yes — six falsifiable hypotheses: ""H1: Delegation creates an endogenous adoption threshold determined by information gains, execution costs, compute prices and agency losses. H2: Shared foundation models correlate trades and may reduce market depth under stress, conditional on common information. H3: …"" through H6 ; ""Pre-register outcomes.""","partial — required at every stage and sketched as a non-binding starting point: ""(b) write down assumptions"" ; ""Provide propositions and rigorous proofs under explicit assumptions, or label unsolved statements conjectures."" ; ""Illustrative starting point, NOT an assumed final model: V_i(s)=max_{c,l,a',d}{…}""","yes — ""For each: mathematical mechanism, formal or numerical prediction, falsification condition, isolation experiment and limitation."" ; ""Science gate: controlled experiments, uncertainty, negative results, sensitivity and mechanism isolation."" ; ""Supply counterexamples and boundary cases.""","yes — ""Before developing the model, search and verify literature on … Create `docs/literature_matrix.md` with verified bibliographic details, URLs/DOIs, modeling differences, and the precise remaining gap. No invented references."" ; ""1. **Novelty gate:** verified literature matrix, precise contribution and competing explanations.""","yes — ""Support local OpenAI-compatible inference and optional BYOK providers; no embedded credentials."" ; ""Request user input only for indispensable private data, external credentials, expensive compute authorization, or major scope changes."" ; ""Use verified public macro, labor, wealth, interest rate and financial data where possible.""","yes — ""Prevent look-ahead and information leakage."" ; ""validate surrogates on held-out actions"" ; ""No final-test-informed"" logic implied by ""Pre-register outcomes.""","yes — ""Controls: rational optimized agents, rules, reinforcement learning, single LLM, multiple heterogeneous LLMs, shared LLM with varied prompts, with/without tools, memory and negotiation."" ; ""Benchmark model with AI switched off against known analytical cases."" ; ""zero-AI limiting case"" (Numerics gate) ; scenario ""no AI""","6 (six numbered ""Milestones and acceptance gates""; the ""Start now"" paragraph adds an ordered sequence; no ""Phase N"" labels)","explicit — ""## Milestones and acceptance gates 1. **Novelty gate:** … 2. **Theory gate:** … 3. **Numerics gate:** … 4. **Agent gate:** … 5. **Science gate:** … 6. **Writing gate:** … Do not proceed to extravagant multi-agent simulations before gates 1–3 are met. If a gate fails, report why and repair the design."" ; ""Build tiny verified economies first; scale only after tests pass.""","partial — gate-failure and escalation rules, no stop: ""If a gate fails, report why and repair the design."" ; ""Request user input only for indispensable private data, external credentials, expensive compute authorization, or major scope changes."" ; ""If internet or TeX is unavailable, state the limitation and continue with honest local deliverables.""","yes — ""Support deterministic seeds, config-driven CLI, checkpointing, experiment manifests, Git revision and reproducible environment locks."" ; ""Cache reproducibly.""","repository scaffold (configs/, data/raw+processed, src/age/{economy,agents,equilibrium,markets,banking,llm,experiments,analysis}, tests/{unit,integration,property}); docs/{literature_matrix.md,model_specification.md,parameter_ledger.csv,research_log.md,limitations.md}; experiments/pre_registration.md; results/{figures,tables} (13 named figure types, 9 named table types, vector quality); paper/main.tex + sections/ + appendices/ (proofs, algorithms, prompts, schemas, replication instructions) + references.bib; README; pyproject.toml; ""replication package""; ""2–3 page research blueprint""","yes — ""Record model/version, prompt, context, temperature, seed, response, latency, tokens and cost. Cache reproducibly."" ; ""experiment manifests, Git revision and reproducible environment locks"" ; ""figure/table provenance"" (Writing gate) ; ""`docs/parameter_ledger.csv`: parameter, units, source, year/geography, moment, method, range, uncertainty.""","yes — ""6. **Writing gate:** complete paper, figure/table provenance, verified references, replication package and hostile-referee critique."" ; execution protocol step ""(e) discuss threats to interpretation""","no","partial — costs recorded and expensive compute requires authorisation, no numeric budget: ""expensive compute authorization"" ; ""Record … tokens and cost"" ; figure ""inference cost frontier"" ; ""Start on a single workstation; optional distributed inference only after a working local baseline.""","yes — ""Never fabricate results, citations, proofs, datasets, or calibrations. Label conjectures and illustrative simulations. Verify novelty before claiming it."" ; ""LLM output is never trusted as accounting truth."" ; ""Never claim a test passed unless it ran."" ; ""Do not call arbitrary LLM-generated market outcomes general equilibrium without verifying feasibility, market clearing and convergence."" ; ""Never treat simulated LLM preferences as verified human preferences.""","""Pre-register outcomes."" and `experiments/pre_registration.md` without any timestamping/registry mechanism — pre-registration by the same agent that runs the experiments is not verifiable. ""hostile-referee critique"" is produced by the same model. Scope tension between ""Aim for a parsimonious groundbreaking mechanism, not complexity for its own sake"" and three nested models (A, B, C) plus an LLM laboratory with eight roles and banking. Negative design constraint stated as judgement: ""The key innovation MUST NOT be simply adding AI to a Cobb–Douglas production function."" Non-verifiable: ""Aim at top economics/finance/computational economics journals without assuming acceptance.""","Prefatory note: ""(UQO Working Paper No. 25 — repository `Recherche-UQO/finance/agentic-general-equilibrium`, spbgit `wp25_uqo.git`. Programme supplied by the author on 2026-10-27; form follows `Recherche-UQO/HARMONISATION.md`.)"" — repository mapping added around the author's programme (dated 2026-10-27, same day as the programme).","Gate structure is the most formal of the theory mandates (six named acceptance gates with contents). Explicit per-stage protocol ""(a) state the precise scientific question, (b) write down assumptions, (c) implement and test, (d) show numerical evidence or mathematical proof, (e) discuss threats to interpretation, (f) log decisions and next tasks."""
++"WP26","WP26_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp26_uqo/main/CLAUDE.md","2026-10-30T03:01:15Z","49afcce91475e5e145b4bd49d29486065c8c613a402b51fdb9baa43c88f4b330","real estate valuation / multi-agent AI (LLM agent deliberation for property valuation, Quebec transactions)","mixed (empirical evaluation + design-science multi-agent system + stylised welfare model)","""RQ1: Do specialized multi-agent systems outperform single LLMs, hedonic models, repeat-sales approaches, gradient boosting, and conventional AVMs on genuinely unseen Quebec transactions?"" (RQ1 of six)","yes — pre-specified primary outcome: ""Pre-register primary endpoints and hypotheses before running final test evaluations. Primary outcome: out-of-time absolute log-price error on arm's-length residential transactions. Co-primary or secondary: MAE in CAD, MdAPE, RMSE log, tail error (P90/P95), interval coverage, interval width, CRPS or pinball loss, cost and latency."" ; ""Propose falsifiable propositions about diversity, correlation, communication topology, and aggregation weights.""","partial — ""State identification assumptions and develop multiple operational definitions of value."" ; ""Transaction prices are noisy proxies, not ground-truth fundamental values."" ; ""Do not claim general existence/uniqueness theorems without proof.""","yes — ""A negative finding is publishable if the design is rigorous."" ; ""Report failure as rigorously as success."" ; placebo arm ""I. Random/shuffled-role or placebo deliberation"" ; ""Explicitly separate improvements from more tokens, more tools, more models, or more data."" ; ""Derive testable conditions under which deliberation reduces or increases mean-squared error""","yes — ""Phase 1: literature review and novelty map; identify close prior multi-agent real-estate/AVM papers and avoid unsupported priority claims."" ; ""Search and verify the relevant academic literature if browsing is available; otherwise flag bibliography for verification.""","yes — ""These are potential sources, not automatically accessible. Begin with a data-access audit"" ; ""Do not bypass authentication, scrape restricted endpoints, or infer consent. Do not send personal identifiers, private listing remarks, occupant information, or confidential records to external LLM APIs without authorization and suitable safeguards."" ; ""use environment variables and a local secrets manager, never put secrets in source control or manuscript"" ; ""Publish only de-identified or synthetic examples if redistribution is not authorized.""","yes — ""Only use features observable as of the valuation timestamp; prevent post-sale information and target leakage."" ; ""Comparable retrieval must be strictly as-of-date; no same-property future transfers, post-sale listings, or near-duplicate records leaking across partitions."" ; ""Use a chronological split with train/validation/test and a final untouched holdout"" ; ""Build a leakage-audit suite and adversarial tests."" ; ""No final-test-informed aggregation weights.""","yes — ""Implement and evaluate at least: A. Hedonic OLS / regularized regression (proper spatial/time controls) B. Repeat-sales or hierarchical hedonic … C. CatBoost/XGBoost/LightGBM tuned on validation only D. Strong tabular AVM … E. Single LLM, evidence-matched F. Independent LLM agents aggregated without communication … J. Cost-matched single-agent repeated reasoning and cost-matched ensemble""","9 (Phase 0–8 in ""Execution phases and acceptance gates"") plus seven ""Immediate first actions""","explicit — ""## Execution phases and acceptance gates Phase 0: inventory … Phase 5: run provider-balanced, information-matched, compute-matched randomized ablations on validation; freeze protocol. Phase 6: evaluate final temporal/spatial holdouts once, with clustered uncertainty and cost accounting. … Phase 8: produce manuscript"" ; ""After each phase, produce a concise `reports/phase_XX.md` with completed artifacts, failed checks, decisions, outstanding assumptions, and exact commands."" (ordering and freeze/once-only conditions; no per-phase pass criteria beyond the phase reports)","partial — escalation rule and debate-round limits only: ""Stop and ask targeted questions only for indispensable access or decisions; otherwise proceed with explicitly documented defaults. Never fabricate completion."" ; ""Limit debate to pre-specified rounds (e.g. 0, 1, 2, 4)"" ; src/debate/ ""stopping rules""","partial — ""privacy-aware caching"" ; ""bounded retries"" ; ""store response artifacts securely and measure run-to-run variation"" ; no resume/checkpoint instruction","README.md, CLAUDE.md, pyproject.toml, .env.example, LICENSE; configs/ (splits, model IDs, treatments, budgets, seeds); src/{data,features,baselines,agents,debate,evaluation,experiments}; tests/ (unit/integration/leakage/mock-provider); notebooks/; paper/ (LaTeX manuscript, BibTeX, figures, tables, appendices, compilation script, PDF); reports/ (experiment cards, failure analyses, model cards, limitations, phase_XX.md); research_plan.md, data_access_checklist.md, preregistration.md, architecture.md; data dictionaries; clearly labeled synthetic dataset and mock LLM adapters; CLI (ingest, validate, train, run agents, evaluate, generate tables, build PDF); limitations register; API-cost budget","yes — ""Store raw snapshots immutable with data dictionaries, versioned transformations, provenance, licenses, and record-level lineage."" ; ""Record model IDs, API parameters, prompt hashes, temperature, tool calls, token usage, cost estimates, and latency."" ; ""All figures/tables must come from versioned outputs."" ; ""Pin dependencies, set seeds, capture versions and hardware""","yes — roles ""11. Data-quality, leakage, and provenance auditor 12. Independent skeptical reviewer / red-team agent"" ; ""Phase 7: human benchmark if authorized, welfare model, robustness, interpretability audits."" ; ""Build a leakage-audit suite and adversarial tests.""","no — ""Agents are **simulated analytic roles**, not licensed Quebec appraisers or real lenders; never misrepresent professional certification."" concerns role representation, not AI-use disclosure for the paper","yes — ""Present an API-cost budget with small pilot, medium validation, and final experiment tiers, without inventing vendor prices."" ; ""token budgets"" ; ""compare all-Claude, all-OpenAI, and mixed-provider committees at matched cost and information budgets"" ; ""async concurrency with strict limits""","yes — ""Never invent data, results, citations, human assessments, API capabilities, or model performance."" ; ""Never fabricate empirical tables: use placeholders clearly marked `NOT YET ESTIMATED` until generated by scripts."" ; ""No p-hacking or test-set prompt tuning."" ; ""do not fabricate a human benchmark"" ; ""Do not claim deterministic reproducibility for hosted LLMs""","""Pre-register primary endpoints and hypotheses before running final test evaluations"" and `preregistration.md` have no registry/timestamp mechanism; the same agent writes and executes. ""evaluate final temporal/spatial holdouts once"" — the once-only rule has no enforcement mechanism. Human-dependent arm: ""recruit licensed appraisal professionals and/or trained human appraisers under an approved protocol"" cannot be executed autonomously (mitigated: ""mark this arm as pending and do not claim it was performed""). ""Respect Quebec privacy requirements and organizational research-ethics review where applicable"" is not operational for an agent. Tension between ""make outputs reproducible"" and ""Do not claim deterministic reproducibility for hosted LLMs"" (resolved by storing response artifacts). Scope (12 default roles, up to 20, ten treatment arms, three provider configurations) versus an API budget that is to be proposed rather than given.","Explicit post-hoc section: ""## Repository conventions (added by the implementation, 2026-10-27) - UQO Working Paper No. 26, folder `Recherche-UQO/immobilier/agentic-valuation-quebec`, git remote `gitsrv:srv/git/wp26_uqo.git`. - Python package: `src/agentic_valuation/` (installed editable: `pip install -e .`). CLI: `av <command>` (see README). - Secrets only in `.env` (gitignored). Snapshot provenance in `data/raw/README.md`. Every result file is produced by a numbered script in `scripts/`.""","Most complete empirical-design mandate in the corpus: pre-specified primary outcome, placebo arm, cost-matched controls, leakage suite, API budget tiers, phase reports. Research-only clause: ""No live autonomous trading, lending decisions, or real estate offers""."
++"WP28","WP28_CLAUDE.md","claude_md","https://git.spboucher.ai/raw/wp28_uqo/main/CLAUDE.md","2026-10-30T03:01:15Z","c6c50e319f971b01fa0662840feef177d7bc896526956b0b7a3cf7a83f36246d","econometric theory / statistical computing (distributed maximum likelihood, higher-order bias correction, communication-computation trade-off)","mixed (mathematical theory + Monte Carlo simulation + distributed-systems benchmark)","""For regular nonlinear likelihood models with `N` observations and `K` distributed partitions, how can additional local computation replace global network synchronization while preserving the first-order inferential properties of centralized maximum likelihood?""","yes — candidate theorem and proof queue: ""K = o( N^[ 1 - 1 / ( 2^(q+1) * r ) ] )"" ; ""**Theorem 3 — Exact exponential boundary.** Derive all Gamma moments needed and establish the nonzero limit `-4 theta_0 c^4` for half-block jackknife + one global Newton step when `K ~ c N^(7/8)`."" ; Lemmas 1–7, Theorems 1–4, a failure Proposition and a Corollary are enumerated","yes — baseline model assumptions are listed in the mandate and an assumptions file is required: ""### 5.1 Baseline model Start with i.i.d. observations and a correctly specified fixed-dimensional regular likelihood: - `X_1,...,X_N ~ P_{theta_0}` independent; - `theta_0` interior to an open parameter set in `R^p`; - information matrix `I(theta_0)` positive definite; …"" ; ""State precisely which theorem uses which assumption."" ; theory/ASSUMPTIONS.md","yes — ""A dead end with a mathematical explanation is better than a fabricated breakthrough. A strong negative result or counterexample may itself become the contribution."" ; ""**Gate 4:** at least one nontrivial theorem beyond a rephrasing of known one-step-plus-jackknife results is fully proved, **or** the report explicitly concludes that novelty is not yet proved and reframes the paper around validated insights and counterexamples."" ; ""a counterexample or violation for at least one essential assumption"" ; ""**Proposition — Failure/counterexample.**"" ; ""Track E — Lower bounds, counterexamples and impossibility""","yes — ""Do not claim that distributed gradients, one-step Newton, split-sample jackknife, Richardson extrapolation, `K = o(N^{7/8})`, or `K = o(N^{11/12})` are intrinsically novel. Investigate who has already obtained each idea or bound."" ; `literature/PRIOR_ART_MATRIX.csv` with ""novelty_threat"" column ; ""**Gate 1:** no unqualified novelty language is allowed until the closest competing theorems have been inspected and cited."" ; six anchor references with DOIs to verify","yes — ""never scrape or transmit private material to external services without authorization"" ; ""Do not expose API keys, SSH keys, passwords, endpoint secrets or private datasets in source files, logs, paper, artifacts or commits."" ; ""Use the researcher's available CPU/GPU/cluster systems only when provisioned and authorized."" ; ""Avoid destructive commands, forced pushes and unrelated repository modifications.""","no — not applicable (synthetic Monte Carlo); only a literature cutoff: ""**Current date for literature cutoff:** 2026-10-28; search current material rather than assuming bibliographic currency.""","yes — ""Full centralized maximum likelihood, using a trusted optimizer and tight tolerances."" ; ""Credible implementations of at least two strong literature baselines where practical, such as surrogate likelihood/CSL and another relevant distributed estimator."" ; audit items ""New method comparisons include ordinary local averaging + two Newton rounds."" and ""A baseline with exact sufficient-statistic aggregation is shown for applicable families.""","13 (Phase 0–12, each closed by Gate 0–12)","explicit — ""**Execute in order, completing one phase's acceptance tests before starting the next.**"" ; ""**Gate 0: pass only when** all old claims and artifacts are inventoried, every existing number is tagged as replicated / not replicated / unavailable, and a WP28 workspace exists without clobbering other work."" ; ""**Gate 6:** all critical tests pass and the code reconstructs original-paper figures within stated tolerances before large experiments begin."" ; pass/fail rubric in section 16","yes — ""Complete the project from initial inspection through PDF validation; stop only when a real blocker makes an indispensable step impossible. Document blocked items, and continue with whatever can be completed."" ; ""**Gate 11:** produce `FINAL_REVIEW.md` with a final verdict `ready for human review / theoretically incomplete / novelty unresolved / computational evidence insufficient`"" ; ""Never assert results from jobs that have not finished."" ; ""Do not publish a preprint or submit to a journal without explicit instruction.""","partial — phase status and run manifests, failure tracking, no resume instruction: ""After completing each phase, append to `PHASE_STATUS.md`: Phase: Start/finish timestamp: What was actually done: Artifacts created: Tests passed: Tests failed: …"" ; ""Track optimization failures rather than discard failed replications silently."" ; ""straggler failures"" to be bounded","article (~25–40 pages) + mathematical appendix; paper/{main.tex,preamble.tex,sections,appendices,references.bib,figures}; literature/{PRIOR_ART_MATRIX.csv,PRIORITY_AND_GAP.md}; theory/{THEOREM_AUDIT.md,ASSUMPTIONS.md,proofs_check.py,symbolic_checks.py}; src/pamle/ (10 modules) with common-interface estimators; experiments/{configs,run_monte_carlo.py,run_benchmarks.py,run_ablations.py,EXPERIMENT_MANIFEST.csv}; tests/ (7 files); results/{raw,processed,tables,figures,resource_profiles}; scripts/{setup.sh,reproduce_all.sh,compile_paper.sh,validate_pdf.sh}; PROJECT_MAP.md, SOURCE_PROVENANCE.md, PHASE_STATUS.md, research_log.md, LIMITATIONS_AND_CLAIMS.md, FINAL_REVIEW.md, FINAL_DELIVERY.md; proof ledger; 8 figures + 6 tables programme; delivery bundle (PDF, .tex, source-and-reproducibility zip, Research_Summary, Theorem_Audit, Prior_Art_and_Novelty, Experiment_Results.csv, Final_Review); nine-point closing report","yes — ""Extract the existing archive to an immutable `references/initial_pamle/` directory if available; record checksums."" ; run manifest ""run_id,git_commit,python_version,dependency_lock_sha256, seed,N,K,m,p,DGP,method,optimizer,tolerance,replicates, parallel_backend,node_count,hardware,OS,wall_seconds, communicated_bytes,rounds,status,raw_output_sha256"" ; ""Every table value has a traceable input/output path."" ; ""Project checksums and commit state are captured.""","yes — ""## 14. PHASE 11 — Adversarial referee and proof audit Simulate at least three independent review perspectives; log objections and responses"" (Referees A, B, C) ; ""For every objection, respond with (a) exact location in paper/code, (b) correction made, (c) new proof/test if needed, and (d) residual limitation."" ; THEOREM_AUDIT.md with ""proved / conditional / open / false"" labels","yes — ""Confirm the applicable journal/venue authorship and AI-disclosure policy before a submission version; never falsely represent an AI system as a legally accountable human author."" ; ""The journal submission version may need GPT-6.1 removed from the formal author list and placed in transparent AI-use disclosure; **flag this for the human author rather than concealing the difference**."" ; audit item ""AI contribution disclosure and human review requirements are explicit."" ; rubric row ""Attribution | Simon-Pierre Boucher properly named; AI role transparently recorded""","partial — resources bounded by availability, no numeric cap: ""Continue to a publishable-quality, internally consistent draft within the resources and access actually available."" ; ""`N`: logarithmic sequence … chosen based on available RAM/compute"" ; blocker category ""(iv) exhausted compute budget"" ; ""where measured, electricity and dollar-cost assumptions""","yes — ""No invented theorem, proof, assumption, dataset, benchmark, reference, DOI, parameter estimate, speedup, significance level, or journal acceptance."" ; ""Do not call an in-memory mathematical partition a distributed cluster benchmark."" ; ""Never assert results from jobs that have not finished."" ; ""Do not silently describe these as 1,000 replications or as physical-cluster experiments."" ; ""Never explicitly invert the Hessian in production code""","(1) ""Simulate at least three independent review perspectives"" versus ""do not have the same model merely declare its own work accepted"" — the simulated referees are by construction the same model, so independence is not operational. (2) Authorship: ""Preserve this provenance and the user's requested GPT-6.1 attribution in the working draft"" (GPT-6.1 in the author block) versus ""never falsely represent an AI system as a legally accountable human author"" — resolved only by deferring to the human for the submission version. (3) ""Research program funding line to include **only if confirmed** for this particular WP28 project"" — confirmation requires the human; the agent cannot satisfy it. (4) Compute: ""target at least 1,000 per **main statistical design**"" across ≥4 N values, several K, several p, ≥3 models and DGP conditions with no budget beyond ""where practical"". (5) Conditional bonuses (""If Lean is installed, formalize at least one deterministic algebraic lemma as a bonus, not as a blocker""). (6) Rubric criteria such as ""substantive new result or defensible negative discovery"" and ""journal-style typography"" are not script-checkable. (7) ""The researcher may have access to a MacLustr collection"" together with ""never assume the existence … of a MacLustr node"" is consistent but leaves hardware scope undetermined until run time.","none identified as post-hoc; the header records prior provenance rather than an addition: ""**Prior exploratory draft credits:** Simon-Pierre Boucher and GPT-6.1. Preserve this provenance and the user's requested GPT-6.1 attribution in the working draft.""","Longest mandate in the corpus (8 809 words, 76 headings, 27 code blocks, 2 Markdown tables). The only mandate with an AI-use/authorship disclosure instruction, a per-phase acceptance-test rule (""completing one phase's acceptance tests before starting the next""), a pass/fail rubric table, a multi-referee audit phase and a verdict vocabulary. Explicitly a re-examination of a prior AI-assisted draft (""This is NOT an instruction to paraphrase the exploratory note."")."
++"WP27_BRIEF","WP27_BRIEF_DESIGN-BRIEF.md","design_brief","https://git.spboucher.ai/raw/wp27_uqo/main/docs/DESIGN-BRIEF.md","2026-10-30T03:01:15Z","72dc7ab846c6d8f8e0cc4101b6bdb600884179e9467c43fddfd3aece395e236e","finance / market microstructure (agent-based limit-order-book simulation with LLM trading agents)","simulation (agent-based market simulator with a stylised one-period theoretical model)","none — the brief describes ""what the simulator *actually* implements"" and lists hypotheses H1–H6; no research question is stated","yes — ""Hypotheses the simulator tests: H1 informativeness falls in the share using a single shared model (holding information quality fixed) and rises in M_eff; H2 order-flow correlation and synchrony rise in φ; H3 bubble/crash frequency and liquidity spirals rise with φ × leverage; H4 prompt/model diversity restores part of the loss; H5 communication channels raise synchrony; H6 circuit breakers and position limits cut crash depth at a cost in time-to-absorb."" ; objects defined: ""price informativeness τ = 1 − Var(v | Y)/σ_v²; pricing error Var(P − v); order-flow correlation ρ_x = Corr(x_i, x_j); synchrony; effective number of models M_eff = 1/Σ_g φ_g²""","yes — model assumptions stated in the text: ""One-period, one asset, liquidation value v ~ N(0, σ_v²) around the public PV. N traders receive s_i = v + ε_i with ε_i = η_{g(i)} + u_i"" ; ""β > 0 a fixed response intensity; the behavioral assumption mirrors rule-like LLM policies and is relaxed in a CARA extension"" ; ""A competitive, risk-neutral market maker sets P = E[v | Y]""","partial — directional hypotheses are testable and a seed/power design is sketched (""≥ 30 seeds exploratory, power-based for confirmatory""), but no null-result condition is stated","no — the brief is addressed to ""the sub-agents writing the literature review, theory and pre-analysis plan"" but imposes no literature or novelty requirement","no — synthetic data; providers listed without access rules: ""Providers: OpenAI (Responses API, json_schema), Anthropic (Messages API, json_schema), mock (seeded rule with injected invalid answers).""","yes — information-set discipline inside the simulator: ""Agents never see V_t."" ; ""No agent sees future draws."" ; ""orders arrive at decision time + latency and are processed in arrival order""","partial — control arm and matched design rather than named baseline methods: ""Matched pairs across `llm_share` share every stream except the LLM slot draw."" ; ""mock (seeded rule …)"" provider ; ""frozen decision library replay vs online calls""","none","none","no","no","none stated explicitly; implied: literature review, theory write-up (""to be written up by the theory agent, must map to the above"") and a pre-analysis plan; the simulator reports ""Realized LLM share of agents, orders and volume""","partial — ""Randomization: master seed → independent streams (fundamentals, news, slots, policy assignment, LLM slot assignment, activation, tie-breaks, per-agent RNG)."" ; ""Invalid decisions = hold, logged."" ; ""exact conservation checked after every fill"" ; no manifest/hash requirement","no","no","partial — budgets appear as experimental treatments, not as resource limits: ""equal token / USD / decision-opportunity budgets""","no","Not a mandate, so few directives. Non-operational: ""power-based for confirmatory"" without a power target or effect size; ""must map to the above"" asserts a correspondence between the one-period theory and the multi-tick simulator (fixed β market orders versus a continuous double auction) that the brief does not check.","none identified — but the whole document is by nature post-implementation (""It describes what the simulator *actually* implements (src/market_agents)"").","Supplementary design brief, not a CLAUDE.md; coded separately and excluded from all ""of 11"" counts. WP27's own CLAUDE.md returned HTTP 404 and is not represented in the corpus. 820 words, 3 headings."
++"WP15_PROMPT","WP15_PROMPT_PROMPT_INITIAL_CLAUDE.md","duplicate","https://git.spboucher.ai/raw/wp15_uqo/main/docs/PROMPT_INITIAL_CLAUDE.md","2026-10-30T03:01:13Z","2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77","see WP15","see WP15","see WP15 (byte-identical duplicate; not coded separately)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)","docs/PROMPT_INITIAL_CLAUDE.md in the wp15_uqo repository is byte-identical to docs/CLAUDE.md in the retrieved snapshot. Recorded once in the corpus manifest for completeness; counted as one mandate (WP15) in all tallies. The two paths suggest the initial prompt was preserved verbatim as the working CLAUDE.md, but the snapshot alone cannot establish which file came first."

added research/corpus_coding_protocol.md +98 −0

++# WP29 — Content-coding protocol for the mandate corpus (codebook)
++
++Version 1.0 — 2026-10-29. Applies to `research/corpus/*.md` (13 files, hashes in `research/corpus_manifest.csv`).
++
++## 1. Scope, provenance and limits of the coding
++
++- **Corpus.** Thirteen files retrieved on 2026-10-29 (UTC 2026-10-30T03:01). They contain **eleven distinct CLAUDE.md mandates** (WP15, WP18, WP19, WP20, WP21, WP22, WP23, WP24, WP25, WP26, WP28), **one supplementary design brief** (WP27 `DESIGN-BRIEF.md`, which is not a CLAUDE.md) and **one byte-identical duplicate** (`WP15_PROMPT_PROMPT_INITIAL_CLAUDE.md`, SHA-256 `2dd19c59…1b77`, identical to `WP15_CLAUDE.md`). The duplicate is recorded but coded once. WP27's own CLAUDE.md returned HTTP 404 and is therefore absent; nothing is inferred about it.
++- **Who coded.** A **single automated + LLM-analyst pass** (Claude Code subagent, model Claude Fable 5.1, 2026-10-29). The automated variables were computed by `research/code_corpus.py`; the analyst variables were produced by the same subagent after reading each document in full. **There was no human second coder, so no intercoder reliability (kappa, agreement rate) is reported and none should be inferred.** The analyst columns are the subagent's reading of the text and may contain judgement errors; every yes/partial/no judgement is accompanied by a verbatim quote so that it can be re-checked against the source.
++- **What the coding can and cannot support.** The corpus is **small (11 mandates) and researcher-selected** (the author's own instruction files for earlier UQO working papers). It is used to **motivate design patterns** for WP29's protocol, **not to estimate the prevalence** of practices across autonomous-research mandates in general. Denominators are reported as "x of 11 mandates" and no inferential statistics are computed.
++- **What is coded.** Only what the instruction documents say. The coding does **not** assess whether the earlier working papers were good, whether the instructions were followed, or whether the papers were produced without human assistance. A mandate that *requires* a provenance manifest is coded as requiring one; whether such a manifest exists is outside this coding.
++- **Verbatim vs interpretation.** In `corpus_coding.csv`, verbatim material is always enclosed in double quotes `"…"`; everything outside the quotes is analyst interpretation. Quotes are copied exactly (including capitalisation, spelling and Markdown markup) and truncated with `…` only when the sentence exceeds roughly 40 words; nothing is paraphrased inside quotation marks.
++
++## 2. Files produced
++
++| File | Produced by | Content |
++|---|---|---|
++| `research/code_corpus.py` | script (stdlib only) | computes the automated variables |
++| `research/corpus_automated.csv` | script | 13 rows (one per file, duplicate flagged) |
++| `research/corpus_coding.csv` | analyst (written with `csv` module, RFC-4180) | 13 rows: 11 mandates + 1 design brief + 1 duplicate-note row |
++| `research/corpus_summary.md` | analyst | counts, patterns, excerpts |
++
++## 3. Variable types
++
++- **(A) automated** — computed by `code_corpus.py` from the file bytes; fully reproducible by re-running the script.
++- **(I) analyst-interpreted** — a categorical judgement made after reading the whole document; always accompanied by a supporting verbatim quote or by `none`.
++- **(V) verbatim extraction** — text copied from the document, or metadata copied from `corpus_manifest.csv`.
++
++## 4. Automated variables (`corpus_automated.csv`) — type (A)
++
++| Variable | Definition |
++|---|---|
++| `file` | file name in `research/corpus/` |
++| `wp` | leading `WP\d+` token of the file name |
++| `document_type` | `claude_md`; `design_brief` if the name contains `BRIEF`; `duplicate_claude_md` if the SHA-256 equals that of an earlier file in sorted order |
++| `duplicate_of` | file name of the first file with the same SHA-256, else empty |
++| `sha256`, `sha256_matches_manifest` | SHA-256 of the bytes; `yes` if equal to the manifest value |
++| `manifest_url`, `manifest_retrieved_utc` | copied from `corpus_manifest.csv` |
++| `bytes`, `lines`, `words` | byte length; newline count (+1 if no trailing newline); `len(text.split())` |
++| `n_headings` | lines matching `^#{1,6}\s+\S` (ATX Markdown headings) |
++| `n_phase_labels_distinct` | number of distinct N in matches of `\bphase\s*(\d+)` (case-insensitive) |
++| `n_stage_labels_distinct` | distinct capital letters X in `(?i:\bstage)\s+([A-Z])\b` |
++| `n_gate_labels_distinct` | distinct N in `\bgate\s*(\d+)` (case-insensitive) |
++| `n_numbered_items_in_phase_sections` | numbered list items (`^\s*\d+\.\s`) located inside a section whose heading contains one of *phase(s), stage(s), sequence, execution order, work sequence, execution protocol, execution phases, milestones*; a section extends to the next heading of equal or higher level |
++| `n_numbered_items_total` | all numbered list items in the file |
++| `n_numbered_phases` | mechanical phase count. Rule, in order: distinct `Phase N` labels if any; else distinct `Stage X` labels; else distinct `Gate N` labels; else numbered items inside phase/sequence sections. `n_numbered_phases_rule` records which branch fired. Known limits: WP20 states a 6-step "Mandatory sequence: (1) … (6)" inline with parentheses (not matched) and 7 numbered gates (matched → 7); WP21 lists steps "A … G" inline (→ 0); WP28's "Stage A–G" are message-protocol steps, not phases, but its 13 `Phase N` labels take precedence. The analyst variable `n_phases_declared` is authoritative. |
++| `n_tables` | Markdown table separator rows (`|---|---|`): one per table |
++| `n_code_blocks` | pairs of ``` fences |
++| `language_of_document`, `fr_token_share` | heuristic: share of French function-word tokens (le, la, les, des, est, une, ce, cette, dans, pour, sur, avec, pas, aux, qui, que, ci-dessous, dossier, appelle, correspond, auteur) among French + English function-word tokens; `en` < 0.015 ≤ `mixed` < 0.50 ≤ `fr`. Tokens shared with English in this corpus (*conventions, journal, du, et*) are excluded. Result: all files `en` except WP18 and WP20 (`mixed`: a French prefatory paragraph on an English body). |
++| `mentions_<family>` / `mentions_<family>_n` | boolean / count of case-insensitive regex matches. Families: `preregist` `pre-?regist\w*`; `estimand` `\bestimands?\b`; `hypothes` `\bhypothes\w*`; `falsif` `\bfalsif\w*`; `baseline` `\bbaselines?\b`; `leakage` `leakage|look-?ahead|look ahead|point-in-time|point in time`; `provenance` `provenance|hash(es|ed|ing)?|sha-?256|checksums?`; `reproduc` `\breproduc\w*`; `stopping` `stopping|stop rules?|stop conditions?|termination|stop and|stop if|stop only`; `recovery` `recover\w*|resum\w*|checkpoint\w*`; `gate` `gates?|acceptance|criteria`; `exhibit` `screenshots?|figures?|tables?`; `disclos` `disclos\w*|AI-use|AI use|AI contribution`; `budget` `budgets?|costs?|USD|\$`; `license` `licen[cs]e[sd]?|licensing`; `seed` `seeds?|seeded`. **Caveat:** these are mention counts, not judgements. The `budget` family is inflated where "cost" is a research object (WP20: the *cost approach* to appraisal, 42 hits; WP24: adjustment *costs*); the `gate` family also catches "criteria" used in "inclusion criteria" (WP21). The analyst variables, not these counts, carry the substantive coding. |
++
++## 5. Analyst variables (`corpus_coding.csv`)
++
++Allowed values for every yes/no-type variable are **`yes` / `partial` / `no`** (plus `n/a` for the duplicate row). `partial` means the mandate addresses the feature but only indirectly, conditionally, or without an operational mechanism (e.g. it *requires* that assumptions be stated but does not state them). Each value is followed, in the same cell, by a supporting verbatim quote `"…"` or by an analyst remark outside quotes.
++
++| Variable | Type | Definition and allowed values |
++|---|---|---|
++| `wp` | V | WP15 … WP28; `WP27_BRIEF` for the design brief; `WP15_PROMPT` for the duplicate row |
++| `file` | V | corpus file name |
++| `document_type` | I | `claude_md` (an instruction file addressed to Claude Code); `design_brief` (WP27, an internal description of the simulator, not a mandate); `duplicate` |
++| `source_url`, `retrieved_utc`, `sha256` | V | copied from `corpus_manifest.csv` |
++| `research_domain` | I | free label: real estate economics; finance / market microstructure; macro-finance theory; econometric theory / statistical computing; applied econometrics (meta-analysis); etc. |
++| `research_type` | I | `empirical`, `theoretical`, `simulation`, `design-science`, or `mixed (…)` with the components in parentheses |
++| `explicit_question` | V | the research question verbatim (≤ 40 words; the first RQ when several are listed), or `none` when the document states objectives but no question |
++| `explicit_estimand_or_hypotheses` | I + V | `yes` = named estimand(s) / hypotheses / theorems to prove, or a pre-specified primary outcome; `partial` = research questions or candidate contributions treated "as hypotheses" without formal statements; `no` |
++| `stated_assumptions` | I + V | `yes` = the mandate itself states substantive model/identification assumptions or requires a numbered assumptions register; `partial` = requires that assumptions be stated with each result but does not state them; `no` |
++| `falsification_or_null_result_conditions` | I + V | `yes` = explicit instruction to attempt disproof, required counterexamples/placebos, or a declared acceptable null outcome; `partial` = failures/negative results must be reported but no disproof condition is defined; `no` |
++| `literature_or_novelty_requirement` | I + V | `yes` = verified literature review and/or novelty gate required before claiming a contribution; `no` |
++| `data_access_controls` | I + V | `yes` = explicit rules on credentials, secrets, scraping, licensing, privacy or permission; `partial` = only generic "do not pretend access / log unavailable files"; `no` |
++| `temporal_information_controls` | I + V | `yes` = look-ahead / as-of-date / point-in-time / vintage / chronological-split rules; `partial` = vintage awareness without a leakage rule; `no` (including not applicable) |
++| `baseline_requirement` | I + V | `yes` = named comparison baselines/benchmark methods; `partial` = a "baseline scenario" or benchmark model, not comparison methods; `no` |
++| `n_phases_declared` | I | integer count of execution phases/stages the document declares, or `none`; the labelling scheme is noted in parentheses |
++| `dependency_or_gate_structure` | I + V | `explicit` = named gates or "do not start X until Y" conditions; `implicit` = ordering only; `none` |
++| `stopping_rules` | I + V | `yes` = conditions under which work must stop / a verdict be issued; `partial` = escalation or fallback rules only ("if blocked, document and deliver partial result"); `no` |
++| `recovery_or_resume_instructions` | I + V | `yes` = resumable/idempotent/checkpointed execution required; `partial` = phase logs, caching or retry limits that enable resumption only indirectly; `no` |
++| `artifact_requirements` | V (list) | semicolon-separated list of required deliverables (paper, tables, figures, code, data, README, logs, audits …) |
++| `provenance_requirements` | I + V | `yes` = hashes/manifests/pinned revisions/traceable number-to-file mapping/versioned outputs; `partial` = "every number must map to a result file" or logs without hashes/manifests; `no` |
++| `review_or_self_audit_stage` | I + V | `yes` = a dedicated audit/referee/validation stage; `partial` = audit items inside a final checklist only; `no` |
++| `disclosure_or_AI_use_statement` | I + V | `yes` = an AI-use / authorship-disclosure instruction; `no` (statements about prose style, e.g. "not AI-generated prose", are **not** disclosure) |
++| `budget_or_resource_limits` | I + V | `yes` = an explicit budget (API cost tiers, token budgets) or numeric resource cap; `partial` = resource estimation/profiling or "within available resources" without a cap; `no` |
++| `integrity_prohibitions` | I + V | `yes` = explicit "never invent / fabricate …" prohibitions; `no` |
++| `contradictory_or_non_operational_requirements` | I | free text listing instructions that cannot be verified from the document's own criteria, or that conflict with another instruction; `none found` otherwise |
++| `statements_added_during_implementation` | V | passages that the document itself marks as added later or reconstructed (headers such as "added 2026-10-27", bracketed reconstruction notes, prefatory mapping notes dated after the programme); `none identified` otherwise |
++| `analyst_notes` | I | anything else relevant |
++
++## 6. Procedure
++
++1. Compute hashes and automated variables (`python3 -I research/code_corpus.py`); confirm every hash equals the manifest (`sha256_matches_manifest = yes` for all 13 files) and identify duplicates.
++2. Read each distinct document in full (the two long documents, WP15 at 2 165 lines and WP28 at 1 055 lines, were read in consecutive line ranges).
++3. For each analyst variable, locate the supporting passage, copy it verbatim, then assign the value. Where no passage exists, assign `no`/`none` without quote.
++4. Write `corpus_coding.csv` with Python's `csv` module (`QUOTE_ALL`), re-read it with the same module and check the row count (13) and column count.
++5. Tabulate counts over the 11 mandates only (brief and duplicate excluded) for `corpus_summary.md`.
++
++## 7. Known weaknesses of this coding
++
++- Single coder; no reliability statistics (see §1).
++- Keyword counts are crude (see the `budget`/`gate` caveats in §4) and are reported only as descriptive context.
++- The `partial` category absorbs heterogeneous cases; the quotes allow a reader to re-cut the categories.
++- The design brief (WP27) is a different genre; its row is kept separate and excluded from all "of 11" counts.

added research/corpus_summary.md +86 −0

++# WP29 — Descriptive summary of the mandate corpus
++
++Coding date 2026-10-29. Inputs: `research/corpus/` (13 files, hashes verified against `corpus_manifest.csv`), `research/corpus_automated.csv` (script), `research/corpus_coding.csv` (analyst). Codebook: `research/corpus_coding_protocol.md`.
++
++**Denominator.** Eleven distinct CLAUDE.md mandates (WP15, WP18–WP26, WP28). `WP15_PROMPT_PROMPT_INITIAL_CLAUDE.md` is byte-identical to `WP15_CLAUDE.md` (same SHA-256) and is counted once. The WP27 design brief is a different genre (a post-implementation description of a simulator, not an instruction file) and is excluded from every "of 11" count; WP27's CLAUDE.md was not retrievable (HTTP 404) and nothing is inferred about it. Coding was a single automated + LLM-analyst pass with no human second coder; no intercoder reliability is claimed. The corpus is small and researcher-selected: the counts motivate design patterns for WP29 and do not estimate prevalence.
++
++**Important limit.** These documents are instructions. They say what the author asked Claude Code to do. They do **not** establish how the earlier working papers were actually executed, whether the instructions were followed, or whether the papers were produced without human assistance (several mandates in fact anticipate human steps: expert raters, human review of ambiguous studies, credential provision, confirmation of funding lines).
++
++## 1. Length and form
++
++| Statistic (11 mandates) | Value |
++|---|---|
++| Words — min / median / max / mean | 1 092 (WP19) / 1 966 (WP22) / 8 809 (WP28) / 2 879 |
++| Sorted word counts | 1 092, 1 114, 1 132, 1 358, 1 671, 1 966, 2 240, 2 285, 2 314, 7 685, 8 809 |
++| Markdown headings — min / median / max | 1 (WP21) / 19 (WP25, WP26) / 151 (WP15) |
++| Code blocks | 0 in six mandates; 1 in WP18, WP20, WP25; 12 in WP15; 27 in WP28 |
++| Markdown tables | 0 except WP28 (2) |
++| Language | English body in all; WP18 and WP20 carry a French prefatory paragraph (heuristic label `mixed`) |
++
++Two mandates (WP15, WP28) are an order of magnitude longer than the other nine, which cluster between 1 100 and 2 300 words. Length tracks the amount of engineering prescription (directory trees, manifests, CLI commands, rubrics), not the number of substantive research rules.
++
++## 2. Feature counts
++
++Values are the analyst codes from `corpus_coding.csv` (first token of each cell). "partial" is defined in the codebook as present but indirect, conditional or without an operational mechanism.
++
++| Feature | yes | partial | no | Note |
++|---|---|---|---|---|
++| Explicit research question (verbatim) | 10 of 11 | — | 1 (WP22 states objectives, not a question) | |
++| Explicit estimand or hypotheses | 7 | 4 | 0 | H1–H6 lists (WP25), theorem queues (WP24, WP28), pre-specified primary outcome (WP26), core-estimand section (WP22) |
++| Assumptions stated in the mandate | 2 (WP24, WP28) | 8 | 1 (WP23) | most mandates *require* assumptions to accompany every result without stating them |
++| Falsification / null-result conditions | 6 | 4 | 1 (WP21) | "attempt to disprove its own central claim" (WP15); "A negative finding is publishable" (WP26) |
++| Literature / novelty requirement | 11 | 0 | 0 | universal; usually a "novelty gate" plus a verified literature matrix |
++| Data-access controls | 7 | 4 | 0 | credentials, scraping, privacy, licensing rules; `partial` = theory papers with only "do not pretend access" |
++| Temporal-information controls | 6 | 1 | 4 | universal among the data-based mandates (WP15, WP20, WP22, WP23, WP25, WP26); not applicable to the pure-theory ones |
++| Baseline / benchmark requirement | 8 | 3 | 0 | `partial` = baseline scenario or benchmark model rather than comparison methods |
++| Phases declared | 10 of 11 | — | 1 (WP23) | 5 to 13 phases; median 7 |
++| Dependency / gate structure | 10 explicit | 1 implicit (WP21) | 0 none | but only 2 (WP15, WP28) tie a gate to an executable test |
++| Stopping rules | 2 (WP15, WP28) | 6 | 3 | `partial` = "if blocked, document and deliver a partial result" |
++| Recovery / resume instructions | 2 (WP15, WP25) | 6 | 3 | `partial` = progress logs, caching, retry limits |
++| Provenance requirements | 9 | 2 | 0 | manifests with hashes in WP15, WP28; prompt/model/seed logging in WP25, WP26 |
++| Review / self-audit stage | 10 | 1 (WP23) | 0 | results audits, adversarial referee reports (WP24, WP28), red-team agent (WP26) |
++| AI-use / disclosure statement | 1 (WP28) | 0 | 10 | |
++| Budget / resource limits | 1 (WP26) | 3 | 7 | WP26 asks for API-cost tiers; others estimate or profile without a cap |
++| Integrity prohibitions ("never invent …") | 11 | 0 | 0 | universal, usually in the opening paragraph |
++| Pre-registration mentioned (automated keyword) | 4 (WP19, WP21, WP25, WP26) | — | 7 | none specifies a registry or timestamp mechanism |
++| Random seeds mentioned (automated keyword) | 11 | — | 0 | |
++| Statements marked as added/reconstructed | 6 | — | 5 | explicit "added" sections in WP24, WP26; reconstruction notes in WP23; prefatory repository-mapping notes in WP18, WP20, WP25 |
++
++## 3. Recurring design patterns (what the mandates consistently require)
++
++1. **Role framing + integrity preamble.** Every mandate opens by casting Claude Code as a multidisciplinary "research team" and immediately prohibits fabrication of data, results, citations, proofs or significance (11 of 11). The prohibition is the single most stable element of the corpus.
++2. **Ordered phases ending in "only then write the paper".** Ten of eleven declare 5–13 phases; nine make manuscript drafting conditional on validated results ("Never write a result in the paper before it has been generated and verified from a saved machine-readable output", WP15). Gates are named in ten mandates, most explicitly as numbered acceptance gates (WP20: Gates 1–7; WP25: six named gates; WP28: Gates 0–12).
++3. **Verified-literature / novelty gate before contribution claims** (11 of 11), typically with a literature matrix file and a "do not call it novel unless …" clause.
++4. **Audit and self-review as a phase** (10 of 11): a results audit mapping every claim to a file (WP18, WP19), an adversarial referee report (WP24), three simulated referees with a verdict vocabulary (WP28), or a red-team agent inside the architecture (WP26).
++5. **Traceability of every number** (9 of 11 "yes"): "Every paper number must map to a result file" (WP18), results registries feeding LaTeX macros (WP15), run manifests with hashes (WP28), versioned outputs (WP26).
++6. **Information-set discipline wherever data exist** (6 of 6 data-based mandates): look-ahead, as-of-date, vintage and chronological-split rules.
++7. **Named baselines** (8 of 11), from "random walk, no change" (WP23) to cost-matched single-agent controls (WP26).
++8. **Honest-failure fallbacks**: "If blocked, document the issue honestly and deliver a scoped partial result" (WP18); "A dead end with a mathematical explanation is better than a fabricated breakthrough" (WP28).
++
++## 4. What the mandates consistently lack
++
++1. **Externally enforced or executable gates.** Gates are declarative. Only WP15 ("The release script must fail if …") and WP28 ("completing one phase's acceptance tests before starting the next") attach a gate to something that can fail mechanically; none specifies who or what checks a gate other than the executing agent itself.
++2. **Independent verification.** "Independent audit" (WP19), "independently checked" (WP20), "independently verified" (WP21), "hostile-referee critique" (WP25) and "three independent review perspectives" (WP28) are all to be performed by the same agent; WP28 is the only mandate that names this tension ("do not have the same model merely declare its own work accepted").
++3. **Operational pre-registration.** Four mandates ask for pre-registration; none specifies a registry, a timestamp, a hash or a freeze mechanism that would make it verifiable.
++4. **Stopping rules.** Only WP15 (a dedicated "Stop conditions" section) and WP28 (stop only on a real blocker; mandatory final verdict) define when to stop; most others say "continue with feasible work".
++5. **Recovery / resumption.** Only WP15 (resumable, idempotent, checkpointed jobs) and WP25 (checkpointing, manifests) require it; the rest rely on progress logs.
++6. **Budgets.** Seven of eleven set no resource limit; only WP26 asks for an API-cost budget, and no mandate states a numeric token, dollar or compute cap.
++7. **AI-use disclosure.** Ten of eleven say nothing about disclosing AI involvement in the paper; WP28 is the exception because it inherits a prior "GPT-6.1" co-author credit that it must reconcile with journal policy.
++8. **Quantified success criteria.** Targets are phrased as "substantially improve" (WP23), "publication-quality", "publishable contribution", "the standard expected in a top finance journal" (WP15) — none is checkable from the document. Page, figure, table and reference counts are given as ranges with anti-padding escape clauses (WP18, WP19, WP20, WP24, WP28).
++9. **Authorial provenance of the instruction itself.** WP23 states that part of its text was reconstructed by an assistant after truncation; WP24 and WP26 carry sections "added" on 2026-10-27; WP18, WP20 and WP25 carry prefatory repository-mapping notes. The mandate as retrieved is therefore not always the mandate as originally issued.
++
++## 5. Verbatim excerpts illustrating the patterns
++
++1. Integrity preamble — WP15_CLAUDE.md: "Never fabricate data, results, citations, institutional details, variable definitions, statistical significance, sample sizes, or conclusions. Never write a result in the paper before it has been generated and verified from a saved machine-readable output."
++2. Phase gate before drafting — WP18_CLAUDE.md: "**Gate:** do not start manuscript drafting until the baseline model is validated, claimed GE equilibria clear markets, principal simulations and exhibits reproduce, bibliography is verified, and theoretical claims have proofs or appropriate qualifications. If blocked, document the issue honestly and deliver a scoped partial result."
++3. Executable release gate — WP15_CLAUDE.md: "The release script must fail if: a table references a missing result; a figure is missing source data; LaTeX does not compile; citations are unresolved; labels are duplicated; page count exceeds the current target; anonymous PDF contains author-identifying text; manuscript claims disagree with the results registry; data revision is not pinned; tests fail."
++4. Novelty gate — WP28_CLAUDE.md: "Do not claim that distributed gradients, one-step Newton, split-sample jackknife, Richardson extrapolation, `K = o(N^{7/8})`, or `K = o(N^{11/12})` are intrinsically novel. Investigate who has already obtained each idea or bound." and "**Gate 1:** no unqualified novelty language is allowed until the closest competing theorems have been inspected and cited."
++5. Temporal-information control — WP22_CLAUDE.md: "Never use post-transaction information or future data in real-time estimates." / WP26_CLAUDE.md: "Comparable retrieval must be strictly as-of-date; no same-property future transfers, post-sale listings, or near-duplicate records leaking across partitions."
++6. Pre-specified primary outcome — WP26_CLAUDE.md: "Pre-register primary endpoints and hypotheses before running final test evaluations. Primary outcome: out-of-time absolute log-price error on arm's-length residential transactions."
++7. Falsification and null results — WP15_CLAUDE.md: "The project must attempt to disprove its own central claim." / WP28_CLAUDE.md: "A dead end with a mathematical explanation is better than a fabricated breakthrough. A strong negative result or counterexample may itself become the contribution."
++8. Self-review by the same model, acknowledged — WP28_CLAUDE.md: "Simulate at least three independent review perspectives; log objections and responses … Record unresolved issues candidly; do not have the same model merely declare its own work accepted."
++9. Instruction provenance — WP23_CLAUDE.md: "[Sections 11–15 and the remainder of the protocol were reconstructed by the author's assistant because the pasted protocol was truncated.]" / WP26_CLAUDE.md: "## Repository conventions (added by the implementation, 2026-10-27)".
++
++## 6. Implications for the WP29 protocol design (motivation only)
++
++The corpus shows a stable *rhetorical* protocol — role, integrity rules, phases, gates, audits, traceability — and an equally stable absence of *mechanisms*: gates are not executable, audits are not independent, pre-registration is not timestamped, budgets and stopping rules are rare, and the instruction text itself is sometimes amended after the fact. WP29's protocol should therefore turn the recurring declarative elements into verifiable ones (hashed and frozen mandates, machine-checked gates, external evaluators, explicit budgets and stop conditions, recorded human interventions) rather than add more prose rules. Nothing in this corpus demonstrates that the earlier papers were produced without human assistance; that question requires run-level evidence, not instruction files.

added research/literature_matrix.csv +87 −0

++ref_key,stream,authors_short,year,title,venue,venue_type,doi_or_arxiv,verification_source,verified_utc,relevance_to_wp29,key_claim_or_finding,peer_reviewed
++lu2024aiscientist,1,Lu et al.,2024,The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery,arXiv preprint,preprint,arXiv:2408.06292,https://export.arxiv.org/api/query?id_list=2408.06292,2026-10-30T03:12:38Z,Reference end-to-end autonomous research system (idea to paper plus simulated review) against which WP29's protocol-guided design is positioned.,"Introduces The AI Scientist, which generates research ideas, writes code, executes experiments, visualizes results, writes a full paper and runs a simulated review, with each paper developed at a cost of less than $15 and an automated reviewer reported to achieve near-human performance on paper scores.",no
++lu2026aiscientist,1,Lu et al.,2026,Towards end-to-end automation of AI research,Nature,journal,doi:10.1038/s41586-026-10265-5,https://api.crossref.org/works/10.1038/s41586-026-10265-5 ; doi.org HEAD None,2026-10-30T03:18:58Z,"Peer-reviewed (Nature, 2026) publication of The AI Scientist line of work, establishing that fully automated ML research pipelines are now part of the refereed literature.",n/a (Nature abstract not retrieved behind the publisher login; see lu2024aiscientist for the system description).,yes
++yamada2025aiscientistv2,1,Yamada et al.,2025,The AI Scientist-v2: Workshop-Level Automated Scientific Discovery via Agentic Tree Search,arXiv preprint,preprint,arXiv:2504.08066,https://export.arxiv.org/api/query?id_list=2504.08066,2026-10-30T03:12:39Z,Closest fully autonomous end-to-end system; its tree-search workflow and in-system AI reviewer are the counterpoint to WP29's executable gates and separated review.,"Describes an end-to-end agentic system with progressive agentic tree search managed by an experiment-manager agent and a VLM feedback loop for figures; of three fully autonomous manuscripts submitted to an ICLR workshop, one scored above the average human acceptance threshold.",no
++schmidgall2025agentlab,1,Schmidgall et al.,2025,Agent Laboratory: Using LLM Agents as Research Assistants,Findings of the Association for Computational Linguistics: EMNLP 2025,conference,doi:10.18653/v1/2025.findings-emnlp.320,https://api.crossref.org/works/10.18653/v1/2025.findings-emnlp.320 ; doi.org HEAD None ; https://export.arxiv.org/api/query?id_list=2501.04227,2026-10-30T03:18:58Z,"Staged (literature review, experimentation, report writing) autonomous research framework with optional human feedback; provides the human-in-the-loop and cost comparisons WP29 builds on.","Agent Laboratory takes a human-provided idea through literature review, experimentation and report writing; the authors report that o1-preview gives the best outcomes, that human feedback at each stage significantly improves research quality, and an 84% decrease in research expenses relative to previous autonomous research methods.",yes
++boiko2023coscientist,1,Boiko et al.,2023,Autonomous chemical research with large language models,Nature,journal,doi:10.1038/s41586-023-06792-0,https://api.crossref.org/works/10.1038/s41586-023-06792-0 ; doi.org HEAD 302,2026-10-30T03:12:40Z,Landmark peer-reviewed demonstration of an LLM agent planning and executing laboratory experiments; defines the 'autonomous research' baseline WP29 compares to.,"Coscientist, driven by GPT-4 with internet/documentation search, code execution and experimental automation tools, autonomously designs, plans and performs experiments across six tasks, including successful reaction optimization of palladium-catalysed cross-couplings.",yes
++bran2024chemcrow,1,M. Bran et al.,2024,Augmenting large language models with chemistry tools,Nature Machine Intelligence,journal,doi:10.1038/s42256-024-00832-8,https://api.crossref.org/works/10.1038/s42256-024-00832-8 ; doi.org HEAD 302,2026-10-30T03:15:06Z,"Tool-augmented LLM research agent whose evaluation combined LLM and expert assessment, an early instance of the evaluator-validity question WP29 addresses with protected oracles.","ChemCrow integrates 18 expert-designed tools with GPT-4, autonomously planned and executed syntheses of an insect repellent and three organocatalysts, and was evaluated with both LLM and expert assessments.",yes
++ifargan2025datatopaper,1,Ifargan et al.,2025,Autonomous LLM-Driven Research — from Data to Human-Verifiable Research Papers,NEJM AI,journal,doi:10.1056/AIoa2400555,https://api.crossref.org/works/10.1056/AIoa2400555 ; doi.org HEAD 302 ; https://export.arxiv.org/api/query?id_list=2404.17605,2026-10-30T03:13:47Z,"Closest prior work on traceability: an autonomous data-to-paper platform that programmatically backtraces information flow for human verification, akin to WP29's persistent evidence records.","data-to-paper guides interacting LLM agents through a stepwise research process from annotated data to papers while programmatically backtracing information flow and allowing human oversight, and can run fully autonomously ('autopilot') or with human intervention.",yes
++gottweis2026coscientist,1,Gottweis et al.,2026,Accelerating scientific discovery with Co-Scientist,Nature,journal,doi:10.1038/s41586-026-10644-y,https://api.crossref.org/works/10.1038/s41586-026-10644-y ; doi.org HEAD 302 ; https://export.arxiv.org/api/query?id_list=2502.18864,2026-10-30T03:13:46Z,Multi-agent hypothesis-generation system with generate/critique/refine loops; illustrates in-system self-critique rather than independent verification.,"Co-Scientist is a Gemini-based multi-agent system that continuously generates, critiques and refines research hypotheses using an asynchronous task framework and a tournament evolution process, scaled by test-time compute, to propose demonstrably novel hypotheses for experimental verification.",yes
++swanson2025virtuallab,1,Swanson et al.,2025,The Virtual Lab of AI agents designs new SARS-CoV-2 nanobodies,Nature,journal,doi:10.1038/s41586-025-09442-9,https://api.crossref.org/works/10.1038/s41586-025-09442-9 ; doi.org HEAD 302,2026-10-30T03:12:48Z,AI-human research collaboration with an LLM principal-investigator agent and human oversight; a human-involvement design point for the novelty matrix.,"The Virtual Lab is an AI-human research collaboration in which an LLM Principal Investigator agent guides a team of LLM scientist agents to perform interdisciplinary research, applied to designing SARS-CoV-2 nanobodies.",yes
++mitchener2025kosmos,1,Mitchener et al.,2025,Kosmos: An AI Scientist for Autonomous Discovery,arXiv preprint,preprint,arXiv:2511.02824,https://export.arxiv.org/api/query?id_list=2511.02824,2026-10-30T03:12:57Z,"Recent long-horizon AI scientist (up to 12 h, 200 rollouts); documents the coherence/verification challenges of long autonomous runs that WP29's gates target.","Kosmos runs for up to 12 hours performing cycles of parallel data analysis, literature search and hypothesis generation, using a structured world model shared between agents to pursue an objective coherently over 200 agent rollouts before synthesizing reports.",no
++luo2025pitfalls,1,Luo et al.,2025,"The More You Automate, the Less You See: Hidden Pitfalls of AI Scientist Systems",arXiv preprint,preprint,arXiv:2509.08713,https://export.arxiv.org/api/query?id_list=2509.08713,2026-10-30T03:16:07Z,"Directly motivates WP29: shows AI scientist systems commit benchmark selection, leakage, metric-misuse and post-hoc selection errors that only traces reveal.","Identifies four failure modes in AI scientist systems (inappropriate benchmark selection, data leakage, metric misuse and post-hoc selection bias) and, via controlled experiments on two open-source systems, finds several of them present.",no
++beel2025sakana,1,Beel et al.,2025,"Evaluating Sakana's AI Scientist: Bold Claims, Mixed Results, and a Promising Future?",ACM SIGIR Forum,journal,doi:10.1145/3769733.3769747,https://api.crossref.org/works/10.1145/3769733.3769747 ; doi.org HEAD None ; https://export.arxiv.org/api/query?id_list=2502.14297,2026-10-30T03:18:59Z,Independent third-party evaluation of The AI Scientist; evidence that unverified autonomous outputs contain novelty and execution errors.,"An independent evaluation of the AI Scientist found several critical shortcomings, including a literature review based on simplistic keyword searches that led to poor novelty assessments, with several generated ideas incorrectly classified as novel.",unknown
++luo2026xscientist,1,Luo,2026,XScientist: A Git-Like Research Protocol for Long-Running Autonomous Scientific Discovery,arXiv preprint,preprint,arXiv:2607.12301,https://export.arxiv.org/api/query?id_list=2607.12301,2026-10-30T03:13:42Z,"Closest 2026 design to a research protocol: git-like typed research state with checkpoints, claim-evidence closure and gates; differs from WP29 in being a protocol artifact rather than a controlled comparison of protocol arms.","Proposes a local-first, git-like protocol that treats research state rather than a manuscript as the unit of continuation, representing hypotheses, attempts, claims, reviews and handoffs as typed content-addressed objects with immutable checkpoints, claim-evidence closure and authority-aware gates, without treating a passing integrity check as scientific truth.",no
++ding2026verificationgap,1,Ding et al.,2026,Autonomous Research Agents: A Survey of AI Scientists and the Verification Gap,arXiv preprint,preprint,arXiv:2608.05179,https://export.arxiv.org/api/query?id_list=2608.05179,2026-10-30T03:13:43Z,"Survey that names the 'verification gap' in AI scientist systems; supplies the audit dimensions (evaluation method, artifacts, human-in-the-loop points, result-selection disclosure) WP29 reports.","Screens 125 works and codes 26 (24 runnable systems) on seven audit dimensions, finding that code release is now common but reproducibility-grade and claim-verification artifacts remain rare.",no
++chen2025scienceagentbench,2,Chen et al.,2024,ScienceAgentBench: Toward Rigorous Assessment of Language Agents for Data-Driven Scientific Discovery,ICLR 2025,conference,arXiv:2410.05080,"https://export.arxiv.org/api/query?id_list=2410.05080 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2410.05080 (venue='arXiv.org', type=None) ; https://api2.openreview.net/notes/search?term=ScienceAgentBench (ICLR 2025 Poster record)",2026-10-30T03:13:01Z,"Benchmark of expert-validated data-driven discovery tasks with program-level outputs, execution metrics and cost; the task style and contamination mitigations inform WP29's task bank.","Presents 102 tasks extracted from 44 publications in four disciplines and validated by nine experts; the best agent solves 32.4% of tasks independently (34.3% with expert knowledge), o1-preview reaches 42.2% at more than 10 times the cost, and two data-contamination mitigation strategies are proposed.",yes
++majumder2025discoverybench,2,Majumder et al.,2024,DiscoveryBench: Towards Data-Driven Discovery with Large Language Models,ICLR 2025,conference,arXiv:2407.01725,"https://export.arxiv.org/api/query?id_list=2407.01725 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2407.01725 (venue='International Conference on Learning Representations', type='conference') ; https://api2.openreview.net/notes/search?term=DiscoveryBench (ICLR 2025 Poster record)",2026-10-30T03:15:06Z,"Formalizes multi-step data-driven discovery as dataset + metadata + goal, the same unit of analysis as WP29's research tasks.","DiscoveryBench formalizes the multi-step process of data-driven discovery with 264 tasks across six domains derived from published papers plus 903 synthetic tasks, each defined by a dataset, its metadata and a natural-language discovery goal.",yes
++jing2025dsbench,2,Jing et al.,2024,DSBench: How Far Are Data Science Agents from Becoming Data Science Experts?,ICLR 2025,conference,arXiv:2409.07703,"https://export.arxiv.org/api/query?id_list=2409.07703 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2409.07703 (venue='', type=None) ; https://api2.openreview.net/notes/search?term=DSBench (ICLR 2025 Poster record)",2026-10-30T03:13:02Z,"Realistic data-science agent benchmark (long contexts, large data) used to characterize executor capability independent of protocol.","DSBench comprises 466 data-analysis and 74 data-modeling tasks sourced from Eloquence and Kaggle competitions, with long contexts, multimodal task backgrounds and reasoning over large data files.",yes
++huang2024mlagentbench,2,Huang et al.,2023,MLAgentBench: Evaluating Language Agents on Machine Learning Experimentation,ICML 2024,conference,arXiv:2310.03302,"https://export.arxiv.org/api/query?id_list=2310.03302 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2310.03302 (venue='International Conference on Machine Learning', type='conference')",2026-10-30T03:13:03Z,Evaluates agents on ML experimentation loops with file/code actions; a precursor of WP29's executor arms.,"MLAgentBench is a suite of 13 ML experimentation tasks (from CIFAR-10 improvement to BabyLM) in which a ReAct-based agent can read/write files, execute code and inspect outputs; a Claude 3 Opus agent had the best success rate.",yes
++gu2024blade,2,Gu et al.,2024,BLADE: Benchmarking Language Model Agents for Data-Driven Science,EMNLP 2024,conference,arXiv:2408.09667,"https://export.arxiv.org/api/query?id_list=2408.09667 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2408.09667 (venue='Conference on Empirical Methods in Natural Language Processing', type='conference')",2026-10-30T03:13:05Z,"Evaluates analysis decisions (variables, transformations, models) against independent expert analyses, the multi-path ground truth WP29's oracles must handle.","BLADE evaluates agents' multifaceted approaches to open-ended research questions using 12 datasets and questions from the literature, with ground truth collected from independent analyses by expert data scientists.",yes
++jimenez2024swebench,2,Jimenez et al.,2023,SWE-bench: Can Language Models Resolve Real-World GitHub Issues?,ICLR 2024,conference,arXiv:2310.06770,"https://export.arxiv.org/api/query?id_list=2310.06770 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2310.06770 (venue='International Conference on Learning Representations', type='conference')",2026-10-30T03:13:08Z,Canonical execution-verified coding benchmark; its test-based grading is the model for WP29's executable verification gates.,"SWE-bench consists of 2,294 software-engineering problems drawn from real GitHub issues and pull requests across 12 Python repositories, where resolving an issue frequently requires coordinating changes across multiple functions, classes and files.",yes
++chan2025mlebench,2,Chan et al.,2024,MLE-bench: Evaluating Machine Learning Agents on Machine Learning Engineering,ICLR 2025,conference,arXiv:2410.07095,"https://export.arxiv.org/api/query?id_list=2410.07095 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2410.07095 (venue='arXiv.org', type=None) ; https://proceedings.iclr.cc/paper_files/paper/2025/hash/7e3767db483c942b883eb4f8cfb74e31-Abstract-Conference.html",2026-10-30T03:13:09Z,"Agentic ML-engineering benchmark with human baselines, resource-scaling and contamination analyses that WP29's resource accounting parallels.","MLE-bench curates 75 Kaggle competitions with human leaderboard baselines; the best setup (o1-preview with AIDE scaffolding) reaches at least bronze-medal level in 16.9% of competitions, and the paper also studies resource scaling and pre-training contamination.",yes
++siegel2024corebench,2,Siegel et al.,2024,CORE-Bench: Fostering the Credibility of Published Research Through a Computational Reproducibility Agent Benchmark,Transactions on Machine Learning Research,journal,arXiv:2409.11363,https://export.arxiv.org/api/query?id_list=2409.11363 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2409.11363 (venue='Trans. Mach. Learn. Res.'),2026-10-30T03:13:10Z,"Benchmarks agents on computational reproducibility of published papers, linking agent evaluation to the reproducibility stream.","CORE-Bench contains 270 tasks based on 90 scientific papers across computer science, social science and medicine, measuring agents' accuracy at reproducing published results from provided code and data at three difficulty levels.",yes
++starace2025paperbench,2,Starace et al.,2025,PaperBench: Evaluating AI's Ability to Replicate AI Research,ICML 2025,conference,arXiv:2504.01848,"https://export.arxiv.org/api/query?id_list=2504.01848 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2504.01848 (venue='International Conference on Machine Learning', type='conference')",2026-10-30T03:13:11Z,Rubric-decomposed replication grading with a validated LLM judge; closest precedent for WP29's rubric oracles and judge validation.,"PaperBench asks agents to replicate 20 ICML 2024 papers from scratch, graded against 8,316 rubric items co-developed with the papers' authors, with an LLM-based judge whose performance is assessed on a separate judge benchmark.",yes
++koster2012snakemake,3,Köster & Rahmann,2012,Snakemake—a scalable bioinformatics workflow engine,Bioinformatics,journal,doi:10.1093/bioinformatics/bts480,https://api.crossref.org/works/10.1093/bioinformatics/bts480 ; doi.org HEAD 302,2026-10-30T03:13:47Z,"Rule-based workflow engine; WP29's protocol stages are an analogue of declarative, re-executable workflow rules.",Snakemake provides a readable Python-based workflow definition language and an execution environment that scales from single-core workstations to compute clusters without modifying the workflow.,yes
++ditommaso2017nextflow,3,Di Tommaso et al.,2017,Nextflow enables reproducible computational workflows,Nature Biotechnology,journal,doi:10.1038/nbt.3820,https://api.crossref.org/works/10.1038/nbt.3820 ; doi.org HEAD 302,2026-10-30T03:13:48Z,Container-based dataflow workflow manager for reproducible pipelines; reference for execution isolation in WP29's executors.,Argues that combining dataflow programming with software containers (Nextflow) yields computational workflows that are reproducible across platforms.,yes
++missier2013prov,3,Missier et al.,2013,The W3C PROV family of specifications for modelling provenance metadata,Proceedings of the 16th International Conference on Extending Database Technology,conference,doi:10.1145/2452376.2452478,https://api.crossref.org/works/10.1145/2452376.2452478 ; doi.org HEAD 302,2026-10-30T03:13:49Z,"W3C PROV family defines the provenance vocabulary (entities, activities, agents) that WP29's evidence records instantiate.","Overview of the W3C PROV family of specifications (data model, ontology, notation and constraints) for interoperable representation and exchange of provenance metadata.",yes
++chirigati2016reprozip,3,Chirigati et al.,2016,ReproZip,Proceedings of the 2016 International Conference on Management of Data,conference,doi:10.1145/2882903.2899401,https://api.crossref.org/works/10.1145/2882903.2899401 ; doi.org HEAD 302,2026-10-30T03:13:49Z,Automatic capture of execution provenance into re-executable packages; a model for evidence capture without relying on the agent's self-report.,"ReproZip automatically captures the provenance of a command-line experiment (files, libraries, environment) and packages it so that it can be re-executed elsewhere.",yes
++sandve2013tensimplerules,3,Sandve et al.,2013,Ten Simple Rules for Reproducible Computational Research,PLoS Computational Biology,journal,doi:10.1371/journal.pcbi.1003285,https://api.crossref.org/works/10.1371/journal.pcbi.1003285 ; doi.org HEAD 302,2026-10-30T03:13:50Z,"Widely cited rules (track provenance, avoid manual steps, record versions and seeds) that WP29 operationalizes as machine-checked gates.","Proposes ten rules for reproducible computational research, including tracking how every result was produced, avoiding manual data manipulation, archiving exact program versions and random seeds, and providing public access to scripts, runs and results.",yes
++stodden2018journalpolicy,3,Stodden et al.,2018,An empirical analysis of journal policy effectiveness for computational reproducibility,Proceedings of the National Academy of Sciences,journal,doi:10.1073/pnas.1708290115,https://api.crossref.org/works/10.1073/pnas.1708290115 ; doi.org HEAD 302,2026-10-30T03:13:50Z,Empirical reproducibility failure rates under policy-only enforcement; motivates executable rather than declarative verification.,"In a random sample of 204 Science papers subject to a data/code-on-request policy, the authors obtained artifacts from 44% of papers and could reproduce the findings for 26%.",yes
++peng2011reproducible,3,Peng,2011,Reproducible Research in Computational Science,Science,journal,doi:10.1126/science.1213847,https://api.crossref.org/works/10.1126/science.1213847 ; doi.org HEAD 302,2026-10-30T03:13:51Z,"Defines reproducibility (data + code available) as the minimum standard for computational claims, the standard WP29's evidence records target.",Reproducibility has the potential to serve as a minimum standard for judging scientific claims when full independent replication of a study is not possible.,yes
++nasem2019reproducibility,3,"National Academies of Sciences, Engineering, and Medicine",2019,Reproducibility and Replicability in Science,National Academies Press,report,doi:10.17226/25303,https://api.crossref.org/works/10.17226/25303 ; doi.org HEAD 302,2026-10-30T03:13:51Z,Authoritative definitions of reproducibility vs replicability used in WP29's outcome definitions.,"Defines reproducibility as obtaining consistent computational results using the same input data, computational steps, methods, code and conditions of analysis, and replicability as obtaining consistent results across studies aimed at the same question with new data.",unknown
++krafczyk2021reproduction,3,Krafczyk et al.,2021,Learning from reproducing computational results: introducing three principles and the <i>Reproduction Package</i>,"Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences",journal,doi:10.1098/rsta.2020.0069,https://api.crossref.org/works/10.1098/rsta.2020.0069 ; doi.org HEAD 302,2026-10-30T03:13:52Z,"Principles (transparency, re-executability, determinism) and a Reproduction Package formalism close to WP29's release bundle.","From reproducing seven articles the authors derive three principles (transparency about how results are produced, ease of re-executability, determinism), 12 guidelines, and a Reproduction Package formalism for sharing artifacts.",yes
++trisovic2022codequality,3,Trisovic et al.,2022,A large-scale study on research code quality and execution,Scientific Data,journal,doi:10.1038/s41597-022-01143-6,https://api.crossref.org/works/10.1038/s41597-022-01143-6 ; doi.org HEAD 302,2026-10-30T03:13:53Z,"Large-scale evidence that deposited research code usually fails to run, justifying execution-based verification gates.","Executing over 9,000 R files from more than 2,000 Harvard Dataverse replication datasets, 74% failed to complete without error initially and 56% still failed after automatic code cleaning.",yes
++nosek2018preregistration,4,Nosek et al.,2018,The preregistration revolution,Proceedings of the National Academy of Sciences,journal,doi:10.1073/pnas.1708274114,https://api.crossref.org/works/10.1073/pnas.1708274114 ; doi.org HEAD 302,2026-10-30T03:13:55Z,Preregistration as prediction/postdiction separation is the direct analogue of WP29's protocol fixed before execution.,"Defining research questions and the analysis plan before observing outcomes (preregistration) distinguishes analyses that result from predictions from those that result from postdictions, and practical strategies exist for cases that fall short of the ideal.",yes
++chambers2013registeredreports,4,Chambers,2013,Registered Reports: A new publishing initiative at Cortex,Cortex,journal,doi:10.1016/j.cortex.2012.12.016,https://api.crossref.org/works/10.1016/j.cortex.2012.12.016 ; doi.org HEAD 302,2026-10-30T03:13:56Z,"Origin of Registered Reports: review of the protocol before results, the publishing analogue of WP29's pre-execution gate.","Introduces Registered Reports at Cortex, in which study protocols are peer reviewed and provisionally accepted before data collection.",unknown
++chambers2022registeredreports,4,Chambers & Tzavella,2021,"The past, present and future of Registered Reports",Nature Human Behaviour,journal,doi:10.1038/s41562-021-01193-7,https://api.crossref.org/works/10.1038/s41562-021-01193-7 ; doi.org HEAD 302,2026-10-30T03:13:57Z,Reviews evidence that pre-acceptance of protocols reduces reporting bias; supports the 'specification before execution' arm.,Registered Reports are a publication format in which study proposals are peer reviewed and pre-accepted before research is undertaken; early evidence indicates they work as intended although they are not a universal solution for irreproducibility.,yes
++simmons2011falsepositive,4,Simmons et al.,2011,False-Positive Psychology,Psychological Science,journal,doi:10.1177/0956797611417632,https://api.crossref.org/works/10.1177/0956797611417632 ; doi.org HEAD 302,2026-10-30T03:13:57Z,Researcher degrees of freedom inflate false positives; WP29's locked analysis specification removes these from the agent.,"Flexibility in data collection, analysis and reporting dramatically increases actual false-positive rates, so that a researcher is often more likely to falsely find evidence that an effect exists than to correctly find evidence that it does not; six disclosure requirements for authors and four reviewer guidelines are proposed.",yes
++munafo2017manifesto,4,Munafò et al.,2017,A manifesto for reproducible science,Nature Human Behaviour,journal,doi:10.1038/s41562-016-0021,https://api.crossref.org/works/10.1038/s41562-016-0021 ; doi.org HEAD 302,2026-10-30T03:13:57Z,"Umbrella statement of reproducibility measures (methods, reporting, evaluation, incentives) that WP29 adapts to autonomous agents.","Argues for measures optimizing methods, reporting and dissemination, reproducibility, evaluation and incentives, noting evidence from simulations and empirical studies but the need for iterative evaluation of their adoption.",yes
++gelman2014statisticalcrisis,4,Gelman & Loken,2014,The Statistical Crisis in Science,American Scientist,journal,doi:10.1511/2014.111.460,https://api.crossref.org/works/10.1511/2014.111.460 ; doi.org HEAD 302,2026-10-30T03:13:58Z,"Garden of forking paths: data-dependent analysis choices invalidate inference even without intent, which an agent in an open instruction arm is free to make.",Argues that data-dependent choices of analysis (the 'garden of forking paths') can produce spurious statistically significant findings even when researchers do not deliberately fish for significance.,unknown
++nosek2015top,4,Nosek et al.,2015,Promoting an open research culture,Science,journal,doi:10.1126/science.aab2374,https://api.crossref.org/works/10.1126/science.aab2374 ; doi.org HEAD 302,2026-10-30T03:13:59Z,"TOP guidelines define graded transparency standards (preregistration, data, code) that WP29's protocol tiers mirror.","Proposes journal author guidelines (the TOP guidelines) to promote transparency, openness and reproducibility, noting that although scientists embrace these norms they are not routine in practice.",yes
++scheel2021excess,4,Scheel et al.,2021,An Excess of Positive Results: Comparing the Standard Psychology Literature With Registered Reports,Advances in Methods and Practices in Psychological Science,journal,doi:10.1177/25152459211007467,https://api.crossref.org/works/10.1177/25152459211007467 ; doi.org HEAD 302,2026-10-30T03:14:00Z,Quantifies how pre-specified protocols change the result distribution; benchmark for interpreting WP29's arm differences.,"Comparing 71 published Registered Reports with 152 standard hypothesis-testing papers, the first hypothesis was positive in 96% of standard reports but only 44% of Registered Reports.",yes
++osc2015reproducibility,4,Open Science Collaboration,2015,Estimating the reproducibility of psychological science,Science,journal,doi:10.1126/science.aac4716,https://api.crossref.org/works/10.1126/science.aac4716 ; doi.org HEAD 302,2026-10-30T03:14:00Z,Baseline replication rates in a human literature; provides a human reference for WP29's validity outcomes.,"Replications of 100 experiments from 2008 papers in three psychology journals found that about one-third to one-half of original findings were also observed in the replication, depending on the criterion.",yes
++kerr1998harking,4,Kerr,1998,HARKing: Hypothesizing After the Results are Known,Personality and Social Psychology Review,journal,doi:10.1207/s15327957pspr0203_4,https://api.crossref.org/works/10.1207/s15327957pspr0203_4 ; doi.org HEAD 302,2026-10-30T03:14:01Z,HARKing (presenting post hoc hypotheses as a priori) is a failure mode an unconstrained agent can reproduce when writing up.,"Defines HARKing (hypothesizing after the results are known) as presenting post hoc hypotheses as if they were a priori, and discusses its prevalence and costs.",yes
++liu2024agentbench,5,Liu et al.,2023,AgentBench: Evaluating LLMs as Agents,ICLR 2024,conference,arXiv:2308.03688,"https://export.arxiv.org/api/query?id_list=2308.03688 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2308.03688 (venue='International Conference on Learning Representations', type='conference')",2026-10-30T03:14:02Z,"Multi-environment agent benchmark identifying long-horizon reasoning and instruction following as main failure causes, relevant to protocol adherence measurement.","AgentBench evaluates LLMs as agents across 8 environments; top commercial LLMs act well in complex environments but a significant gap separates them from open-source models up to 70B, with poor long-term reasoning, decision-making and instruction following as main obstacles.",yes
++yao2024taubench,5,Yao et al.,2024,$τ$-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains,arXiv preprint,preprint,arXiv:2406.12045,https://export.arxiv.org/api/query?id_list=2406.12045,2026-10-30T03:14:02Z,State-based outcome checking and the pass^k reliability metric are reused in WP29's repeated-run reliability analysis.,"tau-bench evaluates agents in simulated user conversations with API tools and policy guidelines by comparing the final database state to an annotated goal state, and proposes pass^k for reliability over multiple trials; gpt-4o succeeds on fewer than 50% of tasks with pass^8 below 25% in retail.",unknown
++kapoor2024agentsthatmatter,5,Kapoor et al.,2024,AI Agents That Matter,Transactions on Machine Learning Research,journal,arXiv:2407.01502,https://export.arxiv.org/api/query?id_list=2407.01502 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2407.01502 (venue='Trans. Mach. Learn. Res.'),2026-10-30T03:14:03Z,"Core methodological critique (cost reporting, holdouts, conflated benchmarking needs) that WP29's evaluation design follows.","Analysis of agent benchmarks finds a narrow focus on accuracy without cost, leading to needlessly complex and costly agents; proposes jointly optimizing accuracy and cost, and notes that model- and downstream-developer needs are conflated and that many benchmarks have inadequate holdout sets.",yes
++sainz2023contamination,5,Sainz et al.,2023,NLP Evaluation in trouble: On the Need to Measure LLM Data Contamination for each Benchmark,Findings of the Association for Computational Linguistics: EMNLP 2023,conference,doi:10.18653/v1/2023.findings-emnlp.722,https://api.crossref.org/works/10.18653/v1/2023.findings-emnlp.722 ; doi.org HEAD 302 ; https://export.arxiv.org/api/query?id_list=2310.18018,2026-10-30T03:14:04Z,Defines contamination levels; WP29's task bank must document contamination risk for each task.,"Position paper arguing that training on a benchmark's test split causes overestimation of performance with potentially harmful scientific conclusions, defining levels of data contamination and calling for community measurement for each benchmark.",yes
++zheng2023mtbench,5,Zheng et al.,2023,Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena,NeurIPS 2023 Datasets and Benchmarks,conference,arXiv:2306.05685,"https://export.arxiv.org/api/query?id_list=2306.05685 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2306.05685 (venue='Neural Information Processing Systems', type='conference') ; https://api2.openreview.net/notes/search?term=Judging%20LLM-as-a-judge (NeurIPS 2023 Datasets and Benchmarks record)",2026-10-30T03:14:05Z,"Establishes LLM-as-a-judge and its biases (position, verbosity, self-enhancement), which WP29's protected oracles are designed to avoid.","Examines LLM-as-a-judge limitations including position, verbosity and self-enhancement biases, and finds that strong judges such as GPT-4 agree with human preferences over 80% of the time on MT-bench and Chatbot Arena, the same level as human-human agreement.",yes
++thakur2025judgingjudges,5,Thakur et al.,2024,Judging the Judges: Evaluating Alignment and Vulnerabilities in LLMs-as-Judges,"GEM2 Workshop, ACL 2025",conference,arXiv:2406.12624,"https://export.arxiv.org/api/query?id_list=2406.12624 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2406.12624 (venue='arXiv.org', type=None) ; arXiv journal_ref: Proceedings of the Fourth Workshop on Generation Evaluation and Metrics GEM2 2025 pages 404 to 430; July 31 August 1 2025; 2025 Association for Computational Linguistics",2026-10-30T03:14:06Z,"Shows even the best judge models lag inter-human agreement, cautioning against unprotected LLM grading of research outputs.","Across thirteen judge models and nine exam-taker models in a high-human-agreement setting, only the best and largest judges reach reasonable alignment with humans, remain well behind inter-human agreement, and may differ from human scores by up to 5 points.",yes
++panickssery2024selfpreference,5,Panickssery et al.,2024,LLM Evaluators Recognize and Favor Their Own Generations,NeurIPS 2024,conference,arXiv:2404.13076,"https://export.arxiv.org/api/query?id_list=2404.13076 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2404.13076 (venue='Neural Information Processing Systems', type='conference')",2026-10-30T03:14:06Z,Self-preference bias is the specific threat WP29 mitigates by separating executor and reviewer and protecting oracles.,"LLM evaluators such as GPT-4 and Llama 2 have non-trivial accuracy at recognizing their own outputs, and fine-tuning reveals a linear correlation between self-recognition capability and the strength of self-preference.",yes
++zhu2025abc,5,Zhu et al.,2025,Establishing Best Practices for Building Rigorous Agentic Benchmarks,arXiv preprint,preprint,arXiv:2507.02825,https://export.arxiv.org/api/query?id_list=2507.02825,2026-10-30T03:13:45Z,"Agentic Benchmark Checklist (task validity, outcome validity, reporting) used as a checklist for WP29's task and oracle construction.","Shows that many agentic benchmarks have task-setup or reward-design flaws (e.g., SWE-bench Verified uses insufficient test cases, TAU-bench counts empty responses as successful) that can mis-estimate performance by up to 100% relative, and introduces the Agentic Benchmark Checklist, which reduced overestimation on CVE-Bench by 33%.",no
++kapoor2025hal,5,Kapoor et al.,2025,Holistic Agent Leaderboard: The Missing Infrastructure for AI Agent Evaluation,arXiv preprint,preprint,arXiv:2510.11977,https://export.arxiv.org/api/query?id_list=2510.11977,2026-10-30T03:13:45Z,"Standardized harness with full cost accounting across models, scaffolds and benchmarks, the infrastructure model for WP29's isolated executors and resource logs.","Introduces a standardized evaluation harness and reports 21,730 agent rollouts across 9 models and 9 benchmarks at a total cost of about $40,000, finding among other things that higher reasoning effort can reduce accuracy.",no
++li2025llmreval,5,Li et al.,2025,LLM-REVal: Can We Trust LLM Reviewers Yet?,arXiv preprint,preprint,arXiv:2510.12367,https://export.arxiv.org/api/query?id_list=2510.12367,2026-10-30T03:16:08Z,"Simulated research-and-review loop showing LLM reviewers misaligned with humans; motivates WP29's separate, protected review arm rather than in-system AI review.","Using a simulation with a research agent that writes and revises papers and a review agent that assesses them, followed by human annotation, the authors identify pronounced misalignment between LLM reviewers and human judgments.",no
++parasuraman1997automation,6,Parasuraman & Riley,1997,"Humans and Automation: Use, Misuse, Disuse, Abuse",Human Factors: The Journal of the Human Factors and Ergonomics Society,journal,doi:10.1518/001872097778543886,https://api.crossref.org/works/10.1518/001872097778543886 ; doi.org HEAD 302,2026-10-30T03:14:09Z,Use/misuse/disuse/abuse taxonomy frames how a researcher delegates to an autonomous agent and over-relies on its outputs.,"Distinguishes use, misuse (over-reliance producing monitoring failures or decision biases), disuse (often caused by false alarms) and abuse of automation, with trust, workload and reliability as key influences.",yes
++parasuraman2000levels,6,Parasuraman et al.,2000,A model for types and levels of human interaction with automation,"IEEE Transactions on Systems, Man, and Cybernetics - Part A: Systems and Humans",journal,doi:10.1109/3468.844354,https://api.crossref.org/works/10.1109/3468.844354 ; doi.org HEAD 302,2026-10-30T03:14:10Z,Levels-of-automation model used to locate WP29's four arms on the acquisition/analysis/decision/implementation dimensions.,"Proposes that automation can be applied to four function classes (information acquisition, information analysis, decision and action selection, action implementation), each across a continuum from fully manual to fully automatic, and that automation changes rather than merely supplants human activity.",yes
++goddard2012automationbias,6,Goddard et al.,2012,"Automation bias: a systematic review of frequency, effect mediators, and mitigators",Journal of the American Medical Informatics Association,journal,doi:10.1136/amiajnl-2011-000089,https://api.crossref.org/works/10.1136/amiajnl-2011-000089 ; doi.org HEAD 302,2026-10-30T03:14:10Z,Systematic review of automation bias frequency and mitigators informing how human review of agent outputs is measured in WP29.,"A systematic review (74 of 13,821 retrieved papers) finds automation bias mediated by user factors such as cognitive style, decision-support design and task experience, discussed alongside automation-induced complacency.",yes
++lai2023humanai,6,Lai et al.,2023,Towards a Science of Human-AI Decision Making: An Overview of Design Space in Empirical Human-Subject Studies,2023 ACM Conference on Fairness Accountability and Transparency,conference,doi:10.1145/3593013.3594087,https://api.crossref.org/works/10.1145/3593013.3594087 ; doi.org HEAD 302 ; https://export.arxiv.org/api/query?id_list=2112.11471,2026-10-30T03:14:11Z,Design-space survey of empirical human-AI decision-making studies used to position WP29's intervention measurement.,"Surveys empirical human-subject studies of AI-assisted decision making and summarizes the design space of tasks, AI assistance elements and evaluation metrics to structure a science of human-AI decision making.",yes
++bansal2021whole,6,Bansal et al.,2021,Does the Whole Exceed its Parts? The Effect of AI Explanations on Complementary Team Performance,Proceedings of the 2021 CHI Conference on Human Factors in Computing Systems,conference,doi:10.1145/3411764.3445717,https://api.crossref.org/works/10.1145/3411764.3445717 ; doi.org HEAD 302,2026-10-30T03:14:11Z,"Shows explanations raise acceptance of AI recommendations regardless of correctness, a risk for human review of agent-generated research.","In studies on three datasets, AI augmentation produced complementary improvements but explanations did not increase them; instead explanations increased the chance that humans accept the AI's recommendation regardless of its correctness.",yes
++lubars2019delegability,6,Lubars & Tan,2019,"Ask Not What AI Can Do, But What AI Should Do: Towards a Framework of Task Delegability",NeurIPS 2019,conference,arXiv:1902.03245,"https://export.arxiv.org/api/query?id_list=1902.03245 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:1902.03245 (venue='Neural Information Processing Systems', type='conference')",2026-10-30T03:14:12Z,"Task-delegability framework (motivation, difficulty, risk, trust) used to characterize which research sub-tasks are delegated in each WP29 arm.","Proposes a delegability framework with four factors (motivation, difficulty, risk, trust) and, surveying 100 tasks, finds little preference for full AI control and a strong preference for machine-in-the-loop designs, with trust most correlated with preferences.",yes
++vaccaro2024combinations,6,Vaccaro et al.,2024,When combinations of humans and AI are useful: A systematic review and meta-analysis,Nature Human Behaviour,journal,doi:10.1038/s41562-024-02024-1,https://api.crossref.org/works/10.1038/s41562-024-02024-1 ; doi.org HEAD 302,2026-10-30T03:14:12Z,Meta-analytic evidence on when human-AI combinations beat either alone; reference point for interpreting WP29's human-review arm.,"A preregistered meta-analysis of 106 experiments (370 effect sizes, 2020-2023) finds that on average human-AI combinations performed worse than the best of humans or AI alone, with losses in decision tasks and gains in content-creation tasks.",yes
++bainbridge1983ironies,6,Bainbridge,1983,Ironies of automation,Automatica,journal,doi:10.1016/0005-1098(83)90046-8,https://api.crossref.org/works/10.1016/0005-1098(83)90046-8 ; doi.org HEAD 302,2026-10-30T03:14:13Z,"Classic argument that automation makes the residual human role harder, relevant to reviewers of autonomous research output.","Argues that the more advanced a control system is, the more crucial the contribution of the human operator becomes, because the operator is left with the tasks the designer could not automate and must monitor a system that rarely needs intervention.",yes
++bucinca2021trust,6,Buçinca et al.,2021,To Trust or to Think,Proceedings of the ACM on Human-Computer Interaction,journal,doi:10.1145/3449287,https://api.crossref.org/works/10.1145/3449287 ; doi.org HEAD 302,2026-10-30T03:14:14Z,Cognitive forcing as a mitigation of overreliance; analogous to WP29's requirement that reviewers execute checks rather than read summaries.,"In an experiment with 199 participants, three cognitive forcing interventions reduced overreliance on AI relative to simple explainable-AI approaches.",yes
++becker2025metr,6,Becker et al.,2025,Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity,arXiv preprint,preprint,arXiv:2507.09089,https://export.arxiv.org/api/query?id_list=2507.09089,2026-10-30T03:14:16Z,Randomized measurement of AI-tool effects on expert developers showing perception-reality gaps; methodological model for WP29's time/cost outcomes.,"In a randomized controlled trial with 16 experienced open-source developers on 246 tasks, allowing early-2025 AI tools increased completion time by 19%, although developers forecast a 24% speedup beforehand and still believed in a 20% speedup afterwards.",no
++dean2013tail,7,Dean & Barroso,2013,The tail at scale,Communications of the ACM,journal,doi:10.1145/2408776.2408794,https://api.crossref.org/works/10.1145/2408776.2408794 ; doi.org HEAD 302,2026-10-30T03:14:17Z,"Tail-tolerance techniques (hedging, timeouts) underlie WP29's executor time budgets and retry policy.",Software techniques that tolerate latency variability are vital to building responsive large-scale Web services.,unknown
++gray1986whystop,7,Gray,1986,Why Do Computers Stop and What Can Be Done About It?,Symposium on Reliability in Distributed Software and Database Systems,conference,s2:87c9e34c39dd1fbd470010dc1ea98ba3517f5a2a,https://api.semanticscholar.org/graph/v1/paper/87c9e34c39dd1fbd470010dc1ea98ba3517f5a2a (record cached in s2_gray1986_search_observed.json),2026-10-30T03:31:46Z,"Foundational failure analysis (software and operations dominate outages; process pairs, transactions) behind WP29's checkpoint/idempotent step design.","Reports Tandem field data attributing most system outages to software and operations/administration rather than hardware, and advocates process pairs and transactions as the means to tolerate faults.",unknown
++basiri2016chaos,7,Basiri et al.,2016,Chaos Engineering,IEEE Software,journal,doi:10.1109/MS.2016.60,https://api.crossref.org/works/10.1109/MS.2016.60 ; doi.org HEAD 302,2026-10-30T03:14:17Z,Chaos engineering as experimentation on failure injection motivates WP29's fault-injection tests of the executors.,"Describes chaos engineering as Netflix's practice of experimenting on distributed systems to verify their reliability, together with the principles underlying it.",yes
++helland2012idempotence,7,Helland,2012,Idempotence is not a medical condition,Communications of the ACM,journal,doi:10.1145/2160718.2160734,https://api.crossref.org/works/10.1145/2160718.2160734 ; doi.org HEAD 302,2026-10-30T03:14:18Z,"Idempotent operations make retries safe, a requirement for WP29's resumable protocol steps.",Messages may be retried; idempotence means that is acceptable.,unknown
++burckhardt2021durablefunctions,7,Burckhardt et al.,2021,Durable functions: semantics for stateful serverless,Proceedings of the ACM on Programming Languages,journal,doi:10.1145/3485510,https://api.crossref.org/works/10.1145/3485510 ; doi.org HEAD 302,2026-10-30T03:14:20Z,"Formal semantics for durable workflow execution (persistent state, reliable progress) that WP29's run ledger approximates.","Describes Azure Durable Functions, which enhance FaaS with actors, workflows and critical sections to provide persistent state and reliable progress, and gives a formal semantics based on an idealized untyped lambda-calculus model.",yes
++erol2025costofpass,7,Erol et al.,2025,Cost-of-Pass: An Economic Framework for Evaluating Language Models,arXiv preprint,preprint,arXiv:2504.13359,https://export.arxiv.org/api/query?id_list=2504.13359,2026-10-30T03:14:21Z,Cost-of-pass (expected cost per correct solution) is the economic outcome metric WP29 reports per arm.,"Defines cost-of-pass as the expected monetary cost of generating a correct solution and the frontier cost-of-pass relative to a human expert, finding lightweight models most cost-effective for basic quantitative tasks and reasoning models for complex quantitative problems.",no
++dong2024agentops,7,Dong et al.,2024,AgentOps: Enabling Observability of LLM Agents,arXiv preprint,preprint,arXiv:2411.05285,https://export.arxiv.org/api/query?id_list=2411.05285,2026-10-30T03:14:22Z,Taxonomy of agent-lifecycle artifacts to trace; WP29's evidence records cover these observability artifacts.,"Presents a taxonomy of AgentOps artifacts and data that should be traced throughout the agent lifecycle to achieve observability, derived from a systematic mapping study of existing AgentOps tools.",no
++khanal2026reliability,7,Khanal et al.,2026,Beyond pass@1: A Reliability Science Framework for Long-Horizon LLM Agents,arXiv preprint,preprint,arXiv:2603.29231,https://export.arxiv.org/api/query?id_list=2603.29231,2026-10-30T03:15:09Z,"Shows capability (pass@1) and reliability diverge with task duration, supporting WP29's repeated-run reliability outcomes.","Introduces four reliability metrics (Reliability Decay Curve, Variance Amplification Factor, Graceful Degradation Score, Meltdown Onset Point) and, over 23,392 episodes of 10 models on 396 tasks, finds reliability decay is domain-stratified (software-engineering GDS falls from 0.90 to 0.44) while document processing is nearly flat.",no
++zhuang2026agentrewind,7,Zhuang et al.,2026,AgentRewind: Recoverable Execution for Long-Horizon LLM Agents,arXiv preprint,preprint,arXiv:2608.14380,https://export.arxiv.org/api/query?id_list=2608.14380,2026-10-30T03:15:09Z,Checkpoint/rewind recovery for long-horizon agents; the failure-recovery mechanism WP29's protocol runs implement at stage boundaries.,"AgentRewind records aligned checkpoints of agent context and a controlled environment so that agents can return to an earlier state and resume with information from previous attempts, evaluated on the MettleBench long-horizon engineering benchmark.",no
++sigelman2010dapper,7,Sigelman et al.,2010,"Dapper, a Large-Scale Distributed Systems Tracing Infrastructure",Google Technical Report dapper-2010-1,report,s2:003d5a65de0ac72daaf105ded903cb3eb88585b3,https://api.semanticscholar.org/graph/v1/paper/003d5a65de0ac72daaf105ded903cb3eb88585b3 (record cached in s2_dapper2010.json),2026-10-30T03:38:36Z,"Classic distributed tracing design (sampling, application-level transparency) referenced for WP29's run tracing.","Describes Google's production distributed tracing infrastructure, designed for low overhead through sampling and application-level transparency.",no
++wadden2020scifact,8,Wadden et al.,2020,Fact or Fiction: Verifying Scientific Claims,Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP),conference,doi:10.18653/v1/2020.emnlp-main.609,https://api.crossref.org/works/10.18653/v1/2020.emnlp-main.609 ; doi.org HEAD 302,2026-10-30T03:14:22Z,Scientific claim verification task and dataset; model for WP29's claim-to-evidence checks in generated reports.,"Introduces scientific claim verification with SciFact, 1.4K expert-written claims paired with evidence abstracts annotated with labels and rationales; the system identified plausible evidence for 23 of 36 COVID-19 claims on CORD-19.",yes
++thorne2018fever,8,Thorne et al.,2018,FEVER: a Large-scale Dataset for Fact Extraction and VERification,"Proceedings of the 2018 Conference of the North American Chapter of
++          the Association for Computational Linguistics: Human Language
++          Technologies, Volume 1 (Long Papers)",conference,doi:10.18653/v1/N18-1074,https://api.crossref.org/works/10.18653/v1/N18-1074 ; doi.org HEAD 302,2026-10-30T03:14:23Z,Canonical fact extraction and verification benchmark defining Supported/Refuted/NotEnoughInfo labels adopted in WP29's citation audit.,"FEVER contains 185,445 claims derived from Wikipedia and labeled Supported, Refuted or NotEnoughInfo (Fleiss kappa 0.6841), with a best pipeline accuracy of 31.87% when the correct evidence is required.",yes
++bohnet2022attributedqa,8,Bohnet et al.,2022,Attributed Question Answering: Evaluation and Modeling for Attributed Large Language Models,arXiv preprint,preprint,arXiv:2212.08037,https://export.arxiv.org/api/query?id_list=2212.08037,2026-10-30T03:14:23Z,Attributed QA frames generation that must cite supporting sources; WP29 requires attributed claims in agent reports.,"Formulates Attributed QA with a reproducible evaluation framework that uses human annotations as gold standard and shows that a correlated automatic metric is suitable for development, benchmarking a broad set of architectures.",no
++walters2023fabrication,8,Walters & Wilder,2023,Fabrication and errors in the bibliographic citations generated by ChatGPT,Scientific Reports,journal,doi:10.1038/s41598-023-41032-5,https://api.crossref.org/works/10.1038/s41598-023-41032-5 ; doi.org HEAD 302,2026-10-30T03:14:24Z,Quantifies fabricated references in LLM literature reviews; justifies WP29's mandatory citation verification gate.,"In 84 short literature reviews on 42 topics containing 636 citations, 55% of GPT-3.5 citations and 18% of GPT-4 citations were fabricated, and 43% versus 24% of the real citations contained substantive errors.",yes
++alkaissi2023hallucinations,8,Alkaissi & McFarlane,2023,Artificial Hallucinations in ChatGPT: Implications in Scientific Writing,Cureus,journal,doi:10.7759/cureus.35179,https://api.crossref.org/works/10.7759/cureus.35179 ; doi.org HEAD 302,2026-10-30T03:14:24Z,Early clinical report of fabricated references ('artificial hallucinations') in scientific writing.,"Reports two case studies in which ChatGPT produced plausible but fabricated content including references when asked to write on rare conditions, documenting positive, negative and troubling aspects of its performance.",unknown
++gao2023rarr,8,Gao et al.,2023,"RARR: Researching and Revising What Language Models Say, Using Language Models",Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers),conference,doi:10.18653/v1/2023.acl-long.910,https://api.crossref.org/works/10.18653/v1/2023.acl-long.910 ; doi.org HEAD 302,2026-10-30T03:14:25Z,Post-hoc attribution and revision pipeline; a model for WP29's independent evidence-grounding pass over agent output.,"RARR automatically finds attribution for the output of any text generator and post-edits unsupported content, significantly improving attribution while otherwise preserving the original output.",yes
++wang2023selfconsistency,8,Wang et al.,2022,Self-Consistency Improves Chain of Thought Reasoning in Language Models,ICLR 2023,conference,arXiv:2203.11171,"https://export.arxiv.org/api/query?id_list=2203.11171 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2203.11171 (venue='International Conference on Learning Representations', type='conference')",2026-10-30T03:14:25Z,Self-consistency is an in-model verification heuristic; WP29 contrasts it with external executable verification.,"Self-consistency samples diverse reasoning paths and selects the most consistent answer, improving chain-of-thought accuracy on GSM8K (+17.9%), SVAMP (+11.0%) and AQuA (+12.2%).",yes
++min2023factscore,8,Min et al.,2023,FActScore: Fine-grained Atomic Evaluation of Factual Precision in Long Form Text Generation,Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing,conference,doi:10.18653/v1/2023.emnlp-main.741,https://api.crossref.org/works/10.18653/v1/2023.emnlp-main.741 ; doi.org HEAD 302 ; https://export.arxiv.org/api/query?id_list=2305.14251,2026-10-30T03:14:25Z,Atomic-fact precision scoring is the template for WP29's claim-level verification of generated reports.,"FActScore decomposes a generation into atomic facts and computes the percentage supported by a reliable knowledge source; ChatGPT biographies reach only 58%, and an automated estimator is introduced.",yes
++huang2024selfcorrect,8,Huang et al.,2023,Large Language Models Cannot Self-Correct Reasoning Yet,ICLR 2024,conference,arXiv:2310.01798,"https://export.arxiv.org/api/query?id_list=2310.01798 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2310.01798 (venue='International Conference on Learning Representations', type='conference')",2026-10-30T03:14:26Z,"Evidence that intrinsic self-correction fails without external feedback, supporting WP29's external gates over agent self-review.","Finds that LLMs struggle to self-correct their reasoning without external feedback, and that performance can even degrade after intrinsic self-correction.",yes
++sakai2026hallucitation,8,Sakai et al.,2026,HalluCitation Matters: Revealing the Impact of Hallucinated References with 300 Hallucinated Papers in ACL Conferences,ACL 2026 (per Semantic Scholar venue record),conference,arXiv:2601.18724,"https://export.arxiv.org/api/query?id_list=2601.18724 ; https://api.semanticscholar.org/graph/v1/paper/arXiv:2601.18724 (venue='Annual Meeting of the Association for Computational Linguistics', type='conference')",2026-10-30T03:15:08Z,"Documents hallucinated citations reaching accepted NLP papers, showing the scale of the problem WP29's citation gate addresses.","Analyzing all ACL, NAACL and EMNLP papers of 2024-2025, nearly 300 papers contain at least one hallucinated citation, half of them at EMNLP 2025, and more than 100 such papers were accepted as main-conference or Findings papers.",yes
++zhao2026hallucinationswild,8,Zhao et al.,2026,LLM hallucinations in the wild: Large-scale evidence from non-existent citations,arXiv preprint,preprint,arXiv:2605.07723,https://export.arxiv.org/api/query?id_list=2605.07723,2026-10-30T03:15:08Z,Large-scale audit of non-existent citations in the literature after LLM adoption; external evidence of the citation-fabrication risk.,"Auditing 111 million references across 2.5 million papers in arXiv, bioRxiv, SSRN and PubMed Central shows a sharp rise in non-existent references after widespread LLM adoption, with a conservative estimate of 146,932 hallucinated citations in 2025 alone.",no

added research/make_coding.py +329 −0

++import csv, os
++ROOT="/Users/simon-pierreboucher/Desktop/Recherche-UQO/methodes/autonomous-research-claude-code/research"
++man={r["wp"]:r for r in csv.DictReader(open(os.path.join(ROOT,"corpus_manifest.csv"),newline="",encoding="utf-8"))}
++F=["wp","file","document_type","source_url","retrieved_utc","sha256","research_domain","research_type","explicit_question","explicit_estimand_or_hypotheses","stated_assumptions","falsification_or_null_result_conditions","literature_or_novelty_requirement","data_access_controls","temporal_information_controls","baseline_requirement","n_phases_declared","dependency_or_gate_structure","stopping_rules","recovery_or_resume_instructions","artifact_requirements","provenance_requirements","review_or_self_audit_stage","disclosure_or_AI_use_statement","budget_or_resource_limits","integrity_prohibitions","contradictory_or_non_operational_requirements","statements_added_during_implementation","analyst_notes"]
++rows=[]
++def R(wp,**k):
++    m=man[wp]; d={"wp":wp,"file":os.path.basename(m["local_file"]),"source_url":m["url"],"retrieved_utc":m["retrieved_utc"],"sha256":m["sha256"]}
++    d.update(k); rows.append(d)
++
++R("WP15",document_type="claude_md",
++research_domain="finance / market microstructure (intraday shock propagation, U.S. equities, OHLCV data)",
++research_type="empirical (with ML extension and synthetic-data tests)",
++explicit_question='"How have the speed, breadth, persistence, and asymmetry of intraday shock propagation across U.S. equities evolved over the past three decades, and under which market conditions does an initially idiosyncratic shock become sectoral or market-wide?"',
++explicit_estimand_or_hypotheses='yes — central hypothesis stated and outcome measures formally defined: "Modern markets may absorb ordinary shocks more efficiently while transmitting extreme shocks more rapidly and discontinuously." ; "Define the Intraday Shock Amplification Ratio: ISAR_{i,t}(h) = …" ; "Optimization must not change estimands or silently alter precision."',
++stated_assumptions='partial — assumptions must be stated and threats listed, and data assumptions are flagged as unverified: "Explain: … identification assumptions; threats." ; "The natural key is initially assumed to be: (symbol, timestamp) But this assumption must be verified."',
++falsification_or_null_result_conditions='yes — "The project must attempt to disprove its own central claim." ; "If a falsification fails, do not hide it. Reassess the claim." ; "A rigorous negative assessment is preferable to a polished but invalid paper."',
++literature_or_novelty_requirement='yes — "Do not overclaim uniqueness until a documented literature search confirms it." ; "never cite a work based only on another paper\'s bibliography." ; literature map with "verification date" column required',
++data_access_controls='yes — "stop if the schema is unusable or if legal/access restrictions prevent research use." ; "authenticated access only if required" ; "No user-specific absolute path may appear in committed code." ; ".env.example" in tree',
++temporal_information_controls='yes — "For a shock at time t, network weights W_{ij,t} must be estimated only from data dated strictly before t." ; "Any liquidity-based inclusion criterion must use lagged data to avoid look-ahead bias." ; "Never randomly split minute observations across train and test." ; "Future information may be used only as a falsification test, never in the baseline estimator."',
++baseline_requirement='yes — "Compare with: unconditional historical mean; linear and logistic regressions; penalized regression; random forest; …" ; "one transparent baseline regression" in first-phase deliverables ; "The primary nonlinear result must also be represented with a transparent non-ML specification."',
++n_phases_declared='7 (Stages A–G in "3. Execution protocol"; plus "30. Minimum deliverables for the first phase" and "33. Immediate actions" 1–16)',
++dependency_or_gate_structure='explicit — "Only after Stage A passes:" ; "Do not run `make release` until the pilot audit and full-data checks pass." ; executable release gate: "The release script must fail if: a table references a missing result; a figure is missing source data; LaTeX does not compile; … manuscript claims disagree with the results registry; data revision is not pinned; tests fail."',
++stopping_rules='yes — dedicated section: "# 31. Stop conditions Stop and write a diagnostic report rather than proceeding if: timestamps cannot be interpreted reliably; OHLC values are extensively inconsistent; … data licensing prevents the intended use; …" ; also "stop if the schema is unusable" (Stage A) and "Escalate only issues that materially alter the research question, data legality, identification, or interpretation."',
++recovery_or_resume_instructions='yes — "use resumable transfers" ; "permit partial reruns and node-level parallelism" ; "Every distributed task must: be idempotent; write to temporary paths; atomically rename on success; save checkpoints; … support retry; validate output before success." ; "never silently overwrite an existing file"',
++artifact_requirements='paper (main.tex + sections, anonymous and named PDFs); Internet Appendix; tables (standalone .tex AND machine-readable .csv/.parquet); figures (vector PDF + PNG, source data in outputs/figures/data/); results registry (outputs/estimates/results_registry.json) feeding LaTeX macros; code (src package, 22 numbered scripts, CLI, Makefile with ~19 targets); tests (8 files); data manifests (raw_files.parquet/csv with sha256, revision, row counts); docs (DATA_DICTIONARY, DATA_AUDIT, EMPIRICAL_DESIGN, LITERATURE_MAP, REPRODUCIBILITY, COMPUTE_LOG, DECISION_LOG, LIMITATIONS); STATUS.md per stage; README, LICENSE, CITATION.cff, pyproject/uv.lock/environment.yml/.env.example; release bundle (cover letter, source_archive.zip, replication_manifest.json, submission_checklist.md); 4 notebooks',
++provenance_requirements='yes — "pin the exact dataset revision or commit hash" ; manifest columns include "sha256; status; download_started_at; … code_commit" ; "Each processed file must record: parent inputs; transformation version; filters; row counts before and after; creation timestamp; code commit." ; "Record: Git commit; Python version; package versions; OS; hardware; dataset revision; …"',
++review_or_self_audit_stage='yes — "Stage C — Raw-data audit" with docs/DATA_AUDIT.md ; "28.3 Release validation" ; decision log "whether pre-specified or data-driven" ; no adversarial referee stage, but "Report blockers and proposed solutions before launching the full download."',
++disclosure_or_AI_use_statement='no — only a style instruction: "The paper must read like a finance paper, not AI-generated prose." (not a disclosure requirement)',
++budget_or_resource_limits='partial — resource estimation required but no cap: "Before a full run: 1. benchmark one month; 2. benchmark one year; 3. estimate CPU hours; 4. estimate memory; 5. estimate temporary storage; 6. estimate final storage; 7. record in docs/COMPUTE_LOG.md." ; "disk-space checks" ; "Avoid loading the full dataset into RAM." ; no monetary or token budget',
++integrity_prohibitions='yes — "Never fabricate data, results, citations, institutional details, variable definitions, statistical significance, sample sizes, or conclusions. Never write a result in the paper before it has been generated and verified from a saved machine-readable output." ; "Never manually type numerical results into LaTeX." ; "Never winsorize away a possible split without logging it."',
++contradictory_or_non_operational_requirements='Non-operational success criteria that no script can check: "the paper documents a new and economically important fact"; "the writing is disciplined"; "prepared to the standard expected in a top finance journal"; "must read like a finance paper, not AI-generated prose". Judgement-dependent trade-off with no threshold: "Do not define isolation so strictly that only trivial events remain. Report the trade-off." External dependency: "main manuscript no longer than the current JF limit" requires checking an external source at run time. Dataset facts are presented as unverified claims ("Claimed coverage: 1992–2026") and must be audited, which is consistent. No internal contradiction found between autonomy ("Do not ask for confirmation for routine implementation choices") and the mandated pause ("Report blockers and proposed solutions before launching the full download") since the latter is an explicit escalation point.',
++statements_added_during_implementation='none identified (no dated additions or reconstruction notes; the WP15 PROMPT_INITIAL copy is byte-identical)',
++analyst_notes='Longest and most engineering-oriented mandate (7 685 words, 151 headings, 12 code blocks). The only mandate with a dedicated stop-condition section and an executable release-validation gate ("must fail if"). No UQO series framing (targets Journal of Finance), no AI-use disclosure, no page-count target other than JF limit. Cluster-compute section (27) presupposes distributed execution.')
++
++R("WP18",document_type="claude_md",
++research_domain="real estate / housing macro-finance (OLG housing economy, leverage, intergenerational inequality)",
++research_type="theoretical (with numerical general-equilibrium simulation)",
++explicit_question='"Under what conditions do inherited wealth, mortgage leverage, nominal debt, housing supply and down-payment constraints generate persistent owner-renter wealth inequality among households with similar labor income? What changes under unexpected inflation?"',
++explicit_estimand_or_hypotheses='partial — candidate contributions to be treated as hypotheses, not formal H statements: "Candidate contributions: (i) an endogenous ownership-entry wealth threshold jointly shaped by bequests, collateral and price feedback; (ii) conditions for persistent ownership/wealth gaps and path dependence; … Treat each as a hypothesis, not a preordained result." ; ten required experiments listed',
++stated_assumptions='partial — assumptions must accompany every proposition but are not stated in the mandate: "For every proposition provide exact assumptions, statement, proof or clearly labeled proof gap." ; one substantive non-assumption imposed: "Do not assume inflation necessarily raises real house prices or enriches every owner."',
++falsification_or_null_result_conditions='partial — failed conjectures and contrary outcomes must be recorded, no disproof condition defined: "Save proofs in `paper/appendix_proofs.tex` and failed conjectures in `research/failed_hypotheses.md`." ; "Investigate contrary outcomes." ; "conditions for persistence/multiple equilibria (only if established)"',
++literature_or_novelty_requirement='yes — "Produce `research/novelty_matrix.csv` comparing each claimed contribution with the closest prior papers. Redesign weak contributions. Do not assert novelty before verifying it." ; "target of 50–80 **verified** references if genuinely relevant and accessible (never pad)"',
++data_access_controls='partial — generic honesty about access only: "Log unavailable files rather than claiming to have read them." ; "ask for essential permissions or missing credentials rather than pretending access" ; calibration "from traceable Canada/Québec sources when justified, or use clearly marked illustrative parameters"',
++temporal_information_controls='no — theoretical paper; only "Record units, observation dates, transformations and sources." (no look-ahead rule)',
++baseline_requirement='partial — benchmark model and baseline scenario, no comparison methods: "First solve a two-/three-period benchmark with known behavior; unit-test budget identities" ; experiment "1. Baseline wealth and ownership by age, income and inheritance quantile."',
++n_phases_declared='5 (Phase 0–4) plus "Final reproducibility and QA"',
++dependency_or_gate_structure='explicit — "**Mandatory order:** inspect previous UQO WPs and review literature → specify mathematical model → derive propositions → implement and validate numerical model → … → audit results → **only then write and compile the LaTeX paper**." ; "**Gate:** do not start manuscript drafting until the baseline model is validated, claimed GE equilibria clear markets, principal simulations and exhibits reproduce, bibliography is verified, and theoretical claims have proofs or appropriate qualifications."',
++stopping_rules='partial — fallback only, no stop condition: "If blocked, document the issue honestly and deliver a scoped partial result."',
++recovery_or_resume_instructions='partial — progress log after every phase, no resume/checkpoint instruction: "Maintain `research/progress.md` after every phase with completed work, evidence, blockers and next steps."',
++artifact_requirements='paper/main.tex + main.pdf; references.bib; appendix_proofs.tex; appendix_computation.tex; 10–14 figures (vector PDF + PNG in results/figures/); 6–9 auto-generated LaTeX tables (results/tables/); raw CSV/Parquet (results/data/); logs; code modules src/{model,household_solver,equilibrium,distributions,simulation,calibration,robustness,figures,tables}.py; tests/; configs YAML; Makefile (setup/test/simulate/figures/tables/paper/all); requirements.txt; research/{progress,wp_style_audit,novelty_matrix,literature_matrix,literature_review,model_specification,failed_hypotheses,results_audit}; README',
++provenance_requirements='partial — traceability without hashes/manifests: "Every paper number must map to a result file." ; "Record units, observation dates, transformations and sources." ; "pinned dependencies, fixed seeds, tests, structured experiment logs"',
++review_or_self_audit_stage='yes — "## Phase 4 — Integrity audit, then write the manuscript Before writing the paper, complete `research/results_audit.md`: experiment, hypotheses, parameters, algorithm, convergence, results, limitations, robustness, and claims actually supported."',
++disclosure_or_AI_use_statement='no — "Do not invent coauthors or acknowledgments." concerns authorship metadata, not AI-use disclosure',
++budget_or_resource_limits='no',
++integrity_prohibitions='yes — "Never invent results, citations, proofs, or data." ; "If general equilibrium does not solve, **never label partial equilibrium as GE**." ; "No fabricated calibration targets or empirical validation." ; "Never manipulate assumptions to force a preferred conclusion." ; "Do not call simulation findings theorems."',
++contradictory_or_non_operational_requirements='Quantity targets coexist with anti-padding clauses and are resolved only by a priority statement: "30–45-page English main text", "10–14 meaningful publication-quality figures and 6–9 substantive tables, adjusted to genuine findings rather than padded", versus "**Priority: scientific correctness, originality and reproducibility over speed, page count or positive findings.**" Non-verifiable from the document: "Rerun from a clean environment" (no environment specification), "Check PDFs visually". The gate condition "bibliography is verified" has no operational verification procedure. The French preamble re-maps the directory name used in the plan ("le nom `wp18_uqo/` du plan ci-dessous désigne ce dossier"), i.e. the plan\'s paths are not literal.',
++statements_added_during_implementation='Prefatory note (French) placed before the mandate: "(Spécification de l\'auteur, 2026-10-20. Conventions de forme : ~/Desktop/Recherche-UQO/HARMONISATION.md ; ce dossier s\'appelle `immobilier/housing-leverage-intergenerational-inequality` et correspond au dépôt spbgit `wp18_uqo.git` — le nom `wp18_uqo/` du plan ci-dessous désigne ce dossier.)" — a repository-mapping note dated with the specification, not marked as post-implementation.',
++analyst_notes='Language: English body with a French prefatory paragraph (automated: mixed). Role framing "Act as an autonomous team of housing economists, …". Requires reading WP1–WP17 for style conventions (research/wp_style_audit.md).')
++
++R("WP19",document_type="claude_md",
++research_domain="real estate / housing market microstructure (search-and-matching, liquidity premium)",
++research_type="theoretical (continuous-time search model with numerical simulation)",
++explicit_question='"How do market tightness, heterogeneous seller reservation values, financing frictions, time-on-market costs, and bargaining power jointly determine an endogenous housing liquidity discount, transaction prices, selling hazards, and price dispersion?"',
++explicit_estimand_or_hypotheses='yes — "Candidate propositions to PROVE: higher carrying cost lowers reservation price; decline in arrival/qualification widens the discount and increases TOM (with caveats); liquidity shocks move prices and volume without a fundamental shock; dispersion from heterogeneous urgency; selection bias in transaction indices." ; defined object "precise liquidity premium/discount definition with sign conventions (D = (p* − p)/p*)" ; "Each: preregistered hypothesis, exact config, output CSV, entry point, diagnostics, interpretation."',
++stated_assumptions='partial — required, not stated: "explicit timing, assumptions, parameter restrictions, identification limits, boundary cases" ; "Full assumptions, statements, proofs or counterexamples, intuition; label numerical patterns as conjectures."',
++falsification_or_null_result_conditions='partial — counterexamples and failures must be reported; no disproof condition: "proofs or counterexamples" ; "record failed experiments and regions without equilibrium" ; "Report failures."',
++literature_or_novelty_requirement='yes — "Novelty gate: if the mechanism is already established, adjust the model and contribution before proceeding." ; "Authors to investigate only with independent bibliographic verification"',
++data_access_controls='partial — "No proprietary data, secrets, or unlicensed material." ; "If an endpoint is unavailable, log the failure and proceed" ; "do not claim to have read inaccessible material"',
++temporal_information_controls='no — not applicable (theoretical, synthetic experiments)',
++baseline_requirement='partial — baseline scenario and frictionless benchmark, not comparison methods: "1 baseline; 2 urgency gradient; …" ; "frictionless benchmark p*" ; "11 Nash vs posted prices"',
++n_phases_declared='8 (Phase 0–7); also an 8-step "Mandatory execution sequence: (0) … (7)"',
++dependency_or_gate_structure='explicit — "Mandatory execution sequence: (0) inspect prior UQO papers … (7) only then draft and compile the full LaTeX manuscript." ; "Novelty gate" ; "## Phase 6 — Independent audit before prose drafting" ; "## Research integrity and publication quality gates" ; "Introduction and abstract written last."',
++stopping_rules='no — "Report failures." only; no condition under which work stops',
++recovery_or_resume_instructions='no',
++artifact_requirements='full repository; paper/main.pdf, main.tex, references.bib; scripts (src/{model,solver,simulation,calibration,diagnostics,plotting,tables}.py); tests (pytest); config/baseline.yaml; 10–14 figures (PNG + PDF); 6–9 tables; research/{wp_style_audit,literature_review,literature_matrix.csv,novelty_matrix.csv,model_specification,proofs,validation,results_audit,limitations}; README "with commands and output inventory"; "final report (contributions, proved propositions, strongest results with figure/table references, literature coverage, unresolved items, reproducibility status, file locations)"',
++provenance_requirements='yes — "Fix random seeds; save environment and configuration hashes." ; "verify every number against result files" ; "`research/results_audit.md` maps every claim to proposition/proof, simulation file/figure/table, or citation"',
++review_or_self_audit_stage='yes — "## Phase 6 — Independent audit before prose drafting `research/results_audit.md` maps every claim … classify as proved, numerically illustrated, empirically documented, or speculative"',
++disclosure_or_AI_use_statement='no',
++budget_or_resource_limits='no',
++integrity_prohibitions='yes — "Never invent a proof, result, reference, DOI, dataset, or empirical validation." ; "Never fabricate outputs, citations, proofs, parameters or significance. No empirical language for synthetic experiments." ; "No \\"publishable / first-of-its-kind\\" claims."',
++contradictory_or_non_operational_requirements='"preregistered hypothesis" is required for each of the 12 experiments but no registration mechanism, timestamp or location is specified, so pre-registration cannot be verified from the document. "Independent audit" (Phase 6) is to be performed by the same agent that produced the results — independence is not operational. Reference target "Collect and verify 50–80 genuinely relevant references, not a quota" and length "30–45-page main paper" are targets with built-in escape clauses. "compile with latexmk; resolve warnings; inspect the rendered PDF" presumes a TeX toolchain not checked for.',
++statements_added_during_implementation='none identified',
++analyst_notes='Most compact fully phased mandate (1 092 words, 8 phases). Explicitly scoped against WP18 ("Key distinction from WP18"). Role framing "You are an autonomous interdisciplinary research team".')
++
++R("WP20",document_type="claude_md",
++research_domain="real estate appraisal / multimodal AI (cost approach from listing images and text; Vrai Prix workflow)",
++research_type="mixed (empirical evaluation + design-science pipeline, with a clearly labeled synthetic fallback)",
++explicit_question='"RQ1: How accurately can multimodal AI extract appraisal-relevant building attributes from listing photographs and descriptions relative to verified property records or expert annotations?" (RQ1 of five)',
++explicit_estimand_or_hypotheses='partial — five research questions and a formal valuation identity, no hypotheses: "\\widehat V_i^{cost}=\\widehat L_i + \\widehat{RCN}_i - \\widehat D_i + \\widehat S_i" ; metrics "attribute extraction precision/recall/F1 for categorical features, MAE/RMSE for continuous features, calibration and abstention metrics, and cost-approach accuracy versus independent credible cost or appraisal benchmarks"',
++stated_assumptions='partial — "Prove only results supported by stated assumptions." ; "Separate observable visual features, inferred proxy features, verified administrative fields, text-claimed features, and latent/unobservable features."',
++falsification_or_null_result_conditions='partial — "Favor transparent uncertainty and falsifiable evidence over marketing language." ; "If evidence for novelty is weak, revise the contribution statement accordingly." ; "never describe synthetic findings as real-world validation" ; no disproof condition for RQ1–RQ5',
++literature_or_novelty_requirement='yes — "aiming for 60–100 genuinely verified scholarly references if sufficient relevant work exists; quality and relevance take priority over quota." ; "Establish novelty only after examining existing literature." ; "Gate 2 — Literature: verified bibliography, mapped novelty and gap."',
++data_access_controls='yes — "Respect website terms, robots policies where applicable, copyright, privacy, and licensing; do not assume scraping or publication permission." ; "Keep secrets in environment variables, never in tracked files." ; "Never bypass access controls or website restrictions." ; "Avoid any use of private API keys in paper, logs, screenshots, or Git history." ; docs/data_rights.md',
++temporal_information_controls='yes — "Prevent train/test leakage by property, duplicate listing, and time." ; "Where feasible, use temporal and geographic holdouts." ; experiment "10. Geographic and temporal out-of-sample performance."',
++baseline_requirement='yes — "Compare at least: - B0: traditional cost approach using verified structured fields and standard cost schedules. - B1: listing-text-only extracted attributes + cost model. - B2: image-only … - B3: multimodal image+text … - B4: multimodal + verified administrative fields + uncertainty-aware reconciliation." ; "Do not make comparisons unfair by giving one method privileged information without identifying it."',
++n_phases_declared='6 (six-step "Mandatory sequence: (1) … (6) ONLY THEN write"); organised in sections A–J with 7 numbered quality gates',
++dependency_or_gate_structure='explicit — "Gate 1 — Repository audit … Gate 2 — Literature … Gate 3 — Theory … Gate 4 — Implementation … Gate 5 — Experiments … Gate 6 — Manuscript: only then draft and compile … Gate 7 — Integrity" ; "Hard gate: Do not draft Results or Conclusions until numerical outputs have been executed, independently checked, and saved."',
++stopping_rules='partial — blocker handling, no stop: "When missing permissions, source data, or access makes a claim impossible to validate, clearly identify the blocker, proceed with the portions that are feasible, and provide the exact minimal information needed to finish."',
++recovery_or_resume_instructions='partial — "caching, retry limits" ; "Maintain a TODO list and research log." ; no resume instruction',
++artifact_requirements='paper/main.pdf + main.tex + sections/ + references.bib + figures/ + tables/; ~12–16 vector PDF figures; 8–12 LaTeX tables generated from saved data; src/{ingestion,extraction,feature_schema,cost_model,evaluation,simulations,visualization}; configs/; data/{README,raw,processed,synthetic}; results/manifest.json; docs/{implementation_audit,literature_matrix.csv,experiment_plan,results_validation,data_rights,limitations,research_log}; tests/; requirements.txt; Makefile; data dictionary + data-flow diagram; annotated extraction schema; reproducibility instructions; limitations report; "final checklist distinguishing completed, blocked, and proposed items"',
++provenance_requirements='yes — "Store prompts, model versions, temperatures, and response schemas." ; "generate a machine-readable results/manifest.json" ; "Maintain docs/implementation_audit.md with citations to local paths or source lines" ; "Every substantive factual claim must have a traceable source." ; "Avoid hardcoded table results; generate them from actual outputs."',
++review_or_self_audit_stage='yes — "Gate 7 — Integrity: audit every numerical claim against saved outputs and every citation against source metadata." ; "Write docs/results_validation.md documenting each check."',
++disclosure_or_AI_use_statement='no',
++budget_or_resource_limits='no — "retry limits" only; experiment 16 mentions "annotation time/cost" as an outcome, not a limit',
++integrity_prohibitions='yes — "Never invent datasets, numerical findings, literature references, citations, software functionality, API results, human labels, or Vrai Prix implementation details. Never fabricate significance." ; "Do NOT infer foundation integrity, hidden mold, structural soundness, exact year built, precise area, code compliance, permit status, or legal tenure from images alone."',
++contradictory_or_non_operational_requirements='Human-dependent steps inside an autonomous mandate: "Propose a rigorous annotation protocol with independent expert raters" and experiment "4. Human expert agreement and AI-human disagreement" cannot be executed by the agent (mitigated by "subject to data availability"). "independently checked" in the hard gate has no independent checker. Verification of 60–100 references "against primary records" presumes network access not confirmed. Figure/table count targets ("approximately 12–16 figures and 8–12 tables") versus "never pad with meaningless exhibits". The French preamble re-maps the directory used in the plan ("le nom `wp20_uqo/` du plan ci-dessous désigne ce dossier").',
++statements_added_during_implementation='Prefatory note (French): "(Spécification de l\'auteur, 2026-10-20. Conventions de forme : ~/Desktop/Recherche-UQO/HARMONISATION.md ; ce dossier s\'appelle `immobilier/multimodal-cost-approach-valuation` et correspond au dépôt spbgit `wp20_uqo.git` — le nom `wp20_uqo/` du plan ci-dessous désigne ce dossier. Journal : `docs/research_log.md`.)" — repository mapping and log location, dated with the specification.',
++analyst_notes='Language mixed (French preamble). Unusually explicit ethics/rights section (E) and a closing principle: "Produce the strongest defensible scientific contribution possible, not the most optimistic portrayal of AI or Vrai Prix." Keyword family `budget` is inflated by "cost approach" (42 hits of "cost").')
++
++R("WP21",document_type="claude_md",
++research_domain="real estate economics / applied econometrics (systematic review and meta-analysis of hedonic pricing models)",
++research_type="empirical (meta-analysis with automated full-text extraction pipeline)",
++explicit_question='"RQ1 characteristics that consistently affect prices across countries and periods; RQ2 size and uncertainty of marginal contributions; RQ3 variation with geography, market conditions, property types, socioeconomics" (RQ1–RQ3 of eight, written as fragments)',
++explicit_estimand_or_hypotheses='partial — effect-size families and pooled quantities defined, no hypotheses: "Families: percentage premiums, elasticities, semi-elasticities, standardised effects, partial correlations, monetary marginal prices." ; "8.1 random-effects (REML) with pooled estimate, SE, 95% CI, 95% PI, τ², I², k studies, n estimates"',
++stated_assumptions='partial — methodological constraints stated as rules rather than assumptions: "no monetary-to-percentage conversion without a defensible reference price" ; "Pool only within comparable groups; document and propagate uncertainty." ; "protocol before synthesis"',
++falsification_or_null_result_conditions='no — robustness and publication-selection diagnostics only ("Leave-one-study-out, leave-one-country-out, …"; "funnel, small-study effects, PET-PEESE where appropriate"); no condition under which a claim is abandoned, except "never relax criteria to reach targets"',
++literature_or_novelty_requirement='yes — the paper is a literature synthesis; "Compare with competing reviews before any \\"largest\\" claim." ; "Explain precisely how the paper extends Sirmans et al. (2005, 2006)"',
++data_access_controls='partial — "read in full when legally accessible" ; "Google Scholar (compliant)" ; no secrets/credential rules',
++temporal_information_controls='no — a search cutoff date is set ("Reproducible search 1970–2026-10-20") but no information-leakage rule applies',
++baseline_requirement='partial — comparison to a prior synthesis rather than baseline methods: "comparison with Sirmans et al." (required table) ; "RQ5 traditional vs spatial vs machine-learning estimates"',
++n_phases_declared='7 (execution order A–G, inline)',
++dependency_or_gate_structure='implicit — ordering only, no gate conditions: "15. EXECUTION ORDER. A research design → B literature acquisition → C data construction → D empirical analysis → E scientific interpretation → F manuscript → G final audit. No results written before analysis"',
++stopping_rules='no — "document obstacles and continue with feasible work."',
++recovery_or_resume_instructions='no',
++artifact_requirements='LaTeX paper (main.tex, sections, tables, figures, appendices, references.bib, reproducibility statement); structured research database data/{raw,metadata,extracted,validated,final}; scripts/{discovery,screening,extraction,harmonization,validation,econometrics,visualization}; protocol/{preregistration,eligibility,search_strategy}.md; reports/{search_audit,extraction_audit,methodological_decisions,limitations}.md; PRISMA flow diagram; 13 required tables and 12 required figures; tests; requirements.txt; README',
++provenance_requirements='yes — "full records of queries, dates, sources, screening decisions, retrieval failures" ; "Store raw and harmonised values; never infer missing SEs except transparently from reported statistics; preserve every conversion formula; every number traceable to source table." ; "coefficient-level information (… page and table, extraction confidence)"',
++review_or_self_audit_stage='yes — "G final audit" ; "Extraction validation: random sample of tables independently verified; report precision, recall, numerical accuracy, error rates; unverified or low-confidence extractions excluded from the primary synthesis." ; "flag ambiguous studies for human review"',
++disclosure_or_AI_use_statement='no',
++budget_or_resource_limits='no',
++integrity_prohibitions='yes — "Never invent studies, citations, coefficients, standard errors, observations, statistical results, or claims of comprehensiveness." ; "never relax criteria to reach targets" ; "Never synthetic results." ; "no promotional language"',
++contradictory_or_non_operational_requirements='Aspirational targets ("≥5,000 unique records screened, ≥1,000 full texts, several hundred eligible studies") are explicitly non-binding ("never relax criteria to reach targets"), so compliance cannot be judged. "protocol/preregistration.md" is required but no mechanism makes it precede the synthesis verifiably. "random sample of tables independently verified" has no independent verifier for a single agent; "flag ambiguous studies for human review" introduces a human-in-the-loop step without specifying who or when. "vision/LLM-assisted classification" implies paid model calls with no budget or recording requirement. "read in full when legally accessible" for ≥1,000 full texts is not checkable. R "where superior" is a judgement call.',
++statements_added_during_implementation='none identified',
++analyst_notes='Densest format: 15 numbered paragraphs, a single Markdown heading (automated n_headings = 1), 1 114 words. Only mandate whose primary object is the literature itself; "Autonomous scientific research assignment, not a narrative review."')
++
++R("WP22",document_type="claude_md",
++research_domain="real estate economics / price-index econometrics (quality-adjusted housing price indices, Quebec transactions)",
++research_type="mixed (empirical index construction + Monte Carlo simulation + methodological contribution)",
++explicit_question='none — stated as objectives, e.g. "Investigate an adaptive estimator that optimizes the trade-off between local information, borrowing strength, temporal responsiveness, bias, and variance." (not phrased as a question)',
++explicit_estimand_or_hypotheses='yes — dedicated section: "## 4. Core estimand Define I[g,k,t] as the quality-constant market price index for geography g, building type k and month t. Establish a reference property distribution and common-support rules. Set 2021 annual average = 100 for the primary index" ; no hypotheses as such',
++stated_assumptions='partial — "Enforce identifiability constraints and explicitly describe priors, likelihood, covariance, temporal evolution and estimation algorithm." ; "Make explicit whether the headline is a price index for the stock, for transacted properties, or for a representative constant-quality basket."',
++falsification_or_null_result_conditions='yes — "Include deliberate counterexamples where SHARP-HPI underperforms simpler alternatives." ; "Report when reconciliation introduces bias or excessive smoothing." ; "Conduct placebo tests, synthetic quality-composition shocks, …" ; "Test whether estimated changes reflect new transaction coverage rather than market dynamics."',
++literature_or_novelty_requirement='yes — "Derive and test an adaptive pooling/shrinkage mechanism; do not call it novel unless a literature review establishes novelty." ; "Explain exactly how the proposed contribution differs from each close predecessor." ; anchor references named (Hill et al. 2022; Ishaak et al. 2024; Hill 2026)',
++data_access_controls='yes — "Discover local Vrai Prix sources, read-only credentials, schemas, backups … Never assume credentials, copy secrets into logs, or modify production." ; "Keep raw transaction records private; publish only legally permissible aggregate results. Never commit credentials or personally identifying records."',
++temporal_information_controls='yes — "Never use post-transaction information or future data in real-time estimates." ; "(2) real-time vintage series estimated using only information available at each historical publication cutoff." ; "Use forward-chaining and rolling-origin backtesting, never random train-test splits for temporal index claims." ; "Prevent image-derived signals from encoding the sale price, future information, listing outcome or date-dependent model artifacts."',
++baseline_requirement='yes — "## 5. Benchmark estimators Implement and compare: A. Raw median and arithmetic mean prices. B. Stratified median. C. Standard pooled hedonic time-dummy OLS. D. Rolling time-dummy … K. Existing QHPI method as a documented benchmark."',
++n_phases_declared='8 (Phase 0–7 in "21. Work sequence")',
++dependency_or_gate_structure='explicit — "## 12. Simulations — mandatory before paper claims" ; "## 22. Final quality gate No paper can be declared complete until all figures and tables are reproducible, every empirical claim is linked to a generated result, all citations are verified, benchmarks have run, Monte Carlo tests are documented, uncertainty is calibrated, geographic coverage is disclosed, sparse cells are labeled, leakage tests pass, the manuscript compiles without substantive errors, and the results have been critically reviewed for overclaiming." (one terminal gate; phases 0–7 are ordered without per-phase pass criteria)',
++stopping_rules='partial — fallback, no stop: "If data access is unavailable, implement testable code and synthetic-data simulations, but never pretend real-data analysis has been completed."',
++recovery_or_resume_instructions='partial — "cached intermediate artifacts" ; "At every phase save machine-readable artifacts and an explicit decision log." ; no resume instruction',
++artifact_requirements='data_dictionary.md; provenance_report.md; cleaned transaction pipeline + exclusion audit; model specification and derivation; reproducible benchmark and SHARP estimators; Monte Carlo framework and results; monthly index panel in Parquet and CSV with a 23-field row schema; coverage/reliability tables; index vintage/revision database; tables and figures from actual outputs; optional interactive geographic diagnostics; limitations and reproducibility documentation; English LaTeX manuscript with BibTeX; unit/integration tests; versioned configs; environment lockfiles; decision log',
++provenance_requirements='yes — "Build an immutable extraction snapshot." ; "provenance_report.md" ; index rows carry "data_cutoff, publication_vintage, model_version, index_method" ; "versioned configurations, unit tests, integration tests, data contracts, environment lockfiles and cached intermediate artifacts"',
++review_or_self_audit_stage='yes — "## 1. Audit and provenance" (data audit) ; final gate requires "the results have been critically reviewed for overclaiming" ; "final reproducibility audit" in Phase 7',
++disclosure_or_AI_use_statement='no',
++budget_or_resource_limits='no — "Profile memory and runtime." and "Use streaming/chunked computation when necessary." are engineering guidance, not limits',
++integrity_prohibitions='yes — "Do not invent data, empirical results, references, statistical significance, or novelty claims." ; "Never equate predictive accuracy with index accuracy." ; "A model estimate with zero local transactions is not an observed monthly price movement." ; "Avoid fabricated precision." ; "Do not silently substitute assessment values for market transactions."',
++contradictory_or_non_operational_requirements='Terminal-gate conditions that cannot be checked from the document alone: "uncertainty is calibrated" (requires truth, available only in simulation), "critically reviewed for overclaiming" (no reviewer defined), "a publishable contribution". Data-dependent requirements that may be unsatisfiable: "aggregation weights, ideally grounded in eligible housing stock", "Compare aggregate series to suitable external indices", "historical boundary crosswalks". Optional/unverifiable: "interactive geographic diagnostics if practical". Factual assertion inside an instruction: "The October 2026 observation is partial through the actual last reliable transaction date". No explicit escalation or stop rule despite "Begin immediately … Continue autonomously".',
++statements_added_during_implementation='none identified',
++analyst_notes='Only mandate with a dedicated "Core estimand" section and a prescribed output data schema. 22 numbered sections, 1 966 words. Strongest temporal-information discipline in the corpus (real-time vintages, revision policy).')
++
++R("WP23",document_type="claude_md",
++research_domain="real estate economics / machine-learning forecasting (spatiotemporal, hierarchical and probabilistic price forecasting, Quebec)",
++research_type="mixed (empirical forecasting evaluation + simulation study)",
++explicit_question='"do newly designed forecasting architectures substantially improve residential real estate price predictions?"',
++explicit_estimand_or_hypotheses='partial — forecasting targets defined, no hypotheses: "Task A — future transaction price: P(i,t+h) = f(X(i,t), S(i,t), M(t), h); address transaction selection explicitly." ; "Task B … horizons 1, 3, 6, 12 months" ; "Task C — probabilistic forecasting: predictive distributions (mean, median, intervals, quantiles, downside risk, P(decline), …)"',
++stated_assumptions='no — none stated or required beyond "Never assume a variable exists."',
++falsification_or_null_result_conditions='partial — the question admits a negative answer and the simulation must show failures, but no disproof condition: "(8) when complex models beat conventional ones" ; "when methods succeed or fail; explain mechanisms" ; "honest novelty statement"',
++literature_or_novelty_requirement='yes — "Never manufacture findings or claim novelty without verifying the literature." ; "# 13. LITERATURE REVIEW — … verify every reference; classify contributions (existing / adapted / new combination / original)." ; "literature search first"',
++data_access_controls='partial — read-only rule on the upstream project only: "WP22 (`../sharp-hpi-quebec`) is read-only for this project." ; "never modify WP22" ; no credential/secret rules',
++temporal_information_controls='yes — "Every feature computed from information available at the forecast origin; no leakage." ; "strict pseudo-real-time expanding/rolling windows; for each origin: information set → estimate → forecast → store → compare. Never random splits." ; "regimes from information available at the origin only" ; "Prevent leakage from WP22: reconstruct index vintages from transactions observable at the origin; audit hedonics, clustering, normalisation, feature selection, imputation, target encoding, graph estimation, tuning, revisions."',
++baseline_requirement='yes — "# 6. BENCHMARKS — econometric (hedonic OLS, ridge/EN, SAR, ARIMA/SARIMA/ARIMAX, VAR/BVAR, DFM, local linear trend, state space), ML (RF, XGBoost, LightGBM, CatBoost, SVR, MLP), deep (LSTM, GRU, TCN, TFT, modern TS), simple (random walk, no change, mean growth, seasonal naive, momentum); fair common origins/information sets"',
++n_phases_declared='none (18 numbered topical sections, no execution phases; only "literature search first" and "SIMULATION STUDY" ordering cues)',
++dependency_or_gate_structure='explicit (terminal gate only) — "# 18. QUALITY GATE — reproducible figures/tables, verified references, leakage audit passed, strict chronology, uncertainty reported, honest novelty statement, manuscript compiles."',
++stopping_rules='no',
++recovery_or_resume_instructions='no',
++artifact_requirements='complete academic LaTeX manuscript (15 sections + appendices on architectures, hyper-parameters, tests, supplementary tables); reproducible Python research pipeline; original forecasting models; empirical results; 15 listed figure types (vector, reproducible); 13 listed table types; supplementary material; simulation study',
++provenance_requirements='partial — "reproducible Python research pipeline", "vector; reproducible" figures and a "leakage audit", but no manifest, hash, seed-logging or number-to-file traceability requirement',
++review_or_self_audit_stage='partial — "leakage audit passed" inside the terminal quality gate; no dedicated results audit or referee stage',
++disclosure_or_AI_use_statement='no',
++budget_or_resource_limits='no — a "computational cost" table is required as a reported outcome, not as a limit',
++integrity_prohibitions='yes — "Never manufacture findings or claim novelty without verifying the literature." ; "no granular results for inadequate cells" ; "predictive importance ≠ causality" ; "no over-complex benchmarks the data cannot estimate"',
++contradictory_or_non_operational_requirements='The document itself declares that it is partly reconstructed: "the pasted text ended at section 17 \\"11. Prob\\"; sections 17–end were completed from the UQO working-paper conventions" and "[Sections 11–15 and the remainder of the protocol were reconstructed by the author\'s assistant because the pasted protocol was truncated.]" — part of the mandate is therefore not the author\'s original instruction. Six named "original" architectures (HSHN, DSGFN, RAREF, BHPF, QANSS, QREFA) are prescribed in advance while novelty is to be "verified" afterwards and "keep only components with incremental out-of-sample value" — pre-specified novelty versus post-hoc selection. "substantially improve" has no effect-size threshold. Heavy methods ("VI / Laplace / HMC on subsets") with no compute budget. Section numbering is internally inconsistent (headings "# 17." and "# 18." versus the note "ended at section 17 \\"11. Prob\\"").',
++statements_added_during_implementation='Two explicit markers: (1) header "> Protocol as received on 2026-10-21 (the pasted text ended at section 17 \\"11. Prob\\"; sections 17–end were completed from the UQO working-paper conventions, see docs/PLAN.md). WP22 (`../sharp-hpi-quebec`) is read-only for this project." ; (2) in section 17: "[Sections 11–15 and the remainder of the protocol were reconstructed by the author\'s assistant because the pasted protocol was truncated.]"',
++analyst_notes='Telegraphic style (1 132 words, 20 headings). The only mandate whose provenance is partly non-authorial by its own admission. No phases, no stop or recovery rules, no provenance manifest, no self-audit beyond the leakage audit.')
++
++R("WP24",document_type="claude_md",
++research_domain="macro-finance theory (AGI, task-based automation, general equilibrium and asset valuation; extension of Restrepo 2025)",
++research_type="mixed (theoretical model + quantitative simulation + empirical calibration/short-run design)",
++explicit_question='"How does increasingly capable and abundant AI reallocate factor income from labor to reproducible and scarce capital, change the ownership distribution of aggregate wealth, and jointly determine the prices and expected returns of financial, real-estate, and other assets?"',
++explicit_estimand_or_hypotheses='yes — nine target results: "T1. Conditions under which Restrepo\'s labor-share asymptote survives multi-sector production with complementary physical inputs and scarce factors; counterexamples with binding energy/land. T2. Sufficient conditions for factor-income reallocation …" through T9 ; "Each result needs explicit assumptions, mathematical statement, rigorous proof or counterexample, economic interpretation, and simulation check."',
++stated_assumptions='yes — primitives are stated and a numbered assumptions protocol and register are required: "Restrepo\'s central primitives include task output X_t(ω)=L_t(ω)+Q_t(ω)/α_t(ω), …" ; "Proof protocol: write assumptions as numbered statements; verify differentiability, convexity/concavity, equilibrium existence, transversality, boundedness, market clearing, timing, stochastic integrability, and no-arbitrage." ; `docs/assumptions_register.md`',
++falsification_or_null_result_conditions='yes — "Do not assume that AI automatically raises profits, all asset prices, inequality, or aggregate welfare. Derive conditions and counterexamples." ; "Tests must fail on deliberately inconsistent accounting." ; "identify parameter regimes where asset valuations fall despite higher output" ; "Provide a falsifiable short-run empirical design: … with pre-trends, confounding, measurement error and alternative mechanisms addressed."',
++literature_or_novelty_requirement='yes — "Prepare a literature matrix: … Verify exact references from authoritative sources. Mark all unverified claims." ; referee question "(1) is this genuinely new relative to Restrepo and task models?" ; "Explicitly separate the original author\'s conclusions from our proposed extensions."',
++data_access_controls='yes — "Do not present proprietary datasets as accessible unless actually available." ; "company annual reports/Compustat if licensed" ; "`data/README.md`, `data/raw/`, `data/processed/`: sources, licenses, provenance and transformations; no fabricated observed data."',
++temporal_information_controls='partial — vintage awareness and pre-trend checks, no leakage rule: "Check exact definitions, vintages, geographic scope, units, time frequency and licenses." ; "Validate against pre-AGI historical patterns without claiming the historical sample identifies post-AGI structural parameters." ; "Do not use speculative AGI dates as facts."',
++baseline_requirement='yes — "Reproduce a minimal baseline numerically or analytically before adding features." ; "Implement a real baseline first." ; paper section "3. Benchmark Restrepo replication and limitations." ; "Define a transparent benchmark and add layers with tests at every stage."',
++n_phases_declared='7 (Phase 0–6) plus a 12-step "EXECUTION ORDER" A–L',
++dependency_or_gate_structure='explicit — "## EXECUTION ORDER AND STOP CONDITIONS A. Audit source PDF and write source notes; B. derive smallest exact benchmark; C. … L. perform referee audit and final replication." ; "Never declare a theorem proven without a proof; never declare a model solved without numerical equilibrium checks; never declare a PDF compiled without verifying the file." ; "Implement deterministic perfect-foresight transition first, then aggregate shocks" (no numbered gates)',
++stopping_rules='partial — the heading says "STOP CONDITIONS" but the content is a fallback: "If a block cannot be solved, deliver a verified simpler model and clearly document the limitation." ; "start implementing without waiting for further permission unless a genuinely blocking external input is required."',
++recovery_or_resume_instructions='partial — "At each stage update `docs/research_log.md` with completed steps, assumptions, residuals, unresolved problems and next actions." ; "Record seeds, solver tolerances and convergence diagnostics." ; no resume/checkpoint instruction',
++artifact_requirements='paper/main.tex (35–60+ pages); paper/appendix.tex; paper/references.bib; slides/main.tex (30–45 Beamer slides); src/ (solver, simulations, calibration, tests); data/README.md + raw/ + processed/; results/ (tables, figures PDF+PNG, parameter files, machine-readable outputs); docs/{model_dictionary,assumptions_register,identification,research_log,replication,referee_report}.md; Makefile; requirements.txt or pyproject.toml; environment lockfile; README with one-command reproduction; compiled PDFs "if TeX available"',
++provenance_requirements='yes — "sources, licenses, provenance and transformations" for data ; "Build a source-to-parameter table with observed moments, uncertainty and identification limits." ; "Clearly separate externally identified, calibrated and scenario-only parameters." ; "every result traceable to output" ; "Record seeds, solver tolerances and convergence diagnostics."',
++review_or_self_audit_stage='yes — "## PHASE 6 — CRITICAL SELF-REVIEW Write an adversarial referee report addressing: (1) is this genuinely new relative to Restrepo and task models? (2) is the model too large to identify? … (12) can the core mechanisms be established in a simpler model? Revise after review." ; docs/referee_report.md',
++disclosure_or_AI_use_statement='no',
++budget_or_resource_limits='no',
++integrity_prohibitions='yes — "no invented citations, DOIs or results" ; "no fabricated empirical estimates, no invented statistical significance" ; "Never declare a theorem proven without a proof; never declare a model solved without numerical equilibrium checks; never declare a PDF compiled without verifying the file." ; "Label conjectures as conjectures, not theorems." ; "Avoid hype words like \'revolutionary\' or \'legendary\' in manuscript."',
++contradictory_or_non_operational_requirements='Scope tension: an 8–12-sector IO economy with heterogeneous households, full asset-pricing block, optional monetary/fiscal/open-economy modules and a 2026–2100 simulation versus "Use a nested, modular economy, not an intractable all-at-once model" and "Prioritize a correct publishable contribution over a grand but incoherent system" (resolved only by priority ordering). Length targets ("35–60+ page", "30–45 Beamer") with no anti-padding clause other than the priority statement. External dependency: "Download and read the complete original PDF" presumes network access. "STOP CONDITIONS" heading without any stop condition. Conditional deliverables ("Compile PDFs if TeX available") make completion ambiguous. Non-verifiable: "publication-quality", "disciplined findings".',
++statements_added_during_implementation='Explicit post-hoc section: "## UQO conventions (added 2026-10-27) This project is **UQO Working Paper No. 24** in `Recherche-UQO/finance/`. Follow `Recherche-UQO/HARMONISATION.md` (canonical title page, `\\WP…` macros, README template, `paper/Makefile` + `.latexmkrc`, git remote `gitsrv:srv/git/wp24_uqo.git`)."',
++analyst_notes='Mandate was written without UQO framing and later attached to the series (addition dated 2026-10-27). Contains a "FIRST RESPONSE EXPECTED FROM CLAUDE CODE" section specifying the first turn. Only mandate requiring seminar slides.')
++
++R("WP25",document_type="claude_md",
++research_domain="economic theory / computational economics (agentic general equilibrium, LLM agents as delegated decision-makers)",
++research_type="mixed (theoretical model + heterogeneous-agent numerics + LLM-agent simulation laboratory)",
++explicit_question='"How does delegation of economic decisions to autonomous AI agents change equilibrium wages, interest rates, asset prices, capital accumulation, production, credit, systemic risk, and wealth inequality?"',
++explicit_estimand_or_hypotheses='yes — six falsifiable hypotheses: "H1: Delegation creates an endogenous adoption threshold determined by information gains, execution costs, compute prices and agency losses. H2: Shared foundation models correlate trades and may reduce market depth under stress, conditional on common information. H3: …" through H6 ; "Pre-register outcomes."',
++stated_assumptions='partial — required at every stage and sketched as a non-binding starting point: "(b) write down assumptions" ; "Provide propositions and rigorous proofs under explicit assumptions, or label unsolved statements conjectures." ; "Illustrative starting point, NOT an assumed final model: V_i(s)=max_{c,l,a\',d}{…}"',
++falsification_or_null_result_conditions='yes — "For each: mathematical mechanism, formal or numerical prediction, falsification condition, isolation experiment and limitation." ; "Science gate: controlled experiments, uncertainty, negative results, sensitivity and mechanism isolation." ; "Supply counterexamples and boundary cases."',
++literature_or_novelty_requirement='yes — "Before developing the model, search and verify literature on … Create `docs/literature_matrix.md` with verified bibliographic details, URLs/DOIs, modeling differences, and the precise remaining gap. No invented references." ; "1. **Novelty gate:** verified literature matrix, precise contribution and competing explanations."',
++data_access_controls='yes — "Support local OpenAI-compatible inference and optional BYOK providers; no embedded credentials." ; "Request user input only for indispensable private data, external credentials, expensive compute authorization, or major scope changes." ; "Use verified public macro, labor, wealth, interest rate and financial data where possible."',
++temporal_information_controls='yes — "Prevent look-ahead and information leakage." ; "validate surrogates on held-out actions" ; "No final-test-informed" logic implied by "Pre-register outcomes."',
++baseline_requirement='yes — "Controls: rational optimized agents, rules, reinforcement learning, single LLM, multiple heterogeneous LLMs, shared LLM with varied prompts, with/without tools, memory and negotiation." ; "Benchmark model with AI switched off against known analytical cases." ; "zero-AI limiting case" (Numerics gate) ; scenario "no AI"',
++n_phases_declared='6 (six numbered "Milestones and acceptance gates"; the "Start now" paragraph adds an ordered sequence; no "Phase N" labels)',
++dependency_or_gate_structure='explicit — "## Milestones and acceptance gates 1. **Novelty gate:** … 2. **Theory gate:** … 3. **Numerics gate:** … 4. **Agent gate:** … 5. **Science gate:** … 6. **Writing gate:** … Do not proceed to extravagant multi-agent simulations before gates 1–3 are met. If a gate fails, report why and repair the design." ; "Build tiny verified economies first; scale only after tests pass."',
++stopping_rules='partial — gate-failure and escalation rules, no stop: "If a gate fails, report why and repair the design." ; "Request user input only for indispensable private data, external credentials, expensive compute authorization, or major scope changes." ; "If internet or TeX is unavailable, state the limitation and continue with honest local deliverables."',
++recovery_or_resume_instructions='yes — "Support deterministic seeds, config-driven CLI, checkpointing, experiment manifests, Git revision and reproducible environment locks." ; "Cache reproducibly."',
++artifact_requirements='repository scaffold (configs/, data/raw+processed, src/age/{economy,agents,equilibrium,markets,banking,llm,experiments,analysis}, tests/{unit,integration,property}); docs/{literature_matrix.md,model_specification.md,parameter_ledger.csv,research_log.md,limitations.md}; experiments/pre_registration.md; results/{figures,tables} (13 named figure types, 9 named table types, vector quality); paper/main.tex + sections/ + appendices/ (proofs, algorithms, prompts, schemas, replication instructions) + references.bib; README; pyproject.toml; "replication package"; "2–3 page research blueprint"',
++provenance_requirements='yes — "Record model/version, prompt, context, temperature, seed, response, latency, tokens and cost. Cache reproducibly." ; "experiment manifests, Git revision and reproducible environment locks" ; "figure/table provenance" (Writing gate) ; "`docs/parameter_ledger.csv`: parameter, units, source, year/geography, moment, method, range, uncertainty."',
++review_or_self_audit_stage='yes — "6. **Writing gate:** complete paper, figure/table provenance, verified references, replication package and hostile-referee critique." ; execution protocol step "(e) discuss threats to interpretation"',
++disclosure_or_AI_use_statement='no',
++budget_or_resource_limits='partial — costs recorded and expensive compute requires authorisation, no numeric budget: "expensive compute authorization" ; "Record … tokens and cost" ; figure "inference cost frontier" ; "Start on a single workstation; optional distributed inference only after a working local baseline."',
++integrity_prohibitions='yes — "Never fabricate results, citations, proofs, datasets, or calibrations. Label conjectures and illustrative simulations. Verify novelty before claiming it." ; "LLM output is never trusted as accounting truth." ; "Never claim a test passed unless it ran." ; "Do not call arbitrary LLM-generated market outcomes general equilibrium without verifying feasibility, market clearing and convergence." ; "Never treat simulated LLM preferences as verified human preferences."',
++contradictory_or_non_operational_requirements='"Pre-register outcomes." and `experiments/pre_registration.md` without any timestamping/registry mechanism — pre-registration by the same agent that runs the experiments is not verifiable. "hostile-referee critique" is produced by the same model. Scope tension between "Aim for a parsimonious groundbreaking mechanism, not complexity for its own sake" and three nested models (A, B, C) plus an LLM laboratory with eight roles and banking. Negative design constraint stated as judgement: "The key innovation MUST NOT be simply adding AI to a Cobb–Douglas production function." Non-verifiable: "Aim at top economics/finance/computational economics journals without assuming acceptance."',
++statements_added_during_implementation='Prefatory note: "(UQO Working Paper No. 25 — repository `Recherche-UQO/finance/agentic-general-equilibrium`, spbgit `wp25_uqo.git`. Programme supplied by the author on 2026-10-27; form follows `Recherche-UQO/HARMONISATION.md`.)" — repository mapping added around the author\'s programme (dated 2026-10-27, same day as the programme).',
++analyst_notes='Gate structure is the most formal of the theory mandates (six named acceptance gates with contents). Explicit per-stage protocol "(a) state the precise scientific question, (b) write down assumptions, (c) implement and test, (d) show numerical evidence or mathematical proof, (e) discuss threats to interpretation, (f) log decisions and next tasks."')
++
++R("WP26",document_type="claude_md",
++research_domain="real estate valuation / multi-agent AI (LLM agent deliberation for property valuation, Quebec transactions)",
++research_type="mixed (empirical evaluation + design-science multi-agent system + stylised welfare model)",
++explicit_question='"RQ1: Do specialized multi-agent systems outperform single LLMs, hedonic models, repeat-sales approaches, gradient boosting, and conventional AVMs on genuinely unseen Quebec transactions?" (RQ1 of six)',
++explicit_estimand_or_hypotheses='yes — pre-specified primary outcome: "Pre-register primary endpoints and hypotheses before running final test evaluations. Primary outcome: out-of-time absolute log-price error on arm\'s-length residential transactions. Co-primary or secondary: MAE in CAD, MdAPE, RMSE log, tail error (P90/P95), interval coverage, interval width, CRPS or pinball loss, cost and latency." ; "Propose falsifiable propositions about diversity, correlation, communication topology, and aggregation weights."',
++stated_assumptions='partial — "State identification assumptions and develop multiple operational definitions of value." ; "Transaction prices are noisy proxies, not ground-truth fundamental values." ; "Do not claim general existence/uniqueness theorems without proof."',
++falsification_or_null_result_conditions='yes — "A negative finding is publishable if the design is rigorous." ; "Report failure as rigorously as success." ; placebo arm "I. Random/shuffled-role or placebo deliberation" ; "Explicitly separate improvements from more tokens, more tools, more models, or more data." ; "Derive testable conditions under which deliberation reduces or increases mean-squared error"',
++literature_or_novelty_requirement='yes — "Phase 1: literature review and novelty map; identify close prior multi-agent real-estate/AVM papers and avoid unsupported priority claims." ; "Search and verify the relevant academic literature if browsing is available; otherwise flag bibliography for verification."',
++data_access_controls='yes — "These are potential sources, not automatically accessible. Begin with a data-access audit" ; "Do not bypass authentication, scrape restricted endpoints, or infer consent. Do not send personal identifiers, private listing remarks, occupant information, or confidential records to external LLM APIs without authorization and suitable safeguards." ; "use environment variables and a local secrets manager, never put secrets in source control or manuscript" ; "Publish only de-identified or synthetic examples if redistribution is not authorized."',
++temporal_information_controls='yes — "Only use features observable as of the valuation timestamp; prevent post-sale information and target leakage." ; "Comparable retrieval must be strictly as-of-date; no same-property future transfers, post-sale listings, or near-duplicate records leaking across partitions." ; "Use a chronological split with train/validation/test and a final untouched holdout" ; "Build a leakage-audit suite and adversarial tests." ; "No final-test-informed aggregation weights."',
++baseline_requirement='yes — "Implement and evaluate at least: A. Hedonic OLS / regularized regression (proper spatial/time controls) B. Repeat-sales or hierarchical hedonic … C. CatBoost/XGBoost/LightGBM tuned on validation only D. Strong tabular AVM … E. Single LLM, evidence-matched F. Independent LLM agents aggregated without communication … J. Cost-matched single-agent repeated reasoning and cost-matched ensemble"',
++n_phases_declared='9 (Phase 0–8 in "Execution phases and acceptance gates") plus seven "Immediate first actions"',
++dependency_or_gate_structure='explicit — "## Execution phases and acceptance gates Phase 0: inventory … Phase 5: run provider-balanced, information-matched, compute-matched randomized ablations on validation; freeze protocol. Phase 6: evaluate final temporal/spatial holdouts once, with clustered uncertainty and cost accounting. … Phase 8: produce manuscript" ; "After each phase, produce a concise `reports/phase_XX.md` with completed artifacts, failed checks, decisions, outstanding assumptions, and exact commands." (ordering and freeze/once-only conditions; no per-phase pass criteria beyond the phase reports)',
++stopping_rules='partial — escalation rule and debate-round limits only: "Stop and ask targeted questions only for indispensable access or decisions; otherwise proceed with explicitly documented defaults. Never fabricate completion." ; "Limit debate to pre-specified rounds (e.g. 0, 1, 2, 4)" ; src/debate/ "stopping rules"',
++recovery_or_resume_instructions='partial — "privacy-aware caching" ; "bounded retries" ; "store response artifacts securely and measure run-to-run variation" ; no resume/checkpoint instruction',
++artifact_requirements='README.md, CLAUDE.md, pyproject.toml, .env.example, LICENSE; configs/ (splits, model IDs, treatments, budgets, seeds); src/{data,features,baselines,agents,debate,evaluation,experiments}; tests/ (unit/integration/leakage/mock-provider); notebooks/; paper/ (LaTeX manuscript, BibTeX, figures, tables, appendices, compilation script, PDF); reports/ (experiment cards, failure analyses, model cards, limitations, phase_XX.md); research_plan.md, data_access_checklist.md, preregistration.md, architecture.md; data dictionaries; clearly labeled synthetic dataset and mock LLM adapters; CLI (ingest, validate, train, run agents, evaluate, generate tables, build PDF); limitations register; API-cost budget',
++provenance_requirements='yes — "Store raw snapshots immutable with data dictionaries, versioned transformations, provenance, licenses, and record-level lineage." ; "Record model IDs, API parameters, prompt hashes, temperature, tool calls, token usage, cost estimates, and latency." ; "All figures/tables must come from versioned outputs." ; "Pin dependencies, set seeds, capture versions and hardware"',
++review_or_self_audit_stage='yes — roles "11. Data-quality, leakage, and provenance auditor 12. Independent skeptical reviewer / red-team agent" ; "Phase 7: human benchmark if authorized, welfare model, robustness, interpretability audits." ; "Build a leakage-audit suite and adversarial tests."',
++disclosure_or_AI_use_statement='no — "Agents are **simulated analytic roles**, not licensed Quebec appraisers or real lenders; never misrepresent professional certification." concerns role representation, not AI-use disclosure for the paper',
++budget_or_resource_limits='yes — "Present an API-cost budget with small pilot, medium validation, and final experiment tiers, without inventing vendor prices." ; "token budgets" ; "compare all-Claude, all-OpenAI, and mixed-provider committees at matched cost and information budgets" ; "async concurrency with strict limits"',
++integrity_prohibitions='yes — "Never invent data, results, citations, human assessments, API capabilities, or model performance." ; "Never fabricate empirical tables: use placeholders clearly marked `NOT YET ESTIMATED` until generated by scripts." ; "No p-hacking or test-set prompt tuning." ; "do not fabricate a human benchmark" ; "Do not claim deterministic reproducibility for hosted LLMs"',
++contradictory_or_non_operational_requirements='"Pre-register primary endpoints and hypotheses before running final test evaluations" and `preregistration.md` have no registry/timestamp mechanism; the same agent writes and executes. "evaluate final temporal/spatial holdouts once" — the once-only rule has no enforcement mechanism. Human-dependent arm: "recruit licensed appraisal professionals and/or trained human appraisers under an approved protocol" cannot be executed autonomously (mitigated: "mark this arm as pending and do not claim it was performed"). "Respect Quebec privacy requirements and organizational research-ethics review where applicable" is not operational for an agent. Tension between "make outputs reproducible" and "Do not claim deterministic reproducibility for hosted LLMs" (resolved by storing response artifacts). Scope (12 default roles, up to 20, ten treatment arms, three provider configurations) versus an API budget that is to be proposed rather than given.',
++statements_added_during_implementation='Explicit post-hoc section: "## Repository conventions (added by the implementation, 2026-10-27) - UQO Working Paper No. 26, folder `Recherche-UQO/immobilier/agentic-valuation-quebec`, git remote `gitsrv:srv/git/wp26_uqo.git`. - Python package: `src/agentic_valuation/` (installed editable: `pip install -e .`). CLI: `av <command>` (see README). - Secrets only in `.env` (gitignored). Snapshot provenance in `data/raw/README.md`. Every result file is produced by a numbered script in `scripts/`."',
++analyst_notes='Most complete empirical-design mandate in the corpus: pre-specified primary outcome, placebo arm, cost-matched controls, leakage suite, API budget tiers, phase reports. Research-only clause: "No live autonomous trading, lending decisions, or real estate offers".')
++
++R("WP28",document_type="claude_md",
++research_domain="econometric theory / statistical computing (distributed maximum likelihood, higher-order bias correction, communication-computation trade-off)",
++research_type="mixed (mathematical theory + Monte Carlo simulation + distributed-systems benchmark)",
++explicit_question='"For regular nonlinear likelihood models with `N` observations and `K` distributed partitions, how can additional local computation replace global network synchronization while preserving the first-order inferential properties of centralized maximum likelihood?"',
++explicit_estimand_or_hypotheses='yes — candidate theorem and proof queue: "K = o( N^[ 1 - 1 / ( 2^(q+1) * r ) ] )" ; "**Theorem 3 — Exact exponential boundary.** Derive all Gamma moments needed and establish the nonzero limit `-4 theta_0 c^4` for half-block jackknife + one global Newton step when `K ~ c N^(7/8)`." ; Lemmas 1–7, Theorems 1–4, a failure Proposition and a Corollary are enumerated',
++stated_assumptions='yes — baseline model assumptions are listed in the mandate and an assumptions file is required: "### 5.1 Baseline model Start with i.i.d. observations and a correctly specified fixed-dimensional regular likelihood: - `X_1,...,X_N ~ P_{theta_0}` independent; - `theta_0` interior to an open parameter set in `R^p`; - information matrix `I(theta_0)` positive definite; …" ; "State precisely which theorem uses which assumption." ; theory/ASSUMPTIONS.md',
++falsification_or_null_result_conditions='yes — "A dead end with a mathematical explanation is better than a fabricated breakthrough. A strong negative result or counterexample may itself become the contribution." ; "**Gate 4:** at least one nontrivial theorem beyond a rephrasing of known one-step-plus-jackknife results is fully proved, **or** the report explicitly concludes that novelty is not yet proved and reframes the paper around validated insights and counterexamples." ; "a counterexample or violation for at least one essential assumption" ; "**Proposition — Failure/counterexample.**" ; "Track E — Lower bounds, counterexamples and impossibility"',
++literature_or_novelty_requirement='yes — "Do not claim that distributed gradients, one-step Newton, split-sample jackknife, Richardson extrapolation, `K = o(N^{7/8})`, or `K = o(N^{11/12})` are intrinsically novel. Investigate who has already obtained each idea or bound." ; `literature/PRIOR_ART_MATRIX.csv` with "novelty_threat" column ; "**Gate 1:** no unqualified novelty language is allowed until the closest competing theorems have been inspected and cited." ; six anchor references with DOIs to verify',
++data_access_controls='yes — "never scrape or transmit private material to external services without authorization" ; "Do not expose API keys, SSH keys, passwords, endpoint secrets or private datasets in source files, logs, paper, artifacts or commits." ; "Use the researcher\'s available CPU/GPU/cluster systems only when provisioned and authorized." ; "Avoid destructive commands, forced pushes and unrelated repository modifications."',
++temporal_information_controls='no — not applicable (synthetic Monte Carlo); only a literature cutoff: "**Current date for literature cutoff:** 2026-10-28; search current material rather than assuming bibliographic currency."',
++baseline_requirement='yes — "Full centralized maximum likelihood, using a trusted optimizer and tight tolerances." ; "Credible implementations of at least two strong literature baselines where practical, such as surrogate likelihood/CSL and another relevant distributed estimator." ; audit items "New method comparisons include ordinary local averaging + two Newton rounds." and "A baseline with exact sufficient-statistic aggregation is shown for applicable families."',
++n_phases_declared='13 (Phase 0–12, each closed by Gate 0–12)',
++dependency_or_gate_structure='explicit — "**Execute in order, completing one phase\'s acceptance tests before starting the next.**" ; "**Gate 0: pass only when** all old claims and artifacts are inventoried, every existing number is tagged as replicated / not replicated / unavailable, and a WP28 workspace exists without clobbering other work." ; "**Gate 6:** all critical tests pass and the code reconstructs original-paper figures within stated tolerances before large experiments begin." ; pass/fail rubric in section 16',
++stopping_rules='yes — "Complete the project from initial inspection through PDF validation; stop only when a real blocker makes an indispensable step impossible. Document blocked items, and continue with whatever can be completed." ; "**Gate 11:** produce `FINAL_REVIEW.md` with a final verdict `ready for human review / theoretically incomplete / novelty unresolved / computational evidence insufficient`" ; "Never assert results from jobs that have not finished." ; "Do not publish a preprint or submit to a journal without explicit instruction."',
++recovery_or_resume_instructions='partial — phase status and run manifests, failure tracking, no resume instruction: "After completing each phase, append to `PHASE_STATUS.md`: Phase: Start/finish timestamp: What was actually done: Artifacts created: Tests passed: Tests failed: …" ; "Track optimization failures rather than discard failed replications silently." ; "straggler failures" to be bounded',
++artifact_requirements='article (~25–40 pages) + mathematical appendix; paper/{main.tex,preamble.tex,sections,appendices,references.bib,figures}; literature/{PRIOR_ART_MATRIX.csv,PRIORITY_AND_GAP.md}; theory/{THEOREM_AUDIT.md,ASSUMPTIONS.md,proofs_check.py,symbolic_checks.py}; src/pamle/ (10 modules) with common-interface estimators; experiments/{configs,run_monte_carlo.py,run_benchmarks.py,run_ablations.py,EXPERIMENT_MANIFEST.csv}; tests/ (7 files); results/{raw,processed,tables,figures,resource_profiles}; scripts/{setup.sh,reproduce_all.sh,compile_paper.sh,validate_pdf.sh}; PROJECT_MAP.md, SOURCE_PROVENANCE.md, PHASE_STATUS.md, research_log.md, LIMITATIONS_AND_CLAIMS.md, FINAL_REVIEW.md, FINAL_DELIVERY.md; proof ledger; 8 figures + 6 tables programme; delivery bundle (PDF, .tex, source-and-reproducibility zip, Research_Summary, Theorem_Audit, Prior_Art_and_Novelty, Experiment_Results.csv, Final_Review); nine-point closing report',
++provenance_requirements='yes — "Extract the existing archive to an immutable `references/initial_pamle/` directory if available; record checksums." ; run manifest "run_id,git_commit,python_version,dependency_lock_sha256, seed,N,K,m,p,DGP,method,optimizer,tolerance,replicates, parallel_backend,node_count,hardware,OS,wall_seconds, communicated_bytes,rounds,status,raw_output_sha256" ; "Every table value has a traceable input/output path." ; "Project checksums and commit state are captured."',
++review_or_self_audit_stage='yes — "## 14. PHASE 11 — Adversarial referee and proof audit Simulate at least three independent review perspectives; log objections and responses" (Referees A, B, C) ; "For every objection, respond with (a) exact location in paper/code, (b) correction made, (c) new proof/test if needed, and (d) residual limitation." ; THEOREM_AUDIT.md with "proved / conditional / open / false" labels',
++disclosure_or_AI_use_statement='yes — "Confirm the applicable journal/venue authorship and AI-disclosure policy before a submission version; never falsely represent an AI system as a legally accountable human author." ; "The journal submission version may need GPT-6.1 removed from the formal author list and placed in transparent AI-use disclosure; **flag this for the human author rather than concealing the difference**." ; audit item "AI contribution disclosure and human review requirements are explicit." ; rubric row "Attribution | Simon-Pierre Boucher properly named; AI role transparently recorded"',
++budget_or_resource_limits='partial — resources bounded by availability, no numeric cap: "Continue to a publishable-quality, internally consistent draft within the resources and access actually available." ; "`N`: logarithmic sequence … chosen based on available RAM/compute" ; blocker category "(iv) exhausted compute budget" ; "where measured, electricity and dollar-cost assumptions"',
++integrity_prohibitions='yes — "No invented theorem, proof, assumption, dataset, benchmark, reference, DOI, parameter estimate, speedup, significance level, or journal acceptance." ; "Do not call an in-memory mathematical partition a distributed cluster benchmark." ; "Never assert results from jobs that have not finished." ; "Do not silently describe these as 1,000 replications or as physical-cluster experiments." ; "Never explicitly invert the Hessian in production code"',
++contradictory_or_non_operational_requirements='(1) "Simulate at least three independent review perspectives" versus "do not have the same model merely declare its own work accepted" — the simulated referees are by construction the same model, so independence is not operational. (2) Authorship: "Preserve this provenance and the user\'s requested GPT-6.1 attribution in the working draft" (GPT-6.1 in the author block) versus "never falsely represent an AI system as a legally accountable human author" — resolved only by deferring to the human for the submission version. (3) "Research program funding line to include **only if confirmed** for this particular WP28 project" — confirmation requires the human; the agent cannot satisfy it. (4) Compute: "target at least 1,000 per **main statistical design**" across ≥4 N values, several K, several p, ≥3 models and DGP conditions with no budget beyond "where practical". (5) Conditional bonuses ("If Lean is installed, formalize at least one deterministic algebraic lemma as a bonus, not as a blocker"). (6) Rubric criteria such as "substantive new result or defensible negative discovery" and "journal-style typography" are not script-checkable. (7) "The researcher may have access to a MacLustr collection" together with "never assume the existence … of a MacLustr node" is consistent but leaves hardware scope undetermined until run time.',
++statements_added_during_implementation='none identified as post-hoc; the header records prior provenance rather than an addition: "**Prior exploratory draft credits:** Simon-Pierre Boucher and GPT-6.1. Preserve this provenance and the user\'s requested GPT-6.1 attribution in the working draft."',
++analyst_notes='Longest mandate in the corpus (8 809 words, 76 headings, 27 code blocks, 2 Markdown tables). The only mandate with an AI-use/authorship disclosure instruction, a per-phase acceptance-test rule ("completing one phase\'s acceptance tests before starting the next"), a pass/fail rubric table, a multi-referee audit phase and a verdict vocabulary. Explicitly a re-examination of a prior AI-assisted draft ("This is NOT an instruction to paraphrase the exploratory note.").')
++
++R("WP27_BRIEF",document_type="design_brief",
++research_domain="finance / market microstructure (agent-based limit-order-book simulation with LLM trading agents)",
++research_type="simulation (agent-based market simulator with a stylised one-period theoretical model)",
++explicit_question='none — the brief describes "what the simulator *actually* implements" and lists hypotheses H1–H6; no research question is stated',
++explicit_estimand_or_hypotheses='yes — "Hypotheses the simulator tests: H1 informativeness falls in the share using a single shared model (holding information quality fixed) and rises in M_eff; H2 order-flow correlation and synchrony rise in φ; H3 bubble/crash frequency and liquidity spirals rise with φ × leverage; H4 prompt/model diversity restores part of the loss; H5 communication channels raise synchrony; H6 circuit breakers and position limits cut crash depth at a cost in time-to-absorb." ; objects defined: "price informativeness τ = 1 − Var(v | Y)/σ_v²; pricing error Var(P − v); order-flow correlation ρ_x = Corr(x_i, x_j); synchrony; effective number of models M_eff = 1/Σ_g φ_g²"',
++stated_assumptions='yes — model assumptions stated in the text: "One-period, one asset, liquidation value v ~ N(0, σ_v²) around the public PV. N traders receive s_i = v + ε_i with ε_i = η_{g(i)} + u_i" ; "β > 0 a fixed response intensity; the behavioral assumption mirrors rule-like LLM policies and is relaxed in a CARA extension" ; "A competitive, risk-neutral market maker sets P = E[v | Y]"',
++falsification_or_null_result_conditions='partial — directional hypotheses are testable and a seed/power design is sketched ("≥ 30 seeds exploratory, power-based for confirmatory"), but no null-result condition is stated',
++literature_or_novelty_requirement='no — the brief is addressed to "the sub-agents writing the literature review, theory and pre-analysis plan" but imposes no literature or novelty requirement',
++data_access_controls='no — synthetic data; providers listed without access rules: "Providers: OpenAI (Responses API, json_schema), Anthropic (Messages API, json_schema), mock (seeded rule with injected invalid answers)."',
++temporal_information_controls='yes — information-set discipline inside the simulator: "Agents never see V_t." ; "No agent sees future draws." ; "orders arrive at decision time + latency and are processed in arrival order"',
++baseline_requirement='partial — control arm and matched design rather than named baseline methods: "Matched pairs across `llm_share` share every stream except the LLM slot draw." ; "mock (seeded rule …)" provider ; "frozen decision library replay vs online calls"',
++n_phases_declared='none',
++dependency_or_gate_structure='none',
++stopping_rules='no',
++recovery_or_resume_instructions='no',
++artifact_requirements='none stated explicitly; implied: literature review, theory write-up ("to be written up by the theory agent, must map to the above") and a pre-analysis plan; the simulator reports "Realized LLM share of agents, orders and volume"',
++provenance_requirements='partial — "Randomization: master seed → independent streams (fundamentals, news, slots, policy assignment, LLM slot assignment, activation, tie-breaks, per-agent RNG)." ; "Invalid decisions = hold, logged." ; "exact conservation checked after every fill" ; no manifest/hash requirement',
++review_or_self_audit_stage='no',
++disclosure_or_AI_use_statement='no',
++budget_or_resource_limits='partial — budgets appear as experimental treatments, not as resource limits: "equal token / USD / decision-opportunity budgets"',
++integrity_prohibitions='no',
++contradictory_or_non_operational_requirements='Not a mandate, so few directives. Non-operational: "power-based for confirmatory" without a power target or effect size; "must map to the above" asserts a correspondence between the one-period theory and the multi-tick simulator (fixed β market orders versus a continuous double auction) that the brief does not check.',
++statements_added_during_implementation='none identified — but the whole document is by nature post-implementation ("It describes what the simulator *actually* implements (src/market_agents)").',
++analyst_notes='Supplementary design brief, not a CLAUDE.md; coded separately and excluded from all "of 11" counts. WP27\'s own CLAUDE.md returned HTTP 404 and is not represented in the corpus. 820 words, 3 headings.')
++
++R("WP15_PROMPT",document_type="duplicate",
++research_domain="see WP15", research_type="see WP15",
++explicit_question="see WP15 (byte-identical duplicate; not coded separately)",
++**{k:"n/a — duplicate of WP15_CLAUDE.md (same SHA-256 2dd19c59fd320ee5fcdbb25f9ebd41b08b612703573cd8af119858e21a521b77)" for k in F[9:28]},
++analyst_notes='docs/PROMPT_INITIAL_CLAUDE.md in the wp15_uqo repository is byte-identical to docs/CLAUDE.md in the retrieved snapshot. Recorded once in the corpus manifest for completeness; counted as one mandate (WP15) in all tallies. The two paths suggest the initial prompt was preserved verbatim as the working CLAUDE.md, but the snapshot alone cannot establish which file came first.')
++
++order=["WP15","WP18","WP19","WP20","WP21","WP22","WP23","WP24","WP25","WP26","WP28","WP27_BRIEF","WP15_PROMPT"]
++rows.sort(key=lambda r:order.index(r["wp"]))
++out=os.path.join(ROOT,"corpus_coding.csv")
++with open(out,"w",newline="",encoding="utf-8") as f:
++    w=csv.DictWriter(f,fieldnames=F,quoting=csv.QUOTE_ALL,lineterminator="\r\n")
++    w.writeheader()
++    for r in rows:
++        missing=[k for k in F if k not in r]
++        assert not missing,(r["wp"],missing)
++        w.writerow(r)
++# validate
++back=list(csv.DictReader(open(out,newline="",encoding="utf-8")))
++assert len(back)==13 and all(len(r)==len(F) for r in back)
++print("ok",len(back),"rows",len(F),"columns ->",out)

added research/references_verified.bib +915 −0

Large diff (915 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/doi_resolution.json +84 −0

Large diff (85 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1006_2Fijhc_1999_0252 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1007_2Fs10994_025_06955_2 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1016_2F0005_1098_2883_2990046_8 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1016_2Fj_cortex_2012_12_016 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1016_2Fj_future_2014_10_008 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1016_2Fj_patter_2021_100322 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1016_2Fj_websem_2015_04_001 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fnbt_3820 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fs41562_016_0021 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fs41562_021_01142_4 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fs41562_021_01193_7 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fs41562_024_02024_1 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fs41586_026_10265_5 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fs41586_026_10644_y +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fs41597_022_01143_6 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fs41598_023_41032_5 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fs42256_024_00832_8 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1038_2Fsdata_2016_18 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1056_2FAIoa2400555 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1073_2Fpnas_1708274114 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1073_2Fpnas_1708290115 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1088_2F1742_6596_2F46_2F1_2F067 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1093_2Fbioinformatics_2Fbts480 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1098_2Frsta_2020_0069 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1109_2F2_84898 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1109_2F3468_844354 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1109_2FMS_2016_60 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1126_2Fscience_1213847 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1126_2Fscience_aab2374 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1126_2Fscience_aac4716 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1126_2Fscience_aah6168 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1126_2Fscitranslmed_aaf5027 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1136_2Famiajnl_2011_000089 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F2160718_2160734 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F2408776_2408794 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F2452376_2452478 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F2670979_2670986 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F2723872_2723882 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F2882903_2899401 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F2987550_2987568 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F3290605_3300233 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F3411764_3445717 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F3449287 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F3485510 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F3486897 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F3571730 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F3593013_3594087 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F3769733_3769747 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F3805760_3814924 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1145_2F568522_568525 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1162_2Fcoli_a_00486 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1177_2F0956797611417632 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1177_2F1745691612463078 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1177_2F17456916231181102 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1177_2F25152459211007467 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1207_2Fs15327957pspr0203_4 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_12688_2Ff1000research_29032_2 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_12688_2Ff1000research_51738_2 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1287_2Fisre_2021_1079 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1371_2Fjournal_pbio_1002106 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1371_2Fjournal_pcbi_1003285 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1371_2Fjournal_pcbi_1008316 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1371_2Fjournal_pmed_0020124 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_14778_2F3529337_3529344 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1511_2F2014_111_460 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1518_2F001872097778543886 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_1518_2Fhfes_46_1_50_30392 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_17226_2F25303 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_18653_2Fv1_2F2020_emnlp_main_609 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_18653_2Fv1_2F2022_acl_short_18 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_18653_2Fv1_2F2023_acl_long_910 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_18653_2Fv1_2F2023_emnlp_main_398 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_18653_2Fv1_2F2023_emnlp_main_741 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_18653_2Fv1_2F2023_findings_emnlp_722 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_18653_2Fv1_2F2025_findings_emnlp_320 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_18653_2Fv1_2FN18_1074 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_2139_2Fssrn_4573321 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_2196_2F53164 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_2196_2F80371 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_3389_2Ffpsyg_2016_01832 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_api_crossref_org_works_10_7759_2Fcureus_35179 +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_1902_03245 +30 −0

Large diff (30 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2005_11401 +59 −0

Large diff (59 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2112_09332 +78 −0

Large diff (78 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2112_11471 +41 −0

Large diff (41 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2203_11147 +55 −0

Large diff (55 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2203_11171 +47 −0

Large diff (47 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2210_13777 +44 −0

Large diff (44 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2211_09110 +175 −0

Large diff (175 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2212_08037 +87 −0

Large diff (87 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2302_06590 +33 −0

Large diff (33 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2305_05176 +33 −0

Large diff (33 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2305_14251 +51 −0

Large diff (51 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2305_14627 +36 −0

Large diff (36 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2305_17926 +53 −0

Large diff (53 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2305_18248 +34 −0

Large diff (34 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2306_05685 +62 −0

Large diff (62 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2308_03688 +90 −0

Large diff (90 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2308_08493 +31 −0

Large diff (31 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2309_11495 +43 −0

Large diff (43 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2310_01798 +44 −0

Large diff (44 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2310_18018 +40 −0

Large diff (40 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2311_01964 +50 −0

Large diff (50 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2311_09783 +38 −0

Large diff (38 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2402_18679 +103 −0

Large diff (103 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2404_13076 +31 −0

Large diff (31 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2405_15793 +47 −0

Large diff (47 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2406_04244 +34 −0

Large diff (34 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2406_12045 +34 −0

Large diff (34 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2406_12624 +39 −0

Large diff (39 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2406_18403 +82 −0

Large diff (82 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2407_01502 +37 −0

Large diff (37 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2407_01725 +54 −0

Large diff (54 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2407_16741 +96 −0

Large diff (96 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2410_06992 +39 −0

Large diff (39 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2411_05285 +32 −0

Large diff (32 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2411_15114 +91 −0

Large diff (91 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2411_15594 +71 −0

Large diff (71 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2502_14297 +38 −0

Large diff (38 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2504_13359 +38 −0

Large diff (38 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2504_18765 +78 −0

Large diff (78 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2507_02825 +97 −0

Large diff (97 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2507_09089 +36 −0

Large diff (36 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2509_08713 +32 −0

Large diff (32 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2509_09912 +40 −0

Large diff (40 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2510_11977 +115 −0

Large diff (115 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2510_12367 +46 −0

Large diff (46 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2601_11868 +277 −0

Large diff (277 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2601_18724 +33 −0

Large diff (33 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2602_08990 +193 −0

Large diff (193 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2603_08127 +63 −0

Large diff (63 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2603_29231 +43 −0

Large diff (43 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2605_07723 +42 −0

Large diff (42 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2605_25415 +47 −0

Large diff (47 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2605_26340 +63 −0

Large diff (63 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2607_12301 +25 −0

Large diff (25 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2608_05179 +34 −0

Large diff (34 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2608_14380 +40 −0

Large diff (40 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/https_export_arxiv_org_api_query_id_list_2608_21374 +52 −0

Large diff (52 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/s2_dapper2010.json +46 −0

Large diff (47 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/s2_gray1986.json +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/s2_gray1986_search_observed.json +5 −0

Large diff (5 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/s2_oppenheimer2003.json +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/s2_search_extra.jsonl +2 −0

Large diff (3 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/s2_yuan2014.json +1 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added research/verify_cache/semanticscholar_batch.json +12727 −0

Large diff (12,728 lines) is not loaded by default to keep the page fast.Load diff

added results/analysis_data/criteria.csv +21 −0

Large diff (21 lines) is not loaded by default to keep the page fast.Load diff

added results/analysis_data/gate_receipts.csv +7 −0

Large diff (7 lines) is not loaded by default to keep the page fast.Load diff

added results/analysis_data/reviews.csv +2 −0

Large diff (2 lines) is not loaded by default to keep the page fast.Load diff

added results/analysis_data/runs.csv +5 −0

Large diff (5 lines) is not loaded by default to keep the page fast.Load diff

added results/analysis_data/sessions.csv +6 −0

Large diff (6 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/artifact_manifest.json +10 −0

Large diff (11 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/behaviour_audit.json +5 −0

Large diff (6 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/contract_receipt.json +162 −0

Large diff (163 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/ctl/prompt.txt +1 −0

Large diff (1 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/ctl/reviewer_prompt.txt +1 −0

Large diff (1 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/ctl/reviewer_system.md +10 −0

Large diff (10 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/ctl/system_append.md +16 −0

Large diff (16 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/evaluation_receipt.json +108 −0

Large diff (109 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/out/analysis.py +56 −0

Large diff (56 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/out/claims.json +6 −0

Large diff (6 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/out/report.md +33 −0

Large diff (33 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/out/results.json +25 −0

Large diff (26 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/prepare.json +20 −0

Large diff (21 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/sessions/587bafe6-c88b-4a80-9f62-4a10d9525c43.jsonl +43 −0

Large diff (43 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0001/system_append.md +16 −0

Large diff (16 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0002/artifact_manifest.json +21 −0

Large diff (22 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0002/behaviour_audit.json +5 −0

Large diff (6 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0002/contract_receipt.json +172 −0

Large diff (173 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0002/ctl/prompt.txt +1 −0

Large diff (1 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0002/ctl/reviewer_prompt.txt +1 −0

Large diff (1 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0002/ctl/reviewer_system.md +10 −0

Large diff (10 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0002/ctl/system_append.md +59 −0

Large diff (59 lines) is not loaded by default to keep the page fast.Load diff

added runs/development/RD0002/evaluation_receipt.json +81 −0

Large diff (81 lines) is not loaded by default to keep the page fast.Load diff

Diff truncated — file too large.

spb/wp29_uqo

Theme