lab-kit-cli 0.1.0__py3-none-any.whl

lab_kit/records.py

@@ -0,0 +1,245 @@
+"""The lab files lab-kit writes and reads: lock records, run records, manifests and scorecards."""
+
+from __future__ import annotations
+
+import datetime as _dt
+import hashlib
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from .errors import LabError
+from .lab import Lab
+
+LOCK = "lock.json"
+RUN = "run.json"
+MANIFEST = "MANIFEST.sha256"
+SCORE = "score.yaml"
+SPEND = "spend.json"  # written by a spending run's own command into out/
+LOCK_KEYS = ("protocol", "path", "sha256", "locked")
+RUN_KEYS = ("protocol", "lock", "config", "mission", "spend", "command", "started", "ended", "exit", "pid",
+            "spent")
+PREDICTION_VERDICTS = ("HIT", "MISS", "INDETERMINATE")
+RULE_VERDICTS = ("FIRED", "NOT FIRED", "INDETERMINATE")
+REVIEW_VERDICTS = ("pass", "fail")
+
+
+def now() -> str:
+    """The current moment in UTC, to the second, as ISO 8601."""
+    return _dt.datetime.now(_dt.timezone.utc).isoformat(timespec="seconds")
+
+
+def script_env() -> dict[str, str]:
+    """The environment lab-kit runs a lab's scripts in: the caller's, with no bytecode written.
+
+    A `__pycache__` folder written into a frozen surface would change it.
+    """
+    env = dict(os.environ)
+    env["PYTHONDONTWRITEBYTECODE"] = "1"
+    return env
+
+
+def parse_moment(value: Any, where: str) -> _dt.datetime:
+    if not isinstance(value, str):
+        raise LabError(f"{where}: expected an ISO 8601 time, not {value!r}")
+    try:
+        moment = _dt.datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise LabError(f"{where}: `{value}` is not an ISO 8601 time") from exc
+    if moment.tzinfo is None:
+        moment = moment.replace(tzinfo=_dt.timezone.utc)
+    return moment
+
+
+def read_json(path: Path, where: str) -> dict[str, Any]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise LabError(f"{where}: not valid JSON: {exc}") from exc
+    if not isinstance(data, dict):
+        raise LabError(f"{where}: must be a JSON object")
+    return data
+
+
+def write_json(path: Path, data: dict[str, Any]) -> None:
+    tmp = path.with_name(path.name + ".tmp")
+    tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def read_yaml(path: Path, where: str) -> dict[str, Any]:
+    try:
+        data = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except yaml.YAMLError as exc:
+        raise LabError(f"{where}: not valid YAML: {exc}") from exc
+    if not isinstance(data, dict):
+        raise LabError(f"{where}: must be a mapping")
+    return data
+
+
+# ---------------------------------------------------------------- locks
+
+
+@dataclass
+class LockRecord:
+    slug: str  # the experiment folder's name
+    path: str  # lock.json from the lab root
+    data: dict[str, Any]
+
+    @property
+    def protocol(self) -> str:
+        return str(self.data.get("protocol", ""))
+
+    @property
+    def sha256(self) -> str:
+        return str(self.data.get("sha256", ""))
+
+    @property
+    def locked(self) -> _dt.datetime:
+        return parse_moment(self.data.get("locked"), self.path)
+
+
+def lock_path(lab: Lab, slug: str) -> Path:
+    return lab.experiments / slug / LOCK
+
+
+def read_lock(lab: Lab, slug: str) -> LockRecord | None:
+    path = lock_path(lab, slug)
+    if not path.is_file():
+        return None
+    where = lab.rel(path)
+    data = read_json(path, where)
+    missing = [k for k in LOCK_KEYS if k not in data]
+    if missing:
+        raise LabError(f"{where}: missing {', '.join(missing)}")
+    return LockRecord(slug, where, data)
+
+
+# ---------------------------------------------------------------- runs
+
+
+@dataclass
+class RunRecord:
+    slug: str
+    run_id: str
+    folder: Path
+    data: dict[str, Any]
+
+    @property
+    def path(self) -> str:
+        return f"experiments/{self.slug}/runs/{self.run_id}/{RUN}"
+
+    @property
+    def out(self) -> Path:
+        return self.folder / "out"
+
+    @property
+    def manifest(self) -> Path:
+        return self.folder / MANIFEST
+
+    @property
+    def ended(self) -> bool:
+        return self.data.get("ended") is not None
+
+    @property
+    def state(self) -> str:
+        """running, finished, failed or orphaned."""
+        if self.ended:
+            return "finished" if self.data.get("exit") == 0 else "failed"
+        return "running" if _alive(self.data.get("pid")) else "orphaned"
+
+
+def _alive(pid: Any) -> bool:
+    if not isinstance(pid, int) or isinstance(pid, bool) or pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OverflowError:
+        return False
+    cmdline = Path(f"/proc/{pid}/cmdline")  # where it exists, tell a reused pid from the supervisor
+    if cmdline.is_file():
+        try:
+            return b"lab_kit.supervise" in cmdline.read_bytes()
+        except OSError:
+            return True
+    return True
+
+
+def runs(lab: Lab, slug: str | None = None) -> list[RunRecord]:
+    """Every run with a run.json, oldest first within each experiment."""
+    out: list[RunRecord] = []
+    for name in [slug] if slug else lab.experiment_slugs():
+        folder = lab.experiments / name / "runs"
+        if not folder.is_dir():
+            continue
+        for run_dir in sorted(p for p in folder.iterdir() if p.is_dir()):
+            path = run_dir / RUN
+            if not path.is_file():
+                continue
+            out.append(RunRecord(name, run_dir.name, run_dir, read_json(path, lab.rel(path))))
+    return out
+
+
+def runs_without_record(lab: Lab) -> list[str]:
+    """Run folders holding no run.json, from the lab root."""
+    out = []
+    for name in lab.experiment_slugs():
+        folder = lab.experiments / name / "runs"
+        if folder.is_dir():
+            out.extend(lab.rel(p) for p in sorted(folder.iterdir()) if p.is_dir() and not (p / RUN).is_file())
+    return out
+
+
+# ---------------------------------------------------------------- manifests
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 16), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def tree_hashes(folder: Path, base: Path) -> dict[str, str]:
+    """Every file under `folder`, by its path from `base`, with its sha256."""
+    if folder.is_file():
+        return {folder.relative_to(base).as_posix(): sha256_file(folder)}
+    if not folder.is_dir():
+        return {}
+    return {p.relative_to(base).as_posix(): sha256_file(p) for p in sorted(folder.rglob("*")) if p.is_file()}
+
+
+def format_hashes(hashes: dict[str, str]) -> str:
+    return "".join(f"{digest}  {path}\n" for path, digest in sorted(hashes.items()))
+
+
+def parse_hashes(text: str, where: str) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for number, line in enumerate(text.splitlines(), 1):
+        if not line.strip():
+            continue
+        digest, sep, path = line.partition("  ")
+        if not sep or len(digest) != 64 or not path:
+            raise LabError(f"{where}:{number}: expected `<sha256>  <path>`")
+        out[path] = digest
+    return out
+
+
+def write_manifest(run: RunRecord) -> None:
+    run.manifest.write_text(format_hashes(tree_hashes(run.out, run.out)), encoding="utf-8")
+
+
+# ---------------------------------------------------------------- scorecards
+
+
+def score_path(lab: Lab, slug: str) -> Path:
+    return lab.experiments / slug / SCORE

