provenance-cli 0.1.0__py3-none-any.whl

prov/__init__.py

@@ -0,0 +1,4 @@
+"""Provenance CLI — spec-driven development. Python 3.9+ stdlib only."""
+from prov.cli import main
+
+__all__ = ["main"]

prov/cli.py

@@ -0,0 +1,105 @@
+"""CLI entry point — argument parsing and command dispatch."""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from prov.commands import (
+    cmd_check_slug,
+    cmd_context,
+    cmd_diff,
+    cmd_domain,
+    cmd_find,
+    cmd_impact,
+    cmd_init,
+    cmd_orient,
+    cmd_rebuild,
+    cmd_reconcile,
+    cmd_scope,
+    cmd_sync,
+    cmd_validate,
+    cmd_write,
+)
+from prov.spec_io import get_repo_root, get_spec_dir
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = argv if argv is not None else sys.argv[1:]
+
+    # Resolve spec dir: entry script's parent dir (e.g. src/ or prov/)
+    entry = Path(sys.argv[0]).resolve()
+    entry_dir = entry.parent if entry.suffix else Path.cwd()
+    spec_dir = get_spec_dir(entry_dir)
+    repo_root = get_repo_root(spec_dir)
+
+    if not args:
+        print("Usage: prov <command> [args]  (or: python prov/prov.py <command> [args])")
+        print(
+            "Commands: orient, scope <path>, context <slug>, impact <slug>, find <kw>, domain <name>,"
+        )
+        print(
+            "          validate, check-slug <slug>, reconcile <path>, sync [path],"
+        )
+        print(
+            "          sync mark-implemented <slug>, sync remove-ref <slug> <ref>,"
+        )
+        print(
+            "          sync update-ref <slug> <old> <new>, sync remove-backlink <file> <line> <slug>,"
+        )
+        print("          write [--yes], diff [ref], rebuild, init")
+        return 0
+
+    cmd = args[0].lower()
+    rest = args[1:]
+
+    # Commands other than init require an existing spec directory
+    if cmd != "init" and not (spec_dir / "CONTEXT.md").exists():
+        print("No spec directory found.")
+        print("  Run 'prov init' to scaffold one, or cd into a project with prov/, spec/, or specs/.")
+        return 1
+
+    if cmd == "orient":
+        cmd_orient(spec_dir, repo_root)
+    elif cmd == "scope":
+        cmd_scope(spec_dir, repo_root, rest[0] if rest else ".")
+    elif cmd == "context":
+        if not rest:
+            print("Usage: prov context <slug>")
+            return 1
+        cmd_context(spec_dir, repo_root, rest[0])
+    elif cmd == "impact":
+        if not rest:
+            print("Usage: prov impact <slug>")
+            return 1
+        cmd_impact(spec_dir, repo_root, rest[0])
+    elif cmd == "find":
+        cmd_find(spec_dir, " ".join(rest) if rest else "")
+    elif cmd == "domain":
+        if not rest:
+            print("Usage: prov domain <name>")
+            return 1
+        cmd_domain(spec_dir, rest[0])
+    elif cmd == "validate":
+        return cmd_validate(spec_dir, repo_root)
+    elif cmd == "check-slug":
+        if not rest:
+            print("Usage: prov check-slug <slug>")
+            return 1
+        cmd_check_slug(spec_dir, rest[0])
+    elif cmd == "reconcile":
+        cmd_reconcile(spec_dir, repo_root, rest[0] if rest else ".")
+    elif cmd == "sync":
+        return cmd_sync(spec_dir, repo_root, rest)
+    elif cmd in ("rebuild", "rebuild-cache"):
+        cmd_rebuild(spec_dir)
+    elif cmd == "write":
+        return cmd_write(spec_dir, repo_root, rest)
+    elif cmd == "diff":
+        ref = rest[0] if rest else "HEAD"
+        cmd_diff(spec_dir, repo_root, ref)
+    elif cmd == "init":
+        cmd_init(spec_dir)
+    else:
+        print(f"Unknown command: {cmd}")
+        return 1
+    return 0

prov/commands/__init__.py

