activegraph 1.5.0__tar.gz → 1.6.0__tar.gz

{activegraph-1.5.0/activegraph.egg-info → activegraph-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activegraph
-Version: 1.5.0
+Version: 1.6.0
 Summary: An event-sourced reactive graph runtime for long-running, auditable, agentic systems.
 Author: Active Graph contributors
 License-Expression: Apache-2.0

{activegraph-1.5.0 → activegraph-1.6.0}/activegraph/__init__.py

@@ -242,4 +242,4 @@ __all__ = [
     "tool",
 ]
 
-__version__ = "1.5.0"
+__version__ = "1.6.0"

{activegraph-1.5.0 → activegraph-1.6.0}/activegraph/packs/loader.py

@@ -27,6 +27,9 @@ from __future__ import annotations
 import copy
 import inspect
 import json
+import logging
+import sys
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Optional
 
 from pydantic import BaseModel, ValidationError
@@ -309,9 +312,114 @@ def load_pack_into_runtime(
             timestamp=rt.graph.clock.now(),
         )
     )
+
+    # ---- 6. manifest warning tier (CONTRACT v1.6 #1) ----------------------
+    _warn_on_manifest_violations(pack)
     return True
 
 
+# --------------------------------------------- manifest warning tier
+# CONTRACT v1.6 #1: when a manifest.toml is discoverable next to the
+# pack's defining modules, load_pack runs load_manifest +
+# verify_surface and WARNs on violations — structured, once per pack
+# per process, never an error before 2.0. Absent manifest: silent.
+# Hash verification (content/bundle) stays host/CI territory: the
+# loader never re-hashes a pack directory on the hot path.
+
+_manifest_log = logging.getLogger("activegraph.packs.manifest")
+
+# (pack name, pack version, manifest path) triples already validated
+# this process — clean or not, the tier runs once per pack.
+_manifest_checked: set[tuple[str, str, str]] = set()
+
+
+def _locate_pack_manifest(pack: Pack) -> Optional[Path]:
+    """Best-effort pack-root discovery: resolve the modules that define
+    the pack's components and walk up (while still inside the package)
+    looking for a sibling ``manifest.toml``. Returns None when the
+    pack has no discoverable manifest — which is not a violation.
+    """
+    components: list[Any] = [getattr(b, "fn", None) for b in pack.behaviors]
+    components += [getattr(t, "fn", None) for t in pack.tools]
+    if pack.settings_schema is not EmptySettings:
+        components.append(pack.settings_schema)
+    components += [ot.schema for ot in pack.object_types]
+
+    seen_modules: set[str] = set()
+    for comp in components:
+        mod_name = getattr(comp, "__module__", None)
+        if not mod_name or mod_name == "__main__" or mod_name in seen_modules:
+            continue
+        seen_modules.add(mod_name)
+        mod_file = getattr(sys.modules.get(mod_name), "__file__", None)
+        if not mod_file:
+            continue
+        directory = Path(mod_file).resolve().parent
+        while True:
+            candidate = directory / "manifest.toml"
+            if candidate.is_file():
+                return candidate
+            # Stop once we step outside the package: the manifest
+            # lives at the pack root, and the pack root is a package.
+            if not (directory / "__init__.py").is_file():
+                break
+            if directory.parent == directory:
+                break
+            directory = directory.parent
+    return None
+
+
+def _warn_on_manifest_violations(pack: Pack) -> None:
+    """The warning tier itself. Never raises: a broken manifest (or a
+    bug in discovery) must not break ``load_pack`` before 2.0.
+    """
+    try:
+        manifest_path = _locate_pack_manifest(pack)
+        if manifest_path is None:
+            return  # no manifest: silent, per the Q2 schedule
+        key = (pack.name, pack.version, str(manifest_path))
+        if key in _manifest_checked:
+            return
+        _manifest_checked.add(key)
+        from activegraph.packs.manifest import (
+            PackManifestError,
+            load_manifest,
+            verify_surface,
+        )
+
+        try:
+            manifest = load_manifest(manifest_path)
+            verify_surface(manifest, pack)
+        except PackManifestError as err:
+            _manifest_log.warning(
+                "pack %s@%s: manifest.toml found at %s but validation "
+                "failed with %d violation(s). The pack still loads — "
+                "this stays a warning until activegraph 2.0. First "
+                "violation: %s",
+                pack.name,
+                pack.version,
+                manifest_path,
+                len(err.violations),
+                err.violations[0] if err.violations else "",
+                extra={
+                    "pack": pack.name,
+                    "pack_version": pack.version,
+                    "manifest_path": str(manifest_path),
+                    "violations": list(err.violations),
+                    "reason": "pack.manifest_invalid",
+                },
+            )
+    except Exception:
+        # The tier is advisory; discovery/IO surprises are debug noise,
+        # not load failures.
+        _manifest_log.debug(
+            "manifest warning tier errored for pack %s@%s",
+            pack.name,
+            pack.version,
+            exc_info=True,
+        )
+
+
 # ---------------------------------------------------------------- state
 
 