lab_kit/rederive.py

@@ -0,0 +1,54 @@
+"""Run a result's re-derive command from the lab root and compare what it prints with its number."""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+
+from folio.documents import Document
+
+from .errors import LabError
+from .lab import Lab
+from .records import script_env
+
+
+@dataclass
+class Outcome:
+    ok: bool
+    expected: str
+    printed: str
+    detail: str  # why it failed, or "" when it passed
+
+
+def number_of(doc: Document) -> str:
+    return str(doc.meta.get("number", "")).strip()
+
+
+def run(lab: Lab, doc: Document) -> Outcome:
+    command = doc.meta.get("rederive")
+    expected = number_of(doc)
+    if not isinstance(command, str) or not command.strip():
+        return Outcome(False, expected, "", "has no `rederive` command")
+    try:
+        done = subprocess.run(command, shell=True, cwd=lab.root, capture_output=True, text=True,
+                              timeout=lab.settings.rederive_timeout, check=False, env=script_env())
+    except subprocess.TimeoutExpired:
+        return Outcome(False, expected, "", f"`{command}` ran past the {lab.settings.rederive_timeout}s timeout")
+    printed = done.stdout.strip()
+    if done.returncode != 0:
+        tail = done.stderr.strip().splitlines()[-1:] or [""]
+        return Outcome(False, expected, printed, f"`{command}` exited {done.returncode}: {tail[0]}".rstrip(": "))
+    if printed != expected:
+        return Outcome(False, expected, printed, f"`{command}` printed `{printed}`, not the number `{expected}`")
+    return Outcome(True, expected, printed, "")
+
+
+def result_doc(lab: Lab, ident: str) -> Document:
+    docs = lab.library().find(ident, "result")
+    if not docs:
+        raise LabError(f"no result `{ident}` in the library")
+    return docs[0]
+
+
+def live_results(lab: Lab) -> list[Document]:
+    return [d for d in lab.library().documents if d.is_a("result") and d.status == "live"]