@@ -0,0 +1,32 @@
+"""CLI command implementations."""
+from prov.commands.orient import cmd_orient
+from prov.commands.scope import cmd_scope
+from prov.commands.context import cmd_context
+from prov.commands.impact import cmd_impact
+from prov.commands.find import cmd_find
+from prov.commands.domain import cmd_domain
+from prov.commands.validate import cmd_validate
+from prov.commands.check_slug import cmd_check_slug
+from prov.commands.reconcile import cmd_reconcile
+from prov.commands.sync import cmd_sync
+from prov.commands.rebuild import cmd_rebuild
+from prov.commands.write import cmd_write
+from prov.commands.diff import cmd_diff
+from prov.commands.init import cmd_init
+
+__all__ = [
+    "cmd_orient",
+    "cmd_scope",
+    "cmd_context",
+    "cmd_impact",
+    "cmd_find",
+    "cmd_domain",
+    "cmd_validate",
+    "cmd_check_slug",
+    "cmd_reconcile",
+    "cmd_sync",
+    "cmd_rebuild",
+    "cmd_write",
+    "cmd_diff",
+    "cmd_init",
+]

prov/commands/check_slug.py

@@ -0,0 +1,27 @@
+"""prov check-slug <slug> — is slug available."""
+from pathlib import Path
+
+from prov.indexing import nodes_by_slug
+from prov.spec_io import load_backend
+
+
+def cmd_check_slug(spec_dir: Path, slug: str) -> None:
+    nodes, _, _, _, _ = load_backend(spec_dir)
+    nodes_by_slug_map = nodes_by_slug(nodes)
+    full = (
+        slug
+        if slug in nodes_by_slug_map
+        else (slug if slug.startswith("C:") or slug.startswith("Q:") else slug)
+    )
+    if full in nodes_by_slug_map or slug in nodes_by_slug_map:
+        key = full if full in nodes_by_slug_map else slug
+        n = nodes_by_slug_map[key]
+        print(f"=== CHECK-SLUG: {slug} ===")
+        print()
+        print(f"TAKEN — {n.file}:")
+        print(f"  {n.slug}: {n.statement[:60]}")
+        print()
+        print("Try: " + slug + "-alt, " + slug + "-v2")
+    else:
+        print(f"=== CHECK-SLUG: {slug} ===")
+        print("Available.")

prov/commands/context.py

@@ -0,0 +1,74 @@
+"""prov context <slug> — full entry details."""
+import sys
+from pathlib import Path
+
+from prov.indexing import build_edges, nodes_by_slug
+from prov.spec_io import load_backend
+
+
+def cmd_context(spec_dir: Path, repo_root: Path, slug: str) -> None:
+    nodes, _, _, _, file_by_domain = load_backend(spec_dir)
+    nodes_by_slug_map = nodes_by_slug(nodes)
+    edges = build_edges(nodes)
+    n = nodes_by_slug_map.get(slug)
+    if not n:
+        for k in nodes_by_slug_map:
+            if k.replace("C:", "").replace("Q:", "") == slug or k.endswith(":" + slug):
+                n = nodes_by_slug_map[k]
+                break
+    if not n:
+        print(f"Entry not found: {slug}")
+        sys.exit(1)
+    domain_nodes = [x for x in nodes if x.domain == n.domain]
+    constraints = [x for x in domain_nodes if x.type == "constraint"]
+    deps = [nodes_by_slug_map[d] for d in n.depends_on if d in nodes_by_slug_map]
+    dep_by = [x for x in nodes if n.slug in x.depends_on]
+    blocked = [
+        nodes_by_slug_map[b] for b in getattr(n, "blocked_by", []) if b in nodes_by_slug_map
+    ]
+
+    print(f"=== CONTEXT: {n.slug} ===")
+    print()
+    status = "planned" if getattr(n, "planned", False) else "implemented"
+    print(f"{n.type}  |  domain: {n.domain}  |  {status}")
+    print(n.file)
+    print()
+    print("Statement:")
+    print(f"  {n.statement}")
+    print()
+    print("Why this exists:")
+    print(f"  > {n.provenance or '(none)'}")
+    if n.assumptions:
+        print()
+        print("Assumptions (unconfirmed):")
+        for a in n.assumptions:
+            print(f"  ! {a}")
+    if n.code_refs and not getattr(n, "planned", True):
+        print()
+        print("Code:")
+        for ref in n.code_refs:
+            print(f"  ~ {ref}")
+    if constraints:
+        print()
+        print("Constraints governing this domain:")
+        for c in constraints:
+            print(f"  {c.slug}    {c.statement}")
+    if deps:
+        print()
+        print("Depends on:")
+        for d in deps:
+            print(f"  {d.slug}    [{d.domain}]    {d.statement[:60]}")
+    if dep_by:
+        print()
+        print("Depended on by:")
+        for d in dep_by[:10]:
+            print(f"  {d.slug}    [{d.domain}]    {d.statement[:60]}")
+    if blocked:
+        print()
+        print("Blocked by:")
+        for b in blocked:
+            print(f"  {b.slug}    {b.statement[:60]}")
+    print()
+    print("─── prov impact <slug>           before making changes")
+    print("─── prov context <dep-slug>      explore a dependency")
+    print("─── prov domain <domain>         load full domain context")

