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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strata-agent-memory
-Version: 0.2.3
+Version: 0.2.4
 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
@@ -201,6 +201,7 @@ tests/             pytest suite; tests/sit/phase3/ is the CLI-driven system test
 - [docs/RESEARCH-SYNTHESIS.md](docs/RESEARCH-SYNTHESIS.md): the nine sources, what was taken from each, and what none of them had.
 - [docs/INTEGRATION.md](docs/INTEGRATION.md): setup per harness, the local verifier lane, the contract loop.
 - [docs/COMMS-BUS-PLAN.md](docs/COMMS-BUS-PLAN.md): how agents talk through the ledger without spending tokens while they wait, and [docs/RUNBOOK-RELAY.md](docs/RUNBOOK-RELAY.md) to run a relay per agent.
+- [docs/HARNESS-MATRIX.md](docs/HARNESS-MATRIX.md): the M3 harness reach matrix: MCP, hooks, wake paths, compile injection and relay fitness for every harness surface, from vendor documentation (nothing run).
 - [docs/LANDSCAPE.md](docs/LANDSCAPE.md): the competing systems, their verified licenses, the standards receipts align with, and what none of them do.
 - [docs/UAT-PLAN.md](docs/UAT-PLAN.md): the one-week acceptance test across Claude Code, Codex, Antigravity and Grok.
 - [docs/UAT-SELF.md](docs/UAT-SELF.md): the same test for one person with two subscriptions, Claude Code and Codex CLI, with `scripts/uat/` to set it up and to run the cross-lineage verification.

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

@@ -177,6 +177,7 @@ tests/             pytest suite; tests/sit/phase3/ is the CLI-driven system test
 - [docs/RESEARCH-SYNTHESIS.md](docs/RESEARCH-SYNTHESIS.md): the nine sources, what was taken from each, and what none of them had.
 - [docs/INTEGRATION.md](docs/INTEGRATION.md): setup per harness, the local verifier lane, the contract loop.
 - [docs/COMMS-BUS-PLAN.md](docs/COMMS-BUS-PLAN.md): how agents talk through the ledger without spending tokens while they wait, and [docs/RUNBOOK-RELAY.md](docs/RUNBOOK-RELAY.md) to run a relay per agent.
+- [docs/HARNESS-MATRIX.md](docs/HARNESS-MATRIX.md): the M3 harness reach matrix: MCP, hooks, wake paths, compile injection and relay fitness for every harness surface, from vendor documentation (nothing run).
 - [docs/LANDSCAPE.md](docs/LANDSCAPE.md): the competing systems, their verified licenses, the standards receipts align with, and what none of them do.
 - [docs/UAT-PLAN.md](docs/UAT-PLAN.md): the one-week acceptance test across Claude Code, Codex, Antigravity and Grok.
 - [docs/UAT-SELF.md](docs/UAT-SELF.md): the same test for one person with two subscriptions, Claude Code and Codex CLI, with `scripts/uat/` to set it up and to run the cross-lineage verification.

{strata_agent_memory-0.2.3 → strata_agent_memory-0.2.4}/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.3"
+__version__ = "0.2.4"

{strata_agent_memory-0.2.3 → strata_agent_memory-0.2.4}/agent_memory/approvals.py

@@ -37,6 +37,7 @@ import re
 from typing import Iterable, List, Optional
 
 from . import contracts
+from .relay.core import agent_name
 from .records import ValidationError, new_record, scope_for_target, sort_key
 
 GATE_KINDS = ("close", "retraction", "reopen", "reject", "constraint", "needs-human")
@@ -80,6 +81,17 @@ def _who(author: dict) -> str:
     return f"{author.get('harness') or author.get('kind') or '?'}/{author.get('user') or '?'}"
 
 