lab_kit/supervise.py

@@ -0,0 +1,80 @@
+"""The background half of `lab-kit run`: run the lab's command, then seal its evidence.
+
+`lab-kit run` starts this module as a detached process with the run's folder,
+and writes its pid into `run.json`. This process waits for that, runs the command from the lab root with its output in
+`run.log`, and when the command exits writes `MANIFEST.sha256` for `out/`,
+the exit code and the end time into `run.json`.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from . import records
+
+ENV_RUN = "LAB_RUN_DIR"
+ENV_OUT = "LAB_OUT"
+ENV_WORK = "LAB_WORK"
+
+
+def _spent(out: Path) -> float | None:
+    path = out / records.SPEND
+    if not path.is_file():
+        return None
+    try:
+        value = json.loads(path.read_text(encoding="utf-8")).get("spent")
+    except (json.JSONDecodeError, AttributeError):
+        return None
+    return value if isinstance(value, (int, float)) and not isinstance(value, bool) else None
+
+
+def _wait_for_pid(run_json: Path) -> dict:
+    """Wait until `lab-kit run` has written this process's pid, so the two never write run.json at once."""
+    deadline = time.monotonic() + 10
+    while True:
+        data = records.read_json(run_json, str(run_json))
+        if data.get("pid") == os.getpid():
+            return data
+        if time.monotonic() > deadline:
+            data["pid"] = os.getpid()
+            records.write_json(run_json, data)
+            return data
+        time.sleep(0.02)
+
+
+def supervise(run_dir: Path, lab_root: Path) -> int:
+    run_json = run_dir / records.RUN
+    data = _wait_for_pid(run_json)
+    env = records.script_env()
+    env[ENV_RUN] = str(run_dir)
+    env[ENV_OUT] = str(run_dir / "out")
+    env[ENV_WORK] = str(run_dir / "work")
+    with (run_dir / "run.log").open("a", encoding="utf-8") as log:
+        log.write(f"lab-kit: started {data['started']}: {' '.join(data['command'])}\n")
+        log.flush()
+        try:
+            code = subprocess.run(data["command"], cwd=lab_root, env=env, stdout=log, stderr=subprocess.STDOUT,
+                                  stdin=subprocess.DEVNULL, check=False).returncode
+        except OSError as exc:
+            log.write(f"lab-kit: the command could not start: {exc}\n")
+            code = 127
+        ended = records.now()
+        log.write(f"lab-kit: ended {ended} with exit code {code}\n")
+    run = records.RunRecord(data["protocol"], run_dir.name, run_dir, data)
+    records.write_manifest(run)
+    data = records.read_json(run_json, str(run_json))
+    data["ended"] = ended
+    data["exit"] = code
+    if data.get("spend"):
+        data["spent"] = _spent(run_dir / "out")
+    records.write_json(run_json, data)
+    return code
+
+
+if __name__ == "__main__":
+    raise SystemExit(supervise(Path(sys.argv[1]), Path(sys.argv[2])))

