capsule-engine 0.2.0__tar.gz → 0.3.0__tar.gz

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: capsule-engine
-Version: 0.2.0
-Summary: The thin single-node engine: guard, append-only fold compute, packs, policy activation, and the local console/report/bundle-viewer runtime for AI agent actions.
+Version: 0.3.0
+Summary: The thin single-node engine: guard, append-only fold compute, packs, policy activation, and the report computation for AI agent actions.
 Author: Action State Group
 License-Expression: Apache-2.0 AND MIT
 Project-URL: Homepage, https://github.com/action-state-group/capsule-engine
@@ -14,9 +14,9 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: capsule_engine/examples/data/tau2_airline/LICENSE-tau2-bench
 Requires-Dist: agent-action-capsule>=0.11.0
-Requires-Dist: checkpointed-local-log>=0.6.0
+Requires-Dist: checkpointed-local-log<0.9,>=0.8.0
 Requires-Dist: jsonschema>=4.18
-Requires-Dist: capsule-emit>=0.12.0
+Requires-Dist: capsule-emit<0.15,>=0.14.0
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
@@ -32,8 +32,8 @@ Dynamic: license-file
 # capsule-engine
 
 The thin single-node enforcement layer for AI agent actions: the guard, append-only fold
-compute, the Terms Packs runtime, policy activation, and the local
-console/report/bundle-viewer runtime.
+compute, the Terms Packs runtime, policy activation, and the report computation
+(pages are drawn by capsule-viewer).
 
 ```
 pip install capsule-engine

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/README.md

@@ -1,8 +1,8 @@
 # capsule-engine
 
 The thin single-node enforcement layer for AI agent actions: the guard, append-only fold
-compute, the Terms Packs runtime, policy activation, and the local
-console/report/bundle-viewer runtime.
+compute, the Terms Packs runtime, policy activation, and the report computation
+(pages are drawn by capsule-viewer).
 
 ```
 pip install capsule-engine

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/capsule_engine/__init__.py

@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: Apache-2.0
 """capsule-engine: the thin single-node engine -- guard, append-only fold
-compute, packs, policy activation, and the local console/report/bundle-viewer
-surfaces for AI agent actions. Ledger storage comes from
-checkpointed-local-log (``cll.ledger``); the action-class registry is this
+compute, packs, policy activation, and the report
+surfaces for AI agent actions. Records are stored in a checkpointed-local-log
+entry log beside capsule-emit's artifact store (``guards/history.py``); the action-class registry is this
 package's own ``registry``.
 """
 

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/capsule_engine/cli/bundle_cmd.py

@@ -41,7 +41,6 @@ from capsule_emit.ledger_io import (
     require_ledger_path,
 )
 from capsule_emit.period import add_period_arg, apply_period
-from cll.ledger.api import ScanQuery
 
 from ..envcompat import env_get
 from ..guards.capsule import local_only_refusal
@@ -63,29 +62,13 @@ def add_parser(sub: argparse._SubParsersAction) -> argparse.ArgumentParser:
         default=env_get("CAPSULE_VERIFY_BASE_URL", DEFAULT_VERIFY_BASE_URL),
         help="base URL the permalink's fragment is appended to (default: %(default)s)",
     )
-    p.add_argument(
-        "--with-viewer",
-        dest="with_viewer",
-        action="store_true",
-        help=(
-            "also write a self-contained offline HTML viewer next to --out, so the "
-            "bundle verifies on a machine with no network (default viewer path: "
-            "--out with a .html extension)"
-        ),
-    )
-    p.add_argument(
-        "--viewer-out",
-        dest="viewer_out",
-        default=None,
-        help="output path for the offline viewer HTML (implies --with-viewer; default: derived from --out)",
-    )
     p.set_defaults(func=run)
     return p
 
 
 def _echo_safe_out(out: str) -> str:
     """The ``--out`` value ``cli_echo`` renders on the public bundle
-    permalink and offline viewer -- it must show where the file went
+    permalink -- it must show where the file went
     relative to the invocation, never the operator's absolute filesystem
     layout. An absolute path outside the cwd tree (no relative route to it)
     falls back to just the filename rather than leaking the full path."""
