puremethod 0.1.0__py3-none-any.whl

loop/decide.py

@@ -0,0 +1,61 @@
+"""Decisions computed by code (03-loop.md §4, §5 step 4.7, INV-2). No LLM involved.
+
+Two rules exist (KB-018): `difference_at_least` and `ratio_at_least`, both on
+direction-adjusted means over the stage's seeds.
+
+Arithmetic is exact on the values' decimal form (what the ledger stores as JSON), so a result
+exactly at the threshold passes: in binary floating point 0.9 - 0.8 < 0.1.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from fractions import Fraction
+from typing import Any, Literal
+
+RULES = ("difference_at_least", "ratio_at_least")
+Outcome = Literal["promote", "discard", "confirm", "inconclusive"]
+
+
+def _mean(values: list[float]) -> Fraction:
+    return sum((Fraction(repr(float(v))) for v in values), Fraction(0)) / len(values)
+
+
+@dataclass(frozen=True)
+class Verdict:
+    outcome: Outcome
+    reason_code: str | None
+    reason_text: str
+    comparison: dict[str, Any]
+
+
+def evaluate(rule: str, direction: str, threshold: float, treatment: list[float],
+             baseline: list[float], *, confirm_stage: bool) -> Verdict:
+    """Pass: promote (or confirm at the confirmation stage). Fail: discard (refuted).
+    Missing values or an unknown rule: inconclusive (no_signal)."""
+    if rule not in RULES or direction not in ("maximize", "minimize"):
+        return Verdict("inconclusive", "no_signal", f"unknown rule {rule!r} or direction",
+                       {"rule": rule})
+    if not treatment or not baseline:
+        return Verdict("inconclusive", "no_signal", "metric missing for an arm",
+                       {"rule": rule, "n_treatment": len(treatment),
+                        "n_baseline": len(baseline)})
+    t, b = _mean(treatment), _mean(baseline)
+    if rule == "difference_at_least":
+        exact = t - b if direction == "maximize" else b - t
+    else:
+        if b <= 0 or t <= 0:
+            return Verdict("inconclusive", "no_signal", "ratio undefined (a mean is not "
+                           "positive)",
+                           {"rule": rule, "treatment_mean": float(t), "baseline_mean": float(b)})
+        exact = t / b if direction == "maximize" else b / t
+    passed = exact >= Fraction(repr(float(threshold)))
+    value = float(exact)
+    comparison = {"rule": rule, "value": value, "threshold": threshold, "passed": passed,
+                  "treatment_mean": float(t), "baseline_mean": float(b),
+                  "n_treatment": len(treatment),
+                  "n_baseline": len(baseline), "direction": direction}
+    if passed:
+        outcome: Outcome = "confirm" if confirm_stage else "promote"
+        return Verdict(outcome, None, f"{rule} {value:.6g} >= {threshold:.6g}", comparison)
+    return Verdict("discard", "refuted", f"{rule} {value:.6g} < {threshold:.6g}", comparison)

loop/harness.py

@@ -0,0 +1,132 @@
+"""Experiment harness conventions (03-loop.md §5 step 4.4, 05-executor.md §4).
+
+The coder LLM writes the files; this module packs them, builds the command, and checks what
+the job reported. Every check here is code: no LLM sees a check it could argue with.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import math
+import re
+import tarfile
+from pathlib import PurePosixPath
+from typing import Any
+
+from executor import METRICS_FILE
+
+MANIFEST_FILE = "outputs/pm_data_manifest.json"
+ROLES = ("selection", "held_out")
+MAX_FILES = 50
+MAX_BUNDLE_BYTES = 1_000_000
+_HEX64 = re.compile(r"^(sha256:)?[0-9a-f]{64}$")
+
+
+class HarnessInvalid(ValueError):
+    """The coder's files cannot be packed (bad paths, too large)."""
+
+
+def bundle(files: list[dict[str, str]]) -> bytes:
+    """A deterministic tar archive of the coder's files (same files, same digest)."""
+    if not files or len(files) > MAX_FILES:
+        raise HarnessInvalid(f"a harness needs 1 to {MAX_FILES} files")
+    seen: set[str] = set()
+    out = io.BytesIO()
+    with tarfile.open(fileobj=out, mode="w", format=tarfile.PAX_FORMAT) as tar:
+        for f in sorted(files, key=lambda f: f["path"]):
+            path = PurePosixPath(f["path"])
+            if (path.is_absolute() or ".." in path.parts or not path.parts
+                    or str(path) in seen or "\\" in f["path"]):
+                raise HarnessInvalid(f"invalid file path {f['path']!r}")
+            seen.add(str(path))
+            data = f["content"].encode("utf-8")
+            info = tarfile.TarInfo(str(path))
+            info.size, info.mtime, info.mode = len(data), 0, 0o644
+            tar.addfile(info, io.BytesIO(data))
+    raw = out.getvalue()
+    if len(raw) > MAX_BUNDLE_BYTES:
+        raise HarnessInvalid("the harness is larger than 1 MB")
+    return raw
+
+
+def unbundle(code: bytes) -> list[dict[str, str]]:
+    files = []
+    with tarfile.open(fileobj=io.BytesIO(code), mode="r:*") as tar:
+        for m in tar.getmembers():
+            fh = tar.extractfile(m) if m.isfile() else None
+            if fh is not None:
+                files.append({"path": m.name, "content": fh.read().decode("utf-8", "replace")})
+    return files
+
+
+def command(entrypoint: str, arm: str, stage: str, budget_s: float) -> str:
+    return f"{entrypoint} --arm {arm} --stage {stage} --budget-s {int(budget_s)}"
+
+
+def _json_list(raw: bytes | None, what: str) -> tuple[list[Any], str | None]:
+    if raw is None:
+        return [], f"{what} missing"
+    try:
+        data = json.loads(raw.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError):
+        return [], f"{what} is not valid JSON"
+    if not isinstance(data, list):
+        return [], f"{what} is not a list"
+    return data, None
+
+
+def parse_metrics(raw: bytes | None) -> tuple[list[dict[str, Any]], str | None]:
+    """Valid metric records, and a problem if the file was missing or malformed. A missing
+    `set` defaults to the data role, so selection and held-out values never share one."""
+    data, problem = _json_list(raw, "metrics file")
+    out: list[dict[str, Any]] = []
+    for m in data:
+        if not isinstance(m, dict):
+            return [], "metrics file has a non-object item"
+        name, value, role = m.get("name"), m.get("value"), m.get("data_role")
+        if (not isinstance(name, str) or not name or isinstance(value, bool)
+                or not isinstance(value, int | float) or not math.isfinite(value)
+                or role not in ROLES):
+            return [], "metrics file has an invalid item (name, finite value, data_role)"
+        unit = m.get("unit")
+        out.append({"name": name, "value": float(value),
+                    "unit": unit if isinstance(unit, str) else "", "data_role": role,
+                    "set": str(m["set"]) if isinstance(m.get("set"), str) else role})
+    return out, problem
+
+
+def parse_manifest(raw: bytes | None) -> tuple[list[dict[str, Any]], str | None]:
+    data, problem = _json_list(raw, "data manifest")
+    if problem:
+        return [], problem
+    out = []
+    for d in data:
+        if not isinstance(d, dict) or not isinstance(d.get("source"), str) or not d["source"]:
+            return [], "data manifest item without a source"
+        if d.get("role") not in ROLES:
+            return [], "data manifest item without a valid role"
+        sha = str(d.get("sha256", "")).lower()
+        if not _HEX64.match(sha):
+            return [], "data manifest item without a SHA-256"
+        licence = d.get("licence")
+        out.append({"source": d["source"], "role": d["role"],
+                    "licence": licence if isinstance(licence, str) else None,
+                    "digest": "sha256:" + sha.removeprefix("sha256:")})
+    roles = {d["role"] for d in out}
+    if roles != set(ROLES):
+        return [], "data manifest must list selection and held-out data"
+    return out, None
+
+
+def manifest_key(sets: list[dict[str, Any]]) -> list[tuple[str, str, str]]:
+    return sorted((str(d["role"]), str(d["source"]), str(d["digest"])) for d in sets)
+
+
+def metric_values(metrics: list[dict[str, Any]], name: str, role: str
+                  ) -> list[dict[str, Any]]:
+    return [m for m in metrics if m["name"] == name and m["data_role"] == role]
+
+
+__all__ = ["MANIFEST_FILE", "METRICS_FILE", "HarnessInvalid", "bundle", "command",
+           "manifest_key", "metric_values", "parse_manifest", "parse_metrics", "unbundle"]