prov/commands/diff.py

@@ -0,0 +1,106 @@
+"""prov diff [ref] — semantic change manifest vs ref."""
+from pathlib import Path
+
+from prov.indexing import nodes_by_slug
+from prov.model import Node
+from prov.spec_io import load_backend, load_nodes_from_ref
+
+
+def cmd_diff(spec_dir: Path, repo_root: Path, ref: str) -> None:
+    nodes, _, _, _, _ = load_backend(spec_dir)
+    old_nodes = load_nodes_from_ref(spec_dir, repo_root, ref)
+    old_by = nodes_by_slug(old_nodes)
+    cur_by = nodes_by_slug(nodes)
+
+    implemented: list[tuple[str, str]] = []
+    new_entries: list[Node] = []
+    modified: list[tuple[Node, Node]] = []
+    resolved_questions: list[str] = []
+    removed: list[Node] = []
+    constraints_changed: list[tuple[Node, Node]] = []
+    assumptions_to_confirm: list[tuple[str, str]] = []
+
+    for slug, n in cur_by.items():
+        if slug not in old_by:
+            new_entries.append(n)
+            for a in n.assumptions:
+                assumptions_to_confirm.append((n.slug, a))
+            continue
+        o = old_by[slug]
+        if n.type == "question":
+            continue
+        if n.type == "constraint":
+            if o.statement != n.statement or o.provenance != n.provenance:
+                constraints_changed.append((o, n))
+            continue
+        if o.planned and not n.planned and n.code_refs:
+            implemented.append((n.slug, n.domain))
+        elif (
+            o.statement != n.statement
+            or o.provenance != n.provenance
+            or set(o.depends_on) != set(n.depends_on)
+            or set(o.blocked_by) != set(n.blocked_by)
+        ):
+            modified.append((o, n))
+        for a in n.assumptions:
+            if (n.slug, a) not in assumptions_to_confirm:
+                assumptions_to_confirm.append((n.slug, a))
+
+    for slug, o in old_by.items():
+        if slug not in cur_by:
+            removed.append(o)
+            if o.type == "question":
+                resolved_questions.append(slug)
+
+    print("=== PROV DIFF ===")
+    print(f"vs {ref}")
+    print()
+    if implemented:
+        print("IMPLEMENTED (was [planned], now has ~ refs):")
+        for slug, dom in implemented:
+            print(f"  {slug}  ({dom})")
+        print()
+    if new_entries:
+        print("NEW ENTRIES:")
+        for n in new_entries:
+            print(f"  {n.slug}  ({n.domain})  {n.statement[:50]}...")
+        print()
+    if modified:
+        print("MODIFIED:")
+        for o, n in modified:
+            print(f"  {o.slug}: statement/provenance/deps changed")
+        print()
+    if resolved_questions:
+        print("RESOLVED QUESTIONS:")
+        for s in resolved_questions:
+            print(f"  {s}")
+        print()
+    if removed:
+        print("REMOVED ENTRIES:")
+        for n in removed:
+            print(f"  {n.slug}  ({n.domain})")
+        print()
+    if constraints_changed:
+        print("CONSTRAINTS CHANGED:")
+        for o, n in constraints_changed:
+            print(f"  {n.slug}")
+        print()
+    if assumptions_to_confirm:
+        print("ASSUMPTIONS REQUIRING CONFIRMATION:")
+        for slug, a in assumptions_to_confirm[:15]:
+            print(f"  {slug}  ! {a[:50]}...")
+        if len(assumptions_to_confirm) > 15:
+            print(f"  ... and {len(assumptions_to_confirm) - 15} more")
+        print()
+    if not any(
+        [
+            implemented,
+            new_entries,
+            modified,
+            resolved_questions,
+            removed,
+            constraints_changed,
+            assumptions_to_confirm,
+        ]
+    ):
+        print("No semantic changes.")