lab_kit_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.5
+Name: lab-kit-cli
+Version: 0.1.0
+Summary: A research lab's method and machinery on top of folio: pre-register, lock, run, score, re-derive.
+Project-URL: Homepage, https://github.com/pierg/lab-kit
+Project-URL: Issues, https://github.com/pierg/lab-kit/issues
+Author: Piergiuseppe Mallozzi
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: folio-kb>=0.1.0
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# lab-kit
+
+lab-kit turns your coding agent into the staff of a research lab: it pre-registers each experiment, locks the plan before the first number, runs the lab's own code against the lock, scores the outcome against it, and records only numbers that re-derive from committed evidence. It is built on [folio](https://github.com/pierg/folio). folio decides what a document is; lab-kit decides when a result counts.
+
+You do not run lab-kit yourself, and you do not walk the agent through each step. You install it by handing your agent one line, set up the lab with its question, and then plan each mission with the agent in plain words. Once you approve the plan, the agent runs it end to end: it drafts the protocol, has a reviewer read it, locks it, runs it, scores it, has the numbers re-derived by an independent reviewer, records the result and writes the report, running the gate before every commit. It stops only where the plan and the method say it must.
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/pierg/lab-kit/main/docs/figures/how-lab-kit-works-dark.svg">
+  <img alt="How lab-kit works. You set up a lab for your question, plan a mission with your coding agent in plain words and approve it, then ask how it is going. The agent works through lab-kit's skills (set-up-lab, plan-mission, run-mission, experiment, review) and folio's skills for documents, and every change passes lab-kit check before it is committed. The lab in git has two zones: the folio library holds the question, the protocol, the result, the claim, the report and the journal; lab-kit's files hold the lock, the runs with sealed evidence, and the score. A protocol crosses into the lab files only through the lock, and a result comes back only through the reviewer pass." src="https://raw.githubusercontent.com/pierg/lab-kit/main/docs/figures/how-lab-kit-works-light.svg">
+</picture>
+
+## Install
+
+Paste this into your coding agent, in the repository that will hold the lab:
+
+```text
+Install lab-kit here: run `uv tool install lab-kit-cli --with-executables-from folio-kb` (or `pipx install --include-deps lab-kit-cli`), then `lab-kit init`, then read .agents/skills/set-up-lab/SKILL.md and follow it.
+```
+
+Installing lab-kit brings folio with it; the flag puts folio's command on the path too. The agent asks you at most three questions in one message (the lab's question, where the library lives, which paths are frozen), sets up the library with folio's lab pack, records the question as `Q-1`, and leaves the gate passing. A longer version of the prompt is in [SETUP.md](https://github.com/pierg/lab-kit/blob/main/SETUP.md). lab-kit needs Python 3.10 or later.
+
+## Give it a mission
+
+**1. Plan the mission together.** Once the lab is set up, state an objective:
+
+```text
+Mission: find out whether our pi estimator's error falls as 1/sqrt(n).
+```
+
+The **plan-mission** skill reads the lab, then asks in one message only what it cannot look up: "How many sample sizes and repeats count as enough? Token-free only? What would make you stop it early?" It drafts the plan: the question served, observable milestones, the scope, the spend, what it never touches, and where it must stop. You change what you want and say "approved". It records your approval and starts nothing.
+
+**2. Let it run.** The **run-mission** skill carries out the approved plan alone; it refuses an unapproved one. It dispatches workers through the **experiment** and **review** skills, sends a reviewer before the protocol locks and before any result counts, and keeps `ops/STATE.md` current so a crashed session resumes from the record. It comes back to you only at the plan's stops, or when a run would spend past the cap, a change would touch a frozen surface, a lock or a recorded result, or the work would leave the plan's scope.
+
+It reports the result by id, the misses as plainly as the hits, and its recommended next step. Meanwhile, ask "how is the mission going?" or "what should we do next?".
+
+## The loop
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/pierg/lab-kit/main/docs/figures/lab-loop-dark.svg">
+  <img alt="The lab loop: in the folio library, a question leads to a draft protocol; it enters lab-kit's files only through the lock, runs and is scored there, and comes back to the library only through the reviewer pass, where the result is re-derived; then the result, the claim and the report. The journal records the lock, the run, the result and the lesson or kill, and lab-kit check runs under everything." src="https://raw.githubusercontent.com/pierg/lab-kit/main/docs/figures/lab-loop-light.svg">
+</picture>
+
+The documents (questions, protocols, results, claims, reports, the journal) are folio's, through its lab pack. The steps between them are lab-kit's skills: **set-up-lab** (once), **plan-mission** (with you, until you approve), **run-mission** (alone: dispatch, supervise, recover, report), **experiment** (draft, lock, launch, watch) and **review** (fold, score, record, report). Four agent roles do the work: **scout**, **runner**, **reviewer** and **reporter**.
+
+## The checks
+
+The gate, `lab-kit check`, runs folio's checks and then the lab's. It runs offline, names every problem in one pass, and changes nothing. CI runs the same command.
+
+- **Locks.** A locked protocol has a lock record, and its bytes still match it (`lab-lock-recorded`, `lab-lock-intact`).
+- **Runs.** Every run started after its lock, used exactly the pinned configuration, and its evidence matches its manifest (`lab-run-after-lock`, `lab-roster-frozen`, `lab-evidence-sealed`).
+- **Results.** Every live result re-derives exactly, rests on a finished run of a locked protocol, and passed an independent reviewer (`lab-rederive`, `lab-result-grounded`).
+- **Scores.** A scorecard scores exactly the ids the lock names (`lab-score-exact`), and a scored experiment is reported or explained (`lab-scored-reported`).
+- **Lab files.** Ids resolve, frozen surfaces are untouched, scripts pass `--selftest`, nothing runs under an unapproved mission, spend stays within its cap, records only grow, the method is current, and the state file stays a short pointer.
+
+Together they hold a chain from every number on a page back to the lock:
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/pierg/lab-kit/main/docs/figures/number-chain-dark.svg">
+  <img alt="The chain behind one number in the example lab: the report's slope of -0.493 cites result R-2; R-2's re-derive command must print -0.493 again from the committed estimates.tsv; the evidence still matches its manifest; the run's lock hash matches the lock record; and the run used exactly the protocol's pinned configuration. Each link names the check that holds it." src="https://raw.githubusercontent.com/pierg/lab-kit/main/docs/figures/number-chain-light.svg">
+</picture>
+
+The gate checks that the record is consistent. Whether it is honest is the reviewer's job.
+
+## An example
+
+[`examples/monte-carlo-lab`](https://github.com/pierg/lab-kit/blob/main/examples/monte-carlo-lab) asks one question: does the error of a Monte Carlo estimate of pi shrink as 1/sqrt(n)? Its protocol, locked before the run, draws 100 seeded estimates at each of five sample sizes from 64 to 16,384 points, in pure Python, in under a second. The RMS error fell with a fitted log-log slope of -0.493 (`R-2`), so the hypothesis is kept; two of the four predictions missed, and the report says so as plainly as it says the rest. `R-2` supersedes `R-1`, which fitted the wrong error measure. Every record in it was made by the loop above, and `lab-kit check` passes on it with no error and no warning.
+
+Open it with your agent and ask "check this lab" or "re-derive R-2".
+
+## Reference
+
+The `lab-kit` command is the interface for agents and CI, the way git is: `init`, `check`, `experiment`, `lock`, `run`, `runs`, `score`, `rederive`, `freeze`, `status` and `version`. Each is specified in [`docs/spec/lab-model.md`](https://github.com/pierg/lab-kit/blob/main/docs/spec/lab-model.md) §6, the contract the skills, the roles, the checks and the command all build on. To work on lab-kit itself, see [CONTRIBUTING.md](https://github.com/pierg/lab-kit/blob/main/CONTRIBUTING.md). Changes: [CHANGELOG.md](https://github.com/pierg/lab-kit/blob/main/CHANGELOG.md).
+
+## License
+
+MIT. See [`LICENSE`](https://github.com/pierg/lab-kit/blob/main/LICENSE).

lab_kit_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+lab_kit/__init__.py,sha256=0FLgBfZ1lPGUCyQU-Q0VrOGG2A0QPXNP-Jmx20Ex9II,93
+lab_kit/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+lab_kit/cli.py,sha256=l91WGLFY3C-DHZQqBLi0U5R2OvnTytGQY2P1dVyruww,6006
+lab_kit/data.py,sha256=Kh9PD5dWxVrbZC-PoVUxMVygAvsx5RiFC6XlLjlEx_4,1802
+lab_kit/errors.py,sha256=gtLSSUhFAR-YDHEEw9PTO1itXMvfuDzzz1AE09fTBzM,115
+lab_kit/frozen.py,sha256=_NOqDbFk1e8j7jauP0xIGxmVkITSgsgO5PrwIU_HJ5I,1758
+lab_kit/gitlog.py,sha256=bZP4llSn4QoDOtkLTZVF_AHEdjLWI7Z9J8pUshkRZy0,2073
+lab_kit/lab.py,sha256=8AMrjG3slUHnfTEclYc-pBFLTQZstMb5Z_0N-5V7Ypc,5073
+lab_kit/ops.py,sha256=ZnDZqci3RqYaC0UOP9_71m22TryACiFhPJzgdiE0uJU,3077
+lab_kit/protocol.py,sha256=oM351rcoRYdJSg-7GE7KC98czogdUT14KctoaWlvrng,3205
+lab_kit/records.py,sha256=lF2QRbsmXKF_77F3okExEuXZs-oeyzDaPNamCFkuTMk,7576
+lab_kit/rederive.py,sha256=seAXN7eYONkOLjGf9dX90sUKCW2aQ5P47GM855g1p6g,1903
+lab_kit/supervise.py,sha256=nC9dLKD3KQPQyRXwwm5G9d2Jh8PLe5kzigsoorqbXN8,2820
+lab_kit/checks/__init__.py,sha256=Hca4tFCyBEsroUmRcJ2lVnJ1F1feB8OBZqyrWmNTnCA,29
+lab_kit/checks/base.py,sha256=oL1dGdYulOVUXFvEFZePY-0lfdG1VhLSDcCShXTECWs,1146
+lab_kit/checks/files.py,sha256=QzgDfIIO33UfVZP2B6FJkG-GzKD7-fun9uUod7V3JyE,14767
+lab_kit/checks/locks.py,sha256=II1AQ72MS3MFDpGQZ55M8o8puhCYeDbrTB7B--u-A3E,6597
+lab_kit/checks/results.py,sha256=ygOYkSrA9qfJlN1ECnEls7aExAzENT1qL0CnZYgprkg,8095
+lab_kit/checks/run.py,sha256=_SkjfXf4b2LeB_zE3ZJ4ckkgTAw2Y8RAWBMQQ_z78I4,2595
+lab_kit/commands/__init__.py,sha256=hOovTB7uH2q2mSEA1mWVIUtQXAGqFJAYmT8Ms4wqNfk,74
+lab_kit/commands/experiments.py,sha256=Mwd8MpwDw1vbeKWNw-jycltV4LhWI5iixpTkmQTYcNs,4032
+lab_kit/commands/runs.py,sha256=jYHKnKZviAzfuqczq20C1_25kaZDevDPn5PvfXH0-_0,4611
+lab_kit/commands/setup.py,sha256=BosaGQG7tRWDU8m7WekuNYNPNJ1FzSo9NX4bvJKsKFE,5113
+lab_kit/commands/status.py,sha256=6bS8v9NbCwPv7SWWf7r4dgmoG1mo29HBQibUhwlKMFo,1183
+lab_kit/_data/agents/reporter.md,sha256=Iv3SPcxLvkDI5LrISgWszdZcCakPwMJFPrPtT5X8YSA,2438
+lab_kit/_data/agents/reviewer.md,sha256=URWaXS1YpfBmOBSUM1PQCRLzJqKQNdpx2fxmOUAbwo4,2697
+lab_kit/_data/agents/runner.md,sha256=-V9HMMTWYNm-_KuR0_lzXkN0cWYA9vhnm7qRDQzl5b8,2248
+lab_kit/_data/agents/scout.md,sha256=tdRsCLriqQJfeiBEMveCe2FctalRy1JjYJSj2Skvx-M,1512
+lab_kit/_data/method/DISCIPLINE.md,sha256=lENc9Myq0d1FWbIYOLJ1Wp8YkCjQ61FTYAh3AFcqiQw,8287
+lab_kit/_data/method/LADDER.md,sha256=F1YnykTdhrQw6URDxyN-7b9iPHd3ejgJOL8v9PZbR2M,5940
+lab_kit/_data/skills/experiment/SKILL.md,sha256=BVBQRD8ATmQC9k46iUJOi1eNcuQ8TjXFxPymA1HDiSI,6290
+lab_kit/_data/skills/plan-mission/SKILL.md,sha256=uTnfPQY_fwCMRJPXqhPtWKQhxMVFdmWJ56V_xyEdHBs,5782
+lab_kit/_data/skills/review/SKILL.md,sha256=zRchLAOLx2fzhkZLWZt0czVvUzI5v8TV4FPld5k6A_U,6981
+lab_kit/_data/skills/run-mission/SKILL.md,sha256=s_mMZsr3uhDzSatcSiP-jE-mFx-YjPGMeklmdqJK7h4,7785
+lab_kit/_data/skills/set-up-lab/SKILL.md,sha256=SstrSgJoJs2aGdwoFa9P7kAFZh0EWMyJS3Xnj4oP_Cg,7902
+lab_kit_cli-0.1.0.dist-info/METADATA,sha256=dpoZBGnnx5sXCSN_0QNmcF8zgaVB_HFQYYQ_wybXnrg,9029
+lab_kit_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lab_kit_cli-0.1.0.dist-info/entry_points.txt,sha256=JYPwpDHfg-4r3J7zfcWjZolWcPiBkM0C1s34A4Lide4,45
+lab_kit_cli-0.1.0.dist-info/licenses/LICENSE,sha256=R58jcDUMiqrgVefliI9qfiTqQU0-yTl1reIQSClNtug,1078
+lab_kit_cli-0.1.0.dist-info/RECORD,,

lab_kit_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

lab_kit_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lab-kit = lab_kit.cli:main

lab_kit_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Piergiuseppe Mallozzi
+
+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.