Python
fix(memhub): repair visibility dirty trigger conflicts (#77)
feitianxiang67ae43f92076
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex d9e5102..816967e 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -14,6 +14,10 @@ Hy Memory and MemHub are versioned and released independently.## Unreleased+- Fixed governed-memory revisions and repeated evidence links failing when the+ visibility dirty-marker trigger encounters the same memory twice. Startup+ now replaces the affected legacy trigger without changing schema versions+ or governed and visibility data.- Serialized each SDK SQLite store's shared connection lifecycle so concurrenthistory/cache operations cannot race with `close()` and crash the process.- Clarified that `add(metadata=...)` carries legacy SDK processing options,diff --git a/memhub/apps/core/src/one_memory/memory_visibility.py b/memhub/apps/core/src/one_memory/memory_visibility.pyindex 1769b5c..bb3bfb4 100644--- a/memhub/apps/core/src/one_memory/memory_visibility.py+++ b/memhub/apps/core/src/one_memory/memory_visibility.py@@ -200,10 +200,12 @@ def _trigger_sql() -> list[tuple[str, str]]:CREATE TRIGGER IF NOT EXISTS memory_visibility_dirty_on_link_updateAFTER UPDATE ON governed_memory_evidenceBEGIN- INSERT OR IGNORE INTO memory_visibility_dirty (memory_id)- VALUES (NEW.memory_id);- INSERT OR IGNORE INTO memory_visibility_dirty (memory_id)- VALUES (OLD.memory_id);+ INSERT INTO memory_visibility_dirty (memory_id)+ VALUES (NEW.memory_id)+ ON CONFLICT(memory_id) DO NOTHING;+ INSERT INTO memory_visibility_dirty (memory_id)+ VALUES (OLD.memory_id)+ ON CONFLICT(memory_id) DO NOTHING;END;""",),(@@ -294,6 +296,10 @@ def install_triggers(db: sqlite3.Connection) -> None:str(row["name"])for row in cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")}+ # CREATE TRIGGER IF NOT EXISTS cannot repair the legacy definition. Replace+ # this derived-cache trigger transactionally on every startup so old+ # libraries get the row-level conflict handling without a schema migration.+ cursor.execute("DROP TRIGGER IF EXISTS memory_visibility_dirty_on_link_update")for table, statement in _trigger_sql():if table not in present:continue@@ -303,11 +309,15 @@ def install_triggers(db: sqlite3.Connection) -> None:def startup(database_path: Path) -> None:"""Idempotent: create the derived tables and triggers. No version change.- Runs through the write connection because the triggers are schema. It is- one short transaction and happens once per start.+ Runs through the write connection because the triggers are schema. The+ trigger replacement is one short transaction and happens once per start."""- with main_database(database_path).write() as db:+ with main_database(database_path).write() as db, db:ensure_tables(db)+ # ensure_tables uses executescript(), which commits any pending legacy+ # transaction. Begin only afterward so replacing the installed trigger+ # is one atomic schema change and a failed CREATE restores the old one.+ db.execute("BEGIN IMMEDIATE")install_triggers(db)diff --git a/memhub/apps/core/tests/test_memory_visibility.py b/memhub/apps/core/tests/test_memory_visibility.pyindex c649dce..9a7028f 100644--- a/memhub/apps/core/tests/test_memory_visibility.py+++ b/memhub/apps/core/tests/test_memory_visibility.py@@ -8,7 +8,14 @@ import pytestfrom one_memory.imports.grants import GRANT_SCHEMAfrom one_memory.imports.models import EvidenceInput, EvidenceOrigin, OriginMetadata, WrittenByfrom one_memory.imports.storage import EvidenceStore-from one_memory.memory_governance import MemoryDraft, MemoryGovernanceStore, MemoryKind+from one_memory.memory_governance import (+ HyCreate,+ HyLink,+ HyRevise,+ MemoryDraft,+ MemoryGovernanceStore,+ MemoryKind,+)from one_memory.memory_tasks import (MemoryTaskOutput,MemoryTaskStore,@@ -19,6 +26,7 @@ from one_memory.memory_visibility import (install_triggers,pending,recompute,+ startup,)from one_memory.model_profiles import (ModelCapabilities,@@ -336,6 +344,197 @@ def test_starting_the_app_creates_the_derived_tables(tmp_path):asyncio.run(scenario())[email protected]("visibility_mode", ["exact", "derived"])+def test_hy_revise_and_repeated_link_reuse_the_same_evidence(library, monkeypatch, visibility_mode):+ """The outer evidence UPSERT must not override the trigger's duplicate handling."""+ database, evidence, _tasks, governance, _profile = library+ monkeypatch.setenv("ONE_MEMORY_READ_VISIBILITY", visibility_mode)+ startup(database)+ record = evidence.put(+ EvidenceInput(+ source_id="cursor",+ conversation_id="trigger-regression",+ message_id="trigger-regression",+ correlation_id="trigger-regression",+ role="user",+ written_by=WrittenBy.PERSON,+ verbatim="用户住在杭州。",+ origin_meta={EvidenceOrigin.FILE: OriginMetadata()},+ )+ ).record+ created = governance.write_from_hy(+ HyCreate(+ draft=MemoryDraft(+ user_id="local",+ kind=MemoryKind.CHAT,+ content="用户住在杭州。",+ scopes=("all-apps",),+ evidence_ids=(record.evidence_id,),+ ),+ request_id="trigger-create",+ memory_id="trigger-memory",+ ),+ user_id="local",+ derivation=governance.hy_derivation((record.evidence_id,)),+ )+ revision = HyRevise(+ memory_id=created.memory_id,+ request_id="trigger-revise",+ expected_revision=created.revision,+ content="用户住在杭州并在那里工作。",+ evidence_ids=(record.evidence_id,),+ )+ revised = governance.write_from_hy(+ revision,+ user_id="local",+ derivation=governance.hy_derivation((record.evidence_id,)),+ )+ replayed = governance.write_from_hy(+ revision,+ user_id="local",+ derivation=governance.hy_derivation((record.evidence_id,)),+ )+ assert replayed == revised+ link = HyLink(memory_id=created.memory_id, evidence_id=record.evidence_id)+ for _ in range(2):+ governance.write_from_hy(+ link,+ user_id="local",+ derivation=governance.hy_derivation((record.evidence_id,)),+ )++ current = governance.get(created.memory_id, user_id="local")+ assert current is not None+ assert current.content == "用户住在杭州并在那里工作。"+ assert current.revision == created.revision + 1+ with main_database_read(database) as db:+ assert db.execute(+ "SELECT memory_id, COUNT(*) FROM memory_visibility_dirty GROUP BY memory_id"+ ).fetchall() == [(created.memory_id, 1)]++ if visibility_mode == "derived":+ monkeypatch.setenv("ONE_MEMORY_READ_VISIBILITY", "exact")+ exact = {memory.memory_id for memory in SourceReadAccess(database).filter([current])}+ with main_database_write(database) as db:+ assert recompute(db, [created.memory_id], readable_sql=_MEMORY_READABLE) == 1+ db.commit()+ monkeypatch.setenv("ONE_MEMORY_READ_VISIBILITY", "derived")+ derived = {memory.memory_id for memory in SourceReadAccess(database).filter([current])}+ assert derived == exact+ with main_database_read(database) as db:+ assert created.memory_id not in pending(db)+++def test_startup_atomically_replaces_the_legacy_link_update_trigger(tmp_path, monkeypatch):+ import one_memory.memory_visibility as visibility_module+ from one_memory.schema_gate import guard_schema_version++ database = tmp_path / "one-memory.sqlite3"+ expected_version = guard_schema_version(database)+ evidence = EvidenceStore(database)+ governance = MemoryGovernanceStore(database)+ record = evidence.put(+ EvidenceInput(+ source_id="cursor",+ conversation_id="legacy-trigger",+ message_id="legacy-trigger",+ correlation_id="legacy-trigger",+ role="user",+ written_by=WrittenBy.PERSON,+ verbatim="升级失败不能改变这条原文。",+ origin_meta={EvidenceOrigin.FILE: OriginMetadata()},+ )+ ).record+ memory = as_person(governance).create(+ MemoryDraft(+ user_id="local",+ kind=MemoryKind.CHAT,+ content="升级失败不能改变这条记忆。",+ scopes=("all-apps",),+ evidence_ids=(record.evidence_id,),+ ),+ request_id="legacy-trigger-memory",+ )+ startup(database)+ with sqlite3.connect(database) as db:+ db.execute("DROP TRIGGER memory_visibility_dirty_on_link_update")+ db.executescript(+ """+ CREATE TRIGGER memory_visibility_dirty_on_link_update+ AFTER UPDATE ON governed_memory_evidence+ BEGIN+ INSERT OR IGNORE INTO memory_visibility_dirty (memory_id)+ VALUES (NEW.memory_id);+ INSERT OR IGNORE INTO memory_visibility_dirty (memory_id)+ VALUES (OLD.memory_id);+ END;+ """+ )+ db.execute(+ "INSERT INTO memory_visibility (memory_id, visible, reason, computed_at) "+ "VALUES (?, 1, 'ok', '2026-10-19T00:00:00+00:00')",+ (memory.memory_id,),+ )+ db.execute(+ "INSERT INTO memory_visibility_dirty (memory_id) VALUES (?)",+ (memory.memory_id,),+ )+ legacy_trigger = db.execute(+ "SELECT sql FROM sqlite_master "+ "WHERE type='trigger' AND name='memory_visibility_dirty_on_link_update'"+ ).fetchone()[0]+ before = tuple(db.iterdump())++ real_trigger_sql = visibility_module._trigger_sql++ def fail_after_drop() -> list[tuple[str, str]]:+ statements = real_trigger_sql()+ return [+ (table, "CREATE TRIGGER")+ if "CREATE TRIGGER IF NOT EXISTS memory_visibility_dirty_on_link_update" in statement+ else (table, statement)+ for table, statement in statements+ ]++ with monkeypatch.context() as failure:+ failure.setattr(visibility_module, "_trigger_sql", fail_after_drop)+ with pytest.raises(sqlite3.OperationalError):+ startup(database)++ with sqlite3.connect(database) as db:+ assert tuple(db.iterdump()) == before+ assert (+ db.execute(+ "SELECT sql FROM sqlite_master "+ "WHERE type='trigger' AND name='memory_visibility_dirty_on_link_update'"+ ).fetchone()[0]+ == legacy_trigger+ )+ assert db.execute("SELECT MAX(version) FROM schema_migrations").fetchone()[0] == (+ expected_version+ )++ startup(database)+ startup(database)++ with sqlite3.connect(database) as db:+ trigger_sql = db.execute(+ "SELECT sql FROM sqlite_master "+ "WHERE type='trigger' AND name='memory_visibility_dirty_on_link_update'"+ ).fetchone()[0]+ assert trigger_sql.count("ON CONFLICT(memory_id) DO NOTHING") == 2+ assert "INSERT OR IGNORE" not in trigger_sql+ assert db.execute("SELECT MAX(version) FROM schema_migrations").fetchone()[0] == (+ expected_version+ )+ assert db.execute("SELECT * FROM memory_visibility").fetchall() == [+ (memory.memory_id, 1, "ok", "2026-10-19T00:00:00+00:00")+ ]+ assert db.execute("SELECT * FROM memory_visibility_dirty").fetchall() == [+ (memory.memory_id,)+ ]++def test_the_audit_notices_a_conclusion_that_no_longer_holds(library):"""The ongoing proof: recompute a slice and compare with what is stored.