results-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{results_cli-0.2.0 → results_cli-0.3.0}/PKG-INFO

@@ -1,7 +1,11 @@
 Metadata-Version: 2.5
 Name: results-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Seal a run, record what it produced, and verify the chain
+Project-URL: Changelog, https://github.com/elliottower/reproducible-science/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/elliottower/reproducible-science
+Project-URL: Issues, https://github.com/elliottower/reproducible-science/issues
+Project-URL: Source, https://github.com/elliottower/reproducible-science/tree/main/packages/results
 Author-email: Elliot Tower <elliot@elliottower.ai>
 License: MIT
 License-File: LICENSE
@@ -12,11 +16,19 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.11
+Requires-Dist: provenance-core<0.4,>=0.3
 Description-Content-Type: text/markdown
 
 # results
 
-Seal a run, record what it produced, and verify the chain.
+[![pypi](https://img.shields.io/pypi/v/results-cli)](https://pypi.org/project/results-cli/)
+[![python](https://img.shields.io/pypi/pyversions/results-cli)](https://pypi.org/project/results-cli/)
+[![license](https://img.shields.io/pypi/l/results-cli)](https://github.com/elliottower/reproducible-science/blob/main/LICENSE)
+[![docs](https://img.shields.io/badge/docs-live-blue)](https://elliottower.github.io/reproducible-science/)
+
+Seal inputs, record outputs, and bind a paper's claims to the runs behind them.
+
+Part of [reproducible-science](https://github.com/elliottower/reproducible-science) alongside `repro`, `citations` and `prereg` — see the [documentation](https://elliottower.github.io/reproducible-science/tools/results/).
 
 ## Install
 
@@ -109,17 +121,35 @@ whether it should have.
 
 ## Claude Code
 
-`plugin/` is a Claude Code plugin that tells Claude when to reach for the CLI.
+`plugin/` is a Claude Code plugin. Three surfaces, because each catches a different failure:
+the hook catches what the model does not think to do, the skill catches what you did not know
+to ask for, and the command is there for when you want the answer now.
+
+| surface | fires |
+|---|---|
+| hook | when a number enters a manuscript that no recorded claim names |
+| skill | when Claude judges the situation calls for sealing inputs, recording outputs, binding a paper's claims to runs |
+| command | when you type `/results-check` |
+
+**Why the hook.** The address is on screen while the sentence is being written and gone immediately afterward. A number recovered later has to be matched by its digits, and a value reported to two or three significant figures matches something in an artifact of any size.
+
+It reports and never blocks, and stays silent in a project with no `.results/` ledger.
 
 ```bash
-/plugin marketplace add elliottower/results
-/plugin install results@results
+/plugin marketplace add elliottower/reproducible-science
+/plugin install results@reproducible-science
 ```
 
-For all three reproducible-science tools in one plugin (results + [prereg](https://github.com/elliottower/prereg) + [citations](https://github.com/elliottower/citations)):
+The plugin ships instructions and hooks, not binaries, so install the tool as well:
 
 ```bash
-/plugin marketplace add elliottower/reproducible-science
+uv tool install results-cli    # or: pip install results-cli
+```
+
+All four tools in one plugin, with every hook, skill and command:
+
+```bash
+/plugin install reproducible-science@reproducible-science
 ```
 
 MIT licensed.

{results_cli-0.2.0 → results_cli-0.3.0}/README.md

@@ -1,6 +1,13 @@
 # results
 
-Seal a run, record what it produced, and verify the chain.
+[![pypi](https://img.shields.io/pypi/v/results-cli)](https://pypi.org/project/results-cli/)
+[![python](https://img.shields.io/pypi/pyversions/results-cli)](https://pypi.org/project/results-cli/)
+[![license](https://img.shields.io/pypi/l/results-cli)](https://github.com/elliottower/reproducible-science/blob/main/LICENSE)
+[![docs](https://img.shields.io/badge/docs-live-blue)](https://elliottower.github.io/reproducible-science/)
+
+Seal inputs, record outputs, and bind a paper's claims to the runs behind them.
+
+Part of [reproducible-science](https://github.com/elliottower/reproducible-science) alongside `repro`, `citations` and `prereg` — see the [documentation](https://elliottower.github.io/reproducible-science/tools/results/).
 
 ## Install
 
@@ -93,17 +100,35 @@ whether it should have.
 
 ## Claude Code
 
-`plugin/` is a Claude Code plugin that tells Claude when to reach for the CLI.
+`plugin/` is a Claude Code plugin. Three surfaces, because each catches a different failure:
+the hook catches what the model does not think to do, the skill catches what you did not know
+to ask for, and the command is there for when you want the answer now.
+
+| surface | fires |
+|---|---|
+| hook | when a number enters a manuscript that no recorded claim names |
+| skill | when Claude judges the situation calls for sealing inputs, recording outputs, binding a paper's claims to runs |
+| command | when you type `/results-check` |
+
+**Why the hook.** The address is on screen while the sentence is being written and gone immediately afterward. A number recovered later has to be matched by its digits, and a value reported to two or three significant figures matches something in an artifact of any size.
+
+It reports and never blocks, and stays silent in a project with no `.results/` ledger.
 
 ```bash
-/plugin marketplace add elliottower/results
-/plugin install results@results
+/plugin marketplace add elliottower/reproducible-science
+/plugin install results@reproducible-science
 ```
 
-For all three reproducible-science tools in one plugin (results + [prereg](https://github.com/elliottower/prereg) + [citations](https://github.com/elliottower/citations)):
+The plugin ships instructions and hooks, not binaries, so install the tool as well:
 
 ```bash
-/plugin marketplace add elliottower/reproducible-science
+uv tool install results-cli    # or: pip install results-cli
+```
+
+All four tools in one plugin, with every hook, skill and command:
+
+```bash
+/plugin install reproducible-science@reproducible-science
 ```
 
 MIT licensed.

results_cli-0.3.0/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "results",
+  "description": "Seal a run's inputs, record what it produced, bind every number in a manuscript to the run behind it as it is written, and verify the chain",
+  "version": "0.2.0",
+  "author": {
+    "name": "Elliot Tower",
+    "email": "elliot@elliottower.ai"
+  },
+  "repository": "https://github.com/elliottower/reproducible-science/tree/main/packages/results",
+  "license": "MIT",
+  "keywords": [
+    "claims",
+    "manuscript",
+    "open science",
+    "provenance",
+    "reproducibility",
+    "results"
+  ]
+}

results_cli-0.3.0/plugin/README.md

@@ -0,0 +1,50 @@
+# The `results` Claude Code plugin
+
+Does every number in the manuscript name the run that produced it?
+
+Three surfaces, because each catches a different failure. The hook catches what the model
+does not think to do, the skill catches what the author did not know to ask for, and the
+command is there for when you want the answer now.
+
+| | |
+|---|---|
+| **hook** `hooks/unbound_numbers.py` | fires when a number enters a manuscript that no recorded claim names |
+| **skill** `skills/results/SKILL.md` | fires when Claude judges the tool relevant |
+| **command** `/results-check` | fires when you type it |
+
+## Why the hook
+
+Recovering a binding after the fact does not work. Measured against 45 CORE-Bench capsules, values precise enough to identify are found about three times in four, and values reported to two or three significant figures cannot be identified at all, because a short number matches something in an artifact of any size. While writing, the address is on screen.
+
+It reports and never blocks, exits zero on every failure path, and stays silent in a project
+with no `.results/` ledger — nothing to check means nothing said.
+
+## What the skill changes
+
+Claude seals a run's inputs before computing, records the outputs after, and binds a number to its run as the sentence is written rather than leaving it to be traced later.
+
+## Install
+
+```bash
+/plugin marketplace add elliottower/reproducible-science
+/plugin install results@reproducible-science
+```
+
+The plugin ships instructions and hooks, not binaries. Install the tool as well:
+
+```bash
+uv tool install results-cli
+```
+
+Against a checkout:
+
+```bash
+/plugin marketplace add ~/Documents/GitHub/reproducible-science
+/plugin install results@reproducible-science
+```
+
+## The other three
+
+`prereg`, `citations`, `results` and `repro` are one lifecycle, and each plugin ships
+separately so you can take only what you use. `reproducible-science@reproducible-science`
+installs all of them at once.

results_cli-0.3.0/plugin/commands/results-check.md

@@ -0,0 +1,25 @@
+---
+description: Does the results chain verify, and is every number in the manuscript bound to a run?
+argument-hint: [manuscript]
+---
+
+Two checks, reported together.
+
+**The chain.** Run `results verify --files`. Report any event whose hash no longer matches,
+any claim naming a run that is not in the ledger, and any output file that has changed since
+it was recorded. A broken chain is reported before anything else, since it invalidates what
+follows.
+
+**The manuscript.** Run `results coverage $1`, defaulting to the newest manuscript source in
+this repository and saying which you chose. Report:
+
+- how many of the author's own numbers are bound to a run, as a count and a share;
+- the unbound ones that state a result, grouped by line, sample sizes and denominators
+  first — an error there survives review;
+- how many sit beside a citation and so belong to the work cited;
+- how many owe no claim at all, named once as a group.
+
+For each unbound result, say what would bind it, naming the run if the ledger already holds
+one that produced it. Record nothing unless asked.
+
+If there is no ledger, say that `results init` starts one.

results_cli-0.3.0/plugin/hooks/hooks.json

@@ -0,0 +1,13 @@
+{
+  "PostToolUse": [
+    {
+      "matcher": "Edit|Write|MultiEdit",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "${CLAUDE_PLUGIN_ROOT}/hooks/unbound_numbers.py"
+        }
+      ]
+    }
+  ]
+}

results_cli-0.3.0/plugin/hooks/unbound_numbers.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""Notice when a number enters a manuscript without a run behind it.
+
+Runs as a Claude Code PostToolUse hook. Reads the tool call on stdin, works out which numbers
+the edit added to a manuscript, and reports any that no recorded claim names.
+
+The reason this is a hook rather than an instruction. Binding a claim to a run is a separate
+deliberate act, and separate deliberate acts do not happen -- literate programming solved this
+problem completely in 1984 and lost anyway. The address is on screen while the sentence is
+written and gone immediately after, so the moment to record it is that moment, and something
+has to notice when the moment passes.
+
+Design constraints, in order:
+
+1. Never break the session. Every failure exits 0 in silence. A hook that can halt the work
+   it observes gets turned off, and a hook that is off notices nothing.
+2. Never block. This witnesses and reports; it does not refuse an edit.
+3. Say nothing when there is nothing to say. A hook that fires on every edit is noise, and
+   noise gets muted. It speaks only when a manuscript gained a number nothing backs.
+"""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import re
+import sys
+
+try:
+    # One source of truth for what counts as a number and what owes no run. The hook runs as
+    # a bare script, so the package may not be importable; the fallbacks below keep it
+    # working rather than silently doing nothing.
+    from results.manuscript import LAYOUT, NUMBER, SUFFIXES, constraining_digits, needs_no_claim
+except ImportError:  # pragma: no cover - exercised only outside an installed environment
+    NUMBER = re.compile(
+        r"(?<![\w.])(?:(?<![-‐‑‒–—])[-+])?"
+        r"\d(?:,?\d)*(?:\.\d+)?(?:[eE][-+]?\d+)?(?![\w])"
+    )
+    LAYOUT = re.compile(
+        r"\\(?:vspace|hspace|setlength|includegraphics|multirow|multicolumn|cmidrule|cline"
+        r"|rule|label|ref|eqref|cite[a-z]*|bibitem|newcommand|usepackage|documentclass)"
+        r"\s*(?:\[[^\]]*\])?\s*(?:\{[^{}]*\})*",
+        re.I,
+    )
+    SUFFIXES = {".tex", ".md", ".rmd", ".qmd", ".typ", ".org", ".rst", ".txt"}
+    _CONSTANTS = {
+        "0",
+        "1",
+        "2",
+        "3",
+        "4",
+        "5",
+        "10",
+        "100",
+        "1000",
+        "1.96",
+        "0.05",
+        "0.01",
+        "0.001",
+        "95",
+        "99",
+        "0.5",
+        "0.95",
+        "2.5",
+        "97.5",
+    }
+
+    def constraining_digits(printed: str) -> int:
+        body = printed.lstrip("-+").replace(",", "")
+        if "." in body:
+            return max(1, len(body.replace(".", "").lstrip("0")))
+        return max(1, len(body.strip("0") or "0"))
+
+    def needs_no_claim(printed: str, line: str, at: int) -> str | None:
+        if printed in _CONSTANTS:
+            return "a constant of the formula"
+        if constraining_digits(printed) < 2:
+            return "a single digit"
+        return None
+
+
+#: Never read a ledger larger than this. A hook runs on every edit and must stay cheap.
+MAX_LEDGER_BYTES = 8 * 1024 * 1024
+
+#: How many unbound values to name before summarising the rest.
+MAX_SHOWN = 8
+
+
+def added_numbers(payload: dict) -> set[str]:
+    """Numbers this edit put into the file that were not in the text it replaced."""
+    tool_input = payload.get("tool_input") or {}
+    before, after = "", ""
+    if "content" in tool_input:
+        after = str(tool_input["content"])
+    elif "edits" in tool_input:
+        for edit in tool_input["edits"] or []:
+            before += str(edit.get("old_string", ""))
+            after += str(edit.get("new_string", ""))
+    else:
+        before = str(tool_input.get("old_string", ""))
+        after = str(tool_input.get("new_string", ""))
+
+    def owing(text: str) -> set[str]:
+        stripped = LAYOUT.sub(" ", text)
+        found = set()
+        for line in stripped.splitlines():
+            for match in NUMBER.finditer(line):
+                if needs_no_claim(match.group(0), line, match.start()) is None:
+                    found.add(match.group(0))
+        return found
+
+    return owing(after) - owing(before)
+
+
+def bound_values(start: pathlib.Path) -> tuple[set[str], pathlib.Path] | None:
+    """Numbers named by a recorded claim, and the ledger naming them, or None if untracked."""
+    for directory in [start, *start.parents]:
+        ledger = directory / ".results" / "ledger.jsonl"
+        if not ledger.is_file():
+            continue
+        try:
+            if ledger.stat().st_size > MAX_LEDGER_BYTES:
+                return None
+            found: set[str] = set()
+            for line in ledger.read_text(errors="replace").splitlines():
+                if '"claim"' not in line:
+                    continue
+                record = json.loads(line)
+                if record.get("event") == "claim":
+                    found.update(NUMBER.findall(record.get("claim", "")))
+            return found, ledger
+        except (OSError, ValueError):
+            return None
+    return None
+
+
+def main() -> int:
+    try:
+        payload = json.load(sys.stdin)
+    except (ValueError, OSError):
+        return 0
+
+    path_text = (payload.get("tool_input") or {}).get("file_path", "")
+    if not path_text:
+        return 0
+    path = pathlib.Path(path_text)
+    if path.suffix.lower() not in SUFFIXES:
+        return 0
+
+    # Only ever walk up from the file itself. Falling back to the working directory finds the
+    # ledger of whichever repository the session started in, and reports an unrelated
+    # project's numbers as unbound.
+    tracked = bound_values(path.parent)
+    if tracked is None:
+        return 0
+    bound, ledger = tracked
+
+    unbound = sorted(added_numbers(payload) - bound)
+    if not unbound:
+        return 0
+
+    shown = ", ".join(unbound[:MAX_SHOWN])
+    if len(unbound) > MAX_SHOWN:
+        shown += f", and {len(unbound) - MAX_SHOWN} more"
+    message = (
+        f"{len(unbound)} number(s) entered {path.name} that no recorded claim names: {shown}. "
+        f"The source is in context now and will not be later. For each one that states a "
+        f"result, record it before moving on:\n"
+        f'  results claim --run-id <run> --location "<where in the manuscript>" '
+        f'"<the sentence as it appears>"\n'
+        f"For a value quoted from another paper, or a parameter fixed by choice, say so once "
+        f"rather than each time. `results coverage {path.name}` audits the whole draft. "
+        f"Ledger: {ledger}"
+    )
+    json.dump(
+        {"hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": message}},
+        sys.stdout,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception:
+        # Constraint 1. Nothing this hook can fail at is worth interrupting the work.
+        sys.exit(0)

results_cli-0.3.0/plugin/skills/results/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: results
+description: Seal a run's inputs before computing, record outputs after, bind manuscript claims to specific runs, and verify the hash chain. Use before launching any computation whose output will appear in a paper, after a run completes, while writing a sentence that states a number, when a number in a manuscript needs tracing to its source, before submitting a draft, or when asked whether results are still what they were. Requires the `results` CLI (`uv tool install results-cli`).
+---
+
+# results
+
+Seal a run, record what it produced, and verify the chain.
+
+## The rule that matters
+
+**Seal before you run. Claim after you verify.**
+
+A number in a manuscript is trustworthy when it names the run that produced it, the run names the
+inputs that were sealed before it started, and the chain from input to claim has not been broken.
+Every way this fails is a version of the result moving without a trace — a script edited after
+the seal, an output overwritten between the run and the claim, a claim attached to a run that
+no longer exists.
+
+## Commands
+
+```bash
+results init                            # start tracking results here
+results seal <file>... [--role input]   # hash inputs before a run
+results access <note> [--level ...]     # record a data-access event
+results run <file>... --run-id <id>     # record outputs after a run
+results claim <text> --run-id <id>      # bind a manuscript claim to a run
+results verify [--files]                # check the chain and every hash it names
+results coverage <manuscript>           # which of a paper's numbers are bound
+```
+
+## The workflow, in order
+
+1. **`results init`** in the experiment directory.
+2. **`results seal prereg.md script.py data.csv`** — hash every input before computing.
+3. **`results access "downloaded zenodo metadata" --level "metadata only"`** — record what
+   was seen and when. This is the data-access taint the chain uses to distinguish confirmatory
+   from exploratory.
+4. **Run the computation.**
+5. **`results run output.json --run-id exp_001`** — hash the outputs.
+6. **`results claim "ICC = 0.42" --run-id exp_001 --confirmatory --location "Table 2"`** —
+   bind the manuscript claim to the run.
+7. **`results verify --files`** — check everything.
+
+## Data-access levels
+
+Four levels, in order of exposure:
+
+| level | meaning |
+|---|---|
+| `nothing seen` | no target data touched |
+| `metadata only` | structure, region names, sample sizes — not outcomes |
+| `structure seen` | data shape and distributions, but not the target variable |
+| `outcomes seen` | the dependent variable was observed |
+
+The level is recorded, not judged — log the honest one even when it is the damaging one.
+
+## Exposure is not contamination
+
+**What threatens a confirmatory reading is propagation, not exposure.** A context reading a
+result is evidence that contamination was possible. Contamination is outcome information
+reaching a consequential choice: selecting an analysis, changing an exclusion, editing the
+code that computes the result, or abandoning an arm after a null.
+
+| situation | disposition |
+|---|---|
+| plan frozen before execution, no premature exposure | confirmatory |
+| results seen *after* every consequential choice was frozen | **confirmatory, exposure logged** |
+| exposed context then changed the analysis or chose follow-up work | exploratory, for the affected decisions |
+| a null caused an arm to be dropped | exploratory — continuation was data-contingent |
+| a human saw results and then exercised discretion | exploratory unless those choices were already fixed |
+
+Row two is the one that gets mishandled. A plan committed to git before the exposure cannot
+be reached by it, so `results claim --confirmatory --frozen-at <commit>` records the claim
+as confirmatory with the exposure logged. `verify` reports it separately from contested
+claims. Without a freeze reference the tool refuses, because it cannot tell the two apart.
+
+**Demote the affected decisions, never the study.** Blanket demotion is a category error, and
+it is why exposures get hidden rather than logged: if disclosure costs everything, nobody
+discloses. Scope the demotion to the choices the exposure could actually have reached.
+
+**The boundary.** If outcome information reaches a human who then exercises relevant
+discretion, non-propagation cannot be *demonstrated* — not because it occurred, but because
+no infrastructure can show it did not. Those decisions do not get the protection available to
+isolated computational contexts.
+
+## Reading `results verify`
+
+The chain check is pass/fail:
+
+| | |
+|---|---|
+| `chain intact` | every event's prev_hash matches the hash of the line before it |
+| `CHAIN BROKEN` | a line was edited, inserted, or deleted after it was written |
+
+With `--files`, every sealed input and recorded output is re-hashed against its current state:
+
+| | |
+|---|---|
+| `ok` | file matches its recorded hash |
+| `CHANGED` | file was modified since it was sealed or recorded |
+| `MISSING` | file no longer exists at the recorded path |
+
+**`CHAIN BROKEN` means the ledger was tampered with.** It does not mean the results are wrong —
+it means the evidence that they are right was damaged. Restore from git history.
+
+## Claims
+
+A claim names a run. A run names its outputs. The outputs were hashed when they were recorded.
+This is the whole chain: manuscript → claim → run → output file → hash. `verify` walks it.
+
+`--confirmatory` marks the claim as backed by a pre-registered hypothesis. Without it, the claim
+is exploratory. The distinction is recorded, not enforced — the access timeline is what makes it
+verifiable.
+
+## Binding while writing
+
+**When a number enters a manuscript, record what produced it before moving on.**
+
+The address is on screen while the sentence is being written and gone immediately afterward.
+Recovering it later is measurably hard: matching a printed value against an artifact by its
+digits fails once the artifact is dense, and on one development repository a four-digit value
+confirms at 94 per cent while a fabricated value of the same shape confirms at 93.8 per cent.
+The values are genuinely there and the match shows nothing. What separates a match from a
+coincidence is the address, and a finished paper carries none.
+
+The plugin's hook watches edits to manuscript files in repositories that have run
+`results init`. When an edit introduces a number no claim names, it says which. Answer it by
+recording the claim, or by noting once that the value needs none.
+
+A value needs no claim when it is a constant of a formula, a number quoted from another
+paper, or a parameter fixed by choice rather than produced by computation. Say so once for
+the document rather than each time it comes up.
+
+## Auditing a draft
+
+```bash
+results coverage paper/paper_v23.tex        # what is bound, and what is not
+results coverage paper.tex --strict         # non-zero exit if anything is unbound
+```
+
+Run it before submitting. On a real manuscript with 21 recorded claims it reported 27 per
+cent of the numbers bound, and among the unbound were sample-size denominators and interval
+bounds — the class of number whose errors survive review.
+
+## When to reach for this
+
+- Before launching any computation whose output will be reported
+- After a run completes, to record what it produced
+- When a number in a manuscript needs tracing to its source run
+- When asked whether results are still what they were
+- In CI, as `results verify --files` and `results coverage <paper> --strict`
+- Before submitting, to see which numbers nothing backs
+
+## What it will not do
+
+It cannot prove the computation was correct. A sealed script that produces the wrong answer
+passes every check here. It also cannot prove the access timeline is honest — the events are
+self-reported, and the tool records them without questioning. The chain is evidence, not proof.
+
+## Where this sits
+
+Four tools guard four moments, and each is weak without the others. A frozen plan over
+unsealed inputs proves nothing; a sealed run whose numbers never reach the manuscript proves
+nothing either.
+
+| moment | tool | what it fixes |
+|---|---|---|
+| before you run | `prereg freeze` | the plan cannot be rewritten around the result |
+| before you compute | `results seal` | the inputs are what you say they were |
+| after a run | `results run` | the outputs are recorded and hashed |
+| writing a number | `results claim` | the number names the run behind it |
+| writing a quotation | a `claims/` entry | the passage is in the source |
+| before submitting | `prereg check`, `results verify`, `citations verify` | nothing drifted |
+
+Every tool named here is installed by `uv tool install reproducible-science`, so the commands
+above are available whatever plugins are present.
+
+Each tool also ships its own plugin, adding a hook that speaks when its moment passes
+unrecorded and a `-check` command. Those commands exist only where the matching plugin is
+installed; the CLI calls in the table always work.

{results_cli-0.2.0 → results_cli-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "hatchling" ]
 
 [project]
 name = "results-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "Seal a run, record what it produced, and verify the chain"
 readme = "README.md"
 keywords = [ "open science", "provenance", "reproducibility", "results" ]
@@ -18,7 +18,11 @@ classifiers = [
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
 ]
-dependencies = [  ]
+dependencies = [ "provenance-core>=0.3,<0.4" ]
+urls.Changelog = "https://github.com/elliottower/reproducible-science/blob/main/CHANGELOG.md"
+urls.Homepage = "https://github.com/elliottower/reproducible-science"
+urls.Issues = "https://github.com/elliottower/reproducible-science/issues"
+urls.Source = "https://github.com/elliottower/reproducible-science/tree/main/packages/results"
 scripts.results = "results.cli:main"
 
 [dependency-groups]