AbstractMemory 0.4.0__tar.gz → 0.5.1__tar.gz

{abstractmemory-0.4.0 → abstractmemory-0.5.1}/CHANGELOG.md

@@ -5,6 +5,238 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) (pre-1.0).
 
+## [0.5.1] - 2026-11-10
+
+### Added: `community_keys_of`, the membership-only read for recall stamping
+
+The runtime stamps every recalled record with its topic by reading the whole `communities()` payload per recall, which
+computes every topic's facts: 19 ms at 2,000 records and 190 ms at 20,000 on its synthetic home.
+
+- `community_index.community_keys_of(system, record_ids, *, scopes, owner_id) -> {record_id: key | None}` and
+  `community_memberships_of(...)` -> `{record_id: {key, provisional} | None}`: the answer `communities()` gives for
+  those records (member, provisional since the version, or none), read from the in-memory community index. The hot
+  path is the formation's catch-up compare (`MAX(rowid)` on the open connection against the index's mark) and a dict
+  lookup per id: no fold, no facts, no file opened, stat'ed or locked. Measured for 50 ids (54 topics, SQLite home):
+  20 µs per call at 2,000 records, 22 µs at 20,000 (`communities()` on the same homes: 12 ms and 65 ms). After a
+  formation, the `placed` events above the last read are fetched once per scope pair; a new version reloads the
+  index. A dissolve-only version is seen at the next version, as at placement (backlog 0066).
+- The runtime switches its recall stamps to it: backlog 0069.
+
+Upgrading from 0.5.0: a host that stamps recalled records with their topic should call `community_keys_of` (or
+`community_memberships_of`) with the records' graph ids instead of reading the whole `communities()` payload per
+recall; nothing else changes. Known limits, carried in the backlog: a version that only dissolves communities (no
+new community record) is seen by the membership reads and by placement at the next version that writes one (0066);
+`communities()` read while a version is being written may serve one empty read (0067).
+
+### Fixed: a standing topic still pending is authored, and its old tasks move up
+
+Castor's second topics night (2026-11-10): 10 of 11 topics got titles; the 11th stood unchanged, its title and
+summary tasks queued on the first night at the old priority 5 behind ~267 repair tasks, so the pass skipped it with 6
+calls of its budget unused, and its receipt said `pending: 0` while the topics route showed it pending.
+
+- `communities_pass` spends what its `budget` leaves after the new and changed topics on the STANDING topics still
+  pending (unchanged tonight), largest first, one call each for the fields still pending, from tonight's briefing.
+  Each is written in place on its current record after the version (`rewrite_digest`, with the title when both are
+  pending, or `retitle`), which completes its live `title.author` / `digest.author` tasks; the record keeps its
+  `title_basis` (with the sample its author saw) and the author's verdict. The receipt's `pending` now counts every
+  topic still without a title or summary after the pass, read back; new keys `authored_in_place`, `reprioritized`
+  and `ids.authored_in_place`; a refused in-place write is a failure line with reason `write_refused`.
+- Every standing topic's live authoring task that waits at a later priority than `COMMUNITY_PRIORITY` (3) is moved up
+  to it, in the version's transaction (its own when no version is written): a topic's legacy priority-5 tasks no
+  longer wait behind the repair tail. New `MemoryTaskQueue.prioritize(target_ids, *, kinds, priority, reason,
+  dry_run=False)`: one UPDATE, never demotes a task already ahead, one `prioritized` log row each.
+
+## [0.5.0] - 2026-11-10
+
+Every memory now carries an authored title and summary, a home keeps a persistent queue of what still needs
+understanding, a record's understanding is rewritten in place with every earlier reading kept, the home's topics are
+formed during sleep, and a host can fence every memory write behind its Stop (backlogs 0059, 0060, 0061;
+[ADR 0001](docs/adr/0001-altered-memories-ripple.md),
+[ADR 0003](docs/adr/0003-one-graph-ledger-provenance-and-revisions.md) decision 6a).
+
+### Upgrading
+
+- **Open homes that form records with `MemorySystem(..., task_queue=True)`.** A missing title or summary is always
+  stored beside the task that writes it, so these refuse a home without a task queue, before writing anything:
+  `world_model_pass`, `dream_pass`, `mine_candidates_pass`, `consolidation_pass`, `wake_cue_dedup_pass`,
+  `sleep_pass`, `communities_pass`, `embed_missing`, the ripple verbs, a `remember_many` record with `pending=...`,
+  and an `engram` whose unnamed spark items get no authored title (`report_only` reads still run). `declare_pending`
+  and `rearm_pending` answer `no_task_queue`. The queue adds its tables (`memq_*`) to the home's file on first open.
+- **Pass an `author` callable.** Memory calls no model: `world_model_pass` / `world_model_update`, `dream_pass`,
+  `mine_candidates_pass`, `consolidation_pass`, `wake_cue_dedup_pass`, `sleep_pass`, `communities_pass` and `engram`
+  take `author(kind, body, context) -> {title, summary, author, reader, sources}`. Without it, or when it fails, the
+  records still form, pending, and every result's `authoring = {authored, failures}` names the failures
+  (`no_author_supplied`, `author_raised`, `invalid_result`).
+- **Treat a title as optional while it is pending.** `MemoryRecordInput.title` may be `None` with
+  `pending=("title",)`, and every read serves a pending title as `None` (`MemoryHandle.title` is `Optional[str]`,
+  display blocks and `record_understanding` carry `pending`), never a placeholder or words from the body. A host's
+  drainer completes `title.author` / `digest.author` tasks with `retitle` / `rewrite_digest`; records stored before
+  0.5.0 without an authored title or summary are brought into the same state with `declare_pending`.
+  `MemoryRecordInput` raises `ValueError` for an empty title without `pending=("title",)`, and for a title given
+  with it.
+- **Memory's passes no longer store their own titles or summaries.** Cards, dreams, offers, consolidation candidates
+  and the dedup day summary form authored or pending; their bookkeeping text ("World model: ...", "Dream: ...") is
+  only the provisional body their tasks author from. `world_model_pass` no longer queues `card.author` for new cards
+  (`digest.author` owns the body; `card.author` remains for legacy cards).
+- **Hosts that fence writes** pass `commit_guard=` and wrap the moment they flip it in `system.write_barrier()`.
+  Two residual windows remain: a LanceDB store takes no write lock (a LanceDB write whose guard passed before the
+  flip may land after it, at most one per concurrent writer; `BarrierHold.uncovered` names it with a `#FALLBACK`
+  warning), and the two SQLite autocommit commit points (`SQLiteTripleStore._write_pin` without a cursor, the
+  off-file graph's `mark_journal_applied`) are covered only by a barrier taken on the same handle.
+- **Community records are never embedded and never recalled**: a store's embedding paths, recall shelves, keyword
+  indexes and memory scans skip kind `community` (`canonical_text.NON_EMBEDDED_KINDS`).
+- `CANONICAL_TEXT_VERSION` is 3 (stored text is never cut). Record digests render as before; a plain assertion
+  with an `original_context` longer than 400 characters keeps its earlier text and vector until `reembed_store`
+  re-derives it.
+- `version_count` is 1 for a record that was never rewritten (was 0); `digest_version` stays 0.
+- `apply_redigestion` is deprecated (it forms a new record with zero usage); use `rewrite_digest`.
+
+### Added: titles and summaries are always authored
+
+- `MemoryRecordInput(pending=(), pending_failure=None)`: `pending` is a subset of `PENDING_FIELDS`
+  (`{"title", "summary"}`). A pending record carries `attributes.pending = {title, summary, since, attempts}` (plus
+  `failure` when authoring failed) and `remember_many` queues its authoring task (`PENDING_TASK_KINDS`:
+  `title.author` / `digest.author`, capability `summaries`, `FORMATION_PRIORITY`). A pending summary is refused on
+  the entity's own words (`UNDERSTANDING_PROTECTED_KINDS`), except a public diary projection's summary.
+- The host's `author` callable on every pass (`formation_authoring`): authored fields are stored with their
+  provenance (`title_provenance`, `understanding`, version 0, cause `formation`) and owe no task; a standing record is
+  never authored again.
+- `engram(..., author=None)`: a spark item without a `name` has its title authored before it forms (it was
+  `<section>-<ordinal>`, such as `trait-0`), else it forms pending; a `name` stays the title. `EngramResult.authoring`.
+- `retitle(record_id, *, title, author, cause, expected_version, ...)`: changes only a record's title, in place, for
+  every kind; the body and the reading stay byte-identical, the previous title is kept as a version, `title_version`
+  is the compare-and-set. Refusals: `empty_title`, `hash_chained` (an owner-direct diary entry whose `entry_hash`
+  attests its title), `closed`, `stale`, `embedder_unavailable`. A digest or card reading that changes the title
+  writes the title version too.
+- `declare_pending(record_id, *, fields=("title", "summary"), cause="repair", reason=None)`: a stored record whose
+  title or summary was never authored gets exactly the state of a record formed pending (marker and tasks in one
+  transaction; a declared title is stored `None`, its old title kept as a version). Idempotent (`already_pending`).
+- `rearm_pending(record_id, ...)` re-queues the authoring task of a pending field whose tasks all ran out, and
+  `pending_records(*, scopes=None, live_task=False)` lists the records still pending, with their live and unowned
+  fields.
+- A public diary entry's summary is authored like any record's (at formation, or declared pending for an existing
+  entry); its body, the book's entry and every hash chain are untouched. Owner-direct, hash-chained and private
+  entries stay protected (`diary.diary_summary_refusal`).
+- `rekey_world_model(old_key, new_key, *, scope, owner_id, author, cause, ...)`: moves a standing card to a new key
+  in place and keeps the old key as an alias, so a retitled interest's next `world_model_pass` forms no second card.
+  An untitled interest's card is keyed `topic:<graph id>` and `retitle` re-keys it when the title lands
+  (`card_rekey` in the result).
+- `REWRITE_CAUSES` gains `repair` (a correction of what a process wrote wrong).
+
+### Added: understanding rewritten in place (0059)
+
+- `rewrite_digest`: replaces a record's digest, title and keywords in place. The record keeps its graph id, digest
+  assertion id, edges, usage counts and journal; its keyword entry and vector are replaced in the same transaction.
+  `expected_version` is a compare-and-set; each reading records `author` (`AUTHOR_KINDS`), `reader`
+  (`{provider, model, thinking}`), `sources` (mandatory for a model author) and `cause`. Refusals are named results
+  that write nothing. Results carry `cosine_distance` between the old and new vectors.
+- `narrate_dream` (a narration beside a dream's summary), `revert_digest`, `versions`, `current_of`,
+  `record_understanding`, `understanding_fields`; `author_world_model` rewrites a card in place by default (accepts
+  `reader`, `sources`, `expected_fingerprint`; `in_place=False` keeps the revision path).
+- The journal's version family `UnderstandingVersion`, and the opt-in replay family `revision`
+  (`OPT_IN_FAMILIES`; the default six families are unchanged). Display blocks carry the reading's provenance
+  (`digest_method`, `digest_version`, `version_count`, `authored_by`, `reader`, `understood_at`, `cause`).
+- Every record says who wrote its words, when and why, even when its writer stamped nothing: a row without a stamp
+  reads as its formation reading, derived from its origin (`understanding.reading_provenance`); `remember_many`
+  records that reading at formation.
+
+### Added: the memory task queue (0060) and ripple v1 (0061)
+
+- `MemorySystem(task_queue=True)` keeps its queue in the home's file (`memq_tasks`, `memq_log`, `memq_windows`,
+  `memq_ripples`, `memq_ripple_gates`, `memq_maintenance`; a private in-memory database for the in-memory store). `system.tasks` (`MemoryTaskQueue`): `enqueue`, `select_for_window(budget_seconds, sensitivity)` (activation
+  through ADR 0001's logistic gate, strongest first, bounded by the window's time; every live task selected or left
+  out with a reason), `claim` / `ack` / `release` (leases, attempts, defer without spending an attempt), `left_out`.
+  `understanding_debt`, `enqueue_debt` (the backfill, dry-run by default) and `task_packet` on `MemorySystem`. The
+  understanding verbs accept `task_id=` and settle the task in their own transaction.
+- A formed record and the tasks it owes commit together (`memory_tasks.form_with_tasks`): one transaction on the
+  SQLite home; on the in-memory pair a failure rolls back exactly that attempt's rows, bindings and tasks.
+- `maintenance_due(..., tasks=)` reports pending tasks and is due when ripple or night-only work is pending.
+- Ripple v1: `seed_ripple`, `settle_reconsideration`, `form_consolidation` (night only), `refresh_ripples`,
+  `revert_ripple`, and the reads `ripples` / `ripple`. Candidates by relation, by the cards built on a memory and by
+  vector similarity; impact decays per hop through the logistic gate (floor 0.1), at most 2 hops and 20
+  reconsiderations per ripple and per window; protected kinds are never reconsidered; every gate decision is stored
+  with its potential.
+
+### Added: communities (topics)
+
+- A community is a formed record of kind `community` (`abstractmemory.communities.COMMUNITY_KIND`), one record per
+  version, with a stable `attributes.community_key` across versions. `communities_pass(system, *, scopes, owner_id,
+  author, cancelled, ...)`, which a host runs during its sleep, detects them (deterministic warm-started Louvain over
+  the vectored records, at most 5 rounds), attaches vector-less records through their engraved relations, lays them
+  out, authors the changed ones and writes the version in one guarded transaction. `embed_missing(...)` embeds the
+  formed records that have no vector with the store's own embedder.
+- Placement at formation: on a `task_queue=True` home, `remember_many` places every record it forms in its
+  provisional community inside the formation's transaction (nearest centroid, else the majority community of its
+  formation edges) and writes one `placed` journal event (an audit kind, never scored).
+- Reads (`abstractmemory.community_index`): `communities(system, *, scopes, owner_id, version=None)` (the payload
+  version 2 a host serves, with each community's `facts`: span, activity, hub, bridges, paths,
+  `changed_since_last_sleep`) and `community_of(system, record_id)`. A community record replays like any formed
+  record; its binding envelope draws only `refines`.
+- Topic titles come first: a community's `title.author` / `digest.author` tasks are queued at `COMMUNITY_PRIORITY`
+  (3, ahead of every other pending record's `FORMATION_PRIORITY` 5), so a drainer with a small budget names the
+  topics before a long repair tail. `communities_pass`'s `budget` goes to its topics, largest first, one call per
+  topic for both its title and its summary (`None` authors every topic); the receipt carries `budget` and
+  `budget_spent`. A topic's briefing keeps its member lines within 1500 tokens, the first line too.
+
+### Added: sleep cadence
+
+- `records_since_maintenance(system, *, scopes=None, after=None) -> {count, last_maintenance_at, since,
+  boundary_source, fragmented}`: the host's idle → sleep threshold. `sleep_pass` records when a whole night ran to
+  its end (a cancelled, `report_only` or anchored night records nothing; a cycle window is recorded as kind `cycle`
+  and does not reset the count); `after` is the host's own last maintenance, and the later of the two is the
+  boundary. `fragmented = {count, share, provisional, unvectored, pending}` says how much of the live home a sleep
+  would make whole. `MemoryTaskQueue.record_maintenance` / `last_maintenance`.
+- `sleep_pass(..., cancelled=None)`: the host's Stop check, read at every sub-phase boundary and immediately before
+  the completion marker; a stopped night records no completion and carries `cancelled_after`.
+
+### Added: the Stop fence hooks
+
+- `MemorySystem(..., commit_guard=None)`: the host's `guard(where)` is installed on the store and journal and called
+  inside every write transaction immediately before its COMMIT, once per outermost transaction, whoever writes (the
+  facade, `MemoryGraph`, the task queue, the sleep passes). Raising rolls the write back; nothing of it lands and the
+  exception reaches the caller unchanged. A store or journal type whose writes do not call a guard is refused
+  (`TypeError`), and so is a second, different guard (`ValueError`).
+- `MemorySystem.write_barrier(*, timeout=None)` / `write_barrier(system, *, timeout=None)`: a context manager the
+  host wraps around its flip of the guard. It holds this home's in-process locks in the writers' own order and one
+  `BEGIN IMMEDIATE` per distinct SQLite file, so every transaction whose guard passed commits before the block and
+  every later one calls its guard after it. It writes nothing; `WriteBarrierTimeout` names the lock or file still
+  held.
+
+### Changed
+
+- Stored text is never cut: a world-model card quotes its evidence whole, a dream signal's `fragment` is kept whole
+  (`dream_signals.FRAGMENT_CAP` is gone), an assertion's `original_context` renders whole in the canonical text, a
+  plain assertion's "s p o" display title and an imported file's prose are kept whole. Readers shorten text at
+  display time (`canonical_text.short_title`).
+- Titles are explicit and whole: a card formed from an interest keeps the interest's whole subject head as its
+  target; lesson-candidate, interest-candidate and group-offer titles are no longer bounded.
+- `world_model_pass`: an interest whose title heads to an alias of a card counts as an election of the card's
+  primary key.
+- `dream_pass` returns `signals` and `signals_omitted`.
+- `journal_cold_cut` copies the version family and the task queue.
+- The identity card's `lessons` section also counts the lessons written in the diary (`diary_type='lesson'`), once
+  each when a lesson record derives from the entry.
+- The identity card's record briefs carry the reading fields (`authored_by`, `understood_at`, `cause`,
+  `digest_version`, `version_count`); diary-redacted replay blocks carry `authored_by`, `understood_at` and `cause`,
+  never the entry's words.
+
+### Fixed
+
+- `records_since_maintenance(...)["fragmented"]["count"]` counts each live record once: a record both vector-less
+  and pending, or placed and pending, is one fragmented record, and a placement whose record has been closed since
+  counts in `provisional` only, so `share` never exceeds 1.0. The per-kind counts are unchanged.
+- Identical authored words settle a pending field: an in-place write whose words equal the provisional ones clears
+  the marker, completes the task and records the reading (it answered `unchanged` and left the task leased).
+- On the in-memory pair, formation and rewriting share one lock (they could deadlock), and a failed formation
+  removes only its own rows and bindings, never a concurrent writer's.
+- `form_with_tasks` calls the commit guard immediately before its COMMITs, after the rows, bindings and tasks.
+- A completed task no longer carries the error of an earlier failed attempt (the failure stays in the task log).
+- The wake-cue dedup pass no longer tokenizes a missing title as "None".
+
+### Deprecated
+
+- `apply_redigestion` (emits `DeprecationWarning`): use `rewrite_digest`.
+
 ## [0.4.0] - 2026-10-27
 
 The memory graph ([ADR 0003](docs/adr/0003-one-graph-ledger-provenance-and-revisions.md), backlogs 0056-0058):