+def _on_thread(ledger, thread: str, author: dict) -> bool:
+    """Whether a note's author is on the thread its tag names: the root's author or one of
+    its addressees, as the relay that stopped the thread is."""
+    root = ledger.get(thread)
+    if not isinstance(root, dict):
+        return False
+    names = {agent_name(root.get("author") or {})}
+    names.update(t[len("to:"):] for t in _tags(root) if t.startswith("to:"))
+    return agent_name(author) in names
+
+
 def _answered(ledger) -> tuple:
     """({item id: the newest human answer's ts}, {thread: the newest human record's ts}).
 
@@ -266,12 +278,20 @@ def pending(ledger, assessment=None, reader: Optional[str] = None) -> dict:
         if "needs-human" in tags:  # an alarm in either mode: auto removes approvals, not alarms
             thread = next((t[len("thread:"):] for t in tags if t.startswith("thread:")), None)
             if thread and released.get(thread, "") <= (note.get("ts") or ""):
+                # a relay's note on a stop something released before the note was due (a
+                # contract update, section 11) is news for a person, and waits on nobody --
+                # when the relay that stopped is the one saying so: any token can file a note,
+                # and one tagged released by a stranger to the thread is still a stop
+                gone = "released" in tags and _on_thread(ledger, thread, note.get("author") or {})
                 items.append(_item(ledger, "needs-human", note["id"], (note.get("body") or {}).get("contract"),
                                    f"thread {thread}", _short(note["body"].get("statement")),
                                    f"evidence: the last message on it is {', '.join(note.get('derived_from') or []) or '?'}",
                                    {"verdict": None, "id": None, "line": "review: none (a breaker, not work)"},
-                                   {"id": None, "line": "risk: the thread stays stopped until a person answers on it"},
-                                   "approve", gate=True, thread=thread))
+                                   {"id": None, "line": ("risk: none -- the thread was released before this note, "
+                                                         "and what it held goes to the agent with the release")
+                                    if gone else
+                                    "risk: the thread stays stopped until a person answers on it"},
+                                   "approve", gate=not gone, thread=thread))
             continue
         kind = next((t[len("approval:"):] for t in tags if t.startswith("approval:")), None)
         if kind not in kinds:

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

@@ -28,8 +28,10 @@ from typing import Dict, List, Optional
 
 from . import evidence as ev
 from . import reliability as rel
+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 .trust import TIERS, assess, lineage_differs, summarize
 
@@ -118,6 +120,74 @@ def _capped(items: List[dict]) -> dict:
     return {"total": len(items), "items": newest[:_SECTION_CAP]}
 
 
+# a line break, or any other control character, in a field a record carries: the report is
+# read by people and, through memory_audit, by models, and one row must stay one row
+_BREAKS = re.compile(r"[\x00-\x1f\x7f-\x9f\u2028\u2029]+")
+
+
+def _one_line(text: str) -> str:
+    """A report row flattened to one line: a harness or a user is whatever the filing
+    process said it was, and a newline in one would forge a heading in the report."""
+    return _BREAKS.sub(" ", str(text))
+
+
+ROSTER_OUTSIDERS = ("people and the ci lineage are on no agent roster by design and are not listed; a "
+                    "person's or ci's record stays what it is (docs/PM-BRIEF.md step 4)")
+
+
+def _roster_sections(ledger, rep: Dict, by_id: Dict[str, dict], reader_user: Optional[str]) -> None:
+    """The three questions the roster answers for a corpus (docs/PROTOCOL.md section 12):
+    who filed without being on it, who filed after being retired from it, and who
+    verified a claim of a project whose roster they are not on.
+
+    None of them moves a tier or refuses anything: each is the question to ask before the
+    lineage sections above are read as facts. A ledger with no roster answers none of
+    them, and says so rather than listing everybody.
+    """
+    config = ledger.config
+    roster = roster_mod.entries(config)
+    on_roster = roster_mod.by_user(config)
+    has_roster = bool(roster)
+    # every lookup the loop makes, built once: per record they would rebuild the roster, and
+    # an audit is records x roster that way
+    retired = {roster_mod.user_key(e.get("user")): e["retired"] for e in roster.values()
+               if isinstance(e, dict) and e.get("retired")}
+    project_users: Dict[str, set] = {}
+    for e in roster.values():
+        for project in (e.get("projects") or []) if isinstance(e, dict) else ():
+            project_users.setdefault(project, set()).add(roster_mod.user_key(e.get("user")))
+    has_projects = bool(project_users)
+    off, late, outside = [], [], []
+    for rec in ledger.all() if has_roster else ():
+        if rec["kind"] not in _IDENTITY_KINDS or not _reader_sees(ledger, rec, by_id, reader_user):
+            continue
+        a = rec["author"]
+        if a.get("kind") == "human" or a.get("harness") == "ci":
+            continue
+        row = {"id": rec["id"], "kind": rec["kind"], "user": a.get("user"), "harness": a.get("harness"),
+               "ts": rec["ts"]}
+        key = roster_mod.user_key(a.get("user"))
+        if key not in on_roster:
+            off.append(row)
+        elif key in retired and rec["ts"][:10] > retired[key]:  # after the retired date, not on it
+            late.append(dict(row, retired=retired[key]))
+        if rec["kind"] == "verification":  # an off-roster verifier is outside the project's roster too
+            claim = ledger.get((rec.get("body") or {}).get("claim"))
+            project = ((claim or {}).get("scope") or {}).get("project")
+            users = project_users.get(project)  # None: the roster says nothing about this project
+            if claim is not None and users is not None and key not in users:
+                outside.append(dict(row, claim=claim["id"], project=project,
+                                    verdict=(rec.get("body") or {}).get("verdict")))
+    rep["records_off_roster"] = _capped(off)
+    rep["records_after_retirement"] = _capped(late)
+    rep["verifications_outside_project_roster"] = _capped(outside)
+    for key in ("records_off_roster", "records_after_retirement", "verifications_outside_project_roster"):
+        if not has_roster:
+            rep[key]["no_roster"] = True
+    if has_roster and not has_projects:
+        rep["verifications_outside_project_roster"]["no_projects"] = True
+
+
 def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Optional[float] = 300,
            path_map=None, reader_user: Optional[str] = None) -> dict:
     """The audit, for one reader. ``reader_user`` is who is asking: a user-scoped claim is
