strata-agent-memory 0.2.1__tar.gz → 0.2.2__tar.gz

{strata_agent_memory-0.2.1/strata_agent_memory.egg-info → strata_agent_memory-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strata-agent-memory
-Version: 0.2.1
+Version: 0.2.2
 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
@@ -45,9 +45,13 @@ service, no dependencies, Python 3.10+.
   commit/file hash. The claim is rejected otherwise. A receipt is the
   filer's record; the proof is the re-run, which `verify` and the nightly
   lane perform, and the audit lists what nobody has re-run.
-- **Same-vendor review is not verification.** A Claude reviewer approving a
-  Claude coder yields `self-verified`. Only a human or a different vendor
-  lineage (Codex, Gemini, a local Qwen) promotes a claim to `verified`.
+- **Self-review is not verification.** A claim reaches `verified` when a
+  person, or an agent that is not its author, re-runs the proof; the author's
+  own re-run stays `self-verified`. A fleet on one vendor gets the same rigor
+  as a mixed one. A ledger that wants the stronger rule sets
+  `cross_vendor_required`, and then only a person or another vendor's agent
+  (Codex, Gemini, a local Qwen) promotes; either way the audit says which
+  lineage verified what.
 - **Refuting a claim taints everything built on it.** Retractions walk the
   provenance graph; nothing is deleted; the audit prints the chain.
 - **Verifiers are isolated, workers fork.** A reviewer never sees the

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2}/README.md

@@ -21,9 +21,13 @@ service, no dependencies, Python 3.10+.
   commit/file hash. The claim is rejected otherwise. A receipt is the
   filer's record; the proof is the re-run, which `verify` and the nightly
   lane perform, and the audit lists what nobody has re-run.
-- **Same-vendor review is not verification.** A Claude reviewer approving a
-  Claude coder yields `self-verified`. Only a human or a different vendor
-  lineage (Codex, Gemini, a local Qwen) promotes a claim to `verified`.
+- **Self-review is not verification.** A claim reaches `verified` when a
+  person, or an agent that is not its author, re-runs the proof; the author's
+  own re-run stays `self-verified`. A fleet on one vendor gets the same rigor
+  as a mixed one. A ledger that wants the stronger rule sets
+  `cross_vendor_required`, and then only a person or another vendor's agent
+  (Codex, Gemini, a local Qwen) promotes; either way the audit says which
+  lineage verified what.
 - **Refuting a claim taints everything built on it.** Retractions walk the
   provenance graph; nothing is deleted; the audit prints the chain.
 - **Verifiers are isolated, workers fork.** A reviewer never sees the

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2}/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.1"
+__version__ = "0.2.2"

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2}/agent_memory/audit.py

@@ -195,8 +195,11 @@ 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})
-        if info["tier"] == "self-verified":
-            rep["same_vendor_only"].append({**entry, "verified_by": info["verified_by"]})
+        # 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") \
+                and info["tier"] in ("verified", "self-verified"):
+            rep["same_vendor_only"].append({**entry, "verified_by": info["verified_by"], "tier": info["tier"]})
         if info.get("self_verified_by_author"):
             rep["self_verified_by_author"].append({**entry, "verified_by": info["verified_by"]})
         if info["tier"] == "refuted":
@@ -406,8 +409,8 @@ def format_report(rep: dict) -> str:
     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)"))
-    section("Verified only by the same vendor (collusion risk)", rep["same_vendor_only"],
-            lambda r: f"{r['id']} [{r['vendor']} verified by {', '.join(r['verified_by'])}] {r['statement']}")
+    section("Verified only by the same vendor (no person or other vendor has re-run it)", rep["same_vendor_only"],
+            lambda r: f"{r['id']} [{r['vendor']} verified by {', '.join(r['verified_by'])}; {r.get('tier','')}] {r['statement']}")
     section("Verified only by the claim's own author", rep["self_verified_by_author"],
             lambda r: f"{r['id']} [{r['by']}] {r['statement']}")
     section("Verified from the claim's own session under another harness (collusion risk)",

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2}/agent_memory/ledger.py