{abstractmemory-0.4.0 → abstractmemory-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: AbstractMemory
-Version: 0.4.0
+Version: 0.5.1
 Summary: AbstractMemory: temporal, provenance-aware semantic memory primitives for AbstractFramework.
 Project-URL: AbstractFramework (monorepo), https://github.com/lpalbou/abstractframework
 Author: Laurent-Philippe Albou
@@ -55,6 +55,20 @@ Storage never decays and nothing is ever deleted; only retrieval strength change
 - The authoritative export list is [`src/abstractmemory/__init__.py`](src/abstractmemory/__init__.py); [`docs/api.md`](docs/api.md) documents it.
 - Requires Python 3.10+.
 
+## What's new in 0.5.1
+
+- `community_keys_of` / `community_memberships_of`: the membership-only topic read for every recalled record, tens of microseconds per call from the in-memory community index (the runtime's recall stamps use it).
+- A standing topic still pending its title or summary is authored in place by `communities_pass` with the budget the changed topics leave, and its queued tasks move up to the topics' priority.
+
+## What's new in 0.5.0
+
+- Every memory's title and summary is authored: memory's passes take a host `author` callable, and a record whose authoring failed forms pending, with its task, until a reader completes it (`retitle`, `rewrite_digest`, `declare_pending`, `rearm_pending`).
+- A persistent task queue per home (`MemorySystem(task_queue=True)`), ripple v1, and understanding rewritten in place with every earlier reading kept as a version.
+- Topics: `community` records formed during sleep, with provisional placement of each new record at formation.
+- The sleep cadence read `records_since_maintenance`, and the Stop fence hooks `commit_guard` and `write_barrier`.
+
+Upgrading from 0.4.x: see the "Upgrading" notes in [`CHANGELOG.md`](CHANGELOG.md).
+
 ## Ecosystem (AbstractFramework)
 
 AbstractMemory is a component of the **AbstractFramework** ecosystem. It has no dependency on AbstractCore or AbstractRuntime; embeddings for semantic retrieval can come from any OpenAI-compatible `/embeddings` endpoint (`OpenAICompatTextEmbedder`), from an AbstractGateway deployment (`AbstractGatewayTextEmbedder`), or from your own `TextEmbedder` implementation.
@@ -181,7 +195,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/reinterpreted/merged); 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/merged); forgetting is decay of retrieval strength plus closures and silencing — the substrate is lossless. The one mutable cell is a record's understanding: `rewrite_digest` and `retitle` rewrite a digest or a title in place and keep every earlier reading as a version.
 - **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.4.0 → abstractmemory-0.5.1}/README.md

