workproof 0.1.0__py3-none-any.whl

workproof/__init__.py

@@ -0,0 +1,8 @@
+from .core import (Finding, check, digest, is_empty, load_record, load_registry, proves_work,
+                   read_evidence_file, record, scheduled_from_crontab, status, to_evidence, watch,
+                   weekday_hours)
+
+__version__ = '0.1.0'
+__all__ = ['Finding', 'check', 'digest', 'is_empty', 'load_record', 'load_registry', 'proves_work',
+           'read_evidence_file', 'record', 'scheduled_from_crontab', 'status', 'to_evidence', 'watch',
+           'weekday_hours']

workproof/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

workproof/cli.py

@@ -0,0 +1,96 @@
+"""Command line: `python -m workproof check|record`.
+
+Exit codes: 0 healthy, 1 findings, 2 the checker itself failed. A monitor that
+crashes quietly reproduces the bug it exists to catch, so crashes are loud and
+distinct from findings.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+
+from . import __version__, core
+
+
+def _scheduled(args):
+    if args.crontab_file:
+        with open(args.crontab_file, encoding='utf-8') as f:
+            return core.scheduled_from_crontab(f.read())
+    if args.crontab:
+        out = subprocess.run(['crontab', '-l'], capture_output=True, text=True, check=True).stdout
+        return core.scheduled_from_crontab(out)
+    return None
+
+
+def cmd_check(args) -> int:
+    registry = core.load_registry(args.registry)
+    findings = core.check(registry, args.store, scheduled=_scheduled(args))
+    if args.json:
+        print(json.dumps([f.as_dict() for f in findings], indent=2))
+    elif findings:
+        for f in findings:
+            print(f'{f.kind.upper():22} {f.agent}: {f.detail}')
+    else:
+        n = len(registry['agents'])
+        print(f'OK: {n} agent{"" if n == 1 else "s"}, all producing new work')
+    return 1 if findings else 0
+
+
+def cmd_status(args) -> int:
+    rows = core.status(core.load_registry(args.registry), args.store)
+    if args.json:
+        print(json.dumps(rows, indent=2))
+        return 0
+    fmt = lambda v: '-' if v is None else f'{v:g}h'  # noqa: E731
+    print(f'{"AGENT":28} {"RUNS":>5} {"SINCE RUN":>10} {"SINCE NEW WORK":>15} {"LIMIT":>7}')
+    for r in rows:
+        print(f'{r["agent"]:28} {r["runs"]:>5} {fmt(r["last_run_h"]):>10} {fmt(r["last_change_h"]):>15} '
+              f'{r["limit_h"]:g}h'.rstrip())
+    return 0
+
+
+def cmd_record(args) -> int:
+    if args.file:
+        raw = core.read_evidence_file(args.file)
+    elif args.error:
+        raw = b''   # a failed run has no evidence; do not block waiting on stdin
+    else:
+        raw = sys.stdin.buffer.read()
+    core.record(args.agent, raw, args.store, error=args.error)
+    return 0
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(prog='workproof', description=__doc__.splitlines()[0])
+    p.add_argument('--version', action='version', version=f'workproof {__version__}')
+    sub = p.add_subparsers(dest='cmd', required=True)
+
+    c = sub.add_parser('check', help='compare recorded evidence with the registry')
+    c.add_argument('--registry', required=True)
+    c.add_argument('--store', default='.workproof')
+    c.add_argument('--json', action='store_true')
+    c.add_argument('--crontab', action='store_true', help='also check coverage against `crontab -l`')
+    c.add_argument('--crontab-file', help='also check coverage against a crontab text file')
+    c.set_defaults(fn=cmd_check)
+
+    s = sub.add_parser('status', help='show how long each agent has been quiet')
+    s.add_argument('--registry', required=True)
+    s.add_argument('--store', default='.workproof')
+    s.add_argument('--json', action='store_true')
+    s.set_defaults(fn=cmd_status)
+
+    r = sub.add_parser('record', help='record one run from the shell (for non-Python agents)')
+    r.add_argument('agent')
+    r.add_argument('--store', default='.workproof')
+    r.add_argument('--file', help='evidence file (tail is hashed); default reads stdin')
+    r.add_argument('--error', help='record this run as failed with this message')
+    r.set_defaults(fn=cmd_record)
+
+    args = p.parse_args(argv)
+    try:
+        return args.fn(args)
+    except Exception as e:  # noqa: BLE001
+        print(f'workproof: {args.cmd} failed: {type(e).__name__}: {e}', file=sys.stderr)
+        return 2

workproof/core.py

@@ -0,0 +1,303 @@
+"""Proof-of-work monitoring for scheduled agents. Standard library only.
+
+An agent records evidence of what it produced after every run. A separate
+checker (cron, CI, anything) compares the evidence against a registry and
+reports agents that stopped running, kept running without producing anything
+new, or produce empty output.
+
+What this catches: agents that are dead or idle while looking healthy.
+What it does NOT catch: agents that produce changing but wrong output.
+"""
+from __future__ import annotations
+
+import functools
+import hashlib
+import json
+import os
+import re
+import sys
+import tempfile
+from dataclasses import asdict, dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+TAIL_BYTES = 65536  # hash only the tail of large evidence files
+EMPTY_FORMS = (b'', b'null', b'[]', b'{}', b'""')
+_SLUG = re.compile(r'[^A-Za-z0-9_.-]+')
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+# ── evidence ────────────────────────────────────────────────────────────────
+
+def to_evidence(obj) -> bytes:
+    """Canonical bytes for whatever an agent returned, so equal output hashes equal."""
+    if obj is None:
+        return b''
+    if isinstance(obj, bytes):
+        return obj
+    if isinstance(obj, str):
+        return obj.encode('utf-8')
+    try:
+        return json.dumps(obj, sort_keys=True, default=str, ensure_ascii=False).encode('utf-8')
+    except (TypeError, ValueError):
+        return repr(obj).encode('utf-8')
+
+
+def is_empty(raw: bytes) -> bool:
+    return raw.strip() in EMPTY_FORMS
+
+
+def read_evidence_file(path) -> bytes:
+    """Tail of a file (large logs only need their newest bytes). b'' if missing."""
+    try:
+        size = os.path.getsize(path)
+        with open(path, 'rb') as f:
+            if size > TAIL_BYTES:
+                f.seek(size - TAIL_BYTES)
+            return f.read()
+    except OSError:
+        return b''
+
+
+def digest(raw: bytes) -> str:
+    return hashlib.sha256(raw).hexdigest()[:16]
+
+
+# ── store ───────────────────────────────────────────────────────────────────
+
+def _path(store, agent: str) -> Path:
+    return Path(store) / (_SLUG.sub('_', agent).strip('_') + '.json')
+
+
+def load_record(store, agent: str):
+    p = _path(store, agent)
+    try:
+        rec = json.loads(p.read_text(encoding='utf-8'))
+    except FileNotFoundError:
+        return None
+    if rec.get('agent') != agent:
+        raise ValueError(f'store name collision: {p.name} belongs to {rec.get("agent")!r}, not {agent!r}')
+    return rec
+
+
+def _write_atomic(p: Path, data: dict) -> None:
+    p.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=str(p.parent), suffix='.tmp')
+    try:
+        with os.fdopen(fd, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2)
+        os.replace(tmp, p)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+
+
+def record(agent: str, evidence=b'', store='.workproof', *, error=None, now=None) -> dict:
+    """Record one run. Call at the end of every run, success or failure.
+
+    Evidence counts as new work only if it is non-empty AND differs from the last
+    non-empty evidence. A failed run (error set) updates last_run but never counts
+    as work, and empty output never counts as work.
+    """
+    raw = evidence if isinstance(evidence, bytes) else to_evidence(evidence)
+    now = now or _utcnow()
+    iso = now.isoformat()
+    prev = load_record(store, agent) or {}
+    h, empty = digest(raw), is_empty(raw)
+
+    if error is not None:
+        rec = {**prev, 'agent': agent, 'last_run': iso, 'last_error': str(error)[:500],
+               'consecutive_errors': prev.get('consecutive_errors', 0) + 1,
+               'runs': prev.get('runs', 0) + 1}
+        rec.setdefault('hash', h)
+        rec.setdefault('last_change', iso)
+        rec.setdefault('empty', empty)
+    else:
+        changed = (not empty) and h != prev.get('hash')
+        rec = {'agent': agent, 'hash': h if not empty else prev.get('hash', h), 'empty': empty,
+               'last_run': iso, 'runs': prev.get('runs', 0) + 1,
+               'last_change': iso if changed or 'last_change' not in prev and not empty
+               else prev.get('last_change', iso),
+               'last_error': None, 'consecutive_errors': 0}
+    _write_atomic(_path(store, agent), rec)
+    return rec
+
+
+def _safe_record(*args, **kwargs) -> None:
+    """A monitor must never break the thing it monitors: report and carry on.
+    The checker will flag the agent as not running if recording keeps failing."""
+    try:
+        record(*args, **kwargs)
+    except Exception as e:  # noqa: BLE001
+        print(f'workproof: could not record heartbeat: {type(e).__name__}: {e}', file=sys.stderr)
+
+
+def proves_work(agent: str, *, store='.workproof', evidence=None, evidence_file=None):
+    """Decorator: record the return value (or evidence(result), or a file's tail)
+    after each run. Exceptions are recorded, then re-raised."""
+    def deco(fn):
+        @functools.wraps(fn)
+        def wrapper(*a, **k):
+            try:
+                result = fn(*a, **k)
+            except Exception as e:
+                _safe_record(agent, b'', store, error=f'{type(e).__name__}: {e}')
+                raise
+            if evidence_file is not None:
+                raw = read_evidence_file(evidence_file)
+            elif evidence is not None:
+                raw = to_evidence(evidence(result))
+            else:
+                raw = to_evidence(result)
+            _safe_record(agent, raw, store)
+            return result
+        return wrapper
+    return deco
+
+
+class watch:
+    """Context manager form: `with watch('name') as w: ...; w.evidence = output`."""
+
+    def __init__(self, agent: str, store='.workproof'):
+        self.agent, self.store, self.evidence = agent, store, None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, etype, exc, tb):
+        if etype is not None and issubclass(etype, Exception):
+            _safe_record(self.agent, b'', self.store, error=f'{etype.__name__}: {exc}')
+        else:
+            _safe_record(self.agent, to_evidence(self.evidence), self.store)
+        return False
+
+
+# ── checking ────────────────────────────────────────────────────────────────
+
+def weekday_hours(start: datetime, end: datetime) -> float:
+    """Hours between start and end counting Mon-Fri only (UTC).
+
+    A weekday-only agent idle over a weekend has missed nothing, but wall-clock age
+    says 48h+. Without this, every Monday raised false alarms for healthy agents.
+    """
+    if end <= start:
+        return 0.0
+    total, cur = 0.0, start
+    while cur < end:
+        midnight = (cur + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+        nxt = min(end, midnight)
+        if cur.weekday() < 5:
+            total += (nxt - cur).total_seconds() / 3600
+        cur = nxt
+    return total
+
+
+def _age_hours(since_iso: str, now: datetime, weekdays_only: bool) -> float:
+    since = datetime.fromisoformat(since_iso)
+    if since.tzinfo is None:
+        since = since.replace(tzinfo=timezone.utc)
+    if weekdays_only:
+        return weekday_hours(since, now)
+    return max(0.0, (now - since).total_seconds() / 3600)
+
+
+@dataclass
+class Finding:
+    kind: str    # never_seen | no_run | no_new_work | empty_output | last_run_failed
+    agent: str   # | unmonitored | retired_but_scheduled
+    detail: str
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+def load_registry(path) -> dict:
+    with open(path, encoding='utf-8') as f:
+        reg = json.load(f)
+    agents = reg.get('agents')
+    if not isinstance(agents, dict) or not agents:
+        raise ValueError('registry needs a non-empty "agents" object')
+    for name, cfg in agents.items():
+        gap = cfg.get('max_gap_hours')
+        if not isinstance(gap, (int, float)) or gap <= 0:
+            raise ValueError(f'agent {name!r}: max_gap_hours must be a positive number')
+    return reg
+
+
+def scheduled_from_crontab(text: str) -> set:
+    """Script names in the ACTIVE (uncommented) lines of a crontab."""
+    found = set()
+    for line in text.splitlines():
+        s = line.strip()
+        if not s or s.startswith('#'):
+            continue
+        found.update(re.findall(r'([A-Za-z0-9_\-]+\.(?:py|sh|js))', s))
+    return found
+
+
+def check(registry: dict, store='.workproof', *, scheduled=None, now=None) -> list:
+    """Compare recorded evidence with the registry. Returns a list of Finding."""
+    now = now or _utcnow()
+    findings = []
+    agents = registry['agents']
+    silent = registry.get('no_evidence_expected', {})
+    retired = registry.get('retired', {})
+
+    for name, cfg in agents.items():
+        wk = bool(cfg.get('weekdays_only'))
+        gap = float(cfg['max_gap_hours'])
+        run_gap = float(cfg.get('max_run_gap_hours', gap))
+        rec = load_record(store, name)
+        if rec is None:
+            findings.append(Finding('never_seen', name, 'declared in the registry but has never recorded a run'))
+            continue
+
+        run_age = _age_hours(rec['last_run'], now, wk)
+        if run_age > run_gap:
+            findings.append(Finding('no_run', name, f'has not run in {run_age:.0f}h (limit {run_gap:g}h)'))
+            continue
+
+        if rec.get('consecutive_errors', 0) > 0:
+            findings.append(Finding('last_run_failed', name,
+                                    f'{rec["consecutive_errors"]} consecutive failed run(s): {rec.get("last_error")}'))
+
+        if rec.get('empty'):
+            findings.append(Finding('empty_output', name, 'last run produced empty output'))
+            continue
+
+        change_age = _age_hours(rec['last_change'], now, wk)
+        if change_age > gap:
+            findings.append(Finding('no_new_work', name,
+                                    f'running, but output unchanged for {change_age:.0f}h (limit {gap:g}h)'))
+
+    if scheduled is not None:
+        declared = {cfg.get('script') for cfg in agents.values() if cfg.get('script')}
+        declared |= {k.split()[0] for k in silent} | set(retired)
+        for script in sorted(set(scheduled) - declared):
+            findings.append(Finding('unmonitored', script, 'scheduled but not declared in the registry'))
+        for script in sorted(set(retired) & set(scheduled)):
+            findings.append(Finding('retired_but_scheduled', script,
+                                    f'marked retired ({retired[script]}) but still scheduled'))
+    return findings
+
+
+def status(registry: dict, store='.workproof', *, now=None) -> list:
+    """One row per declared agent: how long since it last ran and last produced new work."""
+    now = now or _utcnow()
+    rows = []
+    for name, cfg in registry['agents'].items():
+        wk = bool(cfg.get('weekdays_only'))
+        rec = load_record(store, name)
+        row = {'agent': name, 'limit_h': cfg['max_gap_hours'], 'runs': 0, 'last_run_h': None, 'last_change_h': None}
+        if rec is not None:
+            row.update(runs=rec.get('runs', 0),
+                       last_run_h=round(_age_hours(rec['last_run'], now, wk), 1),
+                       last_change_h=round(_age_hours(rec['last_change'], now, wk), 1))
+        rows.append(row)
+    return rows

workproof-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: workproof
+Version: 0.1.0
+Summary: Proof-of-work monitoring for scheduled and AI agents: catches agents that are dead or idle while every health check is green.
+Author: workproof contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/DreamsElectricSheep/workproof
+Project-URL: Issues, https://github.com/DreamsElectricSheep/workproof/issues
+Keywords: agents,monitoring,heartbeat,observability,cron,llm,reliability,dead-man-switch
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# workproof
+
+Proof-of-work monitoring for scheduled and AI agents. Standard library only, Python 3.9+.
+
+Normal health checks look at artifacts: the process is up, the file exists, the file is recent. An agent can pass every one of those and still do nothing. It can crash and rewrite an empty file, swallow a fatal error and exit 0, or have a cron entry that was never added. workproof checks that new work was actually produced.
+
+## Why this exists
+
+It was extracted from a monitor written after an audit of a fleet of scheduled agents found four of them dead for between 5 days and 6 weeks while every existing check reported them healthy:
+
+- one had not run for six weeks and was in no monitor at all;
+- one had been dead for nine days, rewriting an empty output file every day;
+- one had its logic removed by an automated code edit, still compiled and imported, and did nothing for three weeks;
+- one hit a fatal error and exited 0, so the restart policy never fired.
+
+Each check looked at an artifact. None looked at whether work happened. The longer write-up is in [docs/five-failures.md](docs/five-failures.md).
+
+## How it works
+
+Two parts, deliberately separate:
+
+1. The agent records evidence after every run (decorator, context manager, or a shell command).
+2. A checker you run from cron or CI compares the evidence with a registry and exits non-zero on findings. Because the checker is separate, it also catches an agent that never starts, which a decorator alone cannot see.
+
+Evidence is tracked by content hash, not file age. Output identical to the last run does not count as new work, and empty output never does.
+
+## Quick start
+
+```bash
+pip install workproof
+```
+
+Record evidence from Python:
+
+```python
+from workproof import proves_work
+
+@proves_work("daily-summarizer", store=".workproof")
+def run():
+    ...
+    return summary          # hashed; the same output twice is not new work
+```
+
+Or as a context manager, or from the shell for agents in any language:
+
+```python
+from workproof import watch
+
+with watch("nightly-sync") as w:
+    rows = sync()
+    w.evidence = rows
+```
+
+```bash
+./my_agent.sh > out.json && workproof record my-agent --file out.json
+./my_agent.sh || workproof record my-agent --error "exit code $?"
+```
+
+Declare what you expect in a registry:
+
+```json
+{
+  "agents": {
+    "daily-summarizer": {"script": "summarize.py", "max_gap_hours": 30, "weekdays_only": true},
+    "nightly-sync":     {"script": "sync.py",      "max_gap_hours": 30}
+  },
+  "no_evidence_expected": {"cleanup.py": "legitimately produces nothing"},
+  "retired": {"old_bot.py": "replaced by daily-summarizer"}
+}
+```
+
+Run the checker from cron or CI:
+
+```bash
+workproof check --registry agents.json --store .workproof --crontab
+workproof status --registry agents.json --store .workproof
+```
+
+Exit code `0` healthy, `1` findings, `2` the checker itself failed. A monitor that crashes quietly reproduces the bug it exists to catch, so a crash is loud and distinct from a finding.
+
+## What it reports
+
+| Finding | Meaning |
+|---|---|
+| `never_seen` | declared in the registry but has never recorded a run |
+| `no_run` | has not run within its limit (the job is not firing) |
+| `no_new_work` | it runs, but its output has been identical for too long |
+| `empty_output` | the last run produced nothing |
+| `last_run_failed` | consecutive failed runs (a failed run never counts as work) |
+| `unmonitored` | scheduled in cron but not declared in the registry |
+| `retired_but_scheduled` | marked retired but still scheduled |
+
+Registry options per agent: `max_gap_hours` (required), `max_run_gap_hours`, `weekdays_only`, `script`. Weekday-only agents are measured in weekday hours, so a quiet weekend does not raise a false alarm every Monday.
+
+## What it does not do
+
+- It detects dead or idle agents, not wrong ones. An agent emitting changing garbage passes.
+- Output that is legitimately constant will be flagged. Declare it under `no_evidence_expected` or give it a longer limit.
+- Weekdays are evaluated in UTC.
+- One writer per agent name is assumed (no file locking).
+- There is no dashboard and no built-in alerting. Wire the exit code or `--json` output into whatever you already use.
+
+## Is a hosted version useful?
+
+I am deciding whether to build a hosted version with alerting, a dashboard and multi-agent history. If your team would use it, or if something here does not fit how you run agents, please [open an issue](https://github.com/DreamsElectricSheep/workproof/issues) and describe your setup. That is the most useful thing you can send.
+
+## Tests
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+The suite reproduces the four incidents above.
+
+## License
+
+MIT

workproof-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+workproof/__init__.py,sha256=AD78-5xh5U8LV6n3AWHwQuLcp8lbEKJfAIcrFOcGHqQ,481
+workproof/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+workproof/cli.py,sha256=szBj3HUEJCGE9ZZNDs5tpsXS4WJmAwH0NnbyZ6f4RLU,3657
+workproof/core.py,sha256=RnbLe5GWT763oWhqpILAeKxluX4MsUS_dI3ybGAzw30,11641
+workproof-0.1.0.dist-info/licenses/LICENSE,sha256=0YQWvfEY2Qk0FmnhtLQ8xKN8lGpbnQ2r6aPyX5uRBFA,1079
+workproof-0.1.0.dist-info/METADATA,sha256=qca_zjdjLN5IXuN0xf9JWMD0TvOLSBAhv4W2SQ_KUKE,5518
+workproof-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+workproof-0.1.0.dist-info/entry_points.txt,sha256=H6fKs5KER5T9OF-yu6-ABwOCxRAzib1rqo-5Bolnkyk,49
+workproof-0.1.0.dist-info/top_level.txt,sha256=UfDE_y59EN2XBZ_mb-wpxqWdTDPs9oiGq-_rGJeEPqE,10
+workproof-0.1.0.dist-info/RECORD,,

workproof-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

workproof-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+workproof = workproof.cli:main

workproof-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 workproof contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

workproof-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+workproof