@@ -96,17 +79,6 @@ def _echo_safe_out(out: str) -> str:
     return rel if not rel.startswith("..") else p.name
 
 
-def _default_viewer_out(out: str) -> str:
-    """``bundle.json`` -> ``bundle.html`` alongside it; falls back to a
-    ``-viewer.html`` suffix on the rare path where ``--out`` already ends in
-    ``.html`` (so the two outputs never collide)."""
-    p = Path(out)
-    candidate = p.with_suffix(".html")
-    if str(candidate) == out:
-        candidate = p.with_name(p.stem + "-viewer.html")
-    return str(candidate)
-
-
 def _collect_with_parents(store, matched):
     """Pull in any cited chain parent not already selected, so the bundle
     verifies standalone without needing the rest of the ledger. A parent
@@ -207,7 +179,7 @@ def run(args: argparse.Namespace) -> int:
             }
             all_ok = all_ok and result.ok
 
-        tree_size = sum(1 for _ in store.scan(ScanQuery()))
+        tree_size = sum(1 for _ in store.scan())
         completeness_certificate = _build_completeness_certificate(store, records, tree_size)
 
     echo = build_echo(
@@ -255,15 +227,6 @@ def run(args: argparse.Namespace) -> int:
     print(f"checkpoint #{tree_size} · as of {format_staleness(0)}")
     print(f"verify: {permalink}")
 
-    if args.with_viewer or args.viewer_out is not None:
-        from ..bundle_viewer import render_offline_viewer_html
-
-        viewer_out = args.viewer_out or _default_viewer_out(args.out)
-        viewer_html = render_offline_viewer_html(fragment)
-        with open(viewer_out, "w", encoding="utf-8") as fh:
-            fh.write(viewer_html)
-        print(f"wrote {viewer_out} (self-contained, opens with no network)")
-
     print()
     print(echo)
     return 0 if all_ok else 1

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/capsule_engine/cli/format.py

@@ -111,8 +111,8 @@ def build_echo(verb: str, *, positional: str | None = None, flags: list[tuple[st
 
 
 def cli_echo_leaks_absolute_path(cli_echo: str) -> bool:
-    """``cli_echo`` is rendered verbatim on the bundle permalink and the
-    offline viewer -- a public page -- so it must never carry an operator's
+    """``cli_echo`` is rendered verbatim on the bundle permalink
+    -- a public URL -- so it must never carry an operator's
     absolute filesystem layout (home directory, machine username). Flags any
     token that is a POSIX absolute path (a leading ``/``, with no allowlisted
     exception defined) or a Windows drive path (``C:\\...``); callers that

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/capsule_engine/cli/guard_cmds.py

@@ -1,25 +1,25 @@
 # SPDX-License-Identifier: Apache-2.0
-"""``capsule guard`` verbs: dry-run replay + self-contained HTML report (moved
+"""``capsule guard`` verbs: dry-run replay + JSON report (moved
 here, matching ``fold_cmds.py``'s per-verb-module convention, so ``main.py``
 stays a thin dispatcher), plus ``guard enforce`` -- a minimal, honest local
 marker command (see ``_cmd_guard_enforce``'s own docstring for exactly what
 it does and doesn't do).
 
 Every guard-dry-run invocation here checks the current packaging arm
-(``capsule_ledger.packaging``) and, in "guards-only", both suppresses the
-evidence chrome in the rendered HTML report (``render_report_html``'s own
-``arm`` param) and rewords/suppresses this command's own stdout so it never
-prints a capsule id or a share/verify link -- see this module's inline
-comments at each print site.
+(``capsule_engine.packaging``) and, in "guards-only", rewords/suppresses this
+command's own stdout so it never prints a capsule id -- see this module's
+inline comments at each print site.
 """
 from __future__ import annotations
 
 import argparse
+import json
 import sys
 from pathlib import Path
 
 from .. import packaging
 from ..envcompat import env_get
+from ..guards.history import NotAStoreError
 
 __all__ = ["add_parser"]
 
@@ -95,14 +95,28 @@ def _parse_cap_args(items: list[str]) -> dict[str, int] | None:
     return caps_minor
 
 
+def _report_payload(report, *, with_capsules: bool) -> dict:
+    """The report as written to ``--out``. The sealed capsules in it are the
+    shareable part: kept only with ``--share`` (refused earlier when one is
+    local-only), otherwise the rows carry no capsule bodies."""
+    from ..report import to_payload
+
+    payload = to_payload(report)
+    if not with_capsules:
+        for section in payload["guards"]:
+            for row in section["rows"]:
+                row["capsule"] = None
+                row["cited_capsule"] = None
+    return payload
+
+
 def _cmd_guard_dry_run(args: argparse.Namespace) -> int:
     from agent_action_capsule import compute_capsule_id
 
     from ..folds.loader import load_definition_file
     from ..guards.capsule import local_only_refusal
     from ..packs import PackDefinitionError, load_proposals_file
-    from ..report import build_dry_run_report, build_dry_run_report_with_proposal, render_report_html
-    from ..report.render import TelemetryConfig, decode_fragment, to_fragment_payload
+    from ..report import build_dry_run_report, build_dry_run_report_with_proposal
     from ..telemetry.record import record_evidence_touch, record_guard_configured, record_guard_evaluated
 
     if bool(args.model_note) != bool(args.model_id):
@@ -157,7 +171,7 @@ def _cmd_guard_dry_run(args: argparse.Namespace) -> int:
     def _build():
         if proposed_caps_minor is not None:
             return build_dry_run_report_with_proposal(
-                args.ledger,
+                args.store,
                 caps_fold=caps_fold,
                 proposed_caps_minor=proposed_caps_minor,
                 since=since,
@@ -171,7 +185,7 @@ def _cmd_guard_dry_run(args: argparse.Namespace) -> int:
                 per_action_reads=per_action_reads,
             )
         return build_dry_run_report(
-            args.ledger,
+            args.store,
             caps_fold=caps_fold,
             since=since,
             caps_minor=caps_minor,
@@ -183,7 +197,11 @@ def _cmd_guard_dry_run(args: argparse.Namespace) -> int:
             per_action_reads=per_action_reads,
         )
 
-    report = _build()
+    try:
+        report = _build()
+    except NotAStoreError as exc:
+        print(f"capsule guard dry-run: {exc}", file=sys.stderr)
+        return 2
 
     # The printed link carries every row's decision capsule and the capsule
     # it cites; one holding a local-only field must not leave this machine.
@@ -194,24 +212,13 @@ def _cmd_guard_dry_run(args: argparse.Namespace) -> int:
             print(f"capsule guard dry-run --share: refused: {refusal}; rerun without --share", file=sys.stderr)
             return 1
 
-    telemetry = None
-    if args.telemetry_opt_in and args.telemetry_endpoint:
-        telemetry = TelemetryConfig(opted_in=True, endpoint=args.telemetry_endpoint)
-
-    html, fragment = render_report_html(report, arm=arm, telemetry=telemetry)
+    with_capsules = bool(args.share and evidence_visible)
     out_path = Path(args.out)
-    out_path.write_text(html, encoding="utf-8")
-    url = f"file://{out_path.resolve()}#{fragment}"
+    out_path.write_text(json.dumps(_report_payload(report, with_capsules=with_capsules), indent=2, sort_keys=True) + "\n", encoding="utf-8")
 
     print(f"wrote {out_path}")
     if report.manifest_digest is not None:
         print(f"evaluated under manifest {report.manifest_digest}")
-    # Arm A ("guards-only"): the share link is a verify-link suggestion --
-    # not printed, matching the report itself never surfacing its evidence
-    # chrome. The file above still exists and is still openable; this CLI
-    # just doesn't advertise the fragment-carried permalink.
-    if args.share and evidence_visible:
-        print(url)
 
     if caps_minor:
         record_guard_configured(arm)
@@ -221,21 +228,21 @@ def _cmd_guard_dry_run(args: argparse.Namespace) -> int:
         record_evidence_touch(arm)
 
     if args.verify:
-        written_payload = decode_fragment(fragment)
-        rebuilt_payload = to_fragment_payload(_build())
-        # exclude generated_at: the one field that legitimately differs
-        # between two otherwise-identical replays (it's a wall-clock
-        # generation timestamp, not derived from the ledger).
-        lhs = {k: v for k, v in written_payload.items() if k != "generated_at"}
-        rhs = {k: v for k, v in rebuilt_payload.items() if k != "generated_at"}
+        # --verify attests the file itself: it is read back and compared to a
+        # rebuild. generated_at is excluded: the one field that legitimately
+        # differs between two otherwise-identical replays (a wall-clock stamp).
+        written = json.loads(out_path.read_text(encoding="utf-8"))
+        lhs = {k: v for k, v in written.items() if k != "generated_at"}
+        rebuilt = _report_payload(_build(), with_capsules=with_capsules)
+        rhs = {k: v for k, v in rebuilt.items() if k != "generated_at"}
         if lhs != rhs:
-            print("FAIL: replaying the same ledger did not reproduce the same report", file=sys.stderr)
+            print("FAIL: replaying the same records did not reproduce the report written", file=sys.stderr)
             return 1
 
         mismatches = []
-        for section in written_payload["guards"]:
+        for section in written["guards"]:
             for row in section["rows"]:
-                for capsule in (row.get("capsule"), row.get("cited_capsule")):
+                for capsule in (row["capsule"], row["cited_capsule"]):
                     if not capsule:
                         continue
                     if compute_capsule_id(capsule) != capsule.get("capsule_id"):
@@ -245,7 +252,7 @@ def _cmd_guard_dry_run(args: argparse.Namespace) -> int:
             noun = "cited capsule(s)" if evidence_visible else "cited record(s)"
             print(f"FAIL: {len(mismatches)} {noun} do not re-verify", file=sys.stderr)
             return 1
-        tail = " and every cited capsule verifies" if evidence_visible else ""
+        tail = " and every cited capsule verifies" if with_capsules else ""
         print(f"OK: report is reproducible{tail}")
 
     return 0
@@ -273,30 +280,31 @@ def _cmd_guard_enforce(args: argparse.Namespace) -> int:
 
 
 def add_parser(sub: argparse._SubParsersAction) -> argparse.ArgumentParser:
-    guard = sub.add_parser("guard", help="guard API: dry-run replay + report (full CLI lands in a later task)")
+    guard = sub.add_parser("guard", help="guard API: dry-run replay + report")
     guard_sub = guard.add_subparsers(dest="guard_command")
     guard.set_defaults(guard_parser=guard)
 
     p_dry_run = guard_sub.add_parser(
-        "dry-run", help="replay a ledger through the guard checks and emit a self-contained HTML report"
+        "dry-run", help="replay stored records through the guard checks and write a JSON report"
     )
     p_dry_run.add_argument(
-        "--ledger", required=True, action="append", help="ledger JSONL file or LedgerStore directory (repeatable)"
+        "--store", required=True, action="append",
+        help="store directory, JSONL file of capsules or capsule bundle (repeatable)",
     )
     p_dry_run.add_argument(
         "--since", default="7d",
-        help="rolling window, e.g. '7d' (anchored to the ledger's own latest record); 'all' for no filter",
+        help="rolling window, e.g. '7d' (anchored to the records' own latest); 'all' for no filter",
     )
     p_dry_run.add_argument(
         "--share", action="store_true",
-        help="print the full shareable file://...#<fragment> URL (no-op in the guards-only packaging arm)",
+        help="include the sealed capsules in the report file (refused when one is local-only; no-op in the guards-only packaging arm)",
     )
     p_dry_run.add_argument(
         "--verify", action="store_true", help="re-replay and re-verify every cited capsule before exiting"
     )
-    p_dry_run.add_argument("--out", default="dry-run-report.html", help="output HTML path (default: dry-run-report.html)")
+    p_dry_run.add_argument("--out", default="dry-run-report.json", help="output JSON path (default: dry-run-report.json)")
     p_dry_run.add_argument(
-        "--operator", default=None, help="override the displayed operator label (default: the ledger's own)"
+        "--operator", default=None, help="override the displayed operator label (default: the records' own)"
     )
     p_dry_run.add_argument(
         "--cap", action="append", default=[], metavar="CLASS=MINOR_UNITS",
@@ -341,16 +349,6 @@ def add_parser(sub: argparse._SubParsersAction) -> argparse.ArgumentParser:
         "--no-manifest", dest="no_manifest", action="store_true",
         help="skip policy-manifest resolution entirely (report carries no manifest_digest)",
     )
-    p_dry_run.add_argument(
-        "--telemetry-opt-in", action="store_true",
-        help="embed a disclosed, anonymous open-beacon in the report for the M6 (viral unit) metric -- "
-        "requires --telemetry-endpoint too, and is off by default; see `capsule telemetry status`",
-    )
-    p_dry_run.add_argument(
-        "--telemetry-endpoint", default=env_get("CAPSULE_LEDGER_TELEMETRY_ENDPOINT"),
-        help="where the open-beacon above (if enabled) sends its single anonymous event (default: "
-        "$CAPSULE_LEDGER_TELEMETRY_ENDPOINT, or none -- with no endpoint the beacon is never embedded)",
-    )
     p_dry_run.set_defaults(func=_cmd_guard_dry_run)
 
     p_enforce = guard_sub.add_parser(

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/capsule_engine/cli/init_cmds.py

@@ -4,7 +4,7 @@
 Materializes the pack's constraints and folds into ``<project-dir>/.capsule/``,
 writes the policy manifest fragment that cites them plus the pack itself (by
 digest, mode ``observe``) -- so which pack version is in force is provable --
-and, when ``--ledger`` is given, records that installation as a signed
+and, when ``--store`` is given, records that installation as a signed
 ``policy_manifest_activated`` event capsule (``packs/install.py``'s
 ``record_pack_activation``).
 
@@ -32,9 +32,8 @@ import secrets
 import sys
 from pathlib import Path
 
-from cll.ledger import LedgerStore
-
 from ..envcompat import env_get
+from ..guards.history import NotAStoreError, open_store
 from ..guards.signing import LocalSigner
 from ..packs import (
     PackDefinitionError,
@@ -107,9 +106,9 @@ def _cmd_init(args: argparse.Namespace) -> int:
         f"{args.pack}` (not yet built)."
     )
 
-    if not args.ledger:
+    if not args.store:
         print()
-        print("no --ledger given: manifest written to disk only, no activation capsule recorded")
+        print("no --store given: manifest written to disk only, no activation capsule recorded")
         return 0
 
     key_id = args.key_id or env_get(_KEY_ID_ENV)
@@ -121,13 +120,15 @@ def _cmd_init(args: argparse.Namespace) -> int:
         secret_text = secrets.token_hex(32)
     signer = LocalSigner(key_id=key_id, secret=secret_text.encode("utf-8"))
 
-    ledger = LedgerStore(args.ledger)
     try:
+        store = open_store(args.store, signer=signer, create=True)
+    except NotAStoreError as exc:
+        print(f"capsule init: {exc}", file=sys.stderr)
+        return 2
+    with store:
         capsule = record_pack_activation(
-            installed, ledger=ledger, operator=args.operator, developer=args.developer, signer=signer
+            installed, history=store, operator=args.operator, developer=args.developer, signer=signer
         )
-    finally:
-        ledger.close()
 
     print()
     print(f"activation recorded: {capsule['capsule_id']}")
@@ -155,9 +156,9 @@ def add_parser(sub: argparse._SubParsersAction) -> argparse.ArgumentParser:
         "this command still prints each artifact's digest so you can seed one)",
     )
     p_init.add_argument(
-        "--ledger", default=None,
-        help="ledger store directory to record this install's activation capsule into (default: none, manifest "
-        "is still written to disk)",
+        "--store", default=None,
+        help="store directory to record this install's activation capsule into, created if missing (default: "
+        "none, manifest is still written to disk)",
     )
     p_init.add_argument("--operator", default="local", help="operator identity for the activation capsule (default: 'local')")
     p_init.add_argument(

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/capsule_engine/cli/main.py

@@ -4,14 +4,13 @@
 funnel report), `init` (install a starter pack), `constraints` (list the
 registered guard checks + action-class taxonomy), `tenant`
 (engine-instance-per-tenant provisioning), plus the evidence verbs `verify`
-(verify one ledger record or an offline bundle), `bundle` (produce a
-self-contained verifiable slice of the ledger), and `console` (serve the
-local console UI) -- registered only in the "full" packaging arm, same
+(verify one ledger record or an offline bundle), and `bundle` (produce a
+self-contained verifiable slice of the ledger) -- registered only in the "full" packaging arm, same
 two-arm switch (`capsule_engine.packaging`) the original monorepo used.
 
 This is a deliberately minimal dispatcher: the original monorepo's
 `cli/main.py` wired every verb across ledger, folds, guards, packs, policy,
-console, telemetry, etc. Post-split, this repo only owns the verb modules
+telemetry, etc. Post-split, this repo only owns the verb modules
 that actually live here -- the rest stayed with their owning repo.
 `cli/format.py` is not wired as a subcommand: it has no `add_parser`, it is
 shared output-formatting helpers used by the verbs above.
@@ -27,7 +26,6 @@ import sys
 from .. import packaging
 from . import (
     bundle_cmd,
-    console_cmd,
     constraints_cmd,
     guard_cmds,
     init_cmds,
@@ -53,14 +51,13 @@ def _build_parser(arm: str | None = None) -> argparse.ArgumentParser:
     telemetry_cmd.add_parser(sub)
     packs_cmds.add_parser(sub)
 
-    # The record-query/evidence verbs -- capsule verify, the shareable
-    # bundle, and the local console UI -- are the "evidence": registered
+    # The record-query/evidence verbs -- capsule verify and the shareable
+    # bundle -- are the "evidence": registered
     # only in the "full" arm. See ``packaging.py``'s module docstring for
     # why an env var, not a fork, drives this.
     if packaging.evidence_visible(arm):
         verify_cmd.add_parser(sub)
         bundle_cmd.add_parser(sub)
-        console_cmd.add_parser(sub)
 
     return parser
 

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/capsule_engine/cli/tenant_cmds.py

@@ -5,7 +5,7 @@ instance per tenant" pattern for a caller embedding this package for many
 customers. See ``docs/tenant-provisioning.md`` for the layout and the
 isolation rationale.
 
-  init    -- provision a brand-new tenant: fresh ledger dir, this tenant's
+  init    -- provision a brand-new tenant: fresh store dir, this tenant's
              own pinned manifest, first activation capsule. Refuses if the
              tenant already has anything on disk.
   upgrade -- re-materialize an existing tenant's manifest (e.g. after a
@@ -83,7 +83,7 @@ def _cmd_tenant_init(args: argparse.Namespace) -> int:
         return 1
 
     print(f"provisioned tenant {args.tenant_id!r} at {result.layout.root}")
-    print(f"  ledger:          {result.layout.ledger_dir}")
+    print(f"  store:           {result.layout.store_dir}")
     print(f"  manifest:        {result.layout.manifest_path}")
     print(f"  manifest id:     {result.manifest_id}")
     print(f"  manifest digest: {result.manifest_digest}")
@@ -169,7 +169,7 @@ def add_parser(sub: argparse._SubParsersAction) -> argparse.ArgumentParser:
     tenant.set_defaults(tenant_parser=tenant)
 
     p_init = tenant_sub.add_parser(
-        "init", help="provision a brand-new tenant instance (ledger dir + manifest + first activation)"
+        "init", help="provision a brand-new tenant instance (store dir + manifest + first activation)"
     )
     p_init.add_argument("--tenants-root", required=True, help="directory holding one subdirectory per tenant")
     p_init.add_argument("--tenant-id", required=True, help="this tenant's id (becomes a directory name -- lowercase, digits, hyphens)")

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/capsule_engine/cli/verify_cmd.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-"""`capsule verify`: verify one ledger record, or an entire bundle file offline.
+"""`capsule verify`: verify one stored record, or an entire bundle file offline.
 
 Exit codes (CI-friendly, and distinguished because "not found" and "found
 but tampered" are different failure modes a caller may want to branch on):
@@ -11,20 +11,22 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import sys
 
 from agent_action_capsule import verify as verify_capsule
-from capsule_emit.ledger_io import open_ledger, require_ledger_path
 
+from ..envcompat import env_get
+from ..guards.history import History, MemoryHistory, NotAStoreError, open_store, verify_stored
 from .format import build_echo
 
 __all__ = ["add_parser", "run"]
 
 
 def add_parser(sub: argparse._SubParsersAction) -> argparse.ArgumentParser:
-    p = sub.add_parser("verify", help="verify one ledger record, or an entire bundle file")
+    p = sub.add_parser("verify", help="verify one stored record, or an entire bundle file")
     p.add_argument("capsule_id", nargs="?", help="a capsule_id or an unambiguous prefix (omit with --bundle)")
-    p.add_argument("--ledger", help="ledger store directory or a JSONL fixture file (default: $CAPSULE_LEDGER)")
+    p.add_argument("--store", help="store directory or a JSONL fixture file (default: $CAPSULE_STORE)")
     p.add_argument(
         "--bundle", help="verify every record in a bundle file produced by `capsule bundle`, offline and self-contained"
     )
@@ -56,17 +58,26 @@ def run(args: argparse.Namespace) -> int:
         print("capsule verify: capsule_id is required unless --bundle is given", file=sys.stderr)
         return 2
 
-    ledger_path = require_ledger_path("verify", args)
-    if ledger_path is None:
+    store_path = args.store or env_get("CAPSULE_STORE")
+    if store_path is None:
+        print("capsule verify: --store is required (or set $CAPSULE_STORE)", file=sys.stderr)
         return 2
 
-    with open_ledger(ledger_path) as store:
-        record = store.fetch(args.capsule_id)
-        if record is None:
-            print(f"no such capsule {args.capsule_id!r} in ledger {ledger_path}", file=sys.stderr)
+    try:
+        history = _open(store_path)
+    except NotAStoreError as exc:
+        print(f"capsule verify: {exc}", file=sys.stderr)
+        return 2
+    try:
+        verified = verify_stored(history, args.capsule_id)
+        if verified is None:
+            print(f"no such capsule {args.capsule_id!r} in store {store_path}", file=sys.stderr)
             return 2
-        result = store.verify(record.capsule_id)
-        capsule_id = record.capsule_id
+        capsule_id, result = verified
+    finally:
+        close = getattr(history, "close", None)
+        if close is not None:
+            close()
 
     if args.json:
         print(
@@ -88,6 +99,14 @@ def run(args: argparse.Namespace) -> int:
     return 0 if ok else 1
 
 
+def _open(path: str) -> History:
+    """A store directory, or a JSONL fixture file of capsules read in order."""
+    if os.path.isdir(path):
+        return open_store(path)
+    with open(path, encoding="utf-8") as fh:
+        return MemoryHistory(json.loads(line) for line in fh if line.strip())
+
+
 def _run_bundle(args: argparse.Namespace) -> int:
     try:
         with open(args.bundle, encoding="utf-8") as fh:

{capsule_engine-0.2.0 → capsule_engine-0.3.0}/capsule_engine/conversation/__init__.py

@@ -27,7 +27,7 @@ Public surface:
   capsule(s) it gave rise to (e.g. a caller's own tool-call capsules),
   resolved back via ``find_turn_reference``.
 - ``find_session_turns`` / ``find_session_close`` / ``find_turn_reference``
-  -- read a session (or a cross-reference) back off any ``LedgerAPI``.
+  -- read a session (or a cross-reference) back off any ``History``.
 - ``session_root`` / ``turn_inclusion_proof`` / ``verify_turn_inclusion`` --
   the Merkle session-digest primitives (``.merkle``).
 - ``ConversationSession`` -- the stateful recorder: seals and appends each