@@ -13,6 +13,20 @@ Storage never decays and nothing is ever deleted; only retrieval strength change
 - The authoritative export list is [`src/abstractmemory/__init__.py`](src/abstractmemory/__init__.py); [`docs/api.md`](docs/api.md) documents it.
 - Requires Python 3.10+.
 
+## What's new in 0.5.1
+
+- `community_keys_of` / `community_memberships_of`: the membership-only topic read for every recalled record, tens of microseconds per call from the in-memory community index (the runtime's recall stamps use it).
+- A standing topic still pending its title or summary is authored in place by `communities_pass` with the budget the changed topics leave, and its queued tasks move up to the topics' priority.
+
+## What's new in 0.5.0
+
+- Every memory's title and summary is authored: memory's passes take a host `author` callable, and a record whose authoring failed forms pending, with its task, until a reader completes it (`retitle`, `rewrite_digest`, `declare_pending`, `rearm_pending`).
+- A persistent task queue per home (`MemorySystem(task_queue=True)`), ripple v1, and understanding rewritten in place with every earlier reading kept as a version.
+- Topics: `community` records formed during sleep, with provisional placement of each new record at formation.
+- The sleep cadence read `records_since_maintenance`, and the Stop fence hooks `commit_guard` and `write_barrier`.
+
+Upgrading from 0.4.x: see the "Upgrading" notes in [`CHANGELOG.md`](CHANGELOG.md).
+
 ## Ecosystem (AbstractFramework)
 
 AbstractMemory is a component of the **AbstractFramework** ecosystem. It has no dependency on AbstractCore or AbstractRuntime; embeddings for semantic retrieval can come from any OpenAI-compatible `/embeddings` endpoint (`OpenAICompatTextEmbedder`), from an AbstractGateway deployment (`AbstractGatewayTextEmbedder`), or from your own `TextEmbedder` implementation.
@@ -139,7 +153,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/reinterpreted/merged); 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/merged); forgetting is decay of retrieval strength plus closures and silencing — the substrate is lossless. The one mutable cell is a record's understanding: `rewrite_digest` and `retitle` rewrite a digest or a title in place and keep every earlier reading as a version.
 - **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.4.0 → abstractmemory-0.5.1}/docs/adr/0001-altered-memories-ripple.md