@@ -43,7 +43,7 @@ DEFAULT_CONFIG = {
     "project_aliases": [],
     "org_path": None,
     "user": None,
-    "cross_vendor_required": True,
+    "cross_vendor_required": False,
     "org_include_other_projects": True,
     "budget_tokens": 6000,
     "vendor_map": {},
@@ -109,7 +109,7 @@ UNTRUSTED_POLICY = {
     "redact": [],              # an attacker-supplied regex can hang capture (catastrophic backtracking)
     "path_map": [],            # where a re-check runs
     "org_path": None,          # what it reads and writes outside the checkout
-    "cross_vendor_required": True,   # whether same-vendor review counts as verification
+    "cross_vendor_required": False,  # off: any agent other than the author verifies; on: another vendor or a person
     "vendor_map": {},          # which lineage a harness belongs to, which is the same question
     "signers": {},             # whose signature this machine believes
     # A tier is a preference until it is a number: stale_after_days moves claims between

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2}/agent_memory/trust.py

@@ -2,8 +2,11 @@
 
 Tiers (highest first):
     constraint     human-filed hard rule
-    verified       independently verified (human, or a different vendor lineage)
-    self-verified  verified only by the same vendor lineage as the author
+    verified       re-run by an independent verifier: a person, or an agent that is not the
+                   claim's author (a different identity; of another vendor when the ledger
+                   requires that)
+    self-verified  re-run only by the claim's own author, or -- when the ledger requires a
+                   verifier of another vendor -- only by agents of the author's vendor
     evidenced      carries receipts/bindings but nobody has re-run them
     asserted       no evidence (only allowed for non-outcome claim types)
     stale          TTL expired, or a re-check found the world moved (including a changed
@@ -11,11 +14,13 @@ Tiers (highest first):
     refuted        retracted, or a verification refuted it
     tainted        derived (transitively) from a refuted claim
 
-The cross-vendor rule is the structural answer to collusive validation: a
-Claude reviewer approving a Claude coder's claim yields self-verified, not
-verified, when ``cross_vendor_required`` is on. A verification filed by the
-claim's own author (same harness, user and session, or the same person) never
-counts as independent, whatever the lineage rule says.
+Independence is a different identity, not a different vendor. A verification
+filed by the claim's own author (same harness, user and session, or the same
+person) never counts as independent, whatever the ledger's policy says. A ledger
+that wants the stronger rule sets ``cross_vendor_required`` (off by default since
+0.2.2): then a same-vendor verifier yields self-verified and only a person or
+another vendor's agent reaches verified. Either way the audit reports which
+lineage verified what, so a single-vendor fleet sees its own mix.
 """
 from __future__ import annotations
 
@@ -56,6 +61,17 @@ def lineage_differs(a: dict, b: dict) -> bool:
     return (a.get("vendor") or "unknown") != (b.get("vendor") or "unknown")
 
 
+def same_identity(a: dict, b: dict) -> bool:
+    """True when two author blocks are the same identity: same kind, harness and user.
+
+    The session is not part of it. A session is a label the client declares (a header on
+    the served path, a fresh id per initialize on the tool-server path), so an identity
+    that verified its own claim from a second session is still the claim's own author;
+    were the session counted, a coder could reach `verified` alone (review of PR #57).
+    """
+    return (a.get("kind"), a.get("harness"), a.get("user")) == (b.get("kind"), b.get("harness"), b.get("user"))
+
+
 def same_author(a: dict, b: dict) -> bool:
     """True when two author blocks are the same identity: same kind, harness and user,
     and the same session whenever both sessions are known."""
@@ -227,7 +243,7 @@ def assess(ledger, config: Optional[dict] = None, now: Optional[str] = None,
     Tiers are never changed by a statistic: the boundary moves, the rules do not.
     """
     config = config or ledger.config
-    cross_required = bool(config.get("cross_vendor_required", True))
+    cross_required = bool(config.get("cross_vendor_required", False))
     # a number config.json proposes and this code adds to a timestamp: read it through the
     # one accessor that bounds it and names the file when it is malformed (review PE-11)
     from .ledger import stale_after_days as _stale_after_days  # local: ledger imports trust's callers
@@ -279,21 +295,24 @@ def assess(ledger, config: Optional[dict] = None, now: Optional[str] = None,
             info["verdict"] = "verified"
             verifiers = [v for v in verifications if _body(v).get("verdict") == "verified"]
             info["verified_by"] = sorted({f"{v['author'].get('harness')}:{v['author'].get('vendor')}" for v in verifiers})
-            # a claim's own author never counts as an independent check of it
-            independent = any(lineage_differs(author, v["author"]) and not same_author(author, v["author"])
-                              for v in verifiers)
-            own_author_only = bool(verifiers) and all(same_author(author, v["author"]) for v in verifiers)
-            info["cross_vendor"] = independent
+            # a claim's own identity never counts as an independent check of it, from any
+            # session and whatever the policy says; the policy decides whether another
+            # identity of the same vendor does
+            others = [v for v in verifiers if not same_identity(author, v["author"])]
+            cross_vendor = any(lineage_differs(author, v["author"]) for v in others)
+            own_author_only = bool(verifiers) and not others
+            independent = cross_vendor or (bool(others) and not cross_required)
+            info["cross_vendor"] = cross_vendor
             info["self_verified_by_author"] = own_author_only
-            info["tier"] = "verified" if (independent or not cross_required) else "self-verified"
+            info["tier"] = "verified" if independent else "self-verified"
             if own_author_only:
                 info["reasons"].append("verified by the claim's own author")
+            elif cross_vendor:
+                info["reasons"].append("independently verified (another lineage)")
             elif independent:
-                info["reasons"].append("independently verified")
-            elif not cross_required:
-                info["reasons"].append("verified (cross-vendor rule off)")
+                info["reasons"].append("independently verified (another agent of the same vendor)")
             else:
-                info["reasons"].append("verified only by the same vendor lineage as the author")
+                info["reasons"].append("verified only by the same vendor lineage as the author; this ledger requires another vendor or a person")
         elif body.get("type") == "constraint" and author.get("kind") == "human":
             info["tier"] = "constraint"
             info["reasons"].append("human-filed constraint")

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "strata-agent-memory"
-version = "0.2.1"
+version = "0.2.2"
 description = "Portable, auditable, cross-vendor memory for LLM agents: evidence-bound claims, trust tiers, and compiled context views."
 readme = "README.md"
 requires-python = ">=3.10"

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2/strata_agent_memory.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strata-agent-memory
-Version: 0.2.1
+Version: 0.2.2
 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
@@ -45,9 +45,13 @@ service, no dependencies, Python 3.10+.
   commit/file hash. The claim is rejected otherwise. A receipt is the
   filer's record; the proof is the re-run, which `verify` and the nightly
   lane perform, and the audit lists what nobody has re-run.
-- **Same-vendor review is not verification.** A Claude reviewer approving a
-  Claude coder yields `self-verified`. Only a human or a different vendor
-  lineage (Codex, Gemini, a local Qwen) promotes a claim to `verified`.
+- **Self-review is not verification.** A claim reaches `verified` when a
+  person, or an agent that is not its author, re-runs the proof; the author's
+  own re-run stays `self-verified`. A fleet on one vendor gets the same rigor
+  as a mixed one. A ledger that wants the stronger rule sets
+  `cross_vendor_required`, and then only a person or another vendor's agent
+  (Codex, Gemini, a local Qwen) promotes; either way the audit says which
+  lineage verified what.
 - **Refuting a claim taints everything built on it.** Retractions walk the
   provenance graph; nothing is deleted; the audit prints the chain.
 - **Verifiers are isolated, workers fork.** A reviewer never sees the

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2}/tests/test_audit.py

@@ -28,7 +28,8 @@ def test_report_unrechecked_outcomes(ledger, claude_agent, file_evidence):
 
 
 def test_report_same_vendor_only(ledger, claude_agent, codex_agent):
-    """report() lists self-verified claims."""
+    """report() lists claims verified only by the author's own vendor, whatever tier the
+    ledger's policy gave them (a measure, not a tier: `verified` under the default)."""
     scope = make_scope()
 
     body = {"type": "fact", "statement": "test", "source": "test"}
@@ -50,6 +51,7 @@ def test_report_same_vendor_only(ledger, claude_agent, codex_agent):
 
     assert len(rep["same_vendor_only"]) == 1
     assert rep["same_vendor_only"][0]["id"] == claim["id"]
+    assert rep["same_vendor_only"][0]["tier"] == "verified"
 
 
 def test_report_taint_chains(ledger, claude_agent):

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2}/tests/test_ledger.py

