generic-ml-cache-cli 0.3.0__tar.gz → 0.5.0__tar.gz

{generic_ml_cache_cli-0.3.0 → generic_ml_cache_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: generic-ml-cache-cli
-Version: 0.3.0
+Version: 0.5.0
 Summary: Terminal UI for generic-ml-cache: the gmlcache command. A thin inbound driver over generic-ml-cache-core -- reads config, provides the data source, maps commands onto the core library.
 Project-URL: Homepage, https://github.com/danielslobozian/generic-ml-cache
 Project-URL: Repository, https://github.com/danielslobozian/generic-ml-cache
@@ -24,7 +24,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Utilities
 Requires-Python: >=3.9
 Requires-Dist: argcomplete<4,>=3
-Requires-Dist: generic-ml-cache-core>=0.3.0
+Requires-Dist: generic-ml-cache-core>=0.5.0
 Provides-Extra: dev
 Requires-Dist: coverage>=7; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
@@ -80,7 +80,7 @@ gmlcache doctor | models | status | init                     # environment & con
 `gmlcache` is the terminal client — one inbound driver over the engine. The whole cache
 logic and every adapter live in
 [`generic-ml-cache-core`](https://github.com/danielslobozian/generic-ml-cache/tree/main/packages/core),
-a **stateless, dependency-free** library. To embed the cache in your own application
+a **stateless** library. To embed the cache in your own application
 instead of driving it from a terminal, depend on the core and inject your own data
 source — you never reimplement the adapters.
 

{generic_ml_cache_cli-0.3.0 → generic_ml_cache_cli-0.5.0}/README.md

@@ -45,7 +45,7 @@ gmlcache doctor | models | status | init                     # environment & con
 `gmlcache` is the terminal client — one inbound driver over the engine. The whole cache
 logic and every adapter live in
 [`generic-ml-cache-core`](https://github.com/danielslobozian/generic-ml-cache/tree/main/packages/core),
-a **stateless, dependency-free** library. To embed the cache in your own application
+a **stateless** library. To embed the cache in your own application
 instead of driving it from a terminal, depend on the core and inject your own data
 source — you never reimplement the adapters.
 

{generic_ml_cache_cli-0.3.0 → generic_ml_cache_cli-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "generic-ml-cache-cli"
-version = "0.3.0"
+version = "0.5.0"
 description = "Terminal UI for generic-ml-cache: the gmlcache command. A thin inbound driver over generic-ml-cache-core -- reads config, provides the data source, maps commands onto the core library."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -25,7 +25,7 @@ classifiers = [
   "Programming Language :: Python :: 3.13",
   "Topic :: Utilities",
 ]
-dependencies = ["generic-ml-cache-core>=0.3.0", "argcomplete>=3,<4"]
+dependencies = ["generic-ml-cache-core>=0.5.0", "argcomplete>=3,<4"]
 
 [project.urls]
 Homepage = "https://github.com/danielslobozian/generic-ml-cache"

{generic_ml_cache_cli-0.3.0 → generic_ml_cache_cli-0.5.0}/src/generic_ml_cache_cli/cli.py

@@ -31,16 +31,34 @@ except ImportError:  # completion is a convenience; never let its absence break
     argcomplete = None
 
 from generic_ml_cache_core.adapter.inbound.composition import build_use_cases
+from generic_ml_cache_core.adapter.out.crypto.filesystem_encryption_manifest_store import (
+    FilesystemEncryptionManifestStore,
+)
+from generic_ml_cache_core.adapter.out.crypto.store_encryptor import StoreEncryptor
+from generic_ml_cache_core.adapter.out.persistence.sqlite_store_lock import SqliteStoreLock
 from generic_ml_cache_core.adapter.out.client.registry import registered_names
-from generic_ml_cache_core.application.domain.model.execution.artifact import ArtifactType
+from generic_ml_cache_core.application.domain.model.execution.artifact import (
+    INPUT_ARTIFACT_TYPES,
+    ArtifactType,
+)
 from generic_ml_cache_core.application.domain.model.run.cache_mode import CacheMode
+from generic_ml_cache_core.application.domain.model.run.persistence_depth import PersistenceDepth
 from generic_ml_cache_core.application.domain.model.execution.execution_state import ExecutionState
 from generic_ml_cache_core.application.domain.model.execution.ml_execution import MlExecution
 from generic_ml_cache_core.application.port.inbound.run_managed_local_execution_command import (
     RunManagedLocalExecutionCommand,
 )
 from generic_ml_cache_core.application.port.out.base import ClientAdapter
-from generic_ml_cache_core.common.errors import CacheError, CacheMiss, ConfigError, RunInterrupted
+from generic_ml_cache_core.common.errors import (
+    CacheError,
+    CacheMiss,
+    ConfigError,
+    EncryptionStateError,
+    EncryptionTokenRequired,
+    RunInterrupted,
+    StoreLocked,
+    WrongEncryptionToken,
+)
 
 from . import __version__, config
 
@@ -142,7 +160,9 @@ def _cmd_run(args: argparse.Namespace) -> int:
 
     try:
         file_cfg = config.load()
-        settings = config.resolve_settings(file_cfg, mode_flag=args.mode, timeout_flag=args.timeout)
+        settings = config.resolve_settings(
+            file_cfg, mode_flag=args.mode, persist_flag=args.persist, timeout_flag=args.timeout
+        )
     except ConfigError as exc:
         print(f"gmlc: {exc}", file=sys.stderr)
         return 4
@@ -157,6 +177,7 @@ def _cmd_run(args: argparse.Namespace) -> int:
         cache_mode = CacheMode.REFRESH
     else:
         cache_mode = CacheMode(str(settings["mode"][0]))
+    persistence_depth = PersistenceDepth(str(settings["persist"][0]))
 
     command = RunManagedLocalExecutionCommand(
         client=args.client,
@@ -171,6 +192,7 @@ def _cmd_run(args: argparse.Namespace) -> int:
         client_args=list(getattr(args, "client_arg", None) or []),
         grants=list(getattr(args, "grant", None) or []),
         cache_mode=cache_mode,
+        persistence_depth=persistence_depth,
         record_on_error=args.record_on_error,
         tags=list(getattr(args, "tag", None) or []),
     )
@@ -178,9 +200,9 @@ def _cmd_run(args: argparse.Namespace) -> int:
     def executable_override(client: str):
         return config.executable_for(file_cfg, client, flag=args.executable)
 
-    wired = build_use_cases(store_root, executable_override, timeout)
-
+    token = _resolve_token(args)
     try:
+        wired = build_use_cases(store_root, executable_override, timeout, encryption_token=token)
         execution = wired.run_managed.execute(command)
     except RunInterrupted as exc:
         # A requested stop, not a failure: nothing was recorded. Exit 130 is the
@@ -198,6 +220,9 @@ def _cmd_run(args: argparse.Namespace) -> int:
     except CacheMiss as exc:
         print(f"gmlc: {exc}", file=sys.stderr)
         return 3
+    except (EncryptionTokenRequired, WrongEncryptionToken) as exc:
+        print(f"gmlc: {exc} (set --token or GMLCACHE_TOKEN)", file=sys.stderr)
+        return 4
     except CacheError as exc:
         print(f"gmlc: {exc}", file=sys.stderr)
         return 4
@@ -319,6 +344,14 @@ def _cmd_inspect(args: argparse.Namespace) -> int:
     print(f"files  : {len(output_files)}")
     for artifact in output_files:
         print(f"         - {artifact.name} ({artifact.encoding}, {artifact.size_bytes} bytes)")
+    input_parts = [a for a in execution.artifacts if a.artifact_type in INPUT_ARTIFACT_TYPES]
+    if input_parts:
+        print(f"input  : stored ({len(input_parts)} part(s))")
+        for artifact in input_parts:
+            label = artifact.artifact_type.value.replace("input_", "")
+            print(f"         - {label} ({artifact.encoding}, {artifact.size_bytes} bytes)")
+    else:
+        print("input  : not stored")
     usage = execution.token_usage
     if usage is None:
         print("usage  : (none captured)")
@@ -412,6 +445,7 @@ def _cmd_status(args: argparse.Namespace) -> int:
 
     path = config.resolve_config_path()
     loaded = file_cfg.source is not None
+    encryption = FilesystemEncryptionManifestStore(Path(str(settings["store"][0]))).state().value
 
     if args.json:
         import json
@@ -421,6 +455,7 @@ def _cmd_status(args: argparse.Namespace) -> int:
                 {
                     "config_file": str(path),
                     "loaded": loaded,
+                    "encryption": encryption,
                     "settings": {k: {"value": v[0], "source": v[1]} for k, v in settings.items()},
                     "executables": dict(file_cfg.executables),
                 },
@@ -430,8 +465,9 @@ def _cmd_status(args: argparse.Namespace) -> int:
         return 0
 
     print(f"config file : {path}  ({'loaded' if loaded else 'not present'})")
+    print(f"encryption  : {encryption}")
     print("effective settings (no run flags applied):")
-    for key in ("mode", "store", "timeout", "trust_scan", "max_size"):
+    for key in ("mode", "persist", "store", "timeout", "trust_scan", "max_size"):
         value, source = settings[key]
         shown = "none" if value is None else value
         if isinstance(shown, bool):
@@ -522,7 +558,13 @@ def _cmd_stats(args: argparse.Namespace) -> int:
         for (client, model), count in sorted(by_client_model.items()):
             print(f"  {client:<8} {model:<26} {count:>5}")
     if access:
-        event_styles = {"hit": (_GREEN,), "miss": (_AMBER,), "record": (_TEAL,)}
+        event_styles = {
+            "hit": (_GREEN,),
+            "miss": (_AMBER,),
+            "record": (_TEAL,),
+            "would_hit": (_GREEN,),
+            "would_miss": (_AMBER,),
+        }
         parts = ", ".join(
             f"{_paint(event, *event_styles.get(event, ()))}={count}"
             for event, count in sorted(access.items())
@@ -560,6 +602,9 @@ def _cmd_list(args: argparse.Namespace) -> int:
     wanted_tags = set(getattr(args, "tag", None) or [])
     if wanted_tags:
         entries = [entry for entry in entries if wanted_tags & set(entry["tags"])]
+    excluded_tags = set(getattr(args, "exclude_tag", None) or [])
+    if excluded_tags:
+        entries = [entry for entry in entries if not excluded_tags & set(entry["tags"])]
 
     if args.json:
         print(json.dumps({"executions": entries}, indent=2))
@@ -583,6 +628,255 @@ def _cmd_list(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_tags(args: argparse.Namespace) -> int:
+    import json
+
+    try:
+        settings = config.resolve_settings(config.load())
+    except ConfigError as exc:
+        print(f"gmlc: {exc}", file=sys.stderr)
+        return 4
+
+    wired = build_use_cases(Path(str(settings["store"][0])))
+    counts: dict = {}
+    for summary in wired.repository.current_execution_summaries():
+        for tag in wired.repository.tags_for(summary.execution_key):
+            counts[tag] = counts.get(tag, 0) + 1
+
+    tags = [{"tag": tag, "count": counts[tag]} for tag in sorted(counts)]
+
+    if args.json:
+        print(json.dumps({"tags": tags}, indent=2))
+        return 0
+
+    if not tags:
+        print("no tags")
+        return 0
+
+    print(f"tags : {_paint(str(len(tags)), _TEAL, _BOLD)}")
+    for entry in tags:
+        count_text = _paint("count:" + str(entry["count"]), _GREY)
+        print(f"  {entry['tag']:<24} {count_text}")
+    return 0
+
+
+_INPUT_FIELD_BY_TYPE = {
+    ArtifactType.INPUT_CONTEXT: "context",
+    ArtifactType.INPUT_PROMPT: "prompt",
+    ArtifactType.INPUT_SYSTEM: "system",
+}
+
+
+def _export_record(summary, execution, tags, blob_store) -> dict:
+    """Assemble one raw corpus record: the stored input parts and the output,
+    hydrated from the blob store. Curation is the user's (tags); this never
+    judges quality."""
+    import base64
+    import json
+
+    def text(artifact) -> str:
+        return (blob_store.get(artifact.blob_key) or b"").decode("utf-8", "replace")
+
+    input_obj: dict = {}
+    stdout = ""
+    files = []
+    for artifact in execution.artifacts:
+        field_name = _INPUT_FIELD_BY_TYPE.get(artifact.artifact_type)
+        if field_name is not None:
+            input_obj[field_name] = text(artifact)
+        elif artifact.artifact_type is ArtifactType.INPUT_MESSAGES:
+            input_obj["messages"] = json.loads(text(artifact))
+        elif artifact.artifact_type is ArtifactType.INPUT_ARGS:
+            input_obj["args"] = json.loads(text(artifact))
+        elif artifact.artifact_type is ArtifactType.STDOUT:
+            stdout = text(artifact)
+        elif artifact.artifact_type is ArtifactType.OUTPUT_FILE:
+            if artifact.encoding == "binary":
+                raw = blob_store.get(artifact.blob_key) or b""
+                files.append(
+                    {"name": artifact.name, "content_base64": base64.b64encode(raw).decode("ascii")}
+                )
+            else:
+                files.append({"name": artifact.name, "content": text(artifact)})
+
+    output_obj: dict = {"stdout": stdout}
+    if files:
+        output_obj["files"] = files
+    return {
+        "key": summary.execution_key,
+        "kind": summary.kind,
+        "client": summary.client,
+        "model": summary.model,
+        "tags": tags,
+        "input": input_obj,
+        "output": output_obj,
+    }
+
+
+def _cmd_export(args: argparse.Namespace) -> int:
+    import json
+
+    try:
+        settings = config.resolve_settings(config.load())
+    except ConfigError as exc:
+        print(f"gmlc: {exc}", file=sys.stderr)
+        return 4
+
+    include = set(getattr(args, "tag", None) or [])
+    exclude = set(getattr(args, "exclude_tag", None) or [])
+
+    lines = []
+    skipped_no_input = 0
+    try:
+        wired = build_use_cases(
+            Path(str(settings["store"][0])), encryption_token=_resolve_token(args)
+        )
+        for summary in wired.repository.current_execution_summaries():
+            tags = wired.repository.tags_for(summary.execution_key)
+            if include and not include & set(tags):
+                continue
+            if exclude and exclude & set(tags):
+                continue
+            execution = wired.repository.find_current(summary.execution_key)
+            # Only DATASET-depth entries carry the input side of the corpus.
+            if execution is None or not execution.input_persisted:
+                skipped_no_input += 1
+                continue
+            lines.append(json.dumps(_export_record(summary, execution, tags, wired.blob_store)))
+    except (EncryptionTokenRequired, WrongEncryptionToken) as exc:
+        print(f"gmlc: {exc} (set --token or GMLCACHE_TOKEN)", file=sys.stderr)
+        return 4
+
+    if args.output:
+        Path(args.output).write_text("".join(line + "\n" for line in lines), encoding="utf-8")
+        destination = args.output
+    else:
+        for line in lines:
+            print(line)
+        destination = "stdout"
+
+    # Summary on stderr so stdout stays a clean JSONL stream.
+    note = f"exported {len(lines)} record(s) to {destination}"
+    if skipped_no_input:
+        entries = "entry" if skipped_no_input == 1 else "entries"
+        note += f"; skipped {skipped_no_input} matching {entries} without stored input (not dataset depth)"
+    print(note, file=sys.stderr)
+    return 0
+
+
+# -- encryption -------------------------------------------------------------
+
+
+def _resolve_token(args: argparse.Namespace) -> Optional[str]:
+    """The encryption token for this call: the --token flag, else GMLCACHE_TOKEN.
+    A token is a secret, so it is never read from the config file."""
+    flag = getattr(args, "token", None)
+    return flag if flag else (os.environ.get("GMLCACHE_TOKEN") or None)
+
+
+def _load_cipher():
+    """Build the cipher, with a friendly error if the optional extra is missing."""
+    try:
+        from generic_ml_cache_core.adapter.out.crypto.aesgcm_cipher import AesGcmCipher
+    except ImportError as exc:  # pragma: no cover - exercised only without the extra
+        raise SystemExit(
+            "error: encryption needs an optional dependency — install with "
+            '`pip install "generic-ml-cache-core[encryption]"`'
+        ) from exc
+    return AesGcmCipher()
+
+
+def _store_encryptor(store_root: Path, cipher=None) -> StoreEncryptor:
+    return StoreEncryptor(
+        store_root,
+        FilesystemEncryptionManifestStore(store_root),
+        SqliteStoreLock(store_root),
+        cipher,
+    )
+
+
+def _store_root() -> Optional[Path]:
+    try:
+        return Path(str(config.resolve_settings(config.load())["store"][0]))
+    except ConfigError as exc:
+        print(f"gmlc: {exc}", file=sys.stderr)
+        return None
+
+
+def _cmd_encrypt(args: argparse.Namespace) -> int:
+    store_root = _store_root()
+    if store_root is None:
+        return 4
+    cipher = _load_cipher()
+    token = cipher.generate_token()
+    try:
+        _store_encryptor(store_root, cipher).enable(token)
+    except (EncryptionStateError, StoreLocked) as exc:
+        print(f"gmlc: {exc}", file=sys.stderr)
+        return 4
+    print("encryption enabled. Save this token — it is shown once and cannot be recovered:")
+    print(f"\n    {token}\n")
+    print("Pass it with --token or GMLCACHE_TOKEN to read or write this store.")
+    return 0
+
+
+def _cmd_decrypt(args: argparse.Namespace) -> int:
+    store_root = _store_root()
+    if store_root is None:
+        return 4
+    token = _resolve_token(args)
+    if not token:
+        print("gmlc: provide the token with --token or GMLCACHE_TOKEN", file=sys.stderr)
+        return 4
+    try:
+        _store_encryptor(store_root, _load_cipher()).disable(token)
+    except (WrongEncryptionToken, EncryptionStateError, StoreLocked) as exc:
+        print(f"gmlc: {exc}", file=sys.stderr)
+        return 4
+    print("encryption disabled. The store is now public; no token is needed.")
+    return 0
+
+
+def _cmd_rotate(args: argparse.Namespace) -> int:
+    store_root = _store_root()
+    if store_root is None:
+        return 4
+    old_token = _resolve_token(args)
+    if not old_token:
+        print("gmlc: provide the current token with --token or GMLCACHE_TOKEN", file=sys.stderr)
+        return 4
+    cipher = _load_cipher()
+    new_token = cipher.generate_token()
+    try:
+        _store_encryptor(store_root, cipher).rotate(old_token, new_token)
+    except (WrongEncryptionToken, EncryptionStateError, StoreLocked) as exc:
+        print(f"gmlc: {exc}", file=sys.stderr)
+        return 4
+    print("token rotated. Save the new token — it is shown once:")
+    print(f"\n    {new_token}\n")
+    return 0
+
+
+def _cmd_invalidate(args: argparse.Namespace) -> int:
+    store_root = _store_root()
+    if store_root is None:
+        return 4
+    if not args.yes:
+        print(
+            "gmlc: this permanently wipes the cache (crypto-shred) and cannot be undone. "
+            "Re-run with --yes to confirm.",
+            file=sys.stderr,
+        )
+        return 4
+    try:
+        _store_encryptor(store_root).invalidate()  # no token needed
+    except StoreLocked as exc:
+        print(f"gmlc: {exc}", file=sys.stderr)
+        return 4
+    print("store invalidated: the cache was wiped and is now empty and public.")
+    return 0
+
+
 def _use_color() -> bool:
     """Colour only when writing to a real terminal and NO_COLOR is unset, so piped
     or redirected output never carries escape codes (the conventional contract)."""
@@ -742,6 +1036,15 @@ def build_parser() -> argparse.ArgumentParser:
         default=None,
         help="resolution mode (default: cache, or config/env)",
     )
+    run.add_argument(
+        "--persist",
+        choices=[d.value for d in PersistenceDepth],
+        default=None,
+        help=(
+            "how much to keep: meter (usage only, never replays), cache (+output, "
+            "the default), or dataset (+input) (default: cache, or config/env)"
+        ),
+    )
     run.add_argument("--offline", action="store_true", help="shortcut for --mode offline")
     run.add_argument("--force", action="store_true", help="shortcut for --mode refresh")
     run.add_argument(
@@ -750,6 +1053,9 @@ def build_parser() -> argparse.ArgumentParser:
         help="also cache a call that fails (non-zero exit); default is to store only successes",
     )
     run.add_argument("--executable", help="override the client executable (the seam)")
+    run.add_argument(
+        "--token", help="encryption token for an encrypted store (or set GMLCACHE_TOKEN)"
+    )
     run.add_argument(
         "--timeout", type=float, default=None, help="seconds before the real call is killed"
     )
@@ -865,9 +1171,77 @@ def build_parser() -> argparse.ArgumentParser:
         metavar="TAG",
         help="only executions carrying any of these tags (repeatable; match-any)",
     )
+    listp.add_argument(
+        "--exclude-tag",
+        action="append",
+        dest="exclude_tag",
+        metavar="TAG",
+        help="drop executions carrying any of these tags (repeatable; match-any)",
+    )
     listp.add_argument("--json", action="store_true", help="emit machine-readable JSON")
     listp.set_defaults(func=_cmd_list)
 
+    tagsp = sub.add_parser(
+        "tags",
+        help="list the distinct tags in use across current executions, with counts (read-only)",
+    )
+    tagsp.add_argument("--json", action="store_true", help="emit machine-readable JSON")
+    tagsp.set_defaults(func=_cmd_tags)
+
+    exportp = sub.add_parser(
+        "export",
+        help="export the (input, output) dataset corpus as JSONL (read-only). Only entries "
+        "stored at --persist dataset carry an input; others are skipped.",
+    )
+    exportp.add_argument(
+        "--tag",
+        action="append",
+        dest="tag",
+        metavar="TAG",
+        help="only entries carrying any of these tags (repeatable; match-any)",
+    )
+    exportp.add_argument(
+        "--exclude-tag",
+        action="append",
+        dest="exclude_tag",
+        metavar="TAG",
+        help="drop entries carrying any of these tags (repeatable; match-any)",
+    )
+    exportp.add_argument(
+        "-o",
+        "--output",
+        metavar="FILE",
+        help="write JSONL to FILE instead of stdout (a per-record summary still goes to stderr)",
+    )
+    exportp.add_argument(
+        "--token", help="encryption token if the store is encrypted (or set GMLCACHE_TOKEN)"
+    )
+    exportp.set_defaults(func=_cmd_export)
+
+    encryptp = sub.add_parser(
+        "encrypt", help="enable at-rest encryption of the store (generates and shows a token)"
+    )
+    encryptp.set_defaults(func=_cmd_encrypt)
+
+    decryptp = sub.add_parser(
+        "decrypt", help="disable encryption (decrypts the store back to plaintext; needs the token)"
+    )
+    decryptp.add_argument("--token", help="the encryption token (or set GMLCACHE_TOKEN)")
+    decryptp.set_defaults(func=_cmd_decrypt)
+
+    rotatep = sub.add_parser(
+        "rotate", help="rotate the encryption token (needs the current token; shows the new one)"
+    )
+    rotatep.add_argument("--token", help="the current encryption token (or set GMLCACHE_TOKEN)")
+    rotatep.set_defaults(func=_cmd_rotate)
+
+    invalidatep = sub.add_parser(
+        "invalidate",
+        help="wipe the cache (crypto-shred) — the escape when the token is lost. Needs --yes.",
+    )
+    invalidatep.add_argument("--yes", action="store_true", help="confirm the irreversible wipe")
+    invalidatep.set_defaults(func=_cmd_invalidate)
+
     init = sub.add_parser(
         "init",
         help="create the config file in the default location (if absent), then show the store",

{generic_ml_cache_cli-0.3.0 → generic_ml_cache_cli-0.5.0}/src/generic_ml_cache_cli/config.py

@@ -8,14 +8,13 @@ Three rules keep this predictable:
   writes it -- the cache works with no file present. :func:`write_default_config`
   (the ``gmlcache init`` command) writes one on explicit request, never on
   install or first run.
-* **Overridable, with explicit precedence.** For ``mode`` and ``timeout`` the
-  winner is, in order: a CLI flag, an environment variable, the config file, the
-  built-in default. The ``store`` location is the exception -- config file or
+* **Overridable, with explicit precedence.** For ``mode``, ``persist`` and
+  ``timeout`` the winner is, in order: a CLI flag, an environment variable, the
+  config file, the built-in default. The ``store`` location is the exception -- config file or
   built-in default only, with **no flag and no environment** -- because where the
   stored executions live is the cache's own concern, not a per-call knob.
-* **Zero dependencies.** The format is INI (stdlib :mod:`configparser`) and the
-  per-user location is resolved inline, so nothing beyond the standard library is
-  needed on any supported Python.
+* **Plain INI.** The format is INI (stdlib :mod:`configparser`) and the per-user
+  location is resolved inline.
 
 Location (override everything with ``GMLCACHE_CONFIG=/path/to/file``):
 
@@ -27,6 +26,7 @@ File shape::
 
     [defaults]
     mode = cache
+    persist = cache
     # store defaults to the per-user data dir (XDG data home); set a path to change it
     store = /path/to/store
     timeout = 120
@@ -66,6 +66,7 @@ from pathlib import Path
 from typing import Dict, Optional, Tuple
 
 from generic_ml_cache_core.application.domain.model.run.cache_mode import CacheMode
+from generic_ml_cache_core.application.domain.model.run.persistence_depth import PersistenceDepth
 from generic_ml_cache_core.common.errors import ConfigError
 
 CONFIG_ENV = "GMLCACHE_CONFIG"
@@ -77,9 +78,10 @@ EXECUTABLES_SECTION = "executables"
 #: built-in defaults; ``timeout`` of ``None`` means "no timeout". The store has
 #: no static default here -- it resolves to :func:`default_store_path` (per-user
 #: data dir) and has no flag/env layer, only the config file.
-DEFAULTS: Dict[str, Optional[str]] = {"mode": "cache", "timeout": None}
+DEFAULTS: Dict[str, Optional[str]] = {"mode": "cache", "persist": "cache", "timeout": None}
 
 _MODES = {m.value for m in CacheMode}
+_DEPTHS = {d.value for d in PersistenceDepth}
 
 #: written by ``gmlcache init`` (and only then); ``{store}`` is filled with the
 #: resolved per-user default so the user can see and edit where the store lives.
@@ -96,6 +98,10 @@ _DEFAULT_CONFIG_TEMPLATE = """\
 
 [defaults]
 mode = cache
+# How much each call keeps on disk: meter (usage/metadata only, never replays),
+# cache (+ output, the default -- replay on hit), or dataset (+ input, for an
+# exportable (input, output) corpus).
+persist = cache
 # Where the store lives. This is the per-user data dir by default; change freely.
 store = {store}
 # timeout = 120
@@ -161,6 +167,7 @@ class FileConfig:
     or ``None`` when no file was present."""
 
     mode: Optional[str] = None
+    persist: Optional[str] = None
     store: Optional[str] = None
     timeout: Optional[float] = None
     trust_scan: Optional[bool] = None
@@ -226,6 +233,10 @@ def load(path: Optional[Path] = None) -> FileConfig:
     if mode is not None and mode not in _MODES:
         raise ConfigError(f"invalid mode {mode!r} in {p}; expected one of {sorted(_MODES)}")
 
+    persist = get("persist")
+    if persist is not None and persist not in _DEPTHS:
+        raise ConfigError(f"invalid persist {persist!r} in {p}; expected one of {sorted(_DEPTHS)}")
+
     timeout_raw = get("timeout")
     timeout = _parse_timeout(timeout_raw, f"in {p}") if timeout_raw else None
 
@@ -246,6 +257,7 @@ def load(path: Optional[Path] = None) -> FileConfig:
 
     return FileConfig(
         mode=mode,
+        persist=persist,
         store=get("store"),
         timeout=timeout,
         trust_scan=trust_scan,
@@ -287,6 +299,7 @@ def resolve_settings(
     file_cfg: FileConfig,
     *,
     mode_flag: Optional[str] = None,
+    persist_flag: Optional[str] = None,
     timeout_flag: Optional[float] = None,
 ) -> Dict[str, Tuple[object, str]]:
     """Resolve each setting to ``(value, source)`` by the documented precedence.
@@ -304,6 +317,12 @@ def resolve_settings(
             f"invalid mode {mode_env!r} in GMLCACHE_MODE; expected one of {sorted(_MODES)}"
         )
 
+    persist_env = env.get("GMLCACHE_PERSIST")
+    if persist_env and persist_env not in _DEPTHS:
+        raise ConfigError(
+            f"invalid persist {persist_env!r} in GMLCACHE_PERSIST; expected one of {sorted(_DEPTHS)}"
+        )
+
     timeout_env_raw = env.get("GMLCACHE_TIMEOUT")
     timeout_env = (
         _parse_timeout(timeout_env_raw, "in GMLCACHE_TIMEOUT") if timeout_env_raw else None
@@ -319,6 +338,8 @@ def resolve_settings(
 
     return {
         "mode": _pick(mode_flag, mode_env, file_cfg.mode, DEFAULTS["mode"]),
+        # persist: per-call depth (meter/cache/dataset), same precedence as mode.
+        "persist": _pick(persist_flag, persist_env, file_cfg.persist, DEFAULTS["persist"]),
         # store: config file or built-in per-user default only. No flag, no env --
         # a per-call store override would fork the cache and defeat reuse.
         "store": _pick(None, None, file_cfg.store, str(default_store_path())),

{generic_ml_cache_cli-0.3.0 → generic_ml_cache_cli-0.5.0}/tests/conftest.py

@@ -118,7 +118,7 @@ def _isolate_config(monkeypatch, tmp_path):
     monkeypatch.setenv("GMLCACHE_CONFIG", str(tmp_path / "no-such-config.ini"))
     monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path / "xdg-data"))
     monkeypatch.setenv("LOCALAPPDATA", str(tmp_path / "localappdata"))
-    for var in ("GMLCACHE_MODE", "GMLCACHE_TIMEOUT"):
+    for var in ("GMLCACHE_MODE", "GMLCACHE_PERSIST", "GMLCACHE_TIMEOUT", "GMLCACHE_TOKEN"):
         monkeypatch.delenv(var, raising=False)
 
 

{generic_ml_cache_cli-0.3.0 → generic_ml_cache_cli-0.5.0}/tests/test_cli.py

@@ -369,3 +369,238 @@ def test_list_filters_by_tag_and_shows_tags(capsys):
     listed = json.loads(capsys.readouterr().out)["executions"]
     assert len(listed) == 1  # match-any filter keeps only the alpha-tagged entry
     assert listed[0]["tags"] == ["alpha"]
+
+
+def test_list_excludes_by_tag(capsys):
+    import json
+
+    base = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    run_cli(base + ["--prompt", "STDOUT a", "--tag", "alpha"])
+    run_cli(base + ["--prompt", "STDOUT b", "--tag", "beta"])
+    capsys.readouterr()
+
+    rc = main(["list", "--exclude-tag", "beta", "--json"])
+    assert rc == 0
+    listed = json.loads(capsys.readouterr().out)["executions"]
+    assert len(listed) == 1  # the beta-tagged entry is dropped
+    assert listed[0]["tags"] == ["alpha"]
+
+
+def test_list_exclude_tag_overrides_include(capsys):
+    import json
+
+    base = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    # one entry carrying both tags
+    run_cli(base + ["--prompt", "STDOUT a", "--tag", "alpha", "--tag", "beta"])
+    capsys.readouterr()
+
+    rc = main(["list", "--tag", "alpha", "--exclude-tag", "beta", "--json"])
+    assert rc == 0
+    listed = json.loads(capsys.readouterr().out)["executions"]
+    assert listed == []  # exclude wins when a tag is both included and excluded
+
+
+def test_tags_lists_distinct_tags_with_counts(capsys):
+    import json
+
+    base = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    run_cli(base + ["--prompt", "STDOUT a", "--tag", "alpha", "--tag", "shared"])
+    run_cli(base + ["--prompt", "STDOUT b", "--tag", "beta", "--tag", "shared"])
+    capsys.readouterr()
+
+    rc = main(["tags", "--json"])
+    assert rc == 0
+    tags = json.loads(capsys.readouterr().out)["tags"]
+    assert tags == [
+        {"tag": "alpha", "count": 1},
+        {"tag": "beta", "count": 1},
+        {"tag": "shared", "count": 2},
+    ]
+
+
+def test_tags_empty_when_no_tags(capsys):
+    base = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    run_cli(base + ["--prompt", "STDOUT a"])
+    capsys.readouterr()
+
+    rc = main(["tags"])
+    assert rc == 0
+    assert "no tags" in capsys.readouterr().out
+
+
+def test_persist_meter_stores_no_output_so_offline_misses(capsys):
+    common = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    # meter records the run but keeps no output ...
+    rc = run_cli(common + ["--prompt", "STDOUT hello", "--persist", "meter"])
+    assert rc == 0
+    assert "hello" in capsys.readouterr().out
+
+    # ... so there is nothing servable: a later offline call misses (exit 3).
+    rc = run_cli(common + ["--prompt", "STDOUT hello", "--offline"])
+    assert rc == 3
+    assert "offline miss" in capsys.readouterr().err
+
+
+def test_persist_default_cache_replays_offline(capsys):
+    common = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    # default depth is cache: output is stored ...
+    run_cli(common + ["--prompt", "STDOUT hello", "--persist", "cache"])
+    capsys.readouterr()
+    # ... so a later offline call replays from cache.
+    rc = run_cli(common + ["--prompt", "STDOUT hello", "--offline"])
+    assert rc == 0
+
+
+def _only_key(capsys):
+    import json
+
+    main(["list", "--json"])
+    return json.loads(capsys.readouterr().out)["executions"][0]["key"]
+
+
+def test_persist_dataset_stores_input_visible_in_inspect(capsys):
+    common = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    run_cli(common + ["--prompt", "STDOUT hi", "--context", "some context", "--persist", "dataset"])
+    capsys.readouterr()
+
+    # dataset still replays output normally ...
+    rc = run_cli(common + ["--prompt", "STDOUT hi", "--context", "some context", "--offline"])
+    assert rc == 0
+    capsys.readouterr()
+
+    # ... and inspect shows the input was stored (prompt + context parts).
+    rc = main(["inspect", _only_key(capsys)[:12]])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "input  : stored" in out
+    assert "prompt" in out and "context" in out
+
+
+def test_persist_cache_does_not_store_input_in_inspect(capsys):
+    common = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    run_cli(common + ["--prompt", "STDOUT hi", "--persist", "cache"])
+    capsys.readouterr()
+
+    rc = main(["inspect", _only_key(capsys)[:12]])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "input  : not stored" in out
+
+
+def test_export_emits_jsonl_for_dataset_entries_and_skips_others(capsys):
+    import json
+
+    common = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    run_cli(
+        common
+        + [
+            "--prompt",
+            "STDOUT theanswer",
+            "--context",
+            "ctx",
+            "--system-prompt",
+            "terse",
+            "--persist",
+            "dataset",
+        ]
+    )
+    run_cli(common + ["--prompt", "STDOUT other", "--persist", "cache"])  # no input stored
+    capsys.readouterr()
+
+    rc = main(["export"])
+    captured = capsys.readouterr()
+    assert rc == 0
+    lines = [line for line in captured.out.splitlines() if line.strip()]
+    assert len(lines) == 1  # only the dataset entry carries an input
+    record = json.loads(lines[0])
+    assert record["input"] == {"context": "ctx", "prompt": "STDOUT theanswer", "system": "terse"}
+    assert "theanswer" in record["output"]["stdout"]
+    assert record["client"] == "fake" and record["model"] == "m1"
+    # the cache-only entry is reported as skipped, never silently dropped
+    assert "skipped 1" in captured.err
+
+
+def test_export_filters_by_include_and_exclude_tags(capsys):
+    import json
+
+    common = [
+        "run",
+        "--client",
+        "fake",
+        "--model",
+        "m1",
+        "--effort",
+        "high",
+        "--persist",
+        "dataset",
+    ]
+    run_cli(common + ["--prompt", "STDOUT a", "--tag", "keep"])
+    run_cli(common + ["--prompt", "STDOUT b", "--tag", "drop"])
+    capsys.readouterr()
+
+    main(["export", "--tag", "keep"])
+    recs = [json.loads(line) for line in capsys.readouterr().out.splitlines() if line.strip()]
+    assert len(recs) == 1 and recs[0]["tags"] == ["keep"]
+
+    main(["export", "--exclude-tag", "drop"])
+    recs = [json.loads(line) for line in capsys.readouterr().out.splitlines() if line.strip()]
+    assert len(recs) == 1 and recs[0]["tags"] == ["keep"]
+
+
+def test_export_writes_to_output_file(tmp_path, capsys):
+    import json
+
+    common = [
+        "run",
+        "--client",
+        "fake",
+        "--model",
+        "m1",
+        "--effort",
+        "high",
+        "--persist",
+        "dataset",
+    ]
+    run_cli(common + ["--prompt", "STDOUT a"])
+    capsys.readouterr()
+
+    out_file = tmp_path / "corpus.jsonl"
+    rc = main(["export", "--output", str(out_file)])
+    captured = capsys.readouterr()
+    assert rc == 0
+    records = [
+        json.loads(line)
+        for line in out_file.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    assert len(records) == 1
+    assert captured.out == ""  # nothing on stdout when writing a file
+    assert f"exported 1 record(s) to {out_file}" in captured.err
+
+
+def test_dataset_hit_backfills_input_then_exports(capsys):
+    import json
+
+    common = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    run_cli(common + ["--prompt", "STDOUT hi", "--context", "ctx"])  # cache: output only
+    # same input at dataset depth: a hit that back-fills the input onto the entry
+    run_cli(common + ["--prompt", "STDOUT hi", "--context", "ctx", "--persist", "dataset"])
+    capsys.readouterr()
+
+    main(["export"])
+    recs = [json.loads(line) for line in capsys.readouterr().out.splitlines() if line.strip()]
+    assert len(recs) == 1  # the (now-)dataset entry is exportable
+    assert recs[0]["input"] == {"context": "ctx", "prompt": "STDOUT hi"}
+
+
+def test_export_empty_when_no_dataset_entries(capsys):
+    common = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+    run_cli(common + ["--prompt", "STDOUT a", "--persist", "cache"])
+    capsys.readouterr()
+
+    rc = main(["export"])
+    captured = capsys.readouterr()
+    assert rc == 0
+    assert captured.out.strip() == ""
+    assert "exported 0 record(s)" in captured.err
+    assert "skipped 1" in captured.err

{generic_ml_cache_cli-0.3.0 → generic_ml_cache_cli-0.5.0}/tests/test_config.py

@@ -58,6 +58,7 @@ def test_precedence_default_then_config_then_env_then_flag(tmp_path, monkeypatch
 def test_default_when_nothing_set(tmp_path):
     settings = config.resolve_settings(config.load(tmp_path / "absent.ini"))
     assert settings["mode"] == ("cache", "default")
+    assert settings["persist"] == ("cache", "default")
     assert settings["store"] == (str(config.default_store_path()), "default")
     assert settings["timeout"] == (None, "default")
 
@@ -68,6 +69,30 @@ def test_invalid_env_mode_raises(monkeypatch, tmp_path):
         config.resolve_settings(config.load(tmp_path / "absent.ini"))
 
 
+def test_persist_precedence_default_then_config_then_env_then_flag(tmp_path, monkeypatch):
+    # config file sets meter ...
+    p = _write(tmp_path / "c.ini", "[defaults]\npersist = meter\n")
+    cfg = config.load(p)
+    assert config.resolve_settings(cfg)["persist"] == ("meter", "config")
+    # ... env overrides the file ...
+    monkeypatch.setenv("GMLCACHE_PERSIST", "dataset")
+    assert config.resolve_settings(cfg)["persist"] == ("dataset", "env")
+    # ... and an explicit flag overrides env.
+    assert config.resolve_settings(cfg, persist_flag="cache")["persist"] == ("cache", "flag")
+
+
+def test_invalid_persist_in_file_raises(tmp_path):
+    p = _write(tmp_path / "c.ini", "[defaults]\npersist = hoard\n")
+    with pytest.raises(ConfigError):
+        config.load(p)
+
+
+def test_invalid_env_persist_raises(monkeypatch, tmp_path):
+    monkeypatch.setenv("GMLCACHE_PERSIST", "hoard")
+    with pytest.raises(ConfigError):
+        config.resolve_settings(config.load(tmp_path / "absent.ini"))
+
+
 def test_status_cli_reports_source_and_settings(tmp_path, monkeypatch, capsys):
     p = _write(tmp_path / "c.ini", "[defaults]\nmode = offline\nstore = vault\n")
     monkeypatch.setenv("GMLCACHE_CONFIG", str(p))

generic_ml_cache_cli-0.5.0/tests/test_encrypted_run.py

@@ -0,0 +1,91 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""End-to-end: a managed run against an encrypted store (via build_use_cases)."""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("cryptography")
+
+from generic_ml_cache_core.adapter.inbound.composition import build_use_cases  # noqa: E402
+from generic_ml_cache_core.adapter.out.crypto.aesgcm_cipher import AesGcmCipher  # noqa: E402
+from generic_ml_cache_core.adapter.out.crypto.filesystem_encryption_manifest_store import (  # noqa: E402
+    FilesystemEncryptionManifestStore,
+)
+from generic_ml_cache_core.application.domain.model.execution.artifact import (  # noqa: E402
+    ArtifactType,
+)
+from generic_ml_cache_core.application.domain.model.execution.execution_state import (  # noqa: E402
+    ExecutionState,
+)
+from generic_ml_cache_core.application.port.inbound.run_managed_local_execution_command import (  # noqa: E402
+    RunManagedLocalExecutionCommand,
+)
+from generic_ml_cache_core.common.errors import (  # noqa: E402
+    EncryptionTokenRequired,
+    WrongEncryptionToken,
+)
+
+_MARKER = "ENCRYPTME-distinctive-123"
+
+
+def _encrypt_store(store_root, token):
+    manifest, _ = AesGcmCipher().create_envelope(token)
+    FilesystemEncryptionManifestStore(store_root).save(manifest)
+
+
+def _command():
+    return RunManagedLocalExecutionCommand(
+        client="fake", model="m1", effort="high", context="", prompt=f"STDOUT {_MARKER}"
+    )
+
+
+def _blob_bytes(store_root):
+    return b"".join(p.read_bytes() for p in (store_root / "blobs").rglob("*") if p.is_file())
+
+
+def test_encrypted_run_stores_ciphertext_and_replays_with_token(tmp_path):
+    store = tmp_path / "store"
+    token = AesGcmCipher().generate_token()
+    _encrypt_store(store, token)
+
+    execution = build_use_cases(store, encryption_token=token).run_managed.execute(_command())
+    assert execution.execution_state is ExecutionState.SUCCESS
+
+    # the marker must NOT appear in the persisted blobs — they are ciphertext
+    assert _MARKER.encode() not in _blob_bytes(store)
+
+    # replay (a cache hit) with the token decrypts the output correctly
+    served = build_use_cases(store, encryption_token=token).run_managed.execute(_command())
+    stdout = next(a.content for a in served.artifacts if a.artifact_type is ArtifactType.STDOUT)
+    assert _MARKER.encode() in stdout
+
+
+def test_public_store_keeps_plaintext_and_ignores_a_token(tmp_path):
+    store = tmp_path / "store"  # no manifest -> public
+    execution = build_use_cases(store, encryption_token="ignored").run_managed.execute(_command())
+    assert execution.execution_state is ExecutionState.SUCCESS
+    assert _MARKER.encode() in _blob_bytes(store)  # plaintext on disk
+
+
+def test_encrypted_store_without_token_blocks_content_but_not_metadata(tmp_path):
+    store = tmp_path / "store"
+    token = AesGcmCipher().generate_token()
+    _encrypt_store(store, token)
+    recorded = build_use_cases(store, encryption_token=token).run_managed.execute(_command())
+    key = recorded.call_identity.generate_key()
+
+    wired = build_use_cases(store)  # no token
+    # metadata is still readable (it is not encrypted) ...
+    assert wired.repository.find_current(key) is not None
+    # ... but serving the hit must hydrate the blob, which needs the token.
+    with pytest.raises(EncryptionTokenRequired):
+        wired.run_managed.execute(_command())
+
+
+def test_wrong_token_is_rejected_when_opening_the_store(tmp_path):
+    store = tmp_path / "store"
+    _encrypt_store(store, AesGcmCipher().generate_token())
+    with pytest.raises(WrongEncryptionToken):
+        build_use_cases(store, encryption_token=AesGcmCipher().generate_token())

generic_ml_cache_cli-0.5.0/tests/test_encryption_cli.py

@@ -0,0 +1,101 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""End-to-end CLI tests for encrypt / decrypt / rotate / invalidate."""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("cryptography")
+
+from generic_ml_cache_cli.cli import main  # noqa: E402
+
+_RUN = ["run", "--client", "fake", "--model", "m1", "--effort", "high"]
+
+
+def _token_from(out: str) -> str:
+    """The token is printed on its own indented, space-free line."""
+    for line in out.splitlines():
+        s = line.strip()
+        if s and " " not in s and len(s) >= 20:
+            return s
+    raise AssertionError(f"no token found in:\n{out}")
+
+
+def _enable(capsys) -> str:
+    assert main(["encrypt"]) == 0
+    return _token_from(capsys.readouterr().out)
+
+
+def test_encrypt_then_run_with_token_round_trips(capsys, monkeypatch):
+    token = _enable(capsys)
+    monkeypatch.setenv("GMLCACHE_TOKEN", token)
+
+    assert main(_RUN + ["--prompt", "STDOUT SECRETMARKER"]) == 0
+    assert "SECRETMARKER" in capsys.readouterr().out
+    # offline replay against the encrypted store, with the token
+    assert main(_RUN + ["--prompt", "STDOUT SECRETMARKER", "--offline"]) == 0
+    capsys.readouterr()
+
+    assert main(["status"]) == 0
+    assert "encryption  : encrypted" in capsys.readouterr().out
+
+
+def test_run_without_token_on_encrypted_store_is_blocked(capsys, monkeypatch):
+    token = _enable(capsys)
+    monkeypatch.setenv("GMLCACHE_TOKEN", token)
+    main(_RUN + ["--prompt", "STDOUT hi"])  # record one entry
+    capsys.readouterr()
+
+    monkeypatch.delenv("GMLCACHE_TOKEN", raising=False)
+    rc = main(_RUN + ["--prompt", "STDOUT hi"])  # hit -> hydrate -> needs the token
+    assert rc == 4
+    assert "token" in capsys.readouterr().err.lower()
+
+
+def test_decrypt_returns_store_to_public(capsys):
+    token = _enable(capsys)
+    assert main(["decrypt", "--token", token]) == 0
+    capsys.readouterr()
+    main(["status"])
+    assert "encryption  : public" in capsys.readouterr().out
+
+
+def test_decrypt_with_wrong_token_fails(capsys):
+    _enable(capsys)
+    assert main(["decrypt", "--token", "definitely-not-the-right-token-xyz"]) == 4
+    assert "gmlc:" in capsys.readouterr().err
+
+
+def test_rotate_swaps_the_token(capsys, monkeypatch):
+    run = _RUN + ["--prompt", "STDOUT zz"]
+    old = _enable(capsys)
+    monkeypatch.setenv("GMLCACHE_TOKEN", old)
+    main(run)
+    capsys.readouterr()
+
+    assert main(["rotate", "--token", old]) == 0
+    new = _token_from(capsys.readouterr().out)
+    assert new != old
+
+    monkeypatch.setenv("GMLCACHE_TOKEN", new)
+    assert main(run + ["--offline"]) == 0  # new token reads
+    capsys.readouterr()
+    monkeypatch.setenv("GMLCACHE_TOKEN", old)
+    assert main(run + ["--offline"]) == 4  # old token rejected
+
+
+def test_invalidate_requires_yes_then_wipes_to_public(capsys, monkeypatch):
+    token = _enable(capsys)
+    monkeypatch.setenv("GMLCACHE_TOKEN", token)
+    main(_RUN + ["--prompt", "STDOUT x"])
+    capsys.readouterr()
+
+    assert main(["invalidate"]) == 4  # refused without --yes
+    assert "yes" in capsys.readouterr().err.lower()
+
+    assert main(["invalidate", "--yes"]) == 0
+    capsys.readouterr()
+    monkeypatch.delenv("GMLCACHE_TOKEN", raising=False)
+    main(["status"])
+    assert "encryption  : public" in capsys.readouterr().out