@@ -165,6 +235,10 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         "signatures": {},
         "unsigned_by_registered_signers": {},
         "verifications_by_unregistered_identities": {},
+        "roster_problems": list(getattr(ledger, "roster_problems", None) or []),
+        "records_off_roster": {},
+        "records_after_retirement": {},
+        "verifications_outside_project_roster": {},
         "recheck": [],
     }
     # measured history, computed from the ledger alone: counts, intervals, and the word
@@ -173,6 +247,12 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
     rep["reliability"] = measured["table"]
     rep["same_lineage_agreement"] = measured["same_lineage_agreement"]
     rep["staleness"] = measured["staleness"]
+    # roadmap 8.5.1: a project whose pinned sections are over config.compile_pinned_chars:
+    # the board shows every reader fewer contracts than are open, and the constraints, never
+    # cut, make the view longer than the cap. The audit names both, so a person consolidates
+    # the constraints, closes work, or raises the cap
+    from .compiler import pinned_over_cap  # local: the compiler imports the trust layer too
+    rep["pinned_over_cap"] = pinned_over_cap(ledger, assessment, reader_user)
     rep["judgment_calibration"] = measured["judgment_calibration"]
     for c in claims:
         a = c["author"]
@@ -337,6 +417,7 @@ def report(ledger, recheck: bool = False, cwd: Optional[str] = None, timeout: Op
         # a ledger that never registered a key is not a ledger where everybody is
         # unregistered: there is no registry to be outside of
         rep["verifications_by_unregistered_identities"]["no_registry"] = True
+    _roster_sections(ledger, rep, by_id, reader_user)
     if recheck:
         for c in claims:
             info = assessment[c["id"]]
@@ -367,9 +448,8 @@ def format_report(rep: dict) -> str:
     lines.append(f"labels:  unsigned by a registered signer={unsigned.get('total', 0)}, "
                  f"verifications by an unregistered identity={unregistered.get('total', 0)}")
     if not rep.get("trusted", True):
-        lines.append("repo:    UNTRUSTED -- config.json's policy keys (recheck_allow, "
-                     "recheck_allow_shell, redact, path_map, org_path, signers, vendor_map, "
-                     "cross_vendor_required, stale_after_days, reliability, max_clock_skew_seconds) "
+        lines.append("repo:    UNTRUSTED -- config.json's policy keys "
+                     f"({', '.join(sorted(UNTRUSTED_POLICY))}) "
                      "were ignored; run `agent-memory trust .` to honour them")
     if not rep.get("recheck_allow_set"):
         lines.append("note: config.recheck_allow is not set: the re-check lane is held to the starter "
@@ -383,7 +463,7 @@ def format_report(rep: dict) -> str:
         lines.append("")
         lines.append(f"## {title} ({len(rows)})")
         for r in rows[:50]:
-            lines.append("- " + fmt(r))
+            lines.append("- " + _one_line(fmt(r)))
         if len(rows) > 50:
             lines.append(f"- ... {len(rows) - 50} more")
 
@@ -396,7 +476,7 @@ def format_report(rep: dict) -> str:
         if note:
             lines.append(f"- {note}")
         for r in items:
-            lines.append("- " + fmt(r))
+            lines.append("- " + _one_line(fmt(r)))
         if sec.get("total", 0) > len(items):
             lines.append(f"- ... {sec['total'] - len(items)} more")
 
@@ -423,6 +503,12 @@ def format_report(rep: dict) -> str:
     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("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", []),
+            lambda r: (f"{r['project']}{' (' + r['reader'] + ')' if r.get('reader') else ''}: {r['section']} "
+                       f"takes {r['chars']} characters against a cap of {r['cap']}; "
+                       + ("kept whole in every view (constraints are never cut): consolidate them"
+                          if r.get("kept_whole") else f"left out: {', '.join(r['left_out'])}")))
     section("Contracts", rep["contracts"], lambda r: f"{r['id']} {r['status']}: {r['title']} ({r['claims']} claims {r['tiers']})")
     section("Compilation receipts", rep["compilations"],
             lambda r: f"{r['id']} {r['ts']} {r['role']}/{r['mode']} for {r['reader']}: {r['included']} in, {r['excluded']} out, {r['tokens']} tok")
@@ -454,6 +540,24 @@ def format_report(rep: dict) -> str:
                      f"{r['verdict']} at {r['ts']}",
            note=("config.signers is empty: this ledger registered no key, so no identity in it "
                  "can be checked" if unregistered.get("no_registry") else None))
+    section("Roster entries set aside (fix them in config.json)", rep.get("roster_problems") or [], str)
+    no_roster = ("config.agents is empty: this ledger has no roster, so no identity in it is on or off one "
+                 "(docs/PROTOCOL.md section 12)")
+    off = rep.get("records_off_roster") or {}
+    capped("Records by identities not on the roster", off,
+           lambda r: f"{r['id']} [{r['kind']}] {r['user']} via {r['harness']} at {r['ts']}",
+           note=no_roster if off.get("no_roster") else ROSTER_OUTSIDERS)
+    late = rep.get("records_after_retirement") or {}
+    capped("Records filed after their author retired", late,
+           lambda r: f"{r['id']} [{r['kind']}] {r['user']} (retired {r['retired']}) at {r['ts']}",
+           note=no_roster if late.get("no_roster") else None)
+    outside = rep.get("verifications_outside_project_roster") or {}
+    capped("Verifications by an identity outside the claim's project roster", outside,
+           lambda r: f"{r['id']} over {r['claim']} (project {r['project']}) [{r['user']} via {r['harness']}] "
+                     f"{r['verdict']} at {r['ts']}",
+           note=(no_roster if outside.get("no_roster") else
+                 "no roster entry names a project, so no verification is outside one"
+                 if outside.get("no_projects") else ROSTER_OUTSIDERS))
     lines.append("")
     lines.append(f"## Verifier lineage (refutation rates) ({len(rep['lineage_matrix'])})")
     for key, cell in sorted(rep["lineage_matrix"].items()):
@@ -476,4 +580,6 @@ def format_report(rep: dict) -> str:
                 lambda r: f"{r['claim']} {r['evidence']}: {r['outcome']} -- {r['detail']}"
                           + (" [environment binding: staleness, not refutation]" if r.get("role") == "environment" else "")
                           + (f" [{r['note']}]" if r.get("note") else ""))
-    return "\n".join(lines) + "\n"
+    # every line the report prints stays one line, whatever a record carried into it (the
+    # authors line, a harness, a user): one flatten here covers every section, old and new
+    return "\n".join(_one_line(line) for line in lines) + "\n"