program-context-protocol 0.12.4__py3-none-any.whl

pcp/commands/run_log_cmd.py

@@ -0,0 +1,122 @@
+"""pcp run-log — pre/post audit bracket for any development or test run,
+manual or automated. Ganesh, 2026-07-23: "record entry pre and post any
+development run, test run or anything ... so we get a full grip of where
+the bluffing is happening." `pcp build` wires start_run/end_run
+automatically with real usage data; this CLI is for bracketing manual /
+interactive work, which is otherwise invisible to token_ledger.yaml and
+telemetry.jsonl entirely (see project memory,
+project_ontology_foundry_stale_snapshot_2026_07_23 and this session's own
+token_ledger gap).
+"""
+
+import json
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from pcp.pcp_dir import find_pcp_dir, NoPCPDir
+from pcp import run_log
+
+console = Console()
+
+
+def _resolve_pcp_dir(project_path: str | None) -> Path:
+    try:
+        return find_pcp_dir(Path(project_path) if project_path else None)
+    except NoPCPDir as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(2)
+
+
+@click.group("run-log")
+def run_log_cli():
+    """Pre/post audit bracket around any development or test run."""
+
+
+@run_log_cli.command("start")
+@click.option("--module", required=True, help="Module this run is working on.")
+@click.option("--feature", required=True, help="Feature/criterion this run addresses.")
+@click.option("--type", "run_type", type=click.Choice(["dev", "test", "build", "gate", "manual"]), default="dev")
+@click.option("--actor", default="human-interactive", help="Who is actually doing the work.")
+@click.option("--model", default=None, help="Model driving this run, if known up front.")
+@click.option("--path", "project_path", type=click.Path(), default=None)
+def start(module: str, feature: str, run_type: str, actor: str, model: str | None, project_path: str | None):
+    """Open a run — writes the PRE record, prints the run_id to close it with."""
+    pcp_dir = _resolve_pcp_dir(project_path)
+    run_id = run_log.start_run(
+        pcp_dir, module=module, feature=feature, run_type=run_type, actor=actor, model=model,
+    )
+    console.print(f"[green]Run started:[/green] {run_id}")
+    console.print(f"[dim]Close it: pcp run-log end --run-id {run_id} --result success ...[/dim]")
+
+
+@run_log_cli.command("end")
+@click.option("--run-id", required=True)
+@click.option("--result", type=click.Choice(["success", "failure", "partial"]), required=True)
+@click.option("--model", default=None)
+@click.option("--tokens-in", "token_input", type=int, default=0)
+@click.option("--tokens-out", "token_output", type=int, default=0)
+@click.option("--cache-read", "token_cache_read", type=int, default=0)
+@click.option("--cost", "cost_usd", type=float, default=None)
+@click.option("--tests-passed/--tests-failed", "tests_passed", default=None,
+              help="Omit if no test suite ran this run — the ledger records that gap explicitly, it does not guess.")
+@click.option("--real-gate", "real_gates_passed", multiple=True,
+              help="Name a deterministic check (subprocess/AST — not an LLM opinion) that actually ran. Repeatable.")
+@click.option("--llm-gate", "llm_judged_gates_passed", multiple=True,
+              help="Name an LLM-judged check that passed. Repeatable.")
+@click.option("--note", default=None, help="Free-text proof-of-delivery note (what was actually verified).")
+@click.option("--path", "project_path", type=click.Path(), default=None)
+def end(run_id: str, result: str, model: str | None, token_input: int, token_output: int,
+        token_cache_read: int, cost_usd: float | None, tests_passed: bool | None,
+        real_gates_passed: tuple, llm_judged_gates_passed: tuple, note: str | None, project_path: str | None):
+    """Close a run — writes the POST record, prints any anomaly flags."""
+    pcp_dir = _resolve_pcp_dir(project_path)
+    entry = run_log.end_run(
+        pcp_dir, run_id, result=result, model=model,
+        token_input=token_input, token_output=token_output, token_cache_read=token_cache_read,
+        cost_usd=cost_usd, tests_ran=tests_passed is not None, tests_passed=tests_passed,
+        real_gates_passed=list(real_gates_passed), llm_judged_gates_passed=list(llm_judged_gates_passed),
+        note=note, self_reported_usage=True,
+    )
+    console.print(f"[green]Run closed:[/green] {run_id} — result={result}")
+    if entry["anomaly_flags"]:
+        console.print("[yellow bold]Anomalies flagged:[/yellow bold]")
+        for a in entry["anomaly_flags"]:
+            console.print(f"  ⚠ {a}")
+    else:
+        console.print("[dim]No anomalies.[/dim]")
+
+
+@run_log_cli.command("list")
+@click.option("--path", "project_path", type=click.Path(), default=None)
+@click.option("--json", "as_json", is_flag=True)
+@click.option("--limit", type=int, default=30)
+def list_runs(project_path: str | None, as_json: bool, limit: int):
+    """Show recent runs, paired pre+post, with any anomaly flags."""
+    pcp_dir = _resolve_pcp_dir(project_path)
+    records = run_log.load(pcp_dir)
+    pairs = run_log.pair_runs(records)
+    open_ = run_log.open_runs(records)
+
+    if as_json:
+        console.print(json.dumps({"runs": pairs, "open_runs": open_}, indent=2))
+        return
+
+    table = Table(title="Run Ledger")
+    for col in ["run_id", "module", "feature", "actor", "type", "result", "committed", "anomalies"]:
+        table.add_column(col)
+    for p in pairs[-limit:]:
+        proof = p.get("proof_of_delivery", {})
+        table.add_row(
+            str(p.get("run_id", ""))[:8], str(p.get("module", "")), str(p.get("feature", ""))[:30],
+            str(p.get("actor", "")), str(p.get("run_type", "")), str(p.get("result", "")),
+            str(proof.get("committed")), ", ".join(p.get("anomaly_flags", [])) or "-",
+        )
+    console.print(table)
+    if open_:
+        console.print(f"\n[yellow]{len(open_)} open run(s) never closed:[/yellow]")
+        for r in open_:
+            console.print(f"  {r.get('run_id', '')[:8]} — {r.get('module')}/{r.get('feature')} started {r.get('start_time')}")