loop/prompts.py

@@ -0,0 +1,88 @@
+"""Instructions and output schemas for each LLM step (03-loop.md §5).
+
+Every instruction starts with `Task: <name>.` Data the model reads (literature, adapter
+responses, experiment output) goes in the user message, quoted with `LLM.quote` (INV-11).
+No schema has a field that could set an outcome, a limit or a rule in force (INV-2, INV-6).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .decide import RULES
+
+
+def _obj(required: list[str], props: dict[str, Any]) -> dict[str, Any]:
+    return {"type": "object", "additionalProperties": False, "required": required,
+            "properties": props}
+
+
+_STR = {"type": "string", "minLength": 1}
+
+DIRECTIONS = (
+    "Task: directions. From the research idea and the quoted literature evidence, propose "
+    "up to five distinct research directions that the evidence leaves open and that can be "
+    "tested by computation within a small budget. Give each a one-sentence rationale.")
+DIRECTIONS_SCHEMA = _obj(["directions"], {"directions": {
+    "type": "array", "minItems": 1, "maxItems": 5,
+    "items": _obj(["direction", "rationale"], {"direction": _STR, "rationale": _STR})}})
+
+HYPOTHESIS = (
+    "Task: hypothesis. Form one testable hypothesis from the direction, and the baseline it "
+    "will be compared against: the same experiment without the change. Name one metric with "
+    "its unit and direction, the comparison rule and the threshold the treatment must reach "
+    "against the baseline, and the data to evaluate on, with a selection set and a separate "
+    "held-out set. Rules: difference_at_least (treatment mean minus baseline mean, adjusted "
+    "for direction) or ratio_at_least (ratio of the means, adjusted for direction).")
+HYPOTHESIS_SCHEMA = _obj(
+    ["treatment", "baseline", "metric", "rule", "threshold", "data"],
+    {"treatment": _STR, "baseline": _STR,
+     "metric": _obj(["name", "unit", "direction"], {
+         "name": _STR, "unit": {"type": "string"},
+         "direction": {"enum": ["maximize", "minimize"]}}),
+     "rule": {"enum": list(RULES)}, "threshold": {"type": "number"}, "data": _STR})
+
+NOVELTY = (
+    "Task: novelty. Judge whether the hypothesis overlaps with the quoted closest prior work. "
+    "`novel`: no quoted work tests it. `overlap`: a quoted work already tests it; if a "
+    "narrower or different version would still be new, give it in `reframed`, otherwise "
+    "leave `reframed` empty. `unclear`: the evidence does not settle it.")
+NOVELTY_SCHEMA = _obj(["judgement", "reason", "reframed"], {
+    "judgement": {"enum": ["novel", "overlap", "unclear"]}, "reason": _STR,
+    "reframed": {"type": "string"}})
+
+HARNESS = (
+    "Task: harness. Write Python experiment code that tests the hypothesis against its "
+    "baseline. Conventions, all required:\n"
+    "- It is run as `<entrypoint> --arm treatment|baseline --stage smoke|0|1|...|confirm "
+    "--budget-s N`; the seed is in the environment variable PM_SEED. The two arms differ "
+    "only in the change under test.\n"
+    "- It finishes within N seconds of wall-clock time.\n"
+    "- It writes outputs/pm_metrics.json: a JSON list of {name, value, unit, data_role, set}. "
+    "Report the named metric with data_role `selection` at every stage. Only when --stage "
+    "is `confirm`, also report it on the held-out data with data_role `held_out`.\n"
+    "- It writes outputs/pm_data_manifest.json: a JSON list of {source, licence, role, "
+    "sha256} for every data set it uses, role `selection` or `held_out`, sha256 of the "
+    "data's content as used. Both roles must be present.\n"
+    "- Data mounted by the user is read-only under /data/<name>. The network may be off.\n"
+    "Give the files, the entrypoint (for example `python main.py`) and a pinned "
+    "requirements list (may be empty).")
+FIX = (
+    "Task: fix. The harness failed its smoke run. The failure and the job output are "
+    "quoted. Return the corrected harness, complete, under the same conventions:\n"
+    + HARNESS.split("Conventions, all required:\n", 1)[1])
+HARNESS_SCHEMA = _obj(["files", "entrypoint", "requirements"], {
+    "files": {"type": "array", "minItems": 1, "maxItems": 50,
+              "items": _obj(["path", "content"], {"path": _STR, "content": {"type": "string"}})},
+    "entrypoint": _STR, "requirements": {"type": "string"}})
+
+RANK = (
+    "Task: rank. Order the frontier items by expected value per unit of remaining budget. "
+    "Cheap pilots of new hypotheses compete with promotions. Return every item id once.")
+RANK_SCHEMA = _obj(["order"], {"order": {"type": "array", "items": _STR}})
+
+# Thinking counts against these on models that always think (Claude Sonnet 5.5): with 8000,
+# 12 of 16 harness calls returned no text (DL-20261102-03). The cost guard uses the same
+# numbers, so the pre-call bound stays a true upper bound.
+MAX_TOKENS = {"directions": 4000, "hypothesis": 4000, "novelty": 4000, "harness": 32000,
+              "fix": 32000, "rank": 2000}

loop/view.py

@@ -0,0 +1,202 @@
+"""The run as `loop` sees it: a replay of the ledger (03-loop.md §4, INV-10).
+
+Nothing here is stored. `RunView` is rebuilt from the entries whenever `loop` needs it, so
+a restarted worker sees exactly what the crashed one recorded.
+"""
+
+from __future__ import annotations
+
+import copy
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import Any
+
+from ledger import CONFIRM_STAGE, SMOKE_STAGE, Entry
+
+from .config import RunConfig
+
+FINAL = ("discard", "confirm", "inconclusive")
+
+
+def parse_at(at: str) -> datetime:
+    return datetime.fromisoformat(at.replace("Z", "+00:00")).astimezone(UTC)
+
+
+def stage_order(stage: str) -> int:
+    if stage == SMOKE_STAGE:
+        return -1
+    if stage == CONFIRM_STAGE:
+        return 10_000
+    return int(stage)
+
+
+@dataclass
+class Checkpoint:
+    id: str
+    requested: str
+    options: Any
+    decided: str | None = None
+    decision: Any = None
+
+
+@dataclass
+class Hyp:
+    id: str
+    statement: str
+    idea: str
+    kind: str
+    baseline: str | None
+    plan: dict[str, Any]
+    reframes: str | None
+    novelty: dict[str, Any] | None = None
+    decisions: list[tuple[str, dict[str, Any]]] = field(default_factory=list)
+
+    def final(self) -> dict[str, Any] | None:
+        for _, d in reversed(self.decisions):
+            if d["outcome"] in FINAL:
+                return dict(d)
+        return None
+
+
+@dataclass
+class Experiment:
+    id: str
+    prereg: str
+    arm: str
+    seed: int
+    payload: dict[str, Any]
+    finished_id: str | None = None
+    finished: dict[str, Any] | None = None
+
+
+@dataclass
+class RunView:
+    run_id: str
+    config: RunConfig
+    created_at: datetime
+    status: str | None = None
+    phase: str | None = None
+    reason: str = ""
+    resume_status: str | None = None
+    inputs: list[str] = field(default_factory=list)  # entry ids the phase works from
+    status_log: list[tuple[datetime, str]] = field(default_factory=list)
+    ideas: dict[str, dict[str, Any]] = field(default_factory=dict)
+    hypotheses: dict[str, Hyp] = field(default_factory=dict)
+    preregs: dict[str, dict[str, Any]] = field(default_factory=dict)  # merged with amendments
+    prereg_key: dict[str, tuple[str, str]] = field(default_factory=dict)
+    in_force: dict[tuple[str, str], str] = field(default_factory=dict)
+    amendments: dict[tuple[str, str], int] = field(default_factory=dict)
+    experiments: dict[str, Experiment] = field(default_factory=dict)
+    checkpoints: dict[str, Checkpoint] = field(default_factory=dict)
+    calls: dict[str, dict[str, Any]] = field(default_factory=dict)
+    papers: list[str] = field(default_factory=list)
+
+    # ---- queries -----------------------------------------------------------------------
+
+    def active_elapsed_s(self, now: datetime) -> float:
+        """Time since the run was created, minus time spent paused (§5 step 5)."""
+        total, since, active = 0.0, self.created_at, True
+        for at, status in self.status_log:
+            if active:
+                total += (at - since).total_seconds()
+            since = at
+            active = status not in ("paused", "delivered", "failed")
+        if active:
+            total += (now - since).total_seconds()
+        return max(total, 0.0)
+
+    def open_checkpoint(self) -> Checkpoint | None:
+        for cp in reversed(list(self.checkpoints.values())):  # the latest one waiting
+            if cp.decided is None:
+                return cp
+        return None
+
+    def active_directions(self) -> list[str]:
+        c1 = self.checkpoints.get("C1")
+        if c1 is not None and c1.decided is not None:
+            keep = list(c1.decision.get("keep", []))
+            added = [i for i, p in self.ideas.items() if c1.decided in p.get("parents", [])]
+            return [i for i in keep if i in self.ideas] + added
+        return [i for i, p in self.ideas.items() if p.get("_actor") != "user"]
+
+    def treatments(self) -> list[Hyp]:
+        return [h for h in self.hypotheses.values() if h.kind == "treatment"]
+
+    def under(self, prereg_id: str) -> list[Experiment]:
+        return [x for x in self.experiments.values() if x.prereg == prereg_id]
+
+    def stages_of(self, h: str) -> list[tuple[str, str]]:
+        """(stage, prereg in force) for the hypothesis's non-smoke stages, in ladder order."""
+        found = [(stage, pid) for (hh, stage), pid in self.in_force.items()
+                 if hh == h and stage != SMOKE_STAGE]
+        return sorted(found, key=lambda x: stage_order(x[0]))
+
+    def decision_at(self, h: str, stage: str) -> dict[str, Any] | None:
+        for _, d in reversed(self.hypotheses[h].decisions):
+            if d["stage"] == stage:
+                return dict(d)
+        return None
+
+
+def build_view(entries: list[Entry]) -> RunView:
+    created = entries[0]
+    view = RunView(run_id=created.run_id, config=RunConfig.model_validate(
+        created.payload["config"]), created_at=parse_at(created.at))
+    for e in entries[1:]:
+        _apply(view, e)
+    return view
+
+
+def _apply(view: RunView, e: Entry) -> None:
+    p = e.payload
+    t = e.type
+    if t == "run.status":
+        view.status_log.append((parse_at(e.at), p["status"]))
+        view.status = p["status"]
+        view.phase = p.get("phase", view.phase)
+        view.reason = p.get("reason", "")
+        view.resume_status = p.get("resume_status")
+        if "inputs" in p:
+            view.inputs = list(p["inputs"])
+    elif t == "call.recorded":
+        view.calls[e.entry_id] = p
+    elif t == "idea.proposed":
+        view.ideas[e.entry_id] = {**p, "_actor": e.actor}
+    elif t == "hypothesis.proposed":
+        view.hypotheses[e.entry_id] = Hyp(
+            id=e.entry_id, statement=p["statement"], idea=p["idea"], kind=p["kind"],
+            baseline=p.get("baseline"), plan=dict(p.get("plan", {})),
+            reframes=p.get("reframes"))
+    elif t == "hypothesis.novelty":
+        view.hypotheses[p["hypothesis"]].novelty = {**p, "_id": e.entry_id}
+    elif t == "prereg.registered":
+        key = (p["hypothesis"], p["stage"])
+        view.preregs[e.entry_id] = copy.deepcopy(p)
+        view.prereg_key[e.entry_id] = key
+        view.in_force[key] = e.entry_id
+    elif t == "prereg.amended":
+        key = view.prereg_key[p["supersedes"]]
+        merged = copy.deepcopy(view.preregs[p["supersedes"]])
+        merged.update(copy.deepcopy(p["changes"]))
+        view.preregs[e.entry_id] = merged
+        view.prereg_key[e.entry_id] = key
+        view.in_force[key] = e.entry_id
+        view.amendments[key] = view.amendments.get(key, 0) + 1
+    elif t == "experiment.started":
+        view.experiments[e.entry_id] = Experiment(
+            id=e.entry_id, prereg=p["prereg"], arm=str(p.get("arm", "treatment")),
+            seed=int(p["seed"]), payload=p)
+    elif t == "experiment.finished":
+        x = view.experiments.get(p["experiment"])
+        if x is not None:
+            x.finished_id, x.finished = e.entry_id, p
+    elif t == "decision.made":
+        view.hypotheses[p["hypothesis"]].decisions.append((e.entry_id, p))
+    elif t == "checkpoint.requested":
+        view.checkpoints[p["checkpoint_id"]] = Checkpoint(
+            id=p["checkpoint_id"], requested=e.entry_id, options=p.get("options"))
+    elif t == "checkpoint.decided":
+        cp = view.checkpoints[p["checkpoint_id"]]
+        cp.decided, cp.decision = e.entry_id, p["decision"]
+    elif t == "paper.built":
+        view.papers.append(e.entry_id)