prov/commands/domain.py

@@ -0,0 +1,57 @@
+"""prov domain <name> — full domain load."""
+import sys
+from pathlib import Path
+
+from prov.spec_io import load_backend
+
+
+def cmd_domain(spec_dir: Path, name: str) -> None:
+    nodes, _, summaries, refs_by_domain, file_by_domain = load_backend(spec_dir)
+    domain_nodes = [n for n in nodes if n.domain == name]
+    if not domain_nodes:
+        print(f"Domain not found: {name}")
+        sys.exit(1)
+    path = file_by_domain.get(name, "")
+    summary = summaries.get(name, "")
+
+    print(f"=== DOMAIN: {name} ===")
+    print()
+    print(summary)
+    print(f"File: {path}")
+    print()
+    constraints = [n for n in domain_nodes if n.type == "constraint"]
+    reqs = [n for n in domain_nodes if n.type == "requirement"]
+    planned = sum(1 for n in reqs if n.planned)
+    questions = [n for n in domain_nodes if n.type == "question"]
+    print(f"CONSTRAINTS ({len(constraints)}):")
+    for n in constraints:
+        print(f"  {n.slug}: {n.statement}")
+        print(f"    > {n.provenance}")
+        if n.code_refs:
+            print(f"    ~ " + ", ".join(n.code_refs))
+    print()
+    print(f"REQUIREMENTS ({len(reqs) - planned} implemented, {planned} planned):")
+    for n in reqs:
+        suffix = " [planned]" if n.planned else ""
+        print(f"  {n.slug}: {n.statement}{suffix}")
+        print(f"    > {n.provenance}")
+        if n.assumptions:
+            for a in n.assumptions:
+                print(f"    ! {a}")
+        if n.depends_on:
+            for d in n.depends_on:
+                print(f"    @ {d}")
+        if n.code_refs:
+            for r in n.code_refs:
+                print(f"    ~ {r}")
+        if n.blocked_by:
+            for b in n.blocked_by:
+                print(f"    ? {b}")
+    print()
+    print(f"OPEN QUESTIONS ({len(questions)}):")
+    for n in questions:
+        print(f"  {n.slug}: {n.statement}")
+        print(f"    > blocks: {', '.join(n.blocked_by)}")
+    print()
+    print("OUT OF SCOPE:")
+    print("  (see domain file)")

prov/commands/find.py

@@ -0,0 +1,31 @@
+"""prov find <keywords> — search entries."""
+from pathlib import Path
+
+from prov.spec_io import load_backend
+
+
+def cmd_find(spec_dir: Path, keywords: str) -> None:
+    nodes, _, _, _, _ = load_backend(spec_dir)
+    kws = keywords.lower().split()
+    matches = []
+    for n in nodes:
+        score = 0
+        text = f"{n.slug} {n.statement} {n.domain}".lower()
+        for kw in kws:
+            if kw in text:
+                score += 1
+        if score > 0:
+            matches.append((score, n))
+    matches.sort(key=lambda x: -x[0])
+
+    print(f'=== FIND: "{keywords}" ===')
+    print()
+    if not matches:
+        print("No entries match.")
+        print("Try: prov orient    to browse all domains.")
+        return
+    for _, n in matches[:20]:
+        print(f"{n.slug}    [{n.domain}]    {n.type}    {n.statement[:60]}")
+    print()
+    print(f"{len(matches)} results.")
+    print("─── prov context <slug>    for full details")

prov/commands/impact.py