@@ -2,7 +2,10 @@
 
 Status: Accepted (operator ruling, 2026-10-21; activation model confirmed with the operator the same day).
 Amended 2026-10-27 (operator ruling): the ripple is AbstractMemory's process end to end, not a consumer's
-(ADR 0002). Aspirational: AbstractMemory does not implement it yet; AbstractNote holds a prototype
+(ADR 0002). Implemented in part (2026-11-08, backlog 0061, ripple v1): propagation over the memory task queue
+with the logistic gate of decision 7, the floor, decay, hops, budget, refractory-per-ripple, every gate decision on
+record, the no-write unchanged settle, sleep consolidation; mass, edge learning and closures caused by a ripple
+remain planned (backlog 0054). Before 0061: AbstractMemory did not implement it; AbstractNote holds a prototype
 (its ADR 0008 propagation lane) that is to be absorbed here, not kept as the implementation.
 
 ## Context
@@ -132,6 +135,8 @@ asks "given that A changed this much, what must be reconsidered about B and E?".
 - Proposed: [ripple_wave/0001_change_records_and_ripple_primitives.md](../backlog/proposed/ripple_wave/0001_change_records_and_ripple_primitives.md)
   (the AbstractMemory primitives: change records with magnitude, closure causes, `maintenance_due` counting pending
   ripples, `narrow_assertion`).
