strata-agent-memory 0.2.4__tar.gz → 0.2.6__tar.gz

{strata_agent_memory-0.2.4/strata_agent_memory.egg-info → strata_agent_memory-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strata-agent-memory
-Version: 0.2.4
+Version: 0.2.6
 Summary: Portable, auditable, cross-vendor memory for LLM agents: evidence-bound claims, trust tiers, and compiled context views.
 Author: Strata Intelligence
 License-Expression: Apache-2.0
@@ -75,7 +75,7 @@ pip install strata-agent-memory     # the CLI is `agent-memory`; or, from a chec
 cd your-project && agent-memory init
 
 agent-memory run -- pytest -q                     # -> {"id": "ev_…", "kind": "test", "passed": 42, ...}
-agent-memory claim outcome "auth tests pass" -e ev_… --commit
+agent-memory claim outcome "auth tests pass" -e ev_…   # inside a git checkout it binds HEAD too
 agent-memory claim outcome "deployed" # -> rejected: outcome claims require at least one receipt
 
 agent-memory claim fact "sessions renew via renewSession()" --source src/auth.py
@@ -91,6 +91,7 @@ agent-memory claim fact "w3lib.get_meta_refresh takes baseurl" --source w3lib/ht
 agent-memory compile --role worker --task "extend auth"    # a fork-mode brief; reports what memory holds nothing on
 agent-memory compile --role verifier --contract ctr_… --round 2 --lens security   # isolated review brief with a lens
 agent-memory audit                                          # tiers, static-only outcomes, taint chains, verifier lineage matrix
+agent-memory audit --since 2026-09-21 --until 2026-09-28    # and the measurement section for that week (default: the last seven days)
 agent-memory reliability                                    # how often claims like these were refuted, with n and an interval; fitted staleness
 AGENT_MEMORY_HARNESS=ollama agent-memory recheck --map /Users/craig/src=/home/chris/src   # the nightly lane, from another machine
 agent-memory serve                                          # HTTP API, SSE and remote MCP on loopback; add --tokens FILE
@@ -150,8 +151,11 @@ disposable replica: a SQLite index rebuilt from the shards, bearer-token
 identity, an HTTP API, server-sent events, a remote MCP endpoint
 (Streamable HTTP, revisions 2025-03-26, 2025-06-18 and the stateless
 2026-07-28, chosen per request) so cloud agents
-reach the ledger without a clone (Claude Code on the web only through an
-organization-managed connector; Codex cloud unverified), and scheduled
+reach the ledger without a clone (Claude Code on the web through the repo's
+`.mcp.json` in single-repo sessions, organization-managed connectors, beta
+static-header connectors or self-hosted environments
+( https://code.claude.com/docs/en/claude-code-on-the-web ); Codex cloud
+unverified), and scheduled
 recheck and git-sync lanes. Losing the service never loses state
 (docs/BETA-SPEC.md section 4, `examples/remote/`).
 

{strata_agent_memory-0.2.4 → strata_agent_memory-0.2.6}/README.md

@@ -51,7 +51,7 @@ pip install strata-agent-memory     # the CLI is `agent-memory`; or, from a chec
 cd your-project && agent-memory init
 
 agent-memory run -- pytest -q                     # -> {"id": "ev_…", "kind": "test", "passed": 42, ...}
-agent-memory claim outcome "auth tests pass" -e ev_… --commit
+agent-memory claim outcome "auth tests pass" -e ev_…   # inside a git checkout it binds HEAD too
 agent-memory claim outcome "deployed" # -> rejected: outcome claims require at least one receipt
 
 agent-memory claim fact "sessions renew via renewSession()" --source src/auth.py
@@ -67,6 +67,7 @@ agent-memory claim fact "w3lib.get_meta_refresh takes baseurl" --source w3lib/ht
 agent-memory compile --role worker --task "extend auth"    # a fork-mode brief; reports what memory holds nothing on
 agent-memory compile --role verifier --contract ctr_… --round 2 --lens security   # isolated review brief with a lens
 agent-memory audit                                          # tiers, static-only outcomes, taint chains, verifier lineage matrix
+agent-memory audit --since 2026-09-21 --until 2026-09-28    # and the measurement section for that week (default: the last seven days)
 agent-memory reliability                                    # how often claims like these were refuted, with n and an interval; fitted staleness
 AGENT_MEMORY_HARNESS=ollama agent-memory recheck --map /Users/craig/src=/home/chris/src   # the nightly lane, from another machine
 agent-memory serve                                          # HTTP API, SSE and remote MCP on loopback; add --tokens FILE
@@ -126,8 +127,11 @@ disposable replica: a SQLite index rebuilt from the shards, bearer-token
 identity, an HTTP API, server-sent events, a remote MCP endpoint
 (Streamable HTTP, revisions 2025-03-26, 2025-06-18 and the stateless
 2026-07-28, chosen per request) so cloud agents
-reach the ledger without a clone (Claude Code on the web only through an
-organization-managed connector; Codex cloud unverified), and scheduled
+reach the ledger without a clone (Claude Code on the web through the repo's
+`.mcp.json` in single-repo sessions, organization-managed connectors, beta
+static-header connectors or self-hosted environments
+( https://code.claude.com/docs/en/claude-code-on-the-web ); Codex cloud
+unverified), and scheduled
 recheck and git-sync lanes. Losing the service never loses state
 (docs/BETA-SPEC.md section 4, `examples/remote/`).
 

{strata_agent_memory-0.2.4 → strata_agent_memory-0.2.6}/agent_memory/__init__.py

@@ -9,4 +9,4 @@ see, what did it claim, and can the proof be re-run.
 The core is dependency-free (Python 3.10+ standard library only).
 """
 
-__version__ = "0.2.4"
+__version__ = "0.2.6"

{strata_agent_memory-0.2.4 → strata_agent_memory-0.2.6}/agent_memory/audit.py

@@ -27,12 +27,14 @@ from collections import Counter, defaultdict
 from typing import Dict, List, Optional
 
 from . import evidence as ev
+from . import measure as measure_mod
 from . import reliability as rel
+from . import supersession as supersession_mod
 from . import roster as roster_mod
 from . import signing
 from .contracts import status_of
 from .ledger import UNTRUSTED_POLICY
-from .records import is_redacted, receipt_visible_to
+from .records import is_assessment, is_redacted, receipt_visible_to
 from .trust import TIERS, assess, lineage_differs, summarize
 
 # Anything a compiled view would have to render on its own line. The renderer collapses
@@ -189,12 +191,15 @@ def _roster_sections(ledger, rep: Dict, by_id: Dict[str, dict], reader_user: Opt
 
 
 def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Optional[float] = 300,
-           path_map=None, reader_user: Optional[str] = None) -> dict:
+           path_map=None, reader_user: Optional[str] = None, since: Optional[str] = None,
+           until: Optional[str] = None) -> dict:
     """The audit, for one reader. ``reader_user`` is who is asking: a user-scoped claim is
     one person's private memory and is listed for its owner and for nobody else, the same
     rule ``receipt_visible_to`` applies everywhere a record is shown (verification review
     F1: the audit listed every user's private statements to any token). A local audit
-    with no reader named sees everything, as the local ledger's owner does."""
+    with no reader named sees everything, as the local ledger's owner does. ``since`` and
+    ``until`` are the measurement section's window (measure.window; ValueError when it is
+    empty or a bound does not parse)."""
     assessment = assess(ledger)
     claims = ledger.claims()
     if reader_user is not None:
@@ -213,10 +218,14 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         "unrechecked_outcomes": [],
         "failing_receipt_outcomes": [],
         "static_only_outcomes": [],
+        "dirty_bound_outcomes": [],
         "assurance_overridden": [],
         "same_vendor_only": [],
         "self_verified_by_author": [],
         "same_session_different_harness": [],
+        # D6 (ctr_67b26eae6bff4b63): another identity's reading of a claim, asked for; listed
+        # here and nowhere a verdict is counted
+        "assessments": [],
         "formatted_statements": [],
         "redactions": {"count": 0, "ids": []},
         # absent and empty mean different things (an absent key is the starter default
@@ -227,6 +236,11 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         "same_lineage_refutation_rate": None,
         "cross_lineage_refutation_rate": None,
         "refuted": [],
+        # ctr_614162800937e387: outcomes replaced by a later one, records withdrawn as
+        # artefacts, and the old wrong retractions a PM may want to call artefacts
+        "superseded": [],
+        "withdrawn": [],
+        "artefact_candidates": [],
         "taint_chains": [],
         "stale": [],
         "asserted_facts": [],
@@ -241,6 +255,23 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         "verifications_outside_project_roster": {},
         "recheck": [],
     }
+    # retractions filed as wrong -- every one before kinds -- whose reason names the claim
+    # that replaced it or reads like a stray test record: the PM may file an artefact
+    # retraction beside each, which then decides the claim's kind, never editing the old
+    # record (ctr_614162800937e387)
+    for r in sorted(ledger.by_kind("retraction"), key=lambda rec: rec["ts"]):
+        body = r.get("body") if isinstance(r.get("body"), dict) else {}
+        claim_id = body.get("claim")
+        if claim_id not in by_id or supersession_mod.retraction_kind(r) != "wrong":
+            continue
+        if supersession_mod.operative_kind(ledger.retractions_for(claim_id)) != "wrong":
+            continue  # already answered by an artefact retraction beside it
+        reason = str(body.get("reason") or "")
+        why = ("names the claim that replaced it" if supersession_mod.REPLACEMENT.search(reason)
+               else "reads like a stray test record" if supersession_mod.TEST_LEAK.search(reason) else None)
+        if why:
+            rep["artefact_candidates"].append({"retraction": r["id"], "claim": claim_id,
+                                               "reason": reason[:160], "why": why})
     # measured history, computed from the ledger alone: counts, intervals, and the word
     # "insufficient history" wherever there are too few of them
     measured = rel.report(ledger, assessment)
@@ -275,6 +306,12 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
             if backed in ("static", "attested"):
                 # a clean static gate is not evidence that the thing runs
                 rep["static_only_outcomes"].append({**entry, "assurance": backed})
+            # the writer's own word that its receipts ran on a tree no sha reproduces: no
+            # lane checks those out, so a practice of it is a PM's question per author (S3)
+            heads = [item.get("sha") for item in b.get("evidence") or []
+                     if isinstance(item, dict) and item.get("kind") == "commit" and item.get("dirty")]
+            if heads:
+                rep["dirty_bound_outcomes"].append({**entry, "user": a.get("user"), "head": heads[0]})
         # a measure, not a tier: every claim whose only verifiers are agents of its own
         # vendor, whether the ledger's policy lets that reach `verified` or not
         if info["verified_by"] and not info.get("cross_vendor") and not info.get("self_verified_by_author") \
@@ -287,10 +324,15 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
             # byte for byte is not the audit this ledger promises
             deps = sorted(d for d in ledger.dependents_of(c["id"], through_kinds=("claim",)) if d in by_id)
             rep["refuted"].append({**entry, "reasons": info["reasons"], "dependents": len(deps)})
-            if deps:
+            # the rule trust applies: a superseded claim taints nothing unless it was retracted as wrong
+            if deps and not supersession_mod.taint_skipped(info.get("superseded_by"), ledger.retractions_for(c["id"])):
                 rep["taint_chains"].append({"root": c["id"], "tainted": [{"id": d, "statement": by_id[d]["body"]["statement"][:120]} for d in deps]})
         if info["tier"] == "stale":
             rep["stale"].append({**entry, "reasons": info["reasons"]})
+        if info.get("superseded_by"):
+            rep["superseded"].append({**entry, "superseded_by": info["superseded_by"], "tier": info["tier"]})
+        if info["tier"] == "withdrawn":
+            rep["withdrawn"].append({**entry, "reasons": info["reasons"]})
         if info["tier"] == "asserted" and b["type"] == "fact":
             rep["asserted_facts"].append(entry)
         for field in _FORMATTED_FIELDS:
@@ -323,6 +365,17 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         claim = by_id.get(v["body"].get("claim"))
         if claim is None:
             continue
+        if is_assessment(v):  # a reading, not a verdict: its own column, never the matrix
+            rep["assessments"].append({
+                "id": v["id"], "claim": claim["id"], "verdict": v["body"]["verdict"],
+                "by": v["author"].get("harness"), "vendor": v["author"].get("vendor"),
+                "user": v["author"].get("user"), "ts": v["ts"],
+                "lineage": ("another lineage" if lineage_differs(claim["author"], v["author"])
+                            else "same lineage: never counted"),
+                "note": str(v["body"].get("note") or "")[:160], "cited": list(v["body"].get("cited") or []),
+                "statement": claim["body"]["statement"][:120],
+            })
+            continue
         verdict = v["body"]["verdict"]
         key = f"{claim['author'].get('vendor')}->{v['author'].get('vendor')}"
         cell = rep["lineage_matrix"].setdefault(key, {"verified": 0, "refuted": 0, "inconclusive": 0})
@@ -421,8 +474,8 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
     if recheck:
         for c in claims:
             info = assessment[c["id"]]
-            if info["tier"] in ("refuted", "tainted"):
-                continue
+            if info["tier"] in ("refuted", "withdrawn", "tainted") or info.get("superseded_by"):
+                continue  # settled, a stray, or a replaced head: re-running says nothing
             unmet = set(ev.unmet_expectations(ledger, c))
             for r in ev.recheck_claim(ledger, c, cwd=cwd, timeout=timeout, path_map=path_map):
                 if r["outcome"] == "skipped":
@@ -433,6 +486,13 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
                 if r["outcome"] == "match" and r["evidence"] in unmet:
                     entry["note"] = ev.FAILING_RECEIPT_NOTE  # reproducing a failure verifies nothing
                 rep["recheck"].append(entry)
+    # what the reliability measurements leave out, and why (the PE's ruling, item 4)
+    rep["not_measured"] = {"superseded": len(rep["superseded"]), "artefact": len(rep["withdrawn"])}
+    # the vision's numbers for a window, recomputable by anyone with the shards
+    # (ctr_13190a200fbbd682; docs/BENCHMARK-PLAN.md section 3)
+    rep["measurement"] = measure_mod.measurement(
+        ledger, since, until, sees=lambda rec: _reader_sees(ledger, rec, by_id, reader_user),
+        assessment=assessment)
     return rep
 
 
@@ -486,6 +546,9 @@ def format_report(rep: dict) -> str:
             lambda r: f"{r['id']} [{r['by']}] {r['statement']} -- receipts: {', '.join(r['receipts'])}")
     section("Outcome claims backed only by static evidence (static-pass/dynamic-fail risk)",
             rep["static_only_outcomes"], lambda r: f"{r['id']} [{r['by']}, {r['assurance']}] {r['statement']}")
+    section("Outcome claims bound to a dirty tree (their commit is not what ran; no lane re-runs them at it)",
+            rep.get("dirty_bound_outcomes", []),
+            lambda r: f"{r['id']} [{r['by']}, {r['user']}] at {str(r['head'])[:12]} {r['statement']}")
     section("Receipts whose assurance was declared above the computed default", rep["assurance_overridden"],
             lambda r: f"{r['id']} [{r['by']}] declared {r['declared']}, computed {r['computed']}: {r['what']}"
                       + (f" (cited by {', '.join(r['claims'])})" if r["claims"] else " (cited by no claim)"))
@@ -497,11 +560,22 @@ def format_report(rep: dict) -> str:
             rep.get("same_session_different_harness", []),
             lambda r: f"{r['id']} [{r['by']} -> {r['verified_by']}, {r['user']} session {r['session']}] "
                       f"{r['statement']}")
+    section("Assessments (a reading on request, never a check: they move no tier)", rep.get("assessments", []),
+            lambda r: f"{r['id']} on {r['claim']} [{r['verdict']} by {r['by']}, {r['vendor']}, {r['user']}; "
+                      f"{r['lineage']}] {r['note']}" + (f" (cites {', '.join(r['cited'])})" if r["cited"] else ""))
     section("Statements shaped like a document (injection risk)", rep.get("formatted_statements", []),
             lambda r: f"{r['id']} [{r['by']}] {r['field']} starts a line with: {r['line']}")
     section("Refuted", rep["refuted"], lambda r: f"{r['id']} {r['statement']} -- {'; '.join(r['reasons'])} (dependents: {r['dependents']})")
     section("Taint chains", rep["taint_chains"], lambda r: f"{r['root']} -> " + ", ".join(t['id'] for t in r['tainted']))
     section("Stale", rep["stale"], lambda r: f"{r['id']} {r['statement']} -- {'; '.join(r['reasons'])}")
+    section("Superseded outcomes (replaced by a later outcome of their contract; they count nowhere and block nothing)",
+            rep.get("superseded", []),
+            lambda r: f"{r['id']} {r['statement']} -- superseded by {', '.join(r['superseded_by'])} (was {r['tier']})")
+    section("Withdrawn as artefacts (stray or test records; they count nowhere and taint nothing)",
+            rep.get("withdrawn", []), lambda r: f"{r['id']} {r['statement']} -- {'; '.join(r['reasons'])}")
+    section("Retractions filed as wrong that read like an artefact (a PM may file an artefact retraction beside each)",
+            rep.get("artefact_candidates", []),
+            lambda r: f"{r['claim']} (retraction {r['retraction']}): {r['why']} -- {r['reason']}")
     section("Facts with no evidence (asserted)", rep["asserted_facts"], lambda r: f"{r['id']} [{r['by']}] {r['statement']}")
     section("Pinned sections over config.compile_pinned_chars",
             rep.get("pinned_over_cap", []),
@@ -571,10 +645,17 @@ def format_report(rep: dict) -> str:
                  f"cross-lineage refutation rate: {_rate(rep['cross_lineage_refutation_rate'])}")
     if "reliability" in rep:
         lines.append("")
+        if rep.get("not_measured"):
+            nm = rep["not_measured"]
+            lines.append(f"Not measured below: {nm['superseded']} superseded outcome(s) and {nm['artefact']} "
+                         f"artefact retraction(s); refuted counts verification mismatches and wrong retractions only")
         lines.append(rel.format_report({"table": rep["reliability"],
                                         "same_lineage_agreement": rep["same_lineage_agreement"],
                                         "staleness": rep["staleness"],
                                         "judgment_calibration": rep["judgment_calibration"]}).rstrip("\n"))
+    if rep.get("measurement"):  # a replica older than this section sends none
+        lines.extend(measure_mod.format_noise(rep["measurement"]))
+        lines.extend(measure_mod.format_measurement(rep["measurement"]))
     if rep["recheck"]:
         section("Evidence re-check", rep["recheck"],
                 lambda r: f"{r['claim']} {r['evidence']}: {r['outcome']} -- {r['detail']}"