AbstractMemory 0.3.0__tar.gz → 0.3.2__tar.gz

abstractmemory-0.3.2/.gitignore

@@ -0,0 +1,31 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+.DS_Store
+.venv/
+dist/
+build/
+.mypy_cache/
+.ruff_cache/
+untracked/
+.cursor/
+
+# ---------------------------------------------------------------------------
+# Agent harness and local tooling
+#
+# This repository is worked on with coding agents, and their configuration
+# embeds absolute local paths, hook commands, seat identities and empty API-key
+# slots. A `.claude/settings.json` in particular defines hooks that execute in
+# any contributor's session on clone. None of it belongs in a public repository,
+# and it was tracked once — this block is what stops that recurring.
+# ---------------------------------------------------------------------------
+.claude/
+.codex/
+.cursor/
+.agora/
+.abstractcode/
+.mcp.json
+CLAUDE.md
+untracked/
+.venv/
+AGENTS.md

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/CHANGELOG.md

@@ -9,6 +9,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 *No unreleased changes.*
 
+## [0.3.2] - 2026-10-20
+
+### Added
+
+- **A third closure kind, `reinterpreted`**, for an assertion whose reading was
+  superseded by a re-interpretation of its source: the writer no longer reads
+  that source this way (for example, AbstractNote understanding a note again
+  against an earlier foundation withdraws its previous reading). It is neither
+  `retract` (the fact was wrong) nor `supersede` (a later fact replaced it).
+  `ClosureRecord`, `close_assertions` and `close_record` accept it;
+  `replacement_ids` is optional (the new reading's assertions, when there are
+  any); like the other kinds, a `reinterpreted` closure takes the assertion out
+  of ranked retrieval while it stays in the store and in history. The accepted
+  kinds are listed in `abstractmemory.journal.CLOSURE_KINDS`.
+  Additive: existing callers and stored journals are unaffected.
+
+## [0.3.1] - 2026-10-19
+
+### Added
+
+- **`close_assertion(assertion_id, valid_until)`** on `SQLiteTripleStore` and
+  `InMemoryTripleStore`: closes an assertion's open validity window in place
+  (only while `valid_until` is still empty; terms, provenance, attributes,
+  keyword index and vector are untouched) and returns whether a row changed
+  (`False` for an unknown id or a window that is already closed). A writer
+  that supersedes a fact can make `TripleQuery(active_at=...)` agree with its
+  own belief window, where a layer-2 closure record only reaches ranked
+  retrieval. Existing callers are unaffected; `add` stays append-only and
+  `LanceDBTripleStore` keeps the protocol surface (`add`, `query`, `close`).
+  Contributed by the AbstractNote lane.
+
 ## [0.3.0] - 2026-08-06
 
 The first release with **layer 2**: a `MemorySystem` facade that composes the

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: AbstractMemory
-Version: 0.3.0
+Version: 0.3.2
 Summary: AbstractMemory: temporal, provenance-aware semantic memory primitives for AbstractFramework.
 Project-URL: AbstractFramework (monorepo), https://github.com/lpalbou/abstractframework
 Author: Laurent-Philippe Albou