+- Implemented (v1): [knowledge_graph_convergence/0061_ripple_v1_over_the_task_queue.md](../backlog/planned/knowledge_graph_convergence/0061_ripple_v1_over_the_task_queue.md)
+  (the gate and its constants in `activation_gate.py`; propagation, settle and consolidation in `ripple.py`).
 - Planned: [knowledge_graph_convergence/0054_ripple_propagation_and_activation.md](../backlog/planned/knowledge_graph_convergence/0054_ripple_propagation_and_activation.md)
   (the propagation, activation and reconsideration process in AbstractMemory).
 - Prototype to absorb, not to keep: AbstractNote ADR 0008 and its propagation lane (R6, 2026-10-20/21: calibrated

{abstractmemory-0.4.0 → abstractmemory-0.5.1}/docs/adr/0003-one-graph-ledger-provenance-and-revisions.md

@@ -6,6 +6,8 @@ convergence track (backlog 0050-0058).
 Amended 2026-10-27 (operator rulings on `abstractframework/untracked/memory-transition/report.md`): decisions 2 and
 13, visibility is strict ownership (report decision 5); decision 3, one graph surface with stores as connectors
 behind it, SQLite the default connector (report decision 2).
+Amended 2026-11-08 (operator ruling 2026-11-07 rule 2, confirmed in the understanding-pass decisions; backlog 0059):
+decision 6a, a record's understanding is the one mutable cell, rewritten in place with every earlier reading kept.
 
 ## Context
 
@@ -111,6 +113,16 @@ change of understanding, can be reconstructed from the ledger.
    the operations applied together and atomically (assert, close, narrow, and, as the track lands them, entity and
    alias operations). Replaying the revision log into an empty store yields the same graph. A revision is
    idempotent on its id. The in-place `close_assertion` becomes a revision op (`close`) and is journaled with it.
+6a. **A record's understanding is the one mutable cell** (amendment 2026-11-08, backlog 0059). A formed record's
+   digest (its summary text, title and keywords; a card's text; a dream's narration beside its summary) may be
+   rewritten IN PLACE, and only through `rewrite_digest`, `author_world_model` and `narrate_dream`. The record keeps
+   its subject id, its digest assertion id (usage keys on it), its edges and every journal record; the previous
+   reading is appended to the journal's `versions` family with its author, reader, ledger sources and cause, so the
+   as-recorded axis stays answerable ("what did this mind hold at R" reads the version current at R). The verbatim
+   is never touched. The keyword entry and the vector are replaced in the same transaction as the row, so recall
+   never serves words the row no longer holds. Where a home holds the graph tables, a rewrite becomes a revision op
+   (`rewrite`) logged like `close` and `narrow`; entity homes today hold no graph tables, so the version row is the
+   record of the change.
 7. **Closures carry their cause and their successor.** A closed window records `kind`
    (`retract | supersede | reinterpreted | narrowed | merged`), the `revision_id` that closed it, the replacement
    ids ("superseded by ..."), and for a ripple the source memory and hop count (ADR 0001). The window on the row and
@@ -244,7 +256,8 @@ change of understanding, can be reconstructed from the ledger.
   per plane, LanceDB optional, import of the existing plane store),
   [0058](../backlog/planned/knowledge_graph_convergence/0058_home_store_performance_indexes_vectors.md)
   (indexes, column projection, binary vectors and the matrix cache).