puremethod-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.5
+Name: puremethod
+Version: 0.1.0
+Summary: Autonomous research platform: an idea in, a LaTeX paper and a run bundle out
+Author: Networked Systems Laboratory
+License-Expression: Elastic-2.0
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES.md
+Requires-Python: >=3.11
+Requires-Dist: anthropic>=0.40
+Requires-Dist: cryptography>=50.0
+Requires-Dist: fastapi<0.144,>=0.143
+Requires-Dist: httpx>=0.28
+Requires-Dist: jsonschema>=4.23
+Requires-Dist: matplotlib>=3.9
+Requires-Dist: openai>=1.50
+Requires-Dist: paramiko>=3.5
+Requires-Dist: platformdirs==4.13.0
+Requires-Dist: psycopg[binary]>=3.2
+Requires-Dist: pydantic>=2.9
+Requires-Dist: starlette<1.9,>=1.8
+Requires-Dist: tiktoken>=0.8
+Requires-Dist: uvicorn>=0.54
+Description-Content-Type: text/markdown
+
+# puremethod
+
+An autonomous research platform for computational research in ML/DL and simulation/systems.
+You give it a research idea. It maps the literature, forms hypotheses, tests them in staged
+experiments on machines you choose, and writes a LaTeX paper. With the paper you get a run
+bundle: the code, configs, raw results and a log of every idea it tried, failures included.
+
+- **Locked criteria.** Each experiment's metric, threshold and data splits are recorded
+  before it runs.
+- **Grounded citations.** Every citation comes from a source that was actually retrieved.
+- **Traceable numbers.** Every number, table and figure in the paper comes from a recorded
+  run.
+
+## Install
+
+You need Python 3.11 or newer. Docker is recommended (isolated experiments, the LaTeX build).
+
+```sh
+pipx install puremethod      # or: uv tool install puremethod
+puremethod
+```
+
+`puremethod` starts a local server and opens your browser, already signed in. Everything
+runs on your machine and is reachable only from it (127.0.0.1).
+
+## Commands
+
+| Command | Does |
+|---|---|
+| `puremethod` | Start, then open the browser signed in |
+| `puremethod open` | A new sign-in link for a running server |
+| `puremethod stop` | Stop the server |
+| `puremethod doctor` | Check Python, Docker, ports and directories |
+| `puremethod token rotate` | Print a new API token for scripts, and end all sessions |
+
+## Your data and keys
+
+- **Your files:** runs, the ledger and outputs are kept in your user data directory.
+- **The master key:** on first start, puremethod creates `master.key` in your user config
+  directory. Your stored API keys are encrypted with it. Back it up: without it, stored keys
+  cannot be read and must be entered again.
+- **Your accounts:** you bring your own model provider keys and machines. puremethod has
+  no account and no billing of its own.
+
+## Status
+
+Version 0.1, self-hosted. Literature and citations come from PureScholar. By default,
+puremethod runs a bundled local PureScholar in Docker on this computer; you can instead
+connect to a PureScholar deployment with its URL and key.
+
+## Licence
+
+Elastic License 2.0. You may use, modify and share it free of charge. You may not offer it to
+others as a hosted or managed service. See `LICENSE` and `THIRD_PARTY_NOTICES.md`.