pcp/commands/scan.py

@@ -0,0 +1,346 @@
+"""pcp scan — auto-generate current_state.md from acceptance criteria."""
+
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from pcp.pcp_dir import find_pcp_dir, get_modules_dir, NoPCPDir
+from pcp.schema.validator import validate_file, load_yaml
+from pcp.pcp_status import write_pcp_md
+from pcp.commands.diff import run_diff
+from pcp.discovery.scanner import detect_stack, collect_source_files
+from pcp import qa
+from pcp import uat
+
+console = Console()
+
+# Per-process caches: one `pcp scan` invocation is one process, so these are
+# safe to keep for the lifetime of the run and avoid re-globbing/re-reading
+# the whole repo once per acceptance criterion.
+_SOURCE_FILES_CACHE: dict[Path, list[Path]] = {}
+_FILE_CONTENT_CACHE: dict[Path, str] = {}
+
+
+def _project_source_files(project_root: Path) -> list[Path]:
+    cached = _SOURCE_FILES_CACHE.get(project_root)
+    if cached is None:
+        stack = detect_stack(project_root)
+        cached = collect_source_files(project_root, stack)
+        _SOURCE_FILES_CACHE[project_root] = cached
+    return cached
+
+
+def _read_cached(path: Path) -> str:
+    content = _FILE_CONTENT_CACHE.get(path)
+    if content is None:
+        content = path.read_text(errors="replace")
+        _FILE_CONTENT_CACHE[path] = content
+    return content
+
+
+def _check_file_exists(target: str, project_root: Path) -> tuple[bool, str]:
+    path = project_root / target
+    if path.exists():
+        return True, str(path.relative_to(project_root))
+
+    # Fallback: file may have moved/been renamed during a refactor.
+    # Search for a same-basename file elsewhere in the tree before failing.
+    basename = Path(target).name
+    for f in _project_source_files(project_root):
+        if f.name == basename:
+            rel = f.relative_to(project_root)
+            return True, f"{target}: not at declared path, found moved to {rel}"
+
+    return False, f"{target}: not found (declared path or elsewhere)"
+
+
+def _check_ast_pattern(target: str, pattern: str, project_root: Path) -> tuple[bool, str]:
+    path = project_root / target
+    # Real bug, found 2026-07-08: path.exists() is True for a directory too,
+    # and directories don't have text content -- _read_cached(path).read_text()
+    # raised an unhandled IsADirectoryError that crashed the whole `pcp scan`
+    # run outright, whenever any acceptance criterion's ast_pattern target
+    # happened to be a directory rather than a file. is_file() correctly
+    # falls through to the same repo-wide fallback search used for a target
+    # that's simply missing.
+    if path.is_file():
+        if re.search(pattern, _read_cached(path), re.MULTILINE):
+            return True, f"pattern found in {target}"
+
+    # Fallback: feature may have been absorbed into a differently-named file
+    # during a refactor. Search other source files for the same pattern
+    # before declaring the criterion incomplete.
+    for f in _project_source_files(project_root):
+        if f == path:
+            continue
+        if re.search(pattern, _read_cached(f), re.MULTILINE):
+            rel = f.relative_to(project_root)
+            return True, f"pattern not found in {target}, found instead in {rel} — spec target may be stale"
+
+    return False, f"pattern not found in {target} or elsewhere in repo"
+
+
+def _load_prior_manual_status(current_state_path: Path) -> dict[str, str]:
+    """Parse prior current_state.md to preserve manual criterion statuses."""
+    if not current_state_path.exists():
+        return {}
+    statuses = {}
+    content = current_state_path.read_text()
+    for line in content.splitlines():
+        # Format: `- [x] MODULE/ID: description` or `- [ ] MODULE/ID: description`
+        m = re.match(r"- \[([ x])\] ([A-Z]+/[A-Z][0-9]+):", line.strip())
+        if m:
+            done = m.group(1) == "x"
+            key = m.group(2)
+            statuses[key] = "complete" if done else "pending"
+    return statuses
+
+
+def _evaluate_criterion(
+    criterion: dict,
+    module_name: str,
+    project_root: Path,
+    prior_manual: dict[str, str],
+    spec: dict,
+    pcp_dir: Path | None = None,
+) -> tuple[str, str]:
+    """Returns (status, detail)."""
+    cid = criterion["id"]
+    check = criterion.get("check", "manual")
+    target = criterion.get("target", "")
+    pattern = criterion.get("pattern", "")
+
+    if check == "file_exists":
+        ok, detail = _check_file_exists(target, project_root)
+        return ("complete" if ok else "pending"), detail
+
+    elif check == "ast_pattern":
+        if not pattern:
+            return criterion.get("status", "pending"), "no pattern defined"
+        ok, detail = _check_ast_pattern(target, pattern, project_root)
+        return ("complete" if ok else "pending"), detail
+
+    elif check == "test_passes":
+        return criterion.get("status", "pending"), "test_passes: preserved (run tests to update)"
+
+    elif check == "url_responds":
+        ok, detail = uat.check_url_responds(criterion.get("url", ""))
+        return ("complete" if ok else "pending"), detail
+
+    elif check == "dom_contains":
+        ok, detail = uat.check_dom_contains(criterion.get("url", ""), criterion.get("selector", ""))
+        return ("complete" if ok else "pending"), detail
+
+    elif check == "visual":
+        screenshot_path = None
+        if pcp_dir:
+            screenshot_path = pcp_dir / "evidence" / "_visual" / module_name / f"{cid}.png"
+        ok, detail = uat.check_visual(criterion.get("url", ""), screenshot_path)
+        if ok is None:
+            # Optional dependency not installed -- "could not check", not a
+            # verdict. Preserve prior status rather than downgrading it, same
+            # posture the manual fallback below already uses.
+            return criterion.get("status", "pending"), detail
+        return ("complete" if ok else "pending"), detail
+
+    else:  # manual
+        key = f"{module_name.upper()}/{cid}"
+        prior = prior_manual.get(key)
+        if prior:
+            return prior, "manual (preserved from prior scan)"
+        return criterion.get("status", "pending"), "manual"
+
+
+def _scan_module(
+    module_name: str,
+    acceptance_path: Path,
+    project_root: Path,
+    prior_manual: dict[str, str],
+    pcp_dir: Path | None = None,
+) -> dict:
+    errors = validate_file(acceptance_path, "module_acceptance")
+    if errors:
+        console.print(f"[yellow]⚠  {module_name}/acceptance.yaml: schema errors[/yellow]")
+        for e in errors:
+            console.print(f"   {e}")
+
+    data = load_yaml(acceptance_path)
+    criteria = data.get("criteria", [])
+    results = []
+
+    for c in criteria:
+        status, detail = _evaluate_criterion(c, module_name, project_root, prior_manual, data, pcp_dir)
+        results.append({
+            "id": c["id"],
+            "description": c["description"],
+            "check": c.get("check", "manual"),
+            "status": status,
+            "detail": detail,
+            "verified_by": c.get("verified_by"),
+        })
+
+    return {"module": module_name, "criteria": results}
+
+
+def _write_current_state(pcp_dir: Path, modules_results: list[dict], timestamp: str, coverage: dict | None = None) -> None:
+    total = sum(len(m["criteria"]) for m in modules_results)
+    complete = sum(
+        1 for m in modules_results for c in m["criteria"] if c["status"] == "complete"
+    )
+    score = complete / total if total else 0.0
+
+    lines = [
+        "# Current State",
+        f"Generated: {timestamp}",
+        "",
+        "## Summary",
+        f"- Total criteria: {total}",
+        f"- Complete: {complete} ({score:.0%})",
+        f"- Pending: {total - complete}",
+        "",
+        "## Module Status",
+    ]
+
+    for m in modules_results:
+        lines.append(f"\n### {m['module']}")
+        for c in m["criteria"]:
+            mark = "x" if c["status"] == "complete" else " "
+            key = f"{m['module'].upper()}/{c['id']}"
+            verified = f" [verified: {c['verified_by']}]" if c["status"] == "complete" and c.get("verified_by") else (
+                " [unverified — not marked complete by pcp build]" if c["status"] == "complete" else ""
+            )
+            lines.append(f"- [{mark}] {key}: {c['description']}{verified}")
+            if c["detail"] and c["detail"] not in ("manual", ""):
+                lines.append(f"  > {c['detail']}")
+
+    lines += [
+        "",
+        "## Drift Score",
+        f"acceptance coverage: {score:.2f}",
+        "",
+    ]
+
+    if coverage and coverage.get("tool") and coverage.get("percent") is not None:
+        lines += [
+            "## Test Coverage",
+            f"{coverage['percent']:.0f}% ({coverage['tool']})",
+            "",
+        ]
+
+    out = pcp_dir / "current_state.md"
+    out.write_text("\n".join(lines))
+    return out
+
+
+@click.command()
+@click.option("--path", "project_path", type=click.Path(), default=None,
+              help="Project root (default: cwd, walks up to find .pcp/).")
+@click.option("--quiet", is_flag=True, help="Suppress output.")
+@click.option("--coverage", "with_coverage", is_flag=True,
+              help="Also run the test suite under coverage and record %% covered. "
+                   "Off by default — runs the full suite, slower than a plain scan.")
+def scan(project_path: str | None, quiet: bool, with_coverage: bool):
+    """Auto-generate .pcp/current_state.md from acceptance criteria."""
+    try:
+        pcp_dir = find_pcp_dir(Path(project_path) if project_path else None)
+    except NoPCPDir as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(2)
+
+    project_root = pcp_dir.parent
+    modules_dir = get_modules_dir(pcp_dir)
+
+    if not modules_dir.exists():
+        console.print("[yellow]No modules found in .pcp/strategy/modules/.[/yellow]")
+        sys.exit(0)
+
+    current_state_path = pcp_dir / "current_state.md"
+    prior_manual = _load_prior_manual_status(current_state_path)
+
+    acceptance_files = sorted(modules_dir.glob("*/acceptance.yaml"))
+    if not acceptance_files:
+        console.print("[yellow]No acceptance.yaml files found.[/yellow]")
+        sys.exit(0)
+
+    modules_results = []
+    for af in acceptance_files:
+        module_name = af.parent.name
+        result = _scan_module(module_name, af, project_root, prior_manual, pcp_dir)
+        modules_results.append(result)
+
+    coverage = None
+    if with_coverage:
+        if not quiet:
+            console.print("[dim]Running test suite under coverage...[/dim]")
+        coverage = qa.run_coverage(project_root)
+        if not quiet and not coverage.get("tool"):
+            console.print("[dim]No coverage tool detected (coverage/pytest or npm coverage script) — skipped.[/dim]")
+
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    out_path = _write_current_state(pcp_dir, modules_results, timestamp, coverage)
+
+    # Work that landed but whose status still says pending. `scan` is the right
+    # place: it is what regenerates current_state.md, so it is the moment a stale
+    # status starts propagating into the dashboard, diff.md, validate-strategy's
+    # coverage and the next build's pending list. Reported, never auto-corrected —
+    # acceptance.yaml is human-approved, and flipping status here would trade a
+    # false "not built" for a false "built", which is strictly worse.
+    if not quiet:
+        from pcp import orphaned_work
+        try:
+            orphaned = orphaned_work.find_orphaned_work(pcp_dir, project_root)
+        except Exception:
+            orphaned = []
+        if orphaned:
+            console.print("")
+            for line in orphaned_work.format_findings(orphaned):
+                console.print(f"[yellow]{line}[/yellow]" if not line.startswith("   ") else f"[dim]{line}[/dim]")
+
+        # Mirror image of the above: complete with no evidence a gate ever ran.
+        # More dangerous than a stale pending -- a false complete means the
+        # work is never checked again. Advisory only; see
+        # find_unverified_complete's own docstring for why this never blocks.
+        try:
+            unverified = orphaned_work.find_unverified_complete(pcp_dir)
+        except Exception:
+            unverified = []
+        if unverified:
+            console.print("")
+            for line in orphaned_work.format_unverified_findings(unverified):
+                console.print(f"[yellow]{line}[/yellow]" if not line.startswith("   ") else f"[dim]{line}[/dim]")
+
+    # diff.md was previously only ever regenerated by a human remembering to
+    # run `pcp diff` separately -- silently skips if target_state.md doesn't
+    # exist yet, same tolerance the standalone command already had.
+    diff_result = run_diff(pcp_dir)
+    if not quiet and diff_result and diff_result["regressions"]:
+        console.print(f"[red]{len(diff_result['regressions'])} regression(s) in diff.md[/red]")
+
+    # Per-symbol fingerprint churn (build plan 3.4): symbol-level, not
+    # file-level, change signal — "file touched but relevant symbol
+    # unchanged" stops counting as drift noise.
+    try:
+        from pcp import symbols
+        delta = symbols.update_fingerprints(pcp_dir)
+        n_changed = len(delta["changed"])
+        if not quiet and (n_changed or delta["added"] or delta["removed"]):
+            console.print(
+                f"[dim]Symbols since last scan: {n_changed} changed, "
+                f"{len(delta['added'])} added, {len(delta['removed'])} removed[/dim]"
+            )
+    except Exception:
+        pass
+
+    total = sum(len(m["criteria"]) for m in modules_results)
+    complete = sum(1 for m in modules_results for c in m["criteria"] if c["status"] == "complete")
+
+    pcp_md_path = write_pcp_md(pcp_dir, modules_results, timestamp, total, complete)
+
+    if not quiet:
+        score = complete / total if total else 0.0
+        color = "green" if score >= 0.8 else "yellow" if score >= 0.5 else "red"
+        console.print(f"[{color}]{complete}/{total} criteria complete ({score:.0%})[/{color}]  →  {out_path.relative_to(project_root)}  +  {pcp_md_path.name}")