{activegraph-1.5.0 → activegraph-1.6.0/activegraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activegraph
-Version: 1.5.0
+Version: 1.6.0
 Summary: An event-sourced reactive graph runtime for long-running, auditable, agentic systems.
 Author: Active Graph contributors
 License-Expression: Apache-2.0

{activegraph-1.5.0 → activegraph-1.6.0}/activegraph.egg-info/SOURCES.txt

@@ -147,6 +147,7 @@ tests/test_llm_trace_snapshot.py
 tests/test_llm_types.py
 tests/test_llm_wire.py
 tests/test_llms_txt.py
+tests/test_manifest_warning_tier.py
 tests/test_migration.py
 tests/test_observability_logging.py
 tests/test_observability_metrics.py

{activegraph-1.5.0 → activegraph-1.6.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "activegraph"
-version = "1.5.0"
+version = "1.6.0"
 description = "An event-sourced reactive graph runtime for long-running, auditable, agentic systems."
 readme = "README.md"
 requires-python = ">=3.11"

activegraph-1.6.0/tests/test_manifest_warning_tier.py

@@ -0,0 +1,171 @@
+"""Loader-side manifest validation, warning tier (CONTRACT v1.6 #1).
+
+When a ``manifest.toml`` sits at the pack root, ``load_pack`` runs
+``load_manifest`` + ``verify_surface`` and WARNs on violations —
+structured, once per pack per process, never an error before 2.0.
+Absent manifest: silent. All offline and deterministic.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import logging
+import sys
+
+import pytest
+
+from activegraph import Graph, Runtime
+from activegraph.packs import loader as pack_loader
+from activegraph.packs.manifest import compute_content_hash
+
+PACK_INIT_TEMPLATE = '''
+from activegraph.packs import Pack, behavior
+
+
+@behavior(name="greeter", on=["goal.created"])
+def greeter(event, graph, ctx):
+    graph.add_object("greeting", {{"text": "hi"}})
+
+
+pack = Pack(name="{name}", version="0.1.0", behaviors=(greeter,))
+'''
+
+MANIFEST_TEMPLATE = """
+[pack]
+name = "{name}"
+version = "0.1.0"
+description = "Warning-tier fixture."
+license = ""
+
+[pack.provenance]
+authored_by = "agent"
+generator = "test"
+
+[pack.integrity]
+content_hash = "{content_hash}"
+
+[dependencies]
+activegraph = ">=1.5,<2.0"
+python-deps = []
+
+[surface]
+object_types = []
+relation_types = []
+behaviors = [{behaviors}]
+tools = []
+settings_schema = ""
+
+[fixtures]
+entrypoint = "fixtures/run_fixtures.py"
+deterministic = true
+"""
+
+
+@pytest.fixture(autouse=True)
+def _fresh_tier():
+    """Each test exercises the tier from scratch: the once-per-process
+    dedupe set is process state, so tests reset it explicitly."""
+    pack_loader._manifest_checked.clear()
+    yield
+    pack_loader._manifest_checked.clear()
+
+
+def _make_pack(tmp_path, name, *, declared_behaviors='"greeter"',
+               manifest=True, manifest_text=None):
+    """Write a real pack package to disk, import it so its module has
+    a resolvable ``__file__``, and return the live Pack."""
+    root = tmp_path / name
+    root.mkdir()
+    (root / "__init__.py").write_text(PACK_INIT_TEMPLATE.format(name=name))
+    if manifest:
+        if manifest_text is None:
+            manifest_text = MANIFEST_TEMPLATE.format(
+                name=name,
+                content_hash=compute_content_hash(root),
+                behaviors=declared_behaviors,
+            )
+        (root / "manifest.toml").write_text(manifest_text)
+    spec = importlib.util.spec_from_file_location(
+        name, root / "__init__.py", submodule_search_locations=[str(root)]
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    try:
+        spec.loader.exec_module(module)
+    except BaseException:
+        del sys.modules[name]
+        raise
+    return module.pack
+
+
+def _tier_records(caplog):
+    return [
+        r
+        for r in caplog.records
+        if r.name == "activegraph.packs.manifest"
+        and r.levelno >= logging.WARNING
+    ]
+
+
+def test_matching_manifest_loads_silently(tmp_path, caplog):
+    pack = _make_pack(tmp_path, "warn_tier_clean")
+    with caplog.at_level(logging.WARNING, logger="activegraph.packs.manifest"):
+        rt = Runtime(Graph(), behaviors=[])
+        assert rt.load_pack(pack) is True
+    assert _tier_records(caplog) == []
+
+
+def test_absent_manifest_stays_silent(tmp_path, caplog):
+    pack = _make_pack(tmp_path, "warn_tier_bare", manifest=False)
+    with caplog.at_level(logging.WARNING, logger="activegraph.packs.manifest"):
+        rt = Runtime(Graph(), behaviors=[])
+        assert rt.load_pack(pack) is True
+    assert _tier_records(caplog) == []
+
+
+def test_surface_mismatch_warns_once_structured_and_still_loads(
+    tmp_path, caplog
+):
+    # The manifest declares a behavior the Pack never registers: a
+    # real violation. The pack STILL loads — warning tier only.
+    pack = _make_pack(
+        tmp_path, "warn_tier_drift", declared_behaviors='"greeter", "ghost"'
+    )
+    with caplog.at_level(logging.WARNING, logger="activegraph.packs.manifest"):
+        rt = Runtime(Graph(), behaviors=[])
+        assert rt.load_pack(pack) is True
+        # Loaded despite the violation: the behavior dispatches.
+        rt.run_goal("check")
+        assert [
+            o for o in rt.graph.all_objects() if o.type == "greeting"
+        ]
+        # A second runtime loading the same pack does not re-warn:
+        # once per pack per process.
+        rt2 = Runtime(Graph(), behaviors=[])
+        assert rt2.load_pack(pack) is True
+
+    records = _tier_records(caplog)
+    assert len(records) == 1
+    (record,) = records
+    # Structured: the record carries the machine-readable fields.
+    assert record.pack == "warn_tier_drift"
+    assert record.pack_version == "0.1.0"
+    assert record.reason == "pack.manifest_invalid"
+    assert record.manifest_path.endswith("manifest.toml")
+    assert any("ghost" in v for v in record.violations)
+    # And the human line says the pack still loads.
+    assert "still loads" in record.getMessage()
+
+
+def test_malformed_manifest_warns_never_raises(tmp_path, caplog):
+    pack = _make_pack(
+        tmp_path,
+        "warn_tier_garbage",
+        manifest_text="this is not toml [[[",
+    )
+    with caplog.at_level(logging.WARNING, logger="activegraph.packs.manifest"):
+        rt = Runtime(Graph(), behaviors=[])
+        assert rt.load_pack(pack) is True  # never an error before 2.0
+    records = _tier_records(caplog)
+    assert len(records) == 1
+    assert records[0].violations  # the parse failure, verbatim

{activegraph-1.5.0 → activegraph-1.6.0}/tests/test_promote.py

@@ -819,3 +819,64 @@ def test_promote_of_unknown_types_passes_untyped(tmp_path):
     n = fork.graph.add_object("freeform", {"anything": ["goes", 1]})
     parent.promote(fork)
     assert parent.graph.get_object(n.id).data == {"anything": ["goes", 1]}
+
+
+# --------------------------- fork-tail removals are ordinary events
+# The downstream residue policy (evolution pack): before promoting, a
+# fork removes every fork-created object/relation it scaffolded so
+# those entities read base-None/fork-None and vanish from the delta,
+# while patches to shared state still promote. Promote must never
+# special-case fork-tail removals — they are ordinary events
+# (CONTRACT v1.3 #4 addendum 4d). This test is the pin.
+
+
+def test_residue_policy_fork_tail_removal_of_fork_created_entities(tmp_path):
+    parent = _parent(tmp_path)
+    task = _task_id(parent)
+    fork = _fork_at_tip(parent)
+
+    # The fork does real work on shared state...
+    fork.graph.patch_object(task, {"status": "done"})
+
+    # ...and scaffolds trial residue: two fork-created objects, a
+    # relation between them, and a relation into shared state.
+    a = fork.graph.add_object("scaffold", {"n": 1})
+    b = fork.graph.add_object("scaffold", {"n": 2})
+    rel_ab = fork.graph.add_relation(a.id, b.id, "supports")
+    rel_task = fork.graph.add_relation(task, a.id, "tried")
+
+    # Fork tail: remove the residue with ordinary events — one
+    # explicit relation removal, then object removals whose cascade
+    # sweeps the relation into shared state.
+    fork.graph.remove_relation(rel_ab.id)
+    fork.graph.remove_object(a.id)  # cascade removes rel_task too
+    fork.graph.remove_object(b.id)
+    assert fork.graph.get_relation(rel_task.id) is None
+
+    # The residue reads base-None/fork-None: not part of the delta.
+    plan = parent.promote(fork, dry_run=True)
+    assert plan.is_promotable
+    assert plan.object_creates == []
+    assert plan.relation_creates == []
+    assert plan.object_removes == []
+    assert plan.relation_removes == []
+    # The shared-state patch is the WHOLE delta, and it survives.
+    assert [o["id"] for o in plan.object_patches] == [task]
+
+    result = parent.promote(fork)
+    assert parent.graph.get_object(task).data["status"] == "done"
+    for residue_id in (a.id, b.id):
+        assert parent.graph.get_object(residue_id) is None
+    for residue_rel in (rel_ab.id, rel_task.id):
+        assert parent.graph.get_relation(residue_rel) is None
+    # And no removal events were manufactured for entities the parent
+    # never had: the promote block carries only the task patch.
+    marker = next(
+        e for e in parent.trace.events() if e.type == "promote.applied"
+    )
+    assert marker.payload["objects_patched"] == [task]
+    assert marker.payload["objects_created"] == []
+    assert marker.payload["objects_removed"] == []
+    assert marker.payload["relations_created"] == []
+    assert marker.payload["relations_removed"] == []
+    assert result.plan.is_promotable

{activegraph-1.5.0 → activegraph-1.6.0}/tests/test_sandbox_trial.py

@@ -258,3 +258,110 @@ pack = Pack(
     assert report.outcome == "materialization_failed"
     assert "undeclared" in report.detail
     _parent_untouched(path, parent_run, n_parent)
+
+
+REPLAY_PACK_INIT = '''
+from activegraph.packs import Pack, behavior
+
+
+@behavior(name="responder", on=["chat.message"])
+def responder(event, graph, ctx):
+    graph.add_object(
+        "reply", {"to": event.payload.get("text", ""), "text": "ack"}
+    )
+
+
+pack = Pack(name="trial_candidate", version="0.1.0", behaviors=(responder,))
+'''
+
+REPLAY_MANIFEST = MANIFEST_TEMPLATE.replace(
+    'behaviors = ["greeter"]', 'behaviors = ["responder"]'
+)
+
+REPLAY_SCENARIO = '''
+from activegraph.core.event import Event
+
+
+def main(rt):
+    # The recorded input segment IS the fork's history: read it back
+    # and re-inject each input as a fresh event so the candidate's
+    # behaviors process it live inside the trial.
+    segment = [e for e in rt.trace.events() if e.type == "chat.message"]
+    for recorded in segment:
+        rt.graph.emit(
+            Event(
+                id=rt.graph.ids.event(),
+                type="chat.message",
+                payload=dict(recorded.payload),
+                actor="trial.replay",
+                frame_id=None,
+                caused_by=None,
+                timestamp=rt.graph.clock.now(),
+            )
+        )
+    rt.run_until_idle()
+'''
+
+
+def test_recorded_segment_replay_inside_the_trial(tmp_path):
+    # THE consumer use case (evolution stage 3): fork a run, replay a
+    # recorded input segment against the fork inside the child, read
+    # failures + counts from the fork's run in the store afterward.
+    from activegraph.core.event import Event
+
+    clear_registry()
+    rt = Runtime(Graph())
+    # The parent's recorded inputs: three chat messages, no subscriber
+    # in the parent (they are raw recorded history).
+    for text in ("hello", "what's on today?", "thanks"):
+        rt.graph.emit(
+            Event(
+                id=rt.graph.ids.event(),
+                type="chat.message",
+                payload={"text": text},
+                actor="user",
+                frame_id=None,
+                caused_by=None,
+                timestamp=rt.graph.clock.now(),
+            )
+        )
+    rt.run_until_idle()
+    path = str(tmp_path / "run.db")
+    rt.save_state(path)
+    parent_run, tip, n_parent = (
+        rt.run_id,
+        rt.trace.events()[-1].id,
+        len(rt.graph.events),
+    )
+    del rt
+
+    root = tmp_path / "trial_candidate"
+    root.mkdir()
+    (root / "__init__.py").write_text(REPLAY_PACK_INIT)
+    (root / "scenario.py").write_text(REPLAY_SCENARIO)
+    content = compute_content_hash(root)
+    (root / "manifest.toml").write_text(
+        REPLAY_MANIFEST.format(content_hash=content)
+    )
+
+    report = run_forked_trial(
+        path,
+        parent_run_id=parent_run,
+        at_event=tip,
+        pack_source=PackSource(
+            root_dir=str(root),
+            expected_bundle_hash=compute_bundle_hash(root),
+        ),
+        scenario="scenario.py",
+    )
+    assert report.outcome == "completed", report.detail
+    assert report.behavior_failures == 0
+
+    # The candidate processed exactly the recorded segment, in order,
+    # inside the fork — and the evidence is ordinary fork history.
+    fork = Runtime.load(path, run_id=report.fork_run_id, behaviors=[])
+    replies = [
+        o.data["to"] for o in fork.graph.all_objects() if o.type == "reply"
+    ]
+    assert replies == ["hello", "what's on today?", "thanks"]
+    _parent_untouched(path, parent_run, n_parent)