@@ -164,7 +164,7 @@ system.commit_selection(result.trace_id, [h.record_id for h in result.handles[:2
 
 ## Design principles
 
-- **Append-only, no deletion**: updates are new assertions; belief revision is closure records (retract/supersede); forgetting is decay of retrieval strength plus closures and silencing — the substrate is lossless.
+- **Append-only, no deletion**: updates are new assertions; belief revision is closure records (retract/supersede/reinterpreted); forgetting is decay of retrieval strength plus closures and silencing — the substrate is lossless.
 - **Reads are pure**: reconstruction, inspection, replay, and the entity card deposit nothing. `commit_selection` is the only strengthening path.
 - **One seq axis**: the journal assigns a monotonic `seq` to every record; any past state is reproducible by anchoring reads at `as_of`.
 - **Works-or-loud**: degraded paths are labeled `#FALLBACK` in result warnings; invalid inputs raise actionable errors instead of silently meaning something else.

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/README.md

@@ -128,7 +128,7 @@ system.commit_selection(result.trace_id, [h.record_id for h in result.handles[:2
 
 ## Design principles
 
-- **Append-only, no deletion**: updates are new assertions; belief revision is closure records (retract/supersede); forgetting is decay of retrieval strength plus closures and silencing — the substrate is lossless.
+- **Append-only, no deletion**: updates are new assertions; belief revision is closure records (retract/supersede/reinterpreted); forgetting is decay of retrieval strength plus closures and silencing — the substrate is lossless.
 - **Reads are pure**: reconstruction, inspection, replay, and the entity card deposit nothing. `commit_selection` is the only strengthening path.
 - **One seq axis**: the journal assigns a monotonic `seq` to every record; any past state is reproducible by anchoring reads at `as_of`.
 - **Works-or-loud**: degraded paths are labeled `#FALLBACK` in result warnings; invalid inputs raise actionable errors instead of silently meaning something else.

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/docs/api.md

@@ -64,6 +64,8 @@ Vector results carry retrieval metadata in `attributes["_retrieval"]` (`score`,
 
 `add(assertions) -> list[str]` (returns assertion ids), `query(q) -> list[TripleAssertion]`, `close()`.
 
+`InMemoryTripleStore` and `SQLiteTripleStore` also expose `close_assertion(assertion_id, valid_until) -> bool`: the one in-place change the stores allow. It sets `valid_until` on an assertion whose window is still open and touches nothing else (terms, provenance, attributes, the keyword index and the stored vector stay as written). It returns `True` when a row changed and `False` for an unknown id or a window that is already closed, so a replay is harmless; an empty `assertion_id` or `valid_until` raises `ValueError`. Use it when a later fact supersedes an earlier one and `TripleQuery(active_at=...)` must stop returning the old row from that moment on. The layer-2 `close_assertions` (below) is a different operation: it appends a closure record and leaves the row's window as written.
+
 - `InMemoryTripleStore(embedder=None)` — dependency-free, volatile, vector-capable.
 - `SQLiteTripleStore(path, embedder=None)` — persistent single file (stdlib only), structured queries and native vector search. With an embedder, `add(...)` embeds each assertion's canonical text and persists the vector in the same file; files created before the vector column existed upgrade in place on open. Rows added without an embedder stay vectorless (vector queries skip them; layer-2 recall labels the degradation `#FALLBACK`).
 - `LanceDBTripleStore(uri, embedder=None, ...)` — persistent, vector-capable; requires the optional `lancedb` dependency (constructing without it raises `ImportError` with an install hint).
@@ -133,7 +135,7 @@ Record families (all append-only, all `seq`-stamped by the journal):
 
 - `MemoryEvent` — attention events. Scoring kinds: `selected`, `co_selected` (pair trails), `pinned`, `silenced`; decay marker: `refocus`; audit-only (recorded, never scored): `listed`, `shown`, `expanded`, `cited`.
 - `ScopeBinding` — visibility: `search_state` (`indexed`/`hidden`), `prompt_state` (`active`/`inactive`), `lifecycle`, `source`, `reason`. Latest per `(record_id, scope, owner_id)` wins; `fold_bindings(bindings)` applies that fold.
-- `ClosureRecord` — belief lifecycle: `kind` (`retract`/`supersede`), mandatory `reason`, `replacement_ids` (required for supersede).
+- `ClosureRecord` — belief lifecycle: `kind` (`retract`/`supersede`/`reinterpreted`), mandatory `reason`, `replacement_ids` (required for supersede, optional otherwise). `reinterpreted` means the writer no longer reads its source this way (a note understood again): neither a correction nor a later fact; it leaves ranked retrieval like the others.
 - `ReconstructionTrace` — one recall: fingerprint, searched scopes, candidates, selected/dropped, cues, budgets, admission labels, warnings.
 - `ActiveMemorySnapshot` — see seam types.
 - `ValenceEvent` — signed appraisals and standing markers (see valence below).
@@ -184,7 +186,7 @@ Diary formation rules: `kind="diary"` requires `provenance.source` ∈ {`diary-p
 ### Bindings and closures
 
 - `bind(record_id, *, scope, owner_id, search_state, prompt_state="inactive", lifecycle="none", source="operator", reason=None, binding_id=None) -> ScopeBinding` — append a visibility event. A folded `hidden` binding removes the record from ranked retrieval in that scope pair only; re-binding `indexed` restores it. `prompt_state="active"` admits the record into the identity (self) component. Record-level bindings hide the digest and its edge assertions together. Direct `store.query` id lookups bypass folds by design.
-- `close_assertions(assertion_ids, *, kind, replacement_ids=(), reason) -> list[str]` — append one closure per assertion (`retract` | `supersede`).
+- `close_assertions(assertion_ids, *, kind, replacement_ids=(), reason) -> list[str]` — append one closure per assertion (`retract` | `supersede` | `reinterpreted`).
 - `close_record(record_id, *, reason, kind="retract", replacement_ids=()) -> list[str]` — close a whole record (digest and its edges) as one belief-revision act; closure ids are deterministic, so replays dedupe.
 
 ### Identity: spark, engram, self core, floors

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/docs/architecture.md

@@ -62,7 +62,7 @@ The same discipline extends to every derived read: inspection (`activation`, `ac
 There is no delete surface anywhere in the package:
 
 - Updates are new assertions with fresh provenance.
-- Belief revision is a `ClosureRecord` (`retract` or `supersede` with replacements) — the old record leaves ranked retrieval but remains in the store and in history.
+- Belief revision is a `ClosureRecord` (`retract`, `supersede` with replacements, or `reinterpreted` when the writer reads the source differently) — the old record leaves ranked retrieval but remains in the store and in history.
 - Visibility is a `ScopeBinding` fold (latest per record/scope/owner wins): `hidden` removes a record from ranked retrieval in that scope pair only; re-binding `indexed` restores it.
 - Forgetting is decay of retrieval strength plus closures and silencing. Storage never decays; only the temporal-access signal does. The global access count (`selected_count`) never decays at all.
 

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/docs/faq.md

@@ -38,8 +38,8 @@ Canonicalization (trim + lowercase) is part of the matching contract: it prevent
 
 There is no update or delete API, by design:
 
-- At layer 1, represent changes by adding a new assertion with fresh provenance.
-- At layer 2, belief revision is a closure record (`close_record` / `close_assertions`: retract or supersede with replacements) — the old record leaves ranked retrieval but stays in the store and in history. Visibility can also be withdrawn per scope with a `hidden` binding and restored with `indexed`.
+- At layer 1, represent changes by adding a new assertion with fresh provenance. When the new assertion supersedes an earlier one, `close_assertion(assertion_id, valid_until)` (in-memory and SQLite stores) closes the earlier validity window in place, so `TripleQuery(active_at=...)` stops returning it from that moment; nothing else about the row changes.
+- At layer 2, belief revision is a closure record (`close_record` / `close_assertions`: retract, supersede with replacements, or reinterpreted when the source is read differently) — the old record leaves ranked retrieval but stays in the store and in history. Visibility can also be withdrawn per scope with a `hidden` binding and restored with `indexed`.
 - Forgetting is decay of retrieval strength plus closures and silencing. The substrate is lossless; there is no compaction.
 
 ## What do `scope` and `owner_id` mean?

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/docs/stores.md

@@ -128,6 +128,7 @@ Canonicalization:
 
 Append-only:
 - There is no update/delete API. Represent changes by adding a new `TripleAssertion` with updated fields and fresh provenance.
+- The one in-place change: `InMemoryTripleStore` and `SQLiteTripleStore` offer `close_assertion(assertion_id, valid_until)`, which sets `valid_until` on an assertion whose window is still open (`True` when a row changed; `False` for an unknown id or an already closed window). Every other column, the keyword index and the stored vector stay as written. `LanceDBTripleStore` does not offer it.
 
 Timestamps are strings:
 - All stores compare `observed_at` / `valid_*` as strings.

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/docs/troubleshooting.md

@@ -70,7 +70,7 @@ explain_recall(store, journal, record_id, trace_id=trace_id)
 recall_history(journal, record_id)
 ```
 
-`absence_diagnosis` reports structural reasons in plain sentences (never formed, retracted, hidden, out of scope, vectorless). `explain_recall` answers the same question against one specific recall. Common structural causes: the record is in a scope the ladder does not include; a closure retracted or superseded it; it is an inactive candidate; or it was formed after the `as_of` seq you anchored to.
+`absence_diagnosis` reports structural reasons in plain sentences (never formed, retracted, hidden, out of scope, vectorless). `explain_recall` answers the same question against one specific recall. Common structural causes: the record is in a scope the ladder does not include; a closure retracted, superseded or reinterpreted it; it is an inactive candidate; or it was formed after the `as_of` seq you anchored to.
 
 ### Recall results change between runs with the same input
 

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/llms-full.txt

@@ -154,7 +154,7 @@ system.commit_selection(result.trace_id, [h.record_id for h in result.handles[:2
 
 ## Design principles
 
-- **Append-only, no deletion**: updates are new assertions; belief revision is closure records (retract/supersede); forgetting is decay of retrieval strength plus closures and silencing — the substrate is lossless.
+- **Append-only, no deletion**: updates are new assertions; belief revision is closure records (retract/supersede/reinterpreted); forgetting is decay of retrieval strength plus closures and silencing — the substrate is lossless.
 - **Reads are pure**: reconstruction, inspection, replay, and the entity card deposit nothing. `commit_selection` is the only strengthening path.
 - **One seq axis**: the journal assigns a monotonic `seq` to every record; any past state is reproducible by anchoring reads at `as_of`.
 - **Works-or-loud**: degraded paths are labeled `#FALLBACK` in result warnings; invalid inputs raise actionable errors instead of silently meaning something else.
@@ -389,7 +389,7 @@ The same discipline extends to every derived read: inspection (`activation`, `ac
 There is no delete surface anywhere in the package:
 
 - Updates are new assertions with fresh provenance.
-- Belief revision is a `ClosureRecord` (`retract` or `supersede` with replacements) — the old record leaves ranked retrieval but remains in the store and in history.
+- Belief revision is a `ClosureRecord` (`retract`, `supersede` with replacements, or `reinterpreted` when the writer reads the source differently) — the old record leaves ranked retrieval but remains in the store and in history.
 - Visibility is a `ScopeBinding` fold (latest per record/scope/owner wins): `hidden` removes a record from ranked retrieval in that scope pair only; re-binding `indexed` restores it.
 - Forgetting is decay of retrieval strength plus closures and silencing. Storage never decays; only the temporal-access signal does. The global access count (`selected_count`) never decays at all.
 
@@ -593,6 +593,8 @@ Vector results carry retrieval metadata in `attributes["_retrieval"]` (`score`,
 
 `add(assertions) -> list[str]` (returns assertion ids), `query(q) -> list[TripleAssertion]`, `close()`.
 
+`InMemoryTripleStore` and `SQLiteTripleStore` also expose `close_assertion(assertion_id, valid_until) -> bool`: the one in-place change the stores allow. It sets `valid_until` on an assertion whose window is still open and touches nothing else (terms, provenance, attributes, the keyword index and the stored vector stay as written). It returns `True` when a row changed and `False` for an unknown id or a window that is already closed, so a replay is harmless; an empty `assertion_id` or `valid_until` raises `ValueError`. Use it when a later fact supersedes an earlier one and `TripleQuery(active_at=...)` must stop returning the old row from that moment on. The layer-2 `close_assertions` (below) is a different operation: it appends a closure record and leaves the row's window as written.
+
 - `InMemoryTripleStore(embedder=None)` — dependency-free, volatile, vector-capable.
 - `SQLiteTripleStore(path, embedder=None)` — persistent single file (stdlib only), structured queries and native vector search. With an embedder, `add(...)` embeds each assertion's canonical text and persists the vector in the same file; files created before the vector column existed upgrade in place on open. Rows added without an embedder stay vectorless (vector queries skip them; layer-2 recall labels the degradation `#FALLBACK`).
 - `LanceDBTripleStore(uri, embedder=None, ...)` — persistent, vector-capable; requires the optional `lancedb` dependency (constructing without it raises `ImportError` with an install hint).
@@ -662,7 +664,7 @@ Record families (all append-only, all `seq`-stamped by the journal):
 
 - `MemoryEvent` — attention events. Scoring kinds: `selected`, `co_selected` (pair trails), `pinned`, `silenced`; decay marker: `refocus`; audit-only (recorded, never scored): `listed`, `shown`, `expanded`, `cited`.
 - `ScopeBinding` — visibility: `search_state` (`indexed`/`hidden`), `prompt_state` (`active`/`inactive`), `lifecycle`, `source`, `reason`. Latest per `(record_id, scope, owner_id)` wins; `fold_bindings(bindings)` applies that fold.
-- `ClosureRecord` — belief lifecycle: `kind` (`retract`/`supersede`), mandatory `reason`, `replacement_ids` (required for supersede).
+- `ClosureRecord` — belief lifecycle: `kind` (`retract`/`supersede`/`reinterpreted`), mandatory `reason`, `replacement_ids` (required for supersede, optional otherwise). `reinterpreted` means the writer no longer reads its source this way (a note understood again): neither a correction nor a later fact; it leaves ranked retrieval like the others.
 - `ReconstructionTrace` — one recall: fingerprint, searched scopes, candidates, selected/dropped, cues, budgets, admission labels, warnings.
 - `ActiveMemorySnapshot` — see seam types.
 - `ValenceEvent` — signed appraisals and standing markers (see valence below).
@@ -713,7 +715,7 @@ Diary formation rules: `kind="diary"` requires `provenance.source` ∈ {`diary-p
 ### Bindings and closures
 
 - `bind(record_id, *, scope, owner_id, search_state, prompt_state="inactive", lifecycle="none", source="operator", reason=None, binding_id=None) -> ScopeBinding` — append a visibility event. A folded `hidden` binding removes the record from ranked retrieval in that scope pair only; re-binding `indexed` restores it. `prompt_state="active"` admits the record into the identity (self) component. Record-level bindings hide the digest and its edge assertions together. Direct `store.query` id lookups bypass folds by design.
-- `close_assertions(assertion_ids, *, kind, replacement_ids=(), reason) -> list[str]` — append one closure per assertion (`retract` | `supersede`).
+- `close_assertions(assertion_ids, *, kind, replacement_ids=(), reason) -> list[str]` — append one closure per assertion (`retract` | `supersede` | `reinterpreted`).
 - `close_record(record_id, *, reason, kind="retract", replacement_ids=()) -> list[str]` — close a whole record (digest and its edges) as one belief-revision act; closure ids are deterministic, so replays dedupe.
 
 ### Identity: spark, engram, self core, floors
@@ -1045,6 +1047,7 @@ Canonicalization:
 
 Append-only:
 - There is no update/delete API. Represent changes by adding a new `TripleAssertion` with updated fields and fresh provenance.
+- The one in-place change: `InMemoryTripleStore` and `SQLiteTripleStore` offer `close_assertion(assertion_id, valid_until)`, which sets `valid_until` on an assertion whose window is still open (`True` when a row changed; `False` for an unknown id or an already closed window). Every other column, the keyword index and the stored vector stay as written. `LanceDBTripleStore` does not offer it.
 
 Timestamps are strings:
 - All stores compare `observed_at` / `valid_*` as strings.
@@ -1276,8 +1279,8 @@ Canonicalization (trim + lowercase) is part of the matching contract: it prevent
 
 There is no update or delete API, by design:
 
-- At layer 1, represent changes by adding a new assertion with fresh provenance.
-- At layer 2, belief revision is a closure record (`close_record` / `close_assertions`: retract or supersede with replacements) — the old record leaves ranked retrieval but stays in the store and in history. Visibility can also be withdrawn per scope with a `hidden` binding and restored with `indexed`.
+- At layer 1, represent changes by adding a new assertion with fresh provenance. When the new assertion supersedes an earlier one, `close_assertion(assertion_id, valid_until)` (in-memory and SQLite stores) closes the earlier validity window in place, so `TripleQuery(active_at=...)` stops returning it from that moment; nothing else about the row changes.
+- At layer 2, belief revision is a closure record (`close_record` / `close_assertions`: retract, supersede with replacements, or reinterpreted when the source is read differently) — the old record leaves ranked retrieval but stays in the store and in history. Visibility can also be withdrawn per scope with a `hidden` binding and restored with `indexed`.
 - Forgetting is decay of retrieval strength plus closures and silencing. The substrate is lossless; there is no compaction.
 
 ## What do `scope` and `owner_id` mean?
@@ -1410,7 +1413,7 @@ explain_recall(store, journal, record_id, trace_id=trace_id)
 recall_history(journal, record_id)
 ```
 
-`absence_diagnosis` reports structural reasons in plain sentences (never formed, retracted, hidden, out of scope, vectorless). `explain_recall` answers the same question against one specific recall. Common structural causes: the record is in a scope the ladder does not include; a closure retracted or superseded it; it is an inactive candidate; or it was formed after the `as_of` seq you anchored to.
+`absence_diagnosis` reports structural reasons in plain sentences (never formed, retracted, hidden, out of scope, vectorless). `explain_recall` answers the same question against one specific recall. Common structural causes: the record is in a scope the ladder does not include; a closure retracted, superseded or reinterpreted it; it is an inactive candidate; or it was formed after the `as_of` seq you anchored to.
 
 ### Recall results change between runs with the same input
 

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/llms.txt

@@ -6,7 +6,7 @@ Key facts for agents:
 
 - The authoritative export list is [src/abstractmemory/__init__.py](src/abstractmemory/__init__.py); [docs/api.md](docs/api.md) documents every export with verified signatures.
 - Reads are pure: `reconstruct`, inspection, replay, and `entity_card` deposit nothing; `commit_selection` is the only strengthening path.
-- Append-only, no deletion: updates are new assertions; belief revision is closure records; forgetting is decay + closures + silencing.
+- Append-only, no deletion: updates are new assertions; belief revision is closure records; forgetting is decay + closures + silencing. The one in-place change is `close_assertion` (in-memory and SQLite stores), which only closes an open validity window.
 - The journal's monotonic `seq` is the time axis: anchor reads with `as_of`/`at_seq`/`since_seq` for deterministic replay.
 - All three stores are vector-capable when constructed with an embedder; `query_text` without one raises (no keyword fallback).
 - Terms are canonicalized (trim + lowercase); timestamps compare as RFC-3339/UTC strings.

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "AbstractMemory"
-version = "0.3.0"
+version = "0.3.2"
 description = "AbstractMemory: temporal, provenance-aware semantic memory primitives for AbstractFramework."
 readme = "README.md"
 requires-python = ">=3.10"

abstractmemory-0.3.2/release-notes.md

@@ -0,0 +1,13 @@
+### Added
+
+- **A third closure kind, `reinterpreted`**, for an assertion whose reading was
+  superseded by a re-interpretation of its source: the writer no longer reads
+  that source this way (for example, AbstractNote understanding a note again
+  against an earlier foundation withdraws its previous reading). It is neither
+  `retract` (the fact was wrong) nor `supersede` (a later fact replaced it).
+  `ClosureRecord`, `close_assertions` and `close_record` accept it;
+  `replacement_ids` is optional (the new reading's assertions, when there are
+  any); like the other kinds, a `reinterpreted` closure takes the assertion out
+  of ranked retrieval while it stays in the store and in history. The accepted
+  kinds are listed in `abstractmemory.journal.CLOSURE_KINDS`.
+  Additive: existing callers and stored journals are unaffected.

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/src/abstractmemory/in_memory_store.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import threading
 import uuid
+from dataclasses import replace
 from typing import Any, Iterable, List, Optional, Sequence
 
 from .embedding_pin import (
@@ -112,6 +113,28 @@ class InMemoryTripleStore:
                 self._embedder = embedder
         return len(clean)
 
+    def close_assertion(self, assertion_id: str, valid_until: str) -> bool:
+        """Close one assertion's validity window in place (SQLite parity):
+        sets `valid_until` only while it is still open; everything else is
+        untouched. True when a row changed; False for an unknown id or an
+        already-closed window."""
+        rid = str(assertion_id or "").strip()
+        until = str(valid_until or "").strip()
+        if not rid:
+            raise ValueError("close_assertion requires an assertion_id")
+        if not until:
+            raise ValueError("close_assertion requires a valid_until timestamp")
+        with self._lock:
+            for row in self._rows:
+                if row.get("assertion_id") != rid:
+                    continue
+                a = row.get("assertion")
+                if not isinstance(a, TripleAssertion) or a.valid_until is not None:
+                    return False
+                row["assertion"] = replace(a, valid_until=until)
+                return True
+        return False
+
     def close(self) -> None:
         return None
 

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/src/abstractmemory/journal.py

@@ -221,12 +221,22 @@ class ScopeBinding:
         return _jsonify(asdict(self))
 
 
+#: The closure kinds a ClosureRecord accepts (``reinterpreted`` is additive, 0.3.2).
+CLOSURE_KINDS = frozenset({"retract", "supersede", "reinterpreted"})
+
+
 @dataclass(frozen=True)
 class ClosureRecord:
-    """Append-only belief-lifecycle record (backlog 0010): retract or supersede."""
+    """Append-only belief-lifecycle record (backlog 0010): retract, supersede or reinterpreted.
+
+    ``reinterpreted`` (additive, 0.3.2): the writer no longer reads its source this way (AbstractNote ADR 0008: a
+    note understood again against an earlier foundation withdraws its previous reading). It is neither a
+    correction of the fact (``retract``) nor a later fact replacing it (``supersede``); like both it leaves
+    ranked retrieval. ``replacement_ids`` is optional (the new reading's assertions, when there are any).
+    """
 
     assertion_id: str
-    kind: str                        # retract | supersede
+    kind: str                        # retract | supersede | reinterpreted
     reason: str
     replacement_ids: Tuple[str, ...] = ()
     observed_at: str = field(default_factory=utc_now_iso)
@@ -240,8 +250,8 @@ class ClosureRecord:
             raise ValueError("ClosureRecord requires assertion_id")
         object.__setattr__(self, "assertion_id", self.assertion_id.strip())
         kind = str(self.kind or "").strip().lower()
-        if kind not in {"retract", "supersede"}:
-            raise ValueError("ClosureRecord.kind must be 'retract' or 'supersede'")
+        if kind not in CLOSURE_KINDS:
+            raise ValueError("ClosureRecord.kind must be 'retract', 'supersede' or 'reinterpreted'")
         object.__setattr__(self, "kind", kind)
         if not (isinstance(self.reason, str) and self.reason.strip()):
             raise ValueError("ClosureRecord requires a non-empty reason")

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/src/abstractmemory/sqlite_store.py

@@ -51,7 +51,8 @@ class SQLiteTripleStore:
 
     Notes:
     - Uses stdlib `sqlite3` (portable; no daemon).
-    - Append-only: there is no update/delete API (see AbstractMemory FAQ).
+    - Append-only: there is no update/delete API (see AbstractMemory FAQ),
+      except `close_assertion`, which only closes an open validity window.
     - VECTORS (a2a 0003, the entity-home pairing): pass `embedder=` and each
       added assertion's canonical text is embedded and persisted in the SAME
       .sqlite3 file (JSON-encoded `embedding` column; in-place ALTER TABLE
@@ -526,6 +527,39 @@ class SQLiteTripleStore:
             rows = self._conn.cursor().execute(sql, params).fetchall()
         return [self._row_to_assertion(r) for r in rows]
 
+    def close_assertion(self, assertion_id: str, valid_until: str) -> bool:
+        """Close one assertion's validity window IN PLACE (additive, backlog:
+        abstractnote supersession). Sets `valid_until` only while it is still
+        open (NULL); every other column — terms, provenance, attributes, the
+        FTS row, the vector — is untouched, so the store stays append-only
+        for content. Returns True when a row changed, False when the id is
+        unknown or the window was already closed (idempotent replays).
+
+        Why: a later fact superseding an earlier one must make
+        `TripleQuery(active_at=...)` agree with the writer's belief window;
+        journal closures alone only reach ranked retrieval, never `query`."""
+        rid = str(assertion_id or "").strip()
+        until = str(valid_until or "").strip()
+        if not rid:
+            raise ValueError("close_assertion requires an assertion_id")
+        if not until:
+            raise ValueError("close_assertion requires a valid_until timestamp")
+        with self._lock:
+            cur = self._conn.cursor()
+            cur.execute("BEGIN IMMEDIATE")
+            try:
+                cur.execute(
+                    f"UPDATE {self._table} SET valid_until = ? "
+                    "WHERE assertion_id = ? AND valid_until IS NULL",
+                    (until, rid),
+                )
+                changed = int(cur.rowcount or 0) > 0
+                cur.execute("COMMIT")
+            except BaseException:
+                cur.execute("ROLLBACK")
+                raise
+        return changed
+
     def replace_vectors(
         self, vectors: dict, pin: dict, *,
         expected_row_count: int, embedder: Optional[TextEmbedder] = None,

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/src/abstractmemory/system.py

@@ -853,7 +853,8 @@ class MemorySystem(ValenceOps, AccessOps):
         replacement_ids: Sequence[str] = (),
         reason: str,
     ) -> List[str]:
-        """Append one ClosureRecord per assertion (retract | supersede);
+        """Append one ClosureRecord per assertion (retract | supersede |
+        reinterpreted);
         returns closure ids. Supersede requires replacement_ids; reason is
         mandatory — validated by ClosureRecord BEFORE any append. A multi-
         assertion supersede shares one replacement set. Accepts either id

abstractmemory-0.3.2/tests/test_close_assertion.py

@@ -0,0 +1,88 @@
+"""close_assertion: the one in-place change both triple stores allow.
+
+It closes an open validity window and nothing else, so TripleQuery(active_at=...)
+agrees with a writer that superseded a fact (AbstractNote supersession)."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from abstractmemory import InMemoryTripleStore, SQLiteTripleStore, TripleAssertion, TripleQuery
+
+
+def _stores(tmp_path: Path):
+    return [InMemoryTripleStore(), SQLiteTripleStore(tmp_path / "kg.sqlite3")]
+
+
+def _fact(aid: str, obj: str, valid_from: str, **kw) -> TripleAssertion:
+    return TripleAssertion(
+        subject="ex:person-dana", predicate="schema:worksFor", object=obj, scope="global",
+        owner_id="abstractnote", observed_at=valid_from, valid_from=valid_from,
+        assertion_id=aid, provenance={"note_id": "nt_x"}, attributes={"certainty": "stated"}, **kw,
+    )
+
+
+@pytest.mark.parametrize("which", [0, 1])
+def test_close_assertion_closes_open_window_only(tmp_path: Path, which: int) -> None:
+    store = _stores(tmp_path)[which]
+    store.add([_fact("cl_1", "ex:org-acme", "2026-01-01T00:00:00+00:00"),
+               _fact("cl_2", "ex:org-beta", "2026-06-01T00:00:00+00:00")])
+
+    before = store.query(TripleQuery(active_at="2026-07-01T00:00:00+00:00", owner_id="abstractnote"))
+    assert {a.assertion_id for a in before} == {"cl_1", "cl_2"}
+
+    assert store.close_assertion("cl_1", "2026-06-01T00:00:00+00:00") is True
+    # Already closed: no change, the first window stands.
+    assert store.close_assertion("cl_1", "2027-01-01T00:00:00+00:00") is False
+    assert store.close_assertion("cl_missing", "2027-01-01T00:00:00+00:00") is False
+
+    after = store.query(TripleQuery(active_at="2026-07-01T00:00:00+00:00", owner_id="abstractnote"))
+    assert {a.assertion_id for a in after} == {"cl_2"}
+    earlier = store.query(TripleQuery(active_at="2026-03-01T00:00:00+00:00", owner_id="abstractnote"))
+    assert {a.assertion_id for a in earlier} == {"cl_1"}
+
+    [closed] = store.query(TripleQuery(assertion_ids=("cl_1",)))
+    assert closed.valid_until == "2026-06-01T00:00:00+00:00"
+    # Everything else is untouched.
+    assert closed.object == "ex:org-acme"
+    assert closed.provenance == {"note_id": "nt_x"}
+    assert closed.attributes.get("certainty") == "stated"
+    assert closed.valid_from == "2026-01-01T00:00:00+00:00"
+    store.close()
+
+
+def test_close_assertion_persists_and_keeps_vectors_and_fts(tmp_path: Path) -> None:
+    class Emb:
+        model_id = "unit-test"
+
+        def embed_texts(self, texts):
+            return [[1.0, float(len(t) % 7), 0.5] for t in texts]
+
+    db = tmp_path / "kg.sqlite3"
+    store = SQLiteTripleStore(db, embedder=Emb())
+    store.add([TripleAssertion(
+        subject="ex:person-dana", predicate="schema:worksFor", object="ex:org-acme", scope="global",
+        owner_id="abstractnote", observed_at="2026-01-01T00:00:00+00:00",
+        valid_from="2026-01-01T00:00:00+00:00", assertion_id="cl_1",
+        attributes={"evidence_quote": "Dana joined Acme"})])
+    vec_before = store.stored_vector("cl_1")
+    assert store.close_assertion("cl_1", "2026-02-01T00:00:00+00:00")
+    assert store.stored_vector("cl_1") == vec_before
+    hits = store.query_keywords(["acme"], scope="global", owner_id="abstractnote")
+    assert [h.assertion_id for h in hits] == ["cl_1"]
+    store.close()
+
+    reopened = SQLiteTripleStore(db, embedder=Emb())
+    [row] = reopened.query(TripleQuery(assertion_ids=("cl_1",)))
+    assert row.valid_until == "2026-02-01T00:00:00+00:00"
+    reopened.close()
+
+
+@pytest.mark.parametrize("which", [0, 1])
+def test_close_assertion_rejects_empty_arguments(tmp_path: Path, which: int) -> None:
+    store = _stores(tmp_path)[which]
+    with pytest.raises(ValueError):
+        store.close_assertion("", "2026-01-01T00:00:00+00:00")
+    with pytest.raises(ValueError):
+        store.close_assertion("cl_1", "")

{abstractmemory-0.3.0 → abstractmemory-0.3.2}/tests/test_journal_backends.py

@@ -462,6 +462,21 @@ def test_record_validation_errors_surface() -> None:
         make_event(kind="co_selected", pair_ids=("rec-a", "rec-a"))
 
 
+def test_reinterpreted_closure_kind(journal) -> None:
+    """Additive closure kind (0.3.2): a source read again withdraws its previous reading; replacements optional."""
+    from abstractmemory.journal import CLOSURE_KINDS
+
+    assert "reinterpreted" in CLOSURE_KINDS
+    journal.append_closure(make_closure(assertion_id="as-r", kind="reinterpreted", reason="read again"))
+    journal.append_closure(make_closure(assertion_id="as-s", kind="REINTERPRETED", reason="read again",
+                                        replacement_ids=("as-t",)))
+    got = {c.assertion_id: c for c in journal.closures()}
+    assert got["as-r"].kind == "reinterpreted" and got["as-r"].replacement_ids == ()
+    assert got["as-s"].kind == "reinterpreted" and got["as-s"].replacement_ids == ("as-t",)
+    with pytest.raises(ValueError, match="kind"):
+        make_closure(kind="revised")
+
+
 # ---------------------------------------------------------------------------
 # JSON round-trip
 # ---------------------------------------------------------------------------

abstractmemory-0.3.0/.abstractcode/agora.state.config.json

@@ -1,17 +0,0 @@
-{
-  "mcp_servers": {
-    "agora": {
-      "transport": "stdio",
-      "command": [
-        "/Users/albou/.local/share/uv/tools/agorahub/bin/agora-mcp"
-      ],
-      "env": {
-        "AGORA_URL": "http://127.0.0.1:8765",
-        "AGORA_AGENT_ID": "memory",
-        "AGORA_ABOUT": "",
-        "AGORA_API_KEY": "",
-        "AGORA_ADMIN_KEY": ""
-      }
-    }
-  }
-}

abstractmemory-0.3.0/.agora/seat.json

@@ -1,10 +0,0 @@
-{
-  "schema": 1,
-  "agent_id": "memory",
-  "url": "http://127.0.0.1:8765",
-  "about": "",
-  "harnesses": [
-    "abstractcode"
-  ],
-  "default_drive_harness": "abstractcode"
-}

abstractmemory-0.3.0/.codex/config.toml

@@ -1,11 +0,0 @@
-[mcp_servers.agora]
-command = "/Users/albou/.local/share/uv/tools/agorahub/bin/agora-mcp"
-required = true
-default_tools_approval_mode = "approve"
-
-[mcp_servers.agora.env]
-AGORA_URL = "http://127.0.0.1:8765"
-AGORA_AGENT_ID = "memory"
-AGORA_ABOUT = ""
-AGORA_API_KEY = ""
-AGORA_ADMIN_KEY = ""

abstractmemory-0.3.0/.gitignore

@@ -1,11 +0,0 @@
-__pycache__/
-*.pyc
-.pytest_cache/
-.DS_Store
-.venv/
-dist/
-build/
-.mypy_cache/
-.ruff_cache/
-untracked/
-.cursor/