@@ -0,0 +1,70 @@
+"""prov impact <slug> — blast radius before changing."""
+import sys
+from pathlib import Path
+
+from prov.indexing import build_edges, nodes_by_slug
+from prov.spec_io import load_backend
+
+
+def cmd_impact(spec_dir: Path, repo_root: Path, slug: str) -> None:
+    nodes, _, _, _, _ = load_backend(spec_dir)
+    nodes_by_slug_map = nodes_by_slug(nodes)
+    build_edges(nodes)
+    if slug not in nodes_by_slug_map:
+        print(f"Entry not found: {slug}")
+        sys.exit(1)
+    direct = [x for x in nodes if slug in x.depends_on]
+    trans: set[str] = set(n.slug for n in direct)
+    worklist = list(trans)
+    while worklist:
+        s = worklist.pop()
+        for x in nodes:
+            if s in x.depends_on and x.slug not in trans:
+                trans.add(x.slug)
+                worklist.append(x.slug)
+    code_paths: list[str] = []
+    all_slugs = (trans | {slug}) if slug in nodes_by_slug_map else trans
+    for n in [nodes_by_slug_map[s] for s in all_slugs if s in nodes_by_slug_map]:
+        if n and n.code_refs:
+            code_paths.extend(n.code_refs)
+    code_paths.extend(nodes_by_slug_map[slug].code_refs if slug in nodes_by_slug_map else [])
+    assumptions: list[tuple[str, str]] = []
+    for s in trans | {slug}:
+        if s in nodes_by_slug_map:
+            for a in nodes_by_slug_map[s].assumptions:
+                assumptions.append((s, a))
+    planned = [
+        nodes_by_slug_map[s]
+        for s in trans
+        if s in nodes_by_slug_map and getattr(nodes_by_slug_map[s], "planned", False)
+    ]
+
+    print(f"=== IMPACT: {slug} ===")
+    print()
+    print(f"Direct dependents ({len(direct)}):")
+    for n in direct:
+        status = "planned" if getattr(n, "planned", False) else "implemented"
+        print(f"  {n.slug}    [{n.domain}]    {n.type}    {status}")
+    print()
+    print(f"Transitive dependents ({len(trans)} total):")
+    for s in list(trans)[:15]:
+        d = nodes_by_slug_map.get(s)
+        if d:
+            print(f"  {s}    [{d.domain}]")
+    if code_paths:
+        print()
+        print("All code in blast radius:")
+        for p in code_paths[:20]:
+            print(f"  {p}    <- {slug}")
+    if assumptions:
+        print()
+        print("Unconfirmed assumptions in blast radius:")
+        for s, a in assumptions[:10]:
+            print(f"  {s}    ! {a[:60]}")
+    if planned:
+        print()
+        print("Planned entries in blast radius:")
+        for n in planned[:10]:
+            print(f"  {n.slug}    [{n.domain}]    [planned]")
+    print()
+    print("─── Proceed carefully. Verify all affected code after changes.")

prov/commands/init.py

@@ -0,0 +1,41 @@
+"""prov init — scaffold CONTEXT.md."""
+from pathlib import Path
+
+
+def cmd_init(spec_dir: Path) -> None:
+    spec_dir.mkdir(parents=True, exist_ok=True)
+    ctx_path = spec_dir / "CONTEXT.md"
+    if ctx_path.exists():
+        print("CONTEXT.md already exists.")
+        return
+    ctx_path.write_text(
+        """# <Project Name>
+
+> <One sentence. What it does and who uses it.>
+
+## Purpose
+
+<2-3 sentences. The problem being solved.>
+
+## User goals
+
+1. <Primary user goal>
+2. <Secondary goal>
+
+## Hard constraints
+
+C:example: <Non-negotiable rule>
+
+> <why>
+
+## Non-goals
+
+- <Explicit out-of-scope items>
+
+## Domain map
+
+<domain> prov/<domain>.md
+""",
+        encoding="utf-8",
+    )
+    print("Created CONTEXT.md. Edit it with your project details.")

prov/commands/orient.py