-- Track: [knowledge_graph_convergence/](../backlog/planned/knowledge_graph_convergence/README.md) (0050-0058);
+- Decision 6a: [0059](../backlog/planned/knowledge_graph_convergence/0059_record_understanding_rewrites_in_place_with_versions.md).
+- Track: [knowledge_graph_convergence/](../backlog/planned/knowledge_graph_convergence/README.md) (0050-0061);
   [ripple_wave/0001](../backlog/proposed/ripple_wave/0001_change_records_and_ripple_primitives.md).
 - Consumers: AbstractNote backlog 0033-0037 (its track `planned/memory_convergence/`); AbstractRuntime ADR 0009 and
   its memory facade item; AbstractGateway memory routes item; AbstractEntity `docs/backlog` memory provenance item.

{abstractmemory-0.4.0 → abstractmemory-0.5.1}/docs/adr/README.md

@@ -5,6 +5,6 @@ policy the work must respect.
 
 | ADR | Title | Status |
 |---|---|---|
-| [0001](0001-altered-memories-ripple.md) | An altered memory ripples through the memories connected to it | Accepted (2026-10-21; amended 2026-10-27: owned by AbstractMemory) |
+| [0001](0001-altered-memories-ripple.md) | An altered memory ripples through the memories connected to it | Accepted (2026-10-21; amended 2026-10-27: owned by AbstractMemory; v1 implemented 2026-11-08, backlog 0061) |
 | [0002](0002-abstractmemory-owns-the-memory-graph.md) | AbstractMemory owns the semantic temporal memory graph and all of its processing | Accepted (2026-10-27) |
-| [0003](0003-one-graph-ledger-provenance-and-revisions.md) | One semantic temporal graph, every memory tied to the ledger, every change a revision | Accepted (2026-10-27; amended 2026-10-27: strict ownership; decision 3, one graph surface, stores as connectors, SQLite default) |
+| [0003](0003-one-graph-ledger-provenance-and-revisions.md) | One semantic temporal graph, every memory tied to the ledger, every change a revision | Accepted (2026-10-27; amended 2026-10-27: strict ownership; decision 3, one graph surface, stores as connectors, SQLite default; amended 2026-11-08: decision 6a, a record's understanding is the one mutable cell) |