@@ -782,11 +782,13 @@ def test_a_cloned_config_does_not_choose_what_this_machine_runs(tmp_path, claude
     assert marker.exists()                            # trusted: the lane re-runs it
 
 
-def test_a_cloned_config_cannot_switch_off_the_cross_vendor_rule(tmp_path, claude_agent,
-                                                                 machine_home, capsys):
-    """F-6: one line in a committed file turned same-vendor review into `verified` for
-    everyone who cloned, and the audit section written to catch that reported zero."""
-    clone = _cloned_repo(tmp_path, {"cross_vendor_required": False})
+def test_a_cloned_config_cannot_switch_the_cross_vendor_rule(tmp_path, claude_agent,
+                                                             machine_home, capsys):
+    """F-6: one line in a committed file changed what `verified` meant for everyone who
+    cloned. The policy key is a proposal until the repository is trusted: with the
+    stronger rule committed, an untrusted clone still applies the default (off) and a
+    same-vendor verifier reaches `verified`; trusting the clone makes it `self-verified`."""
+    clone = _cloned_repo(tmp_path, {"cross_vendor_required": True})
     ledger = Ledger.open(clone)
     claim = ledger.append(new_record("claim", claude_agent, make_scope(),
                                      {"type": "fact", "statement": "the toolchain bootstrap succeeded",
@@ -797,8 +799,8 @@ def test_a_cloned_config_cannot_switch_off_the_cross_vendor_rule(tmp_path, claud
                               "results": [{"outcome": "match"}]}))
 
     info = assess(ledger)[claim["id"]]
-    assert info["tier"] == "self-verified"
-    assert "verified only by the same vendor lineage as the author" in info["reasons"]
+    assert info["tier"] == "verified"          # the committed `true` is a proposal: default applies
+    assert "another agent of the same vendor" in " ".join(info["reasons"])
     rep = audit_report(ledger)
     assert rep["trusted"] is False
     assert [r["id"] for r in rep["same_vendor_only"]] == [claim["id"]]
@@ -806,7 +808,7 @@ def test_a_cloned_config_cannot_switch_off_the_cross_vendor_rule(tmp_path, claud
 
     ledger_mod.trust_repo(clone)
     trusted = Ledger.open(clone)
-    assert assess(trusted)[claim["id"]]["tier"] == "verified"
+    assert assess(trusted)[claim["id"]]["tier"] == "self-verified"   # now the stronger rule holds
     assert audit_report(trusted)["trusted"] is True
 
 

{strata_agent_memory-0.2.1 → strata_agent_memory-0.2.2}/tests/test_trust.py

@@ -37,8 +37,9 @@ def test_asserted_claim_tier_asserted(ledger, claude_agent):
     assert assessment[rec["id"]]["tier"] == "asserted"
 
 
-def test_verification_by_same_vendor_self_verified(ledger, claude_agent, codex_agent):
-    """Verification by same vendor yields 'self-verified'."""
+def test_verification_by_another_agent_of_the_same_vendor_is_verified_by_default(ledger, claude_agent, codex_agent):
+    """Independence is a different identity, not a different vendor (the operator's
+    decision, 2026-09-24): by default another agent of the author's own vendor verifies."""
     scope = make_scope()
 
     # Create claim by Claude
@@ -59,7 +60,44 @@ def test_verification_by_same_vendor_self_verified(ledger, claude_agent, codex_a
     ledger.append(ver_rec)
 
     assessment = assess(ledger)
-    assert assessment[claim["id"]]["tier"] == "self-verified"
+    assert assessment[claim["id"]]["tier"] == "verified"
+    assert assessment[claim["id"]]["cross_vendor"] is False
+    assert "another agent of the same vendor" in " ".join(assessment[claim["id"]]["reasons"])
+    # the stronger policy, per ledger: only a person or another vendor reaches verified
+    strict = assess(ledger, config={"cross_vendor_required": True})
+    assert strict[claim["id"]]["tier"] == "self-verified"
+    assert "requires another vendor or a person" in " ".join(strict[claim["id"]]["reasons"])
+
+
+def test_the_same_identity_from_another_session_is_still_the_own_author(ledger, claude_agent):
+    """A session is client-declared; a coder re-launched, or a second header value, is the
+    same identity and never an independent verifier (review of PR #57, 2026-09-24)."""
+    scope = make_scope()
+    claim = ledger.append(new_record("claim", claude_agent, scope,
+                                     {"type": "fact", "statement": "test", "source": "test"}))
+    second_session = dict(claude_agent, session="a-second-visit")
+    ledger.append(new_record("verification", second_session, scope,
+                             {"claim": claim["id"], "verdict": "verified", "method": "rerun",
+                              "results": [{"outcome": "match"}]}))
+    for config in ({"cross_vendor_required": False}, {"cross_vendor_required": True}):
+        info = assess(ledger, config=config)[claim["id"]]
+        assert info["tier"] == "self-verified", config
+        assert info["self_verified_by_author"] is True
+
+
+def test_the_claims_own_author_never_verifies_it_whatever_the_policy(ledger, claude_agent):
+    """With the rule off the own author's re-run used to reach `verified`; it never does."""
+    scope = make_scope()
+    claim = ledger.append(new_record("claim", claude_agent, scope,
+                                     {"type": "fact", "statement": "test", "source": "test"}))
+    ledger.append(new_record("verification", claude_agent, scope,
+                             {"claim": claim["id"], "verdict": "verified", "method": "rerun",
+                              "results": [{"outcome": "match"}]}))
+    for config in ({"cross_vendor_required": False}, {"cross_vendor_required": True}, None):
+        info = assess(ledger, config=config)[claim["id"]]
+        assert info["tier"] == "self-verified", config
+        assert info["self_verified_by_author"] is True
+        assert "own author" in " ".join(info["reasons"])
 
 
 def test_verification_by_different_vendor_verified(ledger, claude_agent, codex_agent):