@@ -0,0 +1,62 @@
+"""prov orient — session start."""
+from pathlib import Path
+
+from prov.model import Node
+from prov.spec_io import load_backend
+
+
+def cmd_orient(spec_dir: Path, repo_root: Path) -> None:
+    nodes, ctx, summaries, refs_by_domain, _ = load_backend(spec_dir)
+    by_domain: dict[str, list[Node]] = {}
+    for n in nodes:
+        by_domain.setdefault(n.domain, []).append(n)
+
+    print("=== PROV ORIENT ===")
+    print()
+    print(f"Project: {ctx.title}")
+    print(ctx.purpose)
+    print()
+    print(
+        "Hard constraints:",
+        ", ".join(ctx.hard_constraints) if ctx.hard_constraints else "(none)",
+    )
+    print()
+    print("DOMAINS:")
+    for domain in sorted(by_domain.keys()):
+        reqs = [n for n in by_domain[domain] if n.type == "requirement"]
+        planned = sum(1 for n in reqs if n.planned)
+        questions = [n for n in by_domain[domain] if n.type == "question"]
+        assumptions = sum(len(n.assumptions) for n in by_domain[domain])
+        summ = (summaries.get(domain) or "")[:50]
+        print(
+            f"  {domain:12} {summ:50} {len(reqs)} reqs  {planned} planned  {len(questions)} questions  {assumptions} assumptions"
+        )
+
+    open_q = [n for n in nodes if n.type == "question"]
+    if open_q:
+        print()
+        print(f"OPEN QUESTIONS ({len(open_q)} total):")
+        for n in open_q[:20]:
+            stmt = (n.statement or "")[:60]
+            refs = [x for x in nodes if n.slug in getattr(x, "blocked_by", [])]
+            block_slugs = ", ".join(x.slug for x in refs) if refs else ""
+            print(f"  {n.slug}  {n.domain}  {stmt}")
+            if block_slugs:
+                print(f"            -> blocks: {block_slugs}")
+
+    unconf = [(n, a) for n in nodes for a in n.assumptions]
+    if unconf:
+        print()
+        print(f"UNCONFIRMED ASSUMPTIONS ({len(unconf)} total):")
+        for n, a in unconf[:15]:
+            print(f"  {n.slug:20} {n.domain:10} ! {(a or '')[:50]}")
+
+    planned = [n for n in nodes if n.type == "requirement" and n.planned]
+    if planned:
+        print()
+        print(f"PLANNED ({len(planned)} total):")
+        for n in planned[:15]:
+            print(f"  {n.slug:20} {n.domain:10} {(n.statement or '')[:50]}")
+
+    print()
+    print("─── Next: prov domain <name> | prov context <slug> | prov validate")

prov/commands/rebuild.py

@@ -0,0 +1,57 @@
+"""prov rebuild — regenerate .spec/ cache."""
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from prov.indexing import build_edges
+from prov.spec_io import load_backend
+
+
+def cmd_rebuild(spec_dir: Path) -> None:
+    cache_dir = spec_dir / ".spec"
+    cache_dir.mkdir(exist_ok=True)
+    nodes, ctx, summaries, refs_by_domain, file_by_domain = load_backend(spec_dir)
+
+    data = {
+        "generated": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+        "spec_files": list(file_by_domain.values()),
+        "nodes": {
+            n.slug: {
+                "type": n.type,
+                "domain": n.domain,
+                "file": n.file,
+                "statement": n.statement,
+                "planned": getattr(n, "planned", False),
+                "provenance": n.provenance,
+                "assumptions": n.assumptions,
+                "code_refs": n.code_refs,
+                "depends_on": n.depends_on,
+                "blocked_by": getattr(n, "blocked_by", []),
+            }
+            for n in nodes
+        },
+        "edges": [],
+    }
+    edges = build_edges(nodes)
+    for e in edges:
+        if "src/" in e.to_slug or "/" in e.to_slug:
+            data["edges"].append({"from": e.from_slug, "to": e.to_slug, "type": e.type})
+        else:
+            data["edges"].append(
+                {"from": e.from_slug, "to": e.to_slug, "type": "depends-on"}
+            )
+    by_file: dict[str, list[str]] = {}
+    for n in nodes:
+        for ref in n.code_refs:
+            fp = ref.split(":")[0]
+            by_file.setdefault(fp, []).append(n.slug)
+    code_index = {
+        "generated": data["generated"],
+        "by_file": by_file,
+        "by_dir": dict(refs_by_domain),
+    }
+    (cache_dir / "graph.json").write_text(json.dumps(data, indent=2), encoding="utf-8")
+    (cache_dir / "code-index.json").write_text(
+        json.dumps(code_index, indent=2), encoding="utf-8"
+    )
+    print("Cache rebuilt.")