pcp/commands/self_update.py

@@ -0,0 +1,125 @@
+"""`pcp self-update` -- explicit, human-run, git-pull-based update.
+
+Deliberately NOT the shape removed as a launch blocker on 2026-07-27: that
+cron silently curled a mutable file off raw.githubusercontent.com and
+overwrote an agent instruction file with no signature, no hash check, no
+human trigger. This command is the opposite on every axis: only runs when
+a human types it, only touches a real git checkout (refuses cleanly
+otherwise), only ever fast-forwards (never clobbers local changes), and
+reports exactly what changed -- same shape Project P landed on for its own
+agent self-update (`git pull --ff-only`, see decision_git_pull_self_update).
+
+`--check` is the announce-only half, added for the SessionStart hook
+(.pcp/hooks/session_update_check.py, scaffolded by `pcp init`): a project
+opening a session can tell you an update exists without ever pulling one
+byte on its own. Actually updating always stays a separate, explicit
+`pcp self-update` invocation.
+"""
+import subprocess
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from pcp import version_drift
+
+console = Console()
+
+
+def _git(args: list[str], cwd: Path) -> subprocess.CompletedProcess:
+    return subprocess.run(["git", *args], cwd=cwd, capture_output=True, text=True)
+
+
+def _resolve_checkout() -> tuple[Path | None, str | None]:
+    """Returns (root, error_message). error_message is None on success."""
+    root = version_drift.source_root()
+    if root is None:
+        return None, (
+            "No git checkout found for this install. self-update only works on a "
+            "git-cloned source tree (set PCP_SOURCE_ROOT if this one lives somewhere non-standard)."
+        )
+    if not (root / ".git").exists():
+        return None, f"{root} is not a git repository. Cannot self-update."
+    return root, None
+
+
+def check_for_update() -> dict:
+    """Read-only: fetches from origin and reports whether the local checkout
+    is behind, without touching the working tree. Never pulls."""
+    root, err = _resolve_checkout()
+    if root is None:
+        return {"status": "unavailable", "message": err}
+
+    fetch = _git(["fetch", "--quiet"], root)
+    if fetch.returncode != 0:
+        return {"status": "unknown", "message": f"git fetch failed: {(fetch.stderr or fetch.stdout).strip()}"}
+
+    behind = _git(["rev-list", "--count", "HEAD..@{u}"], root)
+    if behind.returncode != 0:
+        # No upstream tracking branch configured -- can't tell.
+        return {"status": "unknown", "message": "No upstream tracking branch configured."}
+
+    count = int(behind.stdout.strip() or "0")
+    if count == 0:
+        return {"status": "current", "message": "PCP is up to date."}
+
+    current = version_drift.source_version(root) or "unknown"
+    return {
+        "status": "behind", "commits_behind": count, "current_version": current,
+        "message": f"PCP update available ({count} commit(s) behind) -- run `pcp self-update`.",
+    }
+
+
+@click.command(name="self-update")
+@click.option("--check", "check_only", is_flag=True,
+              help="Report whether an update is available without pulling it.")
+def self_update(check_only: bool):
+    """Update this PCP install via `git pull --ff-only` on its own checkout."""
+    if check_only:
+        result = check_for_update()
+        console.print(result["message"])
+        raise SystemExit(0 if result["status"] != "unavailable" else 1)
+
+    root, err = _resolve_checkout()
+    if root is None:
+        console.print(f"[red]{err}[/red]")
+        raise SystemExit(1)
+
+    status = _git(["status", "--porcelain"], root)
+    if status.stdout.strip():
+        console.print(
+            f"[yellow]{root} has uncommitted changes.[/yellow] "
+            "Commit or stash them first -- self-update refuses to pull over local edits."
+        )
+        raise SystemExit(1)
+
+    before = version_drift.source_version(root) or "unknown"
+    console.print(f"Current source version: {before}")
+    console.print("Running `git pull --ff-only`...")
+
+    pull = _git(["pull", "--ff-only"], root)
+    if pull.returncode != 0:
+        console.print("[red]git pull --ff-only failed:[/red]")
+        console.print(pull.stdout + pull.stderr)
+        console.print(
+            "[dim]Common cause: local commits diverged from origin. "
+            "Resolve manually (rebase/merge) -- self-update will not force it.[/dim]"
+        )
+        raise SystemExit(1)
+
+    after = version_drift.source_version(root) or "unknown"
+    if pull.stdout.strip():
+        console.print(pull.stdout.strip())
+
+    if before == after:
+        console.print(f"[green]Already up to date[/green] ({after}).")
+        return
+
+    console.print(f"[green]Updated {before} -> {after}.[/green]")
+    if version_drift.is_editable():
+        console.print("Editable install -- code is live now, no reinstall needed.")
+    else:
+        console.print(
+            f"[yellow]This is a wheel install[/yellow] -- source is updated at {root}, "
+            f"but reinstall to pick it up: `pip install -e {root}`."
+        )