1. Executive Summary
PLUR1BUS is a memory plugin for OpenClaw, at release 7.16.10, and the first unusual thing about it is that its test suite is larger than the implementation it covers.
The second unusual thing is the ratio of care to surface.
openclaw.plugin.json declares fifty-five top-level
configuration groups, covering dreaming, emotional state, persona voice,
an Obsidian vault bridge, skill mining, reminders, a semantic lens,
conversation reactivation, and a proactive governor. Underneath that is
a correction path — lib/safe-update.js, 509 lines — that is
more disciplined than most of the dedicated memory systems in this
atlas. A content change is refused unless the caller supplies both an
update source and a quoted piece of evidence, the replacement row is
written and made durable before the old row is marked
superseded, and the whole transition is appended to a reconsolidation
event log keyed by an idempotency hash.
The most interesting single line in the repository is
safe-update.js:440. Before a content change is accepted,
the new embedding is compared against the old one and the update is
rejected if the cosine distance exceeds 0.45 — a machine refusing to let
a "correction" quietly replace a memory with something that means
something else. It is a genuinely novel gate.
The one caller outside the automated conflict apply, the user-facing
/correct command at index.js:9881, passes
skipDriftGate: true — deliberately, with the reasoning
written at the call site. The gate throws rather than degrades, a large
correction is exactly what a user typing /correct intends,
and the confirmation dialog shows the old and new text in full before
anything is written. The measured drift is recorded on the
reconsolidation event either way. A gate that is off by argument is a
different thing from a gate that is off by accident, and this is the
first.
Where it is strongest: scope. checkAccess
(lib/acl-middleware.js:103) denies by default, denies on a
missing owner, denies on a conflicting ownership tuple, and is applied
as a filter on the read path in three places. The tests assert the
denials rather than the permissions.
Doubt acts in two places and is held back in a third on a
measurement rather than an omission.
scoreNeoRecallItem returns -Infinity for
demoted alongside the deletion states, so a record a person
has demoted cannot reach the prompt at all; the claim-level epistemic
status does the same for invalidated at all three read
layers (recall-pipeline.js:180,
neo-arch.js:1484, and the SQL clause at
db-adapter.js:601). conflict is a ranking
penalty, and the comment that keeps it one is the interesting part — the
detector is "an unvalidated LLM", a live probe on 16 August
2026 found 4,017 newest-revision records carrying conflict
(2,505 on a single agent) "with no resolve path that clears the
status", and a twenty-row sample was not pairwise
contradiction.
Hard-filtering on that signal would have withheld thousands of records on a flag the system cannot yet clear. The distinction the code draws — withhold on a state a person set, rank on a state a model guessed — is the right one, and it is drawn with the numbers in the source.
Two mechanisms this atlas looks for are present and unusually
well-tested. A claim carries a real-world validity
window — validFrom/validUntil on the
row, tracked separately from
createdAt/updatedAt and queryable as-of
through a validAt recall parameter, so "where did he work
in 2025" is a different query from "what did we record in 2025". And a
value-keyed tombstone survives a /forget:
a content fingerprint is written to a durable append-only registry and
checked before every card write that adds new text, so the forgotten
sentence cannot be silently re-stored.
The weak joint is the log that explains corrections. Each
reconsolidation event carries the source, the quoted evidence and the
measured drift, and it is written through the same JSONL append as the
turn journal, which caps every file at its newest 5,000 lines
(lib/neo-arch.js:2265-2285); the daily consolidation
rewrites it again. The append-only record of mutations is a different
file, destructive-ops.jsonl, which logs deletions, trust
transitions and curation decisions and is never rewritten.
2. Mental Model
There are two stores and they hold different kinds of thing.
LanceDB cards are the memories proper — one table
per agent, a row per card. A card's life is short to describe: it is
active, or it has been superseded by a newer version that
names it in previousVersion. Retrieval is unforgiving about
this. lib/recall-pipeline.js:176 drops any entry whose
status is set and is not active, so a superseded card is
not ranked down, it is gone from the read path.
Neo records are the JSONL layer — turn journal,
memory candidates, behaviour cards, graph edges, dream diary, episodes —
and they carry the epistemics. Each record has a status
from NEO_STATUSES (lib/neo-arch.js:65):
["candidate", "active", "promoted", "demoted", "conflict", "pruned", "tombstoned"]
and an origin.trustLevel from
NEO_TRUST_LEVELS (lib/neo-arch.js:55), running
untrusted → user_asserted → assistant_asserted → tool_observed → validated → curated.
What moves a record between states is a person.
/plur1bus memory promote|demote|prune|tombstone <id>
(index.js:9026-9036) requires authorization, calls
transitionRecordStatus, and appends the transitioned record
back to the JSONL. There is no automatic promoter; a candidate becomes
promoted because someone typed the command.
The consequence of each state is where the design divides.
scoreNeoRecallItem returns -Infinity for
pruned, tombstoned and demoted —
three states genuinely withheld, and the third is there because a person
set it. conflict stays in the arithmetic below on the
reasoning quoted in section 1. Everything between is arithmetic:
const trustBoost = ({ curated: 0.3, validated: 0.25, user_asserted: 0.18,
tool_observed: 0.18, assistant_asserted: -0.2, untrusted: -0.3 })[item.origin?.trustLevel] ?? 0;
…
const penalties = (item.origin?.role === "assistant" ? 0.2 : 0)
+ (item.status === "demoted" ? 0.35 : 0)
+ (item.status === "conflict" ? 0.3 : 0)
+ (item.stale === true ? 0.15 : 0);
The exits from conflict are authorized and
narrow, which is the right shape for a status a model assigns.
Two subcommands sit behind the same authorization check as
promote/demote/prune/tombstone
(isDestructiveAction, index.js:7271-7285).
/plur1bus curation resolve <id> keep|drop
(lib/curation-resolve.js, dispatched at
index.js:8847) moves one record and appends a
curation.resolve event.
/plur1bus curation drop-injected
(lib/drop-injected-conflicts.js,
index.js:8865) is the bulk form, and it is bounded twice
rather than trusted: previewDropInjected shows the set
before applyDropInjected touches it, and the apply path
refuses any record whose status !== "conflict" or whose
text does not satisfy isInjectedContextText
(:104), so the bulk verb cannot reach a record the narrow
predicate does not already describe. Neither auto-resolves: a
conflict a person never looks at stays a penalty forever,
which is the honest cost of leaving an unvalidated detector's output in
the ranking rather than in a filter.
So the neo statuses split three ways: the deletion states and
demoted withhold, conflict and the trust
ladder rank, and the split tracks who or what set the flag. A record a
person demoted is gone from the read path; a record an LLM detector
flagged as contradicting another is ranked down and can reach the
prompt, carrying its status in the rendered line, which is the
difference between a model that can weigh the flag and one that cannot
see it.
The exception lives on a different axis. Alongside the neo status is
a claim-level epistemic status
(lib/epistemic-status.js) —
untrusted → observed → corroborated → trusted → disputed → invalidated,
explicitly orthogonal to who asserted a memory
(origin.trustLevel) and to its numeric
confidence. Most of its values are a ranking boost
(trusted +0.25 … disputed −0.4), but
invalidated is a hard filter, dropped on the read path at
recall-pipeline.js:180, given -Infinity at
neo-arch.js:1484, and excluded in SQL at
db-adapter.js:601
(epistemicStatus != 'invalidated'). It withholds rather
than ranks, as demoted does on the neo axis, and the
transitions into trusted and invalidated
require an authorized actor, so a memory cannot promote or condemn
itself. A conservative merge rule
(combineEpistemicStatusForMerge) takes the lower of two
inputs, so a weakly-trusted memory cannot launder its way up by being
merged with a trusted one.
Which copy of a record the scorer sees is itself a design
decision here, and it is the one that makes the rest of the vocabulary
mean anything. The JSONL stores are append-only event logs:
transitionRecordStatus appends a fresh line under the same
id rather than replacing the old one, so a record that has moved to
demoted exists on disk twice, once in each state.
routeNeoRecall (lib/neo-arch.js:1530)
deduplicates by id and keeps the newest revision,
ordered by updatedAt — the field a transition sets — while
preserving first-appearance order so the itemIndex tiebreak
below stays stable.
The helper that dates a revision, neoRevisionTimeMs
(:1523), carries a note on why the existing
recordTimeMs will not serve: it reads
startTime/createdAt, which are identical
across every revision of one record, so it cannot tell two revisions
apart. An undated record sorts to -Infinity so any dated
revision beats it and the comparison never lands on
NaN.
Read against an append-only store, that is not a detail. Keeping the
first line seen means scoring the record as it was before the
transition, which would apply the active arithmetic to a
record a person had just demoted — and a status penalty computed against
the wrong copy is not a weakened penalty, it is no penalty.
tests/neo-status-transition-dedupe.test.js fixes the
arithmetic to a number: active=0.371 against
demoted=-0.116 at a live minScore of
0.08, so the two copies fall on opposite sides of the
admission threshold.
The rendered line carries the status the penalty was computed from.
formatNeoRecallContext emits lane,
category, trust, id,
score and status on each
<memory-record>, which matters because the memory
prompt supplement tells the model to prefer active and
promoted over conflicting cards — an instruction that can
only be followed if the distinction is in the payload.
One state transition is not epistemic at all and is worth naming here
because it protects the whole loop. Text that PLUR1BUS itself injected
into a prompt — recall blocks, temporal context, status reminders, cron
output — is matched against a marker list and refused as a capture
candidate (isInjectedContextText,
lib/neo-arch.js:194, applied at
neo-arch.js:1229 and :1276). Without it,
recall output becomes next turn's memory, which the comment above the
marker list dates to a performance analysis on 29 May 2026.
Diagram source
%% caption: supersession is dropped at one line of the recall pipeline, demotion, pruning and tombstoning score -Infinity in the neo scorer, and only conflict is ranked down and injected, so the state a model sets is the one state that ranks rather than withholds
stateDiagram-v2
[*] --> candidate: agent_end capture
candidate --> active: written to LanceDB
active --> promoted: person runs promote
active --> demoted: person runs demote
active --> conflict: contradiction detected
active --> superseded: safeUpdate writes v+1
superseded --> [*]: dropped at recall-pipeline.js 176
promoted --> pruned: person runs prune
demoted --> tombstoned: person runs tombstone
pruned --> [*]: score -Infinity
tombstoned --> [*]: score -Infinity
conflict --> conflict: ranked down 0.3, injected
demoted --> [*]: score -Infinity3. Architecture
An OpenClaw plugin, loaded from index.js, requiring Node
24.16 or later (package.json engines) and a
running OpenClaw gateway. Nothing else has to be stood up: LanceDB is
embedded, the neo store is JSONL on disk, and the caches use the
node:sqlite module built into Node rather than a
dependency.
index.js(13,646 lines) — plugin entry, hook registration, chat commands, and the wiring between every subsystem below.lib/(275 files, 81,669 lines) —obsidian-control-room.js(3,954),neo-arch.js(3,500),obsidian-bridge.js(2,360) andrecall-pipeline.js(2,158) dominate;safe-update.js,acl-middleware.js,memory-history.jsandcontradiction-detector.jscarry the correction path.lib/jobs/— fifteen background jobs: daily consolidation, garbage collection, conflict resolution, skill mining, critical-push classification, memory compaction, reflection.lib/dreaming/—light-dream.js,rem-dream.js,dream-narrative.js.lib/setup/feature-cron-plan.js,scripts/setup-feature-crons.mjs— cron registration through the host's public plugin API; see below.lib/providers/local-model-artifacts.js— the pinned local model artifacts.bench/— a LOCOMO and LongMemEval harness overlib/recall-pipeline.jswith committed results; see section 10.
Storage. LanceDB tables per agent under
{baseDbPath}/{agentId}/ (lib/db-adapter.js),
so agent isolation is a directory boundary before it is a query filter.
Alongside: eleven JSONL files and four JSON files per workspace in the
neo store, an optional SQLite embedding cache and LLM result cache, and
an optional Obsidian vault the bridge keeps in sync as Markdown. Every
neo JSONL file goes through one append, appendJsonl
(lib/neo-arch.js:2265), which caps the file at the newest
NEO_MAX_RECORDS lines — default 5,000, never below 500
(:2159) — once it passes 2 MB, and the daily
consolidation's pruneAll (:1934, called from
lib/jobs/daily-consolidation.js:448) rewrites each file
again, dropping injected-context lines and capping.
Retrieval stack. Vector search over LanceDB with a
lexical fallback when the embedder is not ready, graph hydration of
neighbouring cards (hydrateGraphResults,
recall-pipeline.js:998), and two additive passes — a
precomputed semantic lens and conversation reactivation — that append to
a recall result and, per AGENTS.md, must never replace it.
Both are off by default and both carry a 50 ms hard timeout.
Embeddings come from OpenAI or an optional local
@huggingface/transformers. A key is not required to store a
memory: the adapter falls back to text search when embedding fails.
Every text handed to a local Jina model is cut at
embedding.local.maxTokens, default 512 and bounded to
32–8,192 (lib/providers/embedding-local-transformers.js:17,
:426-430, pinned by
tests/jina-v5-nano-embedding.test.js:179,
:205-211), and the cap is part of the shared model pool's
identity.
The reason is in the comment above the check and in the changelog for 7.11.1. Both pinned Jina models accept 8,192 tokens, and the ONNX runtime holds the attention working set of a batch's longest text times the batch size and never returns it. In the 7.11.0 lab run one 15,000-character card drove the v3 process to 41 GB and the kernel's OOM killer at card 808 in a run of 1,031 cards, and a single batch of the eight longest cards took the nano model to +30 GB and 117 s. At 512 tokens the same batch costs +0.6 GB and 5 s on nano, +1.1 GB and 22 s on v3. Until 7.11.1 on 5 September 2026 no cap existed, so an installation with long cards and a local Jina embedder could be killed by its own embedding cron.
Deployment and ergonomics
Install is npm install into an OpenClaw installation,
and this is where an operator should look before anything else.
package.json declares:
"postinstall": "node scripts/setup-feature-crons.mjs || true"
That script registers the plugin's feature crons and nothing else in
the host. It probes OpenClaw's public plugin capabilities —
registerGatewayMethod, registerCli and
openclaw/plugin-sdk/gateway-runtime — and builds native
cron add invocations against the host's own dispatcher
(lib/setup/feature-cron-plan.js); a capability that is
missing leaves the job unregistered rather than patched in, and the
header states the install contract — it "must NEVER fail an
install" and exits 0 whatever happens. Three committed tests pin
the absence of a host patch:
tests/cron-plugin-direct-dispatch-wiring.test.js asserts
the source does not name the dispatch patch or
PLUR1BUS_SKIP_HOST_PATCH and that neither
patches/apply-memory-patches.sh nor patches/
exists (:13-14), tests/host-patch-skip.test.js
asserts the flag is gone, and
tests/release-750-compat.test.js asserts
package.json's files excludes
patches/. The patch itself was removed in release 7.5.0 on
3 September 2026 and its directory deleted two days later.
Local inference is pinned rather than resolved.
lib/providers/local-model-artifacts.js freezes each model —
E5, Jina v3, the Jina and BGE rerankers, and Jina v5 Text Nano — at an
immutable Hugging Face revision with every artifact's path, size and
SHA-256, checked before Transformers.js sees a file; the two Jina
profiles carry license: "CC-BY-NC-4.0" and
assertPinnedModelLicenseAccepted refuses to load them
without an explicit operator acceptance.
BGE is the wizard's recommended reranker, and Jina v5 Text Nano is
the embedding the wizard and the shell installer propose first for new
installs, each with the lab test's reasoning written into the README. A
non-interactive or dry run that cannot confirm the CC BY-NC licence
falls back to E5 rather than aborting or accepting it silently
(scripts/install-memory-system.sh:772-774,
PLUR1BUS_ACCEPT_NONCOMMERCIAL_LICENSE=1 to accept). Jina v3
stays selectable for existing installs, and the dashboard's dimension
planner shows a migration notice to any install whose current model is
not the recommended one
(lib/setup/control-ui-plugin-runtime.js:863-864).
The store is human-readable and repairable by hand: JSONL and
Markdown for everything except the LanceDB tables, which is a real
operational advantage when a background job has done something
unexpected. scripts/repair-installed-plugin.mjs and
lib/memory-doctor.js exist for when it has.
4. Essential Implementation Paths
Capture —
index.js:10495
api.on("agent_end", …) hands the turn to
runtimeScheduler.enqueueCapture(agentId, …)
(index.js:10553) with an abort signal. Capture is per-agent
queued and runs after the turn ends, so the model's reply is never
waiting on it. Background turns are flagged and treated differently,
which is what stops a cron-triggered agent run from writing memories
about itself.
A capture with four or more sentences can be split before it is
stored (lib/memory-chunking.js): structured text by rule,
eight or more unstructured sentences sentence by sentence with no model
call (planChunks,
lib/memory-chunking.js:190-204), four to seven unstructured
sentences left whole on the reasoning in the file header that cutting
five sentences about one topic is worse than keeping them. Splitting is
on unless captureChunking is false, and by
default the whole original row is kept beside its parts
(index.js:10817-10821). The parts are separate rows linked
by chunkGroupId, and recall admits at most two rows of one
group into a result (DEFAULT_MAX_PER_GROUP,
lib/recall-pipeline.js), so a single long message cannot
occupy the result list.
Correction —
lib/safe-update.js:320
The most carefully built path in the repository, in order:
- Refuse non-active rows. A superseded memory cannot be updated; the chain only grows at the leaf.
- Validate the ownership tuple before any read or write, requiring the binding that the row's own scope demands.
- Demand evidence.
validateUpdatePatchthrows unless a text or summary change carries bothevidence.updateSourceandevidence.updateEvidence. - Check idempotency — a SHA-256 over id, source, evidence and the patched fields, looked up in the reconsolidation event log, so a retried correction is a no-op rather than a second version.
- Demand a new vector. A text change without
patch.vectorthrows: "The embedding must reflect the new content." This closes the failure where a corrected memory keeps ranking under the old text's query. - Gate on semantic drift
(
safe-update.js:438-440) — cosine distance over 0.45 is rejected outright. - Store the new version first, supersede second
(
:456, thendb.updatewith the supersede patch). The comment at:451-455is worth reading in full: storing first means a crash leaves both versions active — "a recoverable fork, never a loss" — whereas superseding first would point the old row at an id that was never written. - Rewrite graph edges onto the new id, then append the event with the action, the source, the evidence, the confidence and the measured drift.
The idempotency lookup in step 4 reads the newest 1,000 events of
that file (isIdempotent,
lib/safe-update.js:281-287), so a retry of a correction
older than that window is written as a second version; the file's own
cap (section 3) sits above that window and does not narrow it.
The
drift gate's two callers — index.js:9881 and
lib/jobs/apply-conflict-resolution.js
/correct <old> to <new> runs a confirmation
token exchange, then calls safeUpdate with
updateSource: "telegram:/correct", an evidence string, and
skipDriftGate: true — the one place in the tree outside a
test where the flag is set.
The reasoning sits at the call site rather than in a commit message:
/correct is a nonce-confirmed user action, the confirmation
dialog shows old and new text in the clear, so high semantic drift there
is intended and consented to, and the gate would block a legitimate
large correction with an exception rather than a warning. The drift is
computed and written onto the reconsolidation event as
semanticDrift either way, so switching the gate off costs
the measurement nothing.
The gate does fire on the other caller, which is the automated path
it was written for. applyConflictViaSafeUpdate
(lib/jobs/apply-conflict-resolution.js:17) refuses outright
unless opts.confirm === true, then calls
safeUpdate without the skip flag; when the
gate throws "Semantic drift too high" the apply catches it and
returns {ok: false, reason: "review_only"} rather than
writing (:35). So a conflict resolution the detector rated
high-confidence cannot rewrite a card that has drifted too far from what
it replaces — it is downgraded to something a person must look at. That
is the shape a drift threshold wants: skipped where a human has
confirmed the exact text, enforced where a job proposes one.
Consolidation and dreaming do not call safeUpdate at all,
so the gate guards the conflict path and not those.
The confirmation dialog is the part worth copying. Target resolution
is fuzzy — candidates are resolved without a minimum score, and
"unambiguous" means only that the top match beats the second by more
than 0.15 — while safeUpdate replaces the entire text. A
prompt naming an 80-character title cannot tell a user which memory they
are about to overwrite, so it renders the stored text and the
replacement at 300 characters each. The same value carries into
provenance: payload.oldText holds the stored content being
replaced rather than the search term that found it, and
updateEvidence builds its evidence line from that.
Scope —
lib/acl-middleware.js:103
checkAccess(ctx, memory) returns
{allowed, reason} and denies with a stable reason code on:
no context, no memory, an unknown scope value, a requester with no agent
id, an invalid or conflicting ownership tuple, a private row with no
owner, a workspace row with no workspace, and a user row whose principal
is not a user:v1:<sha256> string. Every path that is
not an explicit match is a denial.
It is applied on the read path at lib/db-adapter.js:565,
:665 and :685 (query, search, get), at
lib/recall-pipeline.js:263 — where a call with no context
gets DENY_ALL_RECALL_ACL_CONTEXT (:261) rather
than everything — in the shared-memory pool, the wiki command, both
dream passes, and the Telegram query and edit commands.
filterMemoriesByAcl (acl-middleware.js:226) is
the batch form, with optional violation logging to
acl-audit.jsonl. The model's memory_recall
tool takes a query, a limit, a full-text flag and a validAt
instant (index.js:11486-11497); no argument names a scope,
an agent or a workspace.
Note that two scope vocabularies coexist: the ACL's
agent-private | workspace | user and the neo store's
agent_private | workspace_shared | global_user, reconciled
by normalizeNeoScope. Neo records are filtered by
isNeoRecordAccessible (lib/neo-arch.js:1398)
rather than by checkAccess.
Derived records — dreams, episodes, graph edges and patterns — carry
a scope on the row and are mostly read without one. Each append stamps a
visibility from the writer's binding or the record's own
agent and workspace fields (stampDerivedVisibility,
lib/neo-arch.js:1420, wired at :1849-1878);
the light dream builds one directly at
lib/dreaming/light-dream.js:474, the REM-dream pattern
writer at lib/dreaming/rem-dream.js:1204. Each of the four
readers takes an optional requester filtered through
isDerivedRecordAccessible (:1452), which shows
an unstamped legacy row only to its owning agent and denies a foreign
one (tests/derived-record-scope.test.js). The filter runs
only when a requester is passed. The REM-dream pattern read passes one
(lib/dreaming/rem-dream.js:1221); the graph-edge and
episode reads in index.js, the edge rewrite in
lib/safe-update.js:247, reactivation
(lib/conversation-reactivation-recall.js:923) and the
pattern match on the recall path (index.js:12887) pass none
and read the workspace's whole file.
The dream reader shows the failure direction of a fail-closed ACL,
and it is worth recording because it is the opposite of a leak. The
REM-dream candidate loader built its scope partition as
user or workspace only — never
agent-private — so every agent-private candidate was
rejected by the partition match. On stores where the week's candidates
were all agent-private (measured at 70/70 and 49/49 on two live agents),
the job permanently reported too_few_memories and did
nothing: a correct filter handed the wrong partition produces zero
output rather than an exposure. buildRemPartitions
(lib/dreaming/rem-dream.js) runs every sensible partition,
agent-private first, with per-partition dedup and vault
files; tests/rem-dream-acl-partition.test.js asserts the
workspace-only partition returns null candidates against the same
LanceDB table. The per-card ACL also covers the /critical
review surface (lib/critical-review.js).
Status transitions, and a dedupe key that had to be designed
The neo store is append-only JSONL with an id index, and appends are
deduplicated. That creates an obvious hazard:
transitionRecordStatus (lib/neo-arch.js:1372)
returns the same record with a new status, the same id and a
fresh updatedAt, so an id-keyed dedupe would silently
swallow every promotion. It does not, and the reason is three small key
functions at lib/neo-arch.js:2305-2330:
function appendDedupeId(record) {
if (!record || typeof record !== "object" || !record.id) return "";
if (record.updatedAt || record.embeddingUpdatedAt) return "";
return String(record.id);
}
function recordStatusTransitionDedupeKey(record) {
if (!record || typeof record !== "object" || !record.id || !record.updatedAt) return "";
const status = normalizeNeoStatus(record.status, "");
if (!status || status === "candidate") return "";
return `status:${record.id}:${status}:${record.updatedAt}`;
}
function appendCandidateContentDedupeKey(record) {
if (!record || typeof record !== "object") return "";
const statusKey = recordStatusTransitionDedupeKey(record);
if (statusKey) return statusKey;
const key = recordDedupKey(record);
if (!key) return appendDedupeId(record);
return `content:${stableHash("candidate-content", key)}`;
}
Which key applies depends on the file. Turns, reactions and behaviour
cards use appendDedupeId, the default in
appendJsonlDedupe (:2334): a fresh record is
keyed by bare id, and a record carrying updatedAt gets no
key and always appends, so a transitioned behaviour card is never
swallowed. The candidates file passes
appendCandidateContentDedupeKey (:1828), and
that is where the promote, demote, prune and tombstone commands write
(index.js:9035-9036). A transition there is keyed on id,
new status and updatedAt; a record in
candidate is keyed on a hash of its normalized statement
(recordDedupKey, :1655), so a second capture
of the same sentence is dropped while a transition is never mistaken for
one. The residual gap is millisecond-wide: two transitions to the same
status within the same updatedAt collapse into one.
Recall
lib/recall-pipeline.js runs lifecycle filtering, ACL
filtering, namespace merge with canonical-content dedupe, Jaccard dedupe
at 0.78 with the per-message group cap, graph hydration and reranking,
emitting a decision trace throughout
(lib/recall-decision-trace.js) and a retrieval ledger entry
per query. The final cap to topN runs after the reranker
rather than before it, so the reranker can promote a row from below the
cut; the comment at the cap records the measurement behind the move — on
80 benchmark questions whose evidence had been missed, capping after the
rerank found 65 and capping before found 11. Importance is not a ranking
term: applyImportance is fixed to false and
importance reaches the score only through the half-life it sets on
memoryStrength.
/memory <query> --explain renders the trace back to
the user, so "why was this memory shown" is answerable without reading
logs.
Tests covering the behaviour
tests/crr-status-filter.test.js is the sharpest one: it
constructs a superseded and an active memory with identical text, runs
the reactivation selector, and asserts the superseded one is absent from
the block that gets injected into the prompt. The header names the
regression it locks — reactivation reached the semantic lens without a
status filter, so a corrected memory could resurface as current
evidence.
5. Memory Data Model
A LanceDB card, from buildUpdateEntry
(lib/safe-update.js:91), carries roughly fifty fields. The
ones that matter:
- Identity and lineage —
id,versionNumber,previousVersion,supersededBy,status,versionCreatedAt,chunkGroupId. - Provenance —
sourceTurnId,sourceMessageRole,sourceTimestamp,sourceUrl,evidenceQuote,updateSource,updateEvidence,reconsolidationConfidence. This is typed provenance in columns, not a metadata blob, and it is the part most systems in this atlas skip. - Ownership —
agentId,storedBy,workspaceId,workspaceKey,scope,ownerUserId. - Dynamics —
importance,importanceStatus,memoryStrength,halfLifeDays,lastStrengthenedAt,retrievalCount,lastRetrievedAt,replayCount,memoryClass,neverForget,coreMemoryScore. - Affect —
emotionalValence,emotionalIntensity,emotionalDominant,moodContextAtCapture.
neverForget and memoryClass: "core" are
honoured by the garbage collector
(lib/garbage-collector.js:86-88), which is a small thing
that many decay implementations forget: a decay curve with no pin will
eventually reach the memories the user cared most about.
Two fields are value-keyed in the way the atlas asks for.
A validity window. validFrom and
validUntil (lib/db-adapter.js:485) record when
a claim was true in the world, 0 meaning "no known bound"
rather than the epoch. They are separate from
createdAt/updatedAt, and the file header
states the separation outright: they are "the REAL-WORLD validity
window of a claim … independent of and orthogonal to … System
Time."
Recall threads an optional validAt instant through every
chokepoint — isEntryValidAt does a
left-inclusive/right-exclusive
validFrom <= validAt < validUntil, pushed down to the
vector store as SQL — and the memory_recall tool exposes it
directly ("restrict recall to facts valid at this specific point in
time"). The writer is the model's memory_store tool,
whose validFrom and validUntil arguments are
described as dates the user stated or clearly implied
(index.js:11663). Historical facts are sibling rows with
disjoint windows, not edits to a version chain, so validity time and
record time are two different questions. Validity is caller-supplied
only, never guessed from text: a vague phrase resolves to
0/unknown rather than a fabricated date.
A rejected-value tombstone. /forget
soft-deletes the row (tombstoneCard,
db-adapter.js:741 — status="deleted",
epistemicStatus="invalidated") and writes a durable
tombstone keyed on a content fingerprint, a SHA-256 of
the NFKC-normalized text and never the plaintext
(contentFingerprint, lib/tombstone.js:69), to
an append-only registry that survives restore, migration and
re-embedding.
findBlockingTombstoneForCapture runs as step zero of
both capture paths (index.js:6827, :11732),
and assertCardWriteAllowed
(lib/tombstone-write-guard.js) runs the same check in
MemoryDB.store and MemoryDB.update
(index.js:1844, :2190), the adapter's
updateCard (db-adapter.js:790), the compaction
merge (lib/jobs/memory-compaction.js:909), the light-dream
rewrite (lib/dreaming/light-dream.js:159) and the
auto-capture script; corrupt or unreadable registry lines fail closed.
This is the value-keyed mechanism the rejected-value
tombstone pattern describes, and it supersedes the record-keyed
tombstoned neo status as the thing that keeps a forgotten
value gone.
What is absent:
- A requester on the derived-record reads. Dreams,
episodes, graph edges and patterns carry a stamped
visibility, but only the REM-dream pattern read passes a requester to the filter; the others read the workspace's whole file (section 4).
6. Retrieval Mechanics
Automatic injection on the turn, plus explicit /memory
and plur1bus_recall tool access.
Ranking blends vector similarity, lexical overlap, memory strength, emotional and epistemic terms, category lane matching, and the trust and status arithmetic quoted in section 2, followed by a reranker. Results are deduplicated twice — by canonical content key across namespaces, then by Jaccard similarity at 0.78 with at most two rows from one split message — which matters in a system that keeps every version of a memory, because a v3 and a v4 of the same fact are near-identical text.
Two additive passes sit after primary recall and are architecturally
constrained rather than merely documented: the semantic lens reads a
precomputed index and appends community, bridge and faded memories;
conversation reactivation appends a
<memory-reactivation> block on an idle gap or after
compaction. Both cap their output (three memories, one faded, three open
threads), both time out at 50 ms, both fall back to the unmodified base
recall, and neither writes anything.
The failure mode to watch is over-recall by construction. Base recall, plus graph hydration of neighbours, plus lens, plus reactivation, plus temporal context, plus emotional state, plus persona voice all target the same prompt, and they share one aggregate cap.
The auto-recall hook hands its blocks to
applyGlobalInjectBudget
(lib/inject-budget.js:201, called at
index.js:13465) with
recall.globalInjectMaxChars, default 17,000 characters.
Persona voice, mood, reactions, dream echo, open threads, contradiction
disclosure, memories and reactivation travel as one droppable block,
trimmed first and at a </memory-record> boundary so
no record is cut mid-element; the start notice and the neo lanes are
trimmed after it. The time, temporal-continuity and reminder blocks are
marked not droppable and pass whatever their size. The memories text
also carries its own cap, recall.memoriesMaxChars, default
12,000 (index.js:13205). Three other returns bypass the
aggregate cap: a prompt under five characters or a dream-pass prompt
returns the neo lanes alone (index.js:12562,
:12570), the recall error path returns the neo lanes and
the start notice (:13480), and the hook used when
auto-recall is off joins its nudges unbudgeted
(:13593).
lib/temporal-provenance.js is the interesting
counterweight and is unusual enough to name. It classifies a recalled
memory by age and by whether its content is operational — cron,
systemctl, deploy, gateway, migration — and by destructive keywords,
then decides whether the agent must verify live before acting on it. A
memory that a cron job is disabled is treated as a fact about the past
rather than the present after fifteen minutes. That is the right shape
for the class of memory that gets an agent into trouble.
The guard is only as good as the timestamp reaching it, and the
timestamp is produced by the mapping layer rather than by the store.
Canonical hits from KNOWLEDGE.md carry no
createdAt of their own and take the file's mtime as their
age, and they are marked authoritative and exempted from
the operational guard on the reasoning that a canonical document is the
reference something else is verified against. Semantic-lens
hits copy createdAt, updatedAt and
lastRetrievedAt off the underlying entry, and the
reactivation block renders age and freshness rather than omitting them.
parseMemoryTimestamp discards a value outside the
representable Date range the way it discards a missing one,
which keeps buildTemporalProvenance from throwing a
RangeError and taking the whole recall rendering with it —
the age label is therefore always unknown or
<n>[mhd] ago, which is what the reactivation renderer
assumes.
7. Write Mechanics
Writes are created by the agent_end capture, by explicit
tool and command use, by the Obsidian bridge importing vault edits, and
by background jobs.
Conflict handling is split.
lib/contradiction-detector.js asks an injected LLM whether
two interpretation overlays of the same memory are mutually incompatible
and persists findings to contradictions.jsonl;
lib/memory-text-contradiction.js and
lib/jobs/conflict-resolver.js cover the card text. The
output is a conflict status and a listing under
/plur1bus curation conflicts — a queue for a person, not a
resolution.
Malicious input is filtered at capture.
PROMPT_INJECTION_RE (lib/neo-arch.js:106)
matches the familiar overrides plus chat-template delimiters, and a turn
marked quality.promptInjectionSuspected is excluded from
the recallable set at neo-arch.js:1276. The
injected-context marker list discussed in section 2 closes the
self-capture loop. lib/relevant-memory-context.js prepends
a recall safety preamble telling the model that memory content is
data.
What gets logged where. A correction through
safeUpdate appends to
reconsolidation-events.jsonl in the neo store, which is
capped and rewritten (section 3). Deletions, trust transitions
(index.js:2446), validity closes (:2488),
curation resolutions (:8854), injected-conflict drops
(:8925), conflict applies and overlay changes append to
.adaptive-learning/destructive-ops.jsonl through
appendDestructiveOpLog
(lib/sql-safety.js:192), an appendFileSync
that nothing in lib/, index.js or
scripts/ rewrites;
scripts/repair-tombstones.mjs reads it to reconstruct
tombstones. A /forget fails if its line in that file cannot
be written.
Operational cost
- The write path is deferred. Capture runs after
agent_endthrough a per-agent scheduler; the agent never blocks on extraction. - The lag before a memory is retrievable is
capture-queue depth plus an embedding round-trip, and it is not measured
anywhere in the repository. Embeddings are queued through
embedding-queue.jsonland drained by a cron, so a memory can be lexically retrievable before it is vector-retrievable — an interval nothing bounds. - Background passes rewrite broad slices of the
store. Daily consolidation, memory compaction, memory-dynamics
maintenance, GC, skill mining, REM dreaming (weekly) and light dreaming
each read and write in bulk, and their token bill scales with the corpus
rather than with the day's traffic. Most default off;
scripts/setup-feature-crons.mjsregisters only those explicitly enabled. - Read-path injection is bounded in aggregate on the main return. The 17,000-character budget covers every droppable block, and three blocks and three early returns sit outside it (section 6). All of it is injected as a per-turn prefix, which will invalidate a provider's prompt-prefix cache on every turn in which any of it changes.
8. Agent Integration
The plugin registers commands (/memory,
/forget, /correct, /state,
/enable, /disable, and a
/plur1bus namespace covering curation, memory, behaviour,
dreaming, skills, reminders and critical review), an
agent_end hook, gateway start/stop lifecycle hooks, and
tools for explicit recall.
The model has more agency than the command list suggests, and this is
why the report carries no human_review mark. Promotion,
demotion and pruning are authorized human commands:
isDestructiveAction (index.js:7271) routes
them through checkAuth(..., { destructive: true }), which
under isAuthorized (lib/security.js:89)
demands a userId on the allowlist, or — with no allowlist
configured — a private 1:1 chat, refusing groups and unknown chat kinds.
That is a real actor check on the channel, and none of those verbs
appears on the model's tool surface.
Tombstoning does. api.registerTool
(index.js:11474) declares the model's tools, and one of
them is memory_forget (index.js:11911), which
resolves a card by id or query and calls
tombstoneMemoryWithAudit — no confirmation token, no nonce,
no chat. It is scope-checked (checkAccess on every hit,
with a deliberately identical "No matching memory found" for a
denial so the error is not an existence oracle) but not actor-checked.
The only gate is security.allowModelDestructiveMemoryOps,
read as !== false (index.js:11477) and so
on unless explicitly disabled;
tests/config-audit.test.js:440 pins that default. The
refusal text the flag unlocks states the problem exactly:
"model-facing tool calls do not carry a user-bound authorization
context." The repository's own July security scan reached the same
finding, and it is open at this pin.
The second tool, knowledge_update
(index.js:12054), drains the knowledge-promotion queue the
capture path fills. trackKnowledgePending
(index.js:4039) queues a memory for curation into
KNOWLEDGE.md; once three are waiting,
<knowledge-update-reminder> is injected into the
model's own prompt (index.js:3276-3285) telling it to call
the tool. A queue whose only drain is the producer, prompted by the
producer's own context, is not a review.
The critical-review surface is a notification with an acknowledgement
ledger, and it has three doors for a person.
/plur1bus critical accept all, reject all and
several references in one command work every pending review in the
authorised scope. A quoted reply to a push — "accept all",
"alle ablehnen" — is answered on the host's
before_dispatch and before_agent_reply hooks
before the agent sees it (answerQuotedCriticalReply,
index.js:10145, registered at :10246), with
the references taken from the quoted push's fixed header and the same
destructive authorisation as the command.
Each card can also arrive as its own Telegram message with Accept and
Reject buttons (lib/critical-buttons.js, on unless
criticalPush.buttons is false). The handler
(index.js:10187-10234) refuses a group, a sender the host
has not authorised, a click outside the direct chat with that sender,
and a click arriving through a bot other than the one bound to the
card's agent, then runs the same authorised command. A reject never
deletes: markCriticalRejected
(lib/db-adapter.js:1159) sets
confirmed = 1, type = "note". Dream narratives are never
classified or pushed: the classifier query excludes origin
or memoryClass dream in SQL and again in code
(db-adapter.js:952-958, :986), counting them
as skippedDreams
(lib/jobs/critical-classifier.js:150), after a light dream
about a person reached that person's critical push as a relationship
fact.
What the review does not do is hold anything back.
confirmed is written by markConfirmed,
markCriticalAccepted and markCriticalRejected
(lib/db-adapter.js:1117, :1136,
:1159) and read by two functions,
findUnconfirmedCritical and
findPendingCriticalReviews (:1049,
:1192), both of which build a pending list. No recall,
injection, scoring or dream path consults it;
lib/recall-pipeline.js:150 carries the column through and
nothing downstream branches on it. An unconfirmed critical card is
recalled like any other.
And the queue drains itself: the daily job the cron plan registers as
auto-accept-stale under the same criticalPush
switch that creates the cards
(lib/setup/feature-cron-plan.js:63-77,
:331-336) calls expireStaleCriticals
(lib/jobs/auto-accept-stale-criticals.js:73, dispatched at
index.js:7755-7761), which passes every card unconfirmed
for 24 hours to markCriticalRejected. A label nobody
confirmed lapses to a plain note rather than being accepted, which is
the safer default; it is a decision made by a clock, and the card was
recallable throughout. The older autoAcceptStale is kept,
marked deprecated, and has no caller.
The operator dashboard is read-only unless
controlUi.writeActions is set — off by
default, reranker for a runtime switch, all
for the embedding target and the re-embedding migration — with a
single-use form token per page load and a nonce-bound CSP
(lib/setup/control-ui-write.js). Light and REM dream
narratives are written into the workspace DREAMS.md inside
the host's managed block and announced as a
memory.dream.completed event
(lib/dreaming/dream-diary.js).
The Obsidian bridge is the second integration and the more unusual
one. Memory is mirrored into a vault as Markdown, a person edits or
annotates it there, and the bridge syncs changes back — under an
explicit stance stated at the top of
lib/obsidian-control-room.js: PLUR1BUS stays authoritative,
vault text is untrusted input, and apply never mutates memory without
explicit approval plus immediate revalidation. Deleting a vault file
does not delete a memory; it raises an
approval_required_tombstone action
(lib/obsidian-bridge.js:1553). The vault carries human
edits into memory, which is the opposite direction from a gate
on what the machine writes.
A write into a vault needs more than the bridge's approval flow:
lib/obsidian-vault-authority.js binds a confirmation
receipt to the agent, the workspace pool and a SHA-256 of the vault's
real path under
<baseDbPath>/.plur1bus-authority/obsidian-vaults/…,
and obsidianServiceMutationPolicy
(index.js:7002) requires that receipt plus an action
confirmation, with scheduled discovery carrying an explicit plan.
Adapting this to another agent host would be substantial work. The plugin is written against OpenClaw's plugin API, its cron dispatch, its agent workspace resolution and its command registration.
9. Reliability, Safety, and Trust
Strengths:
- Correction demands evidence — a source and a quote — and refuses a text change without a matching new embedding.
- Write ordering is reasoned about explicitly, with the crash window named in a comment and resolved in favour of a recoverable fork.
- Idempotent corrections via a hash checked against the newest 1,000 events of the log.
- An append-only destructive-operation log for
deletions, trust transitions, validity closes and curation decisions,
which a
/forgetrefuses to proceed without. - A fail-closed ACL on the read path, whose tests assert denials, and a recall pipeline that denies everything when it is handed no context.
- Recall output cannot become capture input, closing a feedback loop the project traces to a dated performance analysis.
- Prompt-injection suspicion excludes a turn from recall, rather than only logging it.
- Age-conditioned action guards for operational memories.
- Pins survive decay —
neverForgetandmemoryClass: coreare honoured by the GC. - A repairable store — JSONL and Markdown, plus a doctor and a repair script.
- The scorer reads the newest revision of an append-only record, so a status a person set is the status the ranking arithmetic uses.
- A correction dialog that shows what it will overwrite, at 300 characters of old and new text, against a target resolved by fuzzy match.
- A validity window separate from record time, queryable as-of, so a corrected fact preserves the period the old value was in force rather than erasing it.
- A value-keyed tombstone that blocks re-storing a
forgotten sentence at every card writer that adds new text, keyed on a
content fingerprint and never the plaintext, and gated on a binding
audit —
/forgetfails if the audit record cannot be written. - One doubt state that withholds. The epistemic
invalidatedstatus is a hard filter at all three read layers, and transitions intotrusted/invalidatedrequire an authorized actor, so a memory cannot condemn or promote itself. - One aggregate injection budget, trimmed at record boundaries so a cut never leaves half an element in the prompt.
- A direct chat resolves to an identity-bound
context.
resolveSessionOwnerMemoryContext(lib/memory-request-context.js:744) turns a direct-chat session key into the user, channel, account and conversation principal the chat commands see, while main, heartbeat, cron and group sessions keep the agent-and-workspace context; shared workspace and user pools are named from host configuration and never expose the user identifier. - Pinned model artifacts — revision, size and SHA-256 per file, and a licence acceptance gate on the CC BY-NC models.
Gaps:
- Contradiction does not withhold.
conflictand the trust ladder are ranking arithmetic —conflicta 0.3 penalty atlib/neo-arch.js:1503— so a memory the system records as contradicted can reach the prompt labelled with its status, moving the decision to the model.demotedand the epistemicinvalidatedstate withhold; the status that flags contradiction does not. - The correction evidence is capped.
reconsolidation-events.jsonlholds the source, quote, confidence and drift of every correction, andappendJsonlkeeps its newest 5,000 lines while the daily consolidation rewrites it; the ledger that answers "why does the system believe this" for a corrected card forgets its oldest answers. The uncappeddestructive-ops.jsonldoes not record corrections. - The drift gate is skipped on the confirmed human correction and enforced on the automated conflict apply, where exceeding it downgrades the write to a review rather than blocking with an exception.
- Derived records are read unscoped by most callers.
Dreams, episodes, graph edges and patterns carry a
visibilityand their readers accept a requester, but only the REM-dream pattern read passes one; the pattern match on the recall path (index.js:12887) reads the workspace's whole file. - A tombstoned card reached a push. Until release
7.9.2 on 5 September 2026 the classify-recent cron treated rows removed
by
memory_forget—typememory,statusdeleted— as fresh candidates, typed them and named them in a critical push, while the review path read only active rows and could not resolve the references.findRecentUnclassified(lib/db-adapter.js:933) pushes an active-status clause into the LanceDB query andrunClassifierreports what it skipped asskippedInactive(lib/jobs/critical-classifier.js:116-144), withtests/critical-classifier-double-push.test.jscovering it. The tombstone held at the capture chokepoints and leaked at a read path nobody had listed, which is the shape a value-keyed tombstone's remaining risk takes. - Merging is proposal-only, and nothing acts on the
proposals. With
merging.autoApplyat its defaultfalse,executeActions(lib/jobs/memory-compaction.js:1104) executes nothing and callspersistProposals(:994), which appends one{proposedAt, actions, aclBindings, status: "pending"}line per run to.adaptive-learning/merge-proposals.jsonl(:1002). Searching the tree for that filename finds the writer, the backup and restore scripts that copy it, three tests that assert the file was written, the README, a migration note and an audit artifact — no reader that applies or reviews a proposal. The documented intent, "never auto-applies", is met; the unstated half is that the duplicates the daily job detects are never merged by anything, and the ledger grows. - The model can tombstone without a person.
memory_forgetis a declared tool with no confirmation exchange, enabled unlesssecurity.allowModelDestructiveMemoryOpsis set to exactlyfalse, and the refusal text behind that flag names the reason it should not be: model-facing tool calls carry no user-bound authorization context. The detail is in section 8. postinstallcannot fail by contract, and what it does is bounded to registering crons through the host's public API.- A prompt-facing value can be produced by four different mapping paths, and correctness has to be established at each one rather than at the store.
- The feature surface is the risk. Fifty-five config
groups, fifteen background jobs and two dream passes over one memory
store means the number of paths that can write to a card is large, and
only one of them goes through
safeUpdate.
10. Tests, Evals, and Benchmarks
The memory tests need no framework: npm test is
node --check on selected modules followed by
node --test over tests/ and
test/, and the regression files import only node builtins
and in-tree modules, so they run without the
@lancedb/lancedb install. For this reading nothing was
installed or run; the behaviour was read from the source and its
committed tests. The last executed run, three such files with a negative
control on a scratch copy, is recorded in the History entry of 11 August
2026.
509 test files under tests/ and test/ —
larger than the implementation, and the largest are the subsystems the
marks rest on: valid-time.test.js (1,721 lines),
epistemic-status.test.js (974),
tombstone.test.js (509), and a family of
tombstone-* files covering torn writes, the registry cache,
scope, query recovery, bulk writers and the forget scripts.
What is covered, by name: ACL call-site adapters and ownership
binding, shared-memory recall and the share store, sensitive-read
authorization, safe-update data loss, the DB adapter's
updateCard data loss, dedupe and status-filter regressions,
contradiction detection across four files. Beside those: the embedding
cache, the LLM result cache, cron bootstrap and direct dispatch, GC's
neverForget guard, the injection budget
(tests/inject-budget.test.js), the neo cap's rewrite
behaviour (tests/neo-cap-rewrite-thrash.test.js), Obsidian
command gating, vault confirmation, review authority, and zero-mutation
guarantees.
The negative assertions are real and specific.
tests/crr-status-filter.test.js asserts a superseded memory
must not reach the reactivation block;
semantic-lens-status-filter.test.js asserts an
invalidated memory is not surfaced by the lens while a
trusted one is, so it proves discrimination rather than blanket
suppression. tombstone-e2e.test.js asserts a re-store after
/forget returns tombstone_blocked and that
/forget fails if its binding audit cannot be
written; correct-tombstone-guard.test.js asserts a
tombstoned card is not revived by a correction (updateCard
call count 0). tombstone-bulk-writers.test.js runs eight
cases against the compaction merge, the auto-capture script,
MemoryDB.store and the light-dream rewrite, each asserting
that forgotten text produces no table.add while a same-text
light-dream replay does.
tombstone.test.js asserts no plaintext lands in the
tombstone and that only a committed tombstone blocks — a failed
or merely attempted one does not.
tests/b13-acl-callsite-adapters.test.js asserts an unbound
private row, a conflicting ownership tuple, and a raw user id in place
of a canonical principal all fail closed;
tests/gc-neverforget-guard.test.js asserts pinned memories
are not archived. On the bitemporal side,
valid-time.test.js pins the right-exclusive boundary, the
BigInt-zero open-window sentinel, and that
createdAt/updatedAt are never read as validity
bounds.
Retrieval quality has a harness and committed numbers.
bench/ (1,014 lines) drives
lib/recall-pipeline.js directly against its own LanceDB
stores built from LOCOMO and LongMemEval, never through the gateway and
never against a production store. The datasets and stores are not
committed (bench/.gitignore), the answer and judge models
need an API key, and the harness sits outside npm test.
Five result files are committed: four LOCOMO runs of 1,986 questions
each and one LongMemEval run of 500.
The README scores categories 1–4 only and reports, besides answer
accuracy, an evidence rate — whether recall returned the right memory —
which is independent of the answer model. Recounting the lines of
bench/results/locomo-topn15-prod.jsonl gives 61.4% judged
accuracy and a 91.1% evidence rate over categories 1–4, within a point
of the README's 60.9% and 91.3%; 36 category 1–4 lines carry no
yes-or-no verdict, which is where the counting rules can differ. The
README states its own comparability limit: a retrieval budget of 15
against the top-k 200 other vendors report.
bench/findings/2026-09-20-harness-defer-final-cap.md
records the defect the harness found in itself, a cap applied before the
reranker that understated every run before 20 September 2026.
The harness never touches the neo lane:
scoreNeoRecallItem, routeNeoRecall and
neo-arch appear nowhere under bench/. The
seven weights in the neo scorer are validated by nothing in the
repository; the LanceDB pipeline's ranking is measured end to end.
tests/recall-golden-set-*.test.js are deterministic
regressions over mocked distances that pin the pipeline's arithmetic,
not its quality. No paper about the system and no citation file exists
in the tree; the README's one arXiv link (README.md:1400)
is to the jina-reranker-v3 paper, cited for a reranker table. The
documentation is a 108 KB README, a 318 KB changelog, and a 97 KB
how-to-memory-perfect.md.
Three tests pin the absence of the host patch and one pins the
classifier's tombstone respect, and they are the right shape — each
asserts an absence against the source or the package manifest with a
positive control beside it:
tests/cron-plugin-direct-dispatch-wiring.test.js,
tests/host-patch-skip.test.js,
tests/release-750-compat.test.js and
tests/critical-classifier-double-push.test.js.
tests/neo-status-transition-dedupe.test.js is worth
reading for its shape as much as its subject: it pins the arithmetic to
numbers — active=0.371 against demoted=-0.116
at a live minScore of 0.08 — so the assertion
is about which side of the admission threshold each copy falls on, not
about an ordering that a weight change would silently invert.
What is not asserted: that the reconsolidation log survives its own
cap. tests/neo-cap-rewrite-thrash.test.js tests the cap's
I/O behaviour on a generic file, and no test names
reconsolidation-events.jsonl beside the cap.
11. For Your Own Build
Steal
- Require evidence for a content change. A source and a quote, validated at the function boundary, turns "the model decided to update this" into a record you can audit later. It costs two required arguments.
- Require a new embedding with new text. A corrected memory that keeps its old vector ranks under the old query forever, and nothing about it looks wrong.
- Store the replacement before superseding the
original, and write down why. The crash window is real, the
comment at
safe-update.js:451-455is the artifact, and the resulting failure — both versions active — is one a person can fix. - Key an idempotency hash on the correction, not the record, so a retried correction cannot fork a version chain.
- Make recall output unrecapturable. Marker-match your own injected blocks and refuse them as candidates. The failure this prevents is a store that inflates on its own output.
- Condition action on the age of the specific memory. For operational facts — a service state, a deploy, a cron — "recalled and recent" is a different authorization than "recalled".
- Design the append-key before making a log append-only. A status change carries the same id as the record it changes; an id-keyed dedupe would eat it silently.
- Put the tombstone check in the writer, not the
caller. A guard inside
storeandupdatecovers a background pass nobody has written yet; a guard at two capture call sites covers two call sites. - Pin memories out of decay. A
neverForgetflag the GC honours costs one condition and saves the memories a decay curve is worst at keeping.
Avoid
- Discrete trust states wired to a score. If
conflictis a 0.3 penalty, the system cannot refuse to act on a contradiction — it can only be slightly less enthusiastic. Decide which states filter and which rank, and make the filtering ones filter. - One append helper for journals and ledgers. A bounded-growth rule written so the turn journal cannot fill a disk also caps the file that holds every correction's evidence. Give an audit log its own writer, one with no cap.
- A safety gate with no live caller. A threshold every caller disables is one nobody is maintaining, and it reads as protection in the schema. The resolution worth copying is the one here: keep the skip where a human confirmed the exact replacement text, enforce it where a job proposes one, and convert the exceeded gate into a review outcome instead of an exception the caller has to catch.
- Deduplicating an append-only log by first appearance. If a state change appends rather than replaces, the first copy is the pre-change one, and every consumer that keeps it is reading the record as it was before the decision. Pick the newest revision by a field the transition actually sets, and check that the field differs between revisions before relying on it.
- Instructing a model to weigh a distinction your renderer omits. A prompt supplement that says prefer active over conflicting needs the status in the payload; otherwise it is an instruction the model has no way to follow and no way to report it cannot.
- A review queue nothing reads. A
confirmedflag that no recall path consults, drained by a daily job, records acknowledgement and withholds nothing. If unconfirmed should mean unused, the read path has to say so.
Fit
This suits one specific reader: someone running OpenClaw for themselves or a small team, who wants a memory that grows and is willing to operate it. The feature surface assumes a maintainer who enjoys the surface — dreaming, emotional state, persona voice and an Obsidian vault are not incidental extras, they are most of the product, and someone who wants only "the agent remembers what I told it" will be configuring their way out of features for a while. Defaults help: most of the elaborate machinery ships off.
Walk away if you need multi-tenant guarantees. The read-path ACL is
good, but most readers of derived records pass no requester, background
jobs write across the store, and the failure mode of a scope gap is
unrecoverable. Walk away if you need a complete correction history: the
evidence for each correction lives in a capped file. Walk away if you
cannot accept a postinstall that registers crons in your
host and cannot fail by contract.
The part worth taking whatever you are building is
lib/safe-update.js. It is 509 lines, has one dependency on
the rest of the system, and is the most complete answer in this atlas to
"what does it take to change a memory without losing the old one".
12. Open Questions
- What is the lag between capture and vector-retrievability under a real embedding cron? Nothing in the tree measures it.
- Do the seven weights in
scoreNeoRecallItemcome from measurement or from judgement? The benchmark harness does not reach them. - How large do the non-droppable time, temporal-continuity and reminder blocks grow, and does anything bound them outside the aggregate budget?
- Do the row copiers — the re-embedding backend
(
lib/reembedding/lance-backend.js:474) andscripts/dedupe-memory-ids.mjs— ever copy a row whose text a later/forgetfingerprinted? Both add rows without consulting the tombstone guard. - Which other read paths besides classify-recent touch cards without the active-status clause? The 7.9.2 fix listed one; nothing in the tree enumerates the rest.
- How many other prompt-facing fields are produced by more than one mapping path, and is there a check that all of them agree?
Appendix: File Index
- Correction and versioning:
lib/safe-update.js,lib/memory-history.js,lib/memory-merge-safety.js. - Scope and access:
lib/acl-middleware.js,lib/memory-request-context.js,lib/security.js,lib/sql-safety.js. - Epistemic states, neo store, injection guards, the JSONL cap:
lib/neo-arch.js,lib/epistemic-status.js. - Validity time (bitemporal):
lib/valid-time.js,validFrom/validUntilcolumns inlib/db-adapter.js,validAtrecall parameter inindex.js. - Rejected-value tombstone:
lib/tombstone.js,lib/tombstone-write-guard.js,lib/registry-lock.js,scripts/reapply-tombstones.mjs,scripts/repair-tombstones.mjs. - Audit logs:
lib/sql-safety.js(destructive-ops.jsonl),lib/safe-update.jsandlib/neo-arch.js(reconsolidation-events.jsonl),lib/jobs/daily-consolidation.js(the prune). - Retrieval:
lib/recall-pipeline.js,lib/recall-decision-trace.js,lib/semantic-lens-index.js,lib/conversation-reactivation-recall.js,lib/relevant-memory-context.js,lib/inject-budget.js,lib/memory-chunking.js. - Storage adapter:
lib/db-adapter.js,lib/multi-namespace-pool.js,lib/shared-memory.js. - Contradiction and overlays:
lib/contradiction-detector.js,lib/memory-text-contradiction.js,lib/interpretation-overlay.js,lib/overlay-generator.js. - Decay, GC and dynamics:
lib/memory-dynamics.js,lib/garbage-collector.js,lib/temporal-provenance.js. - Human surfaces:
lib/obsidian-control-room.js,lib/obsidian-bridge.js,lib/obsidian-mutation-policy.js,lib/obsidian-review-authority.js,lib/critical-review.js,lib/critical-buttons.js,lib/telegram-commands/. - Background work:
lib/jobs/,lib/dreaming/,lib/runtime-scheduler.js. - Cron registration through the host's public API:
scripts/setup-feature-crons.mjs,lib/setup/feature-cron-plan.js; nopatches/directory exists, andtests/cron-plugin-direct-dispatch-wiring.test.jsasserts it. - Critical review:
lib/critical-review.js,lib/critical-reply-intent.js,lib/critical-buttons.js,lib/jobs/critical-classifier.js,lib/jobs/auto-accept-stale-criticals.js. - Benchmark:
bench/run.mjs,bench/lib/common.mjs,bench/README.md,bench/results/. - Local model pinning:
lib/providers/local-model-artifacts.js. Dashboard writes:lib/setup/control-ui-write.js. Vault authority:lib/obsidian-vault-authority.js. Dream diary:lib/dreaming/dream-diary.js. - Tests cited:
tests/crr-status-filter.test.js,tests/b13-acl-callsite-adapters.test.js,tests/gc-neverforget-guard.test.js,tests/safe-update-dataloss.test.js,tests/valid-time.test.js,tests/tombstone-e2e.test.js,tests/tombstone-bulk-writers.test.js,tests/correct-tombstone-guard.test.js,tests/semantic-lens-status-filter.test.js,tests/derived-record-scope.test.js,tests/rem-dream-acl-partition.test.js,tests/epistemic-status.test.js,tests/inject-budget.test.js,tests/neo-cap-rewrite-thrash.test.js,tests/cron-plugin-direct-dispatch-wiring.test.js,tests/host-patch-skip.test.js,tests/release-750-compat.test.js,tests/critical-classifier-double-push.test.js.
Recorded searches
Run at the tree root of the pinned checkout with
git grep.
git grep -nE 'globalInjectMaxChars' -- index.js openclaw.plugin.json—index.js:13474, the budget's one reader, and the schema entry atopenclaw.plugin.json:1334.git grep -nE 'prependContext' -- index.js lib— six hits; one return goes throughapplyGlobalInjectBudget(index.js:13465), and the early, error and auto-recall-off returns at:12562,:12570,:13480and:13593do not.git grep -nE 'reconsolidation-events|reconsolidationEvents' -- lib index.js scripts— the path, theappendJsonlwriter atlib/neo-arch.js:1880, a tail reader at:1913, and thepruneAlltarget at:1946; no uncapped writer.git grep -nE 'pruneAll\(' -- index.js lib scripts—lib/jobs/daily-consolidation.js:448only.git grep -n 'destructive-ops' -- lib index.js scripts— theappendFileSyncwriter atlib/sql-safety.js:197, a writability probe inlib/wiki-command.js, and the readerscripts/repair-tombstones.mjs; nothing rewrites, truncates or renames it.git grep -nE '[.?]confirmed([^A-Za-z_]|$)' -- lib index.js— the two pending-list builders atlib/db-adapter.js:1049and:1192; every other hit copies or normalises the value.git grep -nE 'autoAcceptStale|expireStaleCriticals' -- index.js lib scripts—autoAcceptStalehas its definition and no caller;expireStaleCriticalsis imported atindex.js:208.git grep -nE 'read(Dreams|Episodes|GraphEdges|Patterns)\(' -- index.js lib scripts— twelve calls; onlylib/dreaming/rem-dream.js:1221passes a requester.git grep -nE 'assertCardWriteAllowed' -- lib index.js scripts—index.js:1844,:2190,lib/db-adapter.js:790,lib/jobs/memory-compaction.js:909,lib/dreaming/light-dream.js:159,scripts/auto-capture-lancedb.mjs:690.git grep -nE '(table|tbl|Table)\??\.add\(' -- lib index.js scripts— every add of new text sits behind the guard;lib/reembedding/lance-backend.js:474andscripts/dedupe-memory-ids.mjs:326copy existing rows without it.git grep -nE 'scoreNeoRecallItem|routeNeoRecall|neo-arch' -- bench— no match; the harness drives the LanceDB pipeline only.git grep -nE 'skipDriftGate' -- index.js lib— the setter atindex.js:9881and the definition inlib/safe-update.js.git grep -nE 'allowModelDestructiveMemoryOps' -- index.js—index.js:11477, read as!== false.git grep -n 'merge-proposals' -- .— the writer, two snapshot scripts, the README, a migration note, three tests and an audit artifact; no reader that applies a proposal.git grep -niE 'arxiv|bibtex|@article|@misc|doi\.org' -- . ':!docs/**/node_modules/**' ':!package-lock.json'—README.md:1400, the jina-reranker-v3 paper; no paper about the system and noCITATIONfile.git grep -niE 'anthropic|machine learning|not (be )?used (for|to)' -- LICENSE— no match; the MIT text carries no rider.
History
2026-10-15 — cf4bc88e…
— re-pinned at tag v7.16.10, 139 commits on. main is 492
commits past the tag, and releases after 7.18.4 are cut on a side
branch, so the released tag is the pin. Screened first: no auto-run
surface, one build-time execution point, one unpinned surface, nothing
inside the cooldown; nothing installed or run. Changed upstream: a
LOCOMO and LongMemEval harness with committed results (section 10); unconfirmed
critical cards lapse to notes instead of being accepted, with Telegram
buttons and dreams excluded (section
8); importance left the ranking; long messages are split. Six marks
stand; audit_log rests on
destructive-ops.jsonl, because the reconsolidation log it
cited is capped. Six claims wrong at the old pin are corrected and
listed under known limitations, and stale anchors in
index.js and lib/safe-update.js are
re-mapped.
2026-10-01 — c381fd57…
— audited at the same commit; six marks stand. The dedupe section said a
candidate is never deduplicated:
appendCandidateContentDedupeKey
(lib/neo-arch.js:2322) keys a candidate by a hash of its
statement and a transition by id, status and updatedAt, and
the section now quotes it with the bare-id appendDedupeId
default. The derived-record passages cited a comment, absent at this
pin, saying dreams, episodes, edges and patterns carry no scope; they
are stamped with a visibility and filtered only when a
caller passes a requester, which most do not. The diagram still showed
demoted as ranked and injected, against the
-Infinity the scorer returns. Anchors in
neo-arch.js and recall-pipeline.js re-mapped;
the Fit paragraph no longer describes the removed host patch. Read, not
run.
2026-09-25 — c381fd57…
— census re-measured at the same commit from a depth-1 fetch, read and
never run. package.json and
openclaw.plugin.json both declare 7.12.61.
index.js counts 13,306 lines; lib/ holds 263
files and 78,217 lines; lib/safe-update.js counts 480. The
tree at this pin holds 472 *.test.js files, 459 under
tests/ and 13 under test/; the trees API gives
436 at 6317fd9, where section 10's figure and the file
index's 254 lib/ files came from. The summary, section 10,
the file index and section 11 carried figures from earlier pins and now
state these. No mark moved.
2026-09-19 — re-pinned to c381fd57…,
release 7.12.61, eight commits on. human_review is
withdrawn; six marks stand. The previous record read
"/correct and /forget require a
confirmation token bound to the resolved target, the
/critical review surface carries a per-card ACL, and an
Obsidian vault mirrors cards for review outside the chat." Each
clause is true of the chat surface and none of them survives the
producer test, which asks whether a memory waits in a state until an
actor the producing agent cannot be resolves it. The confirmation token
guards the chat commands; the model's own memory_forget
tool (index.js:11574) tombstones a card with no token,
gated only by security.allowModelDestructiveMemoryOps,
which is read as !== false and pinned to true
by tests/config-audit.test.js:424 — and the block message
the flag unlocks says why that matters. The /critical ACL
is real, but confirmed is read by one function that builds
the pending list and by no read path, so nothing is withheld while it is
pending, and autoAcceptStale confirms every card older than
24 hours on a daily cron the shipped plan registers under the same
switch. The Obsidian vault carries human edits into memory,
which is the opposite direction from a review gate. Found in the same
pass and now in section 9: merge-proposals.jsonl is written
by the compaction job and read by nothing in the repository, so
proposal-only merging means the detected duplicates are never merged.
The destructive-command actor check in lib/security.js:89
is unusually good and is described rather than marked. Line anchors
re-mapped across index.js (12,418 to 13,306 lines) and
lib/db-adapter.js. Screened again before reading: six
files, no auto-run surface, one build-time execution point, three
dependency files inside the cooldown, an agent-addressed instruction
file recorded as data. Nothing installed, built or run.
2026-09-16 — 75e1c4c6…
— re-read at a commit dated 12 September 2026, 82 commits past the
previous pin, at release 7.12.57. All seven marks re-tested and
unchanged, and the files they rest on are unchanged with them:
lib/epistemic-status.js, lib/tombstone.js,
lib/valid-time.js and lib/acl-middleware.js
are byte-identical to the previous pin, so the six-value status with its
actor-tiered transition matrix, the content-fingerprint tombstone
consulted at capture, the validity axis and the ACL gate all stand as
described. The growth is storage plumbing rather than mechanism:
lib/neo-arch.js gained about a thousand lines of vector
sidecar — a versioned index, float32 buffers, batched and
lazily-attached reads — alongside stale temp-file cleanup and persisted
cap-recheck state. Screened before reading: six files scanned, no
auto-run surface, one build-time execution point, one unpinned
dependency surface and three dependency files inside the seven-day
cooldown. An agent-addressed instruction file was recorded as data.
Nothing was installed, built or run.
2026-09-07 — 6317fd99…
— re-pinned six commits on, release 7.12.1. The range is the
scoped-embedding IPC owner election on macOS
(lib/providers/scoped-embedding-ipc.js), two macOS CI
workflows, two audit notes and their tests; no file under the recall,
correction, tombstone, ACL or reconsolidation paths changed. Seven marks
stand on the same evidence. Screened before reading: no auto-run
surface, two manifests inside the seven-day cooldown, nothing installed
or run.
2026-09-06 — 6025dbb2…
— re-pinned at the head of main, three commits past 7.11.0,
prompted by the maintainer's comment
on the same issue. Screened again: the same
postinstall, both manifests inside the seven-day cooldown,
one unpinned surface behind the lockfile, an AGENTS.md
treated as data; nothing installed or run. The rewritten
history, accounted for. The maintainer states that on 5
September 2026 every branch and tag was rewritten with
git filter-branch --msg-filter to strip commit trailers
carrying session links, that every hash changed, and that the trees are
identical commit for commit. Checked from here: the previous pin
3479373f… can be fetched
from GitHub by its full hash, its tree is
dd8c73c8…, and so is the
tree of 533fa93a…, the
commit v7.4.0 points at — the code this report read on 17
and 18 August is byte-for-byte the code under the new hash, and that
commit's own message is unchanged, its hash differing only because its
ancestors' messages do. No commit message on main carries a
session trailer. Three commits since the pin, all dated 5 September:
7.11.1 caps every text sent to a local Jina model at 512 tokens after a
lab run in which an uncapped 15,000-character card drove the v3 process
to 41 GB and the OOM killer — a defect present at 7.11.0 and at every
pin before it, described in section 3 with the numbers from the
changelog; 7.12.0 makes Jina v5 Text Nano the installer's first proposal
for new installs with an E5 fallback when a non-interactive run cannot
accept the licence, and adds a migration notice to the dashboard; and
6025dbb2 deletes
patches/apply-memory-patches.sh and its directory, turning
the wiring test's does not run a host patch into no patch
script exists. Marks unchanged at seven; index.js and
lib/ outside the provider and setup files are untouched, so
every line citation in the body holds.
2026-09-05 — 399bfba7…
— re-pinned at release 7.11.0, prompted by the maintainer's request in
neoneye/agent-memory-atlas#20
for 7.10.0 (b4138df5…); the
head of main is one release on, adding the pinned Jina v5
Text Nano artifacts. The previous pin no longer resolves from
the default branch:
git cat-file -t 3479373f87dc8f70d460d09ddeb20ffb83355231
fails in a fresh clone, GitHub still serves the commit, and the
v7.4.0 tag now points at
533fa93a…, dated two hours
after it — the history was rewritten below the tag, so the commit count
between pins cannot be stated. Screened again: the same
postinstall, both manifests inside the seven-day cooldown,
four floating ranges behind the lockfile, an AGENTS.md
treated as data; nothing installed or run, and every claim below was
read from the source and its committed tests rather than from the issue.
Marks unchanged at seven. Every line citation in the body was
re-verified and re-mapped, because index.js grew from
10,867 to 12,418 lines. Corrected as stale rather than wrong: the host
patch and its skip flag were removed in 7.5.0, and the three tests that
pin the removal are named in section 3; the configuration count is
fifty; the matrix's "drift gate still has no live caller"
contradicted the 17 August entry below and is rewritten. New and
described: the classify-recent cron's leak of tombstoned cards into
critical pushes, fixed in 7.9.2; the bulk and quoted-reply forms of
critical review claimed on the host's dispatch hooks; identity-bound
context for direct chats; pinned local model artifacts with a licence
gate; the dashboard's opt-in write actions; vault confirmation receipts;
dream narratives on the host page. Each row of the issue's table was
checked against the file it names and held; the two "still
true" lines — conflict at 0.3
(lib/neo-arch.js:1483) and /correct skipping
the gate (index.js:8995) — hold too.
2026-08-18 — 3479373f…
— same pin, three mechanisms added after a re-read prompted by the
upstream author. The authorized exits from conflict were
missing from this report: /plur1bus curation resolve and
/plur1bus curation drop-injected sit behind the same
authorization gate as the status transitions
(index.js:6853), and the bulk form is doubly bounded — a
preview before the apply, and a refusal of any record that is not
status === "conflict" and does not satisfy
isInjectedContextText
(lib/drop-injected-conflicts.js:104). Derived dream records
stamp a visibility and rem-dream.js hands its
reader a requester triple, which the scoping row now says. Each was read
at this pin against index.js and lib/, not
taken from the report of it.
2026-08-17 — 3479373f…
— re-pinned at release 7.4.0, 49 commits past the previous pin. Screened
again: the same postinstall host patch, both manifests
inside the seven-day cooldown, four floating ranges behind the lockfile;
nothing installed or run, and the new behaviour was read from the source
and its committed tests. Marks unchanged at all seven and now carrying
evidence records. Two published criticisms are corrected, both
in the direction that understated the system.
- The drift gate has a live caller. This report said
a threshold whose only caller disabled it had no live consumer.
lib/jobs/apply-conflict-resolution.jsnow callssafeUpdatewithoutskipDriftGatebehind aconfirm === truecheck, catches the "Semantic drift too high" throw, and returnsreview_onlyinstead of writing — so the automated conflict apply is gated where the confirmed human correction is not./correctkeeps the skip, andindex.js:8995is the only non-testskipDriftGateleft. demotedwithholds. The report recorded the neo doubt states as ranking penalties rather than filters.scoreNeoRecallItemnow returns-Infinityfordemotedalongsideprunedandtombstoned, pinned bytests/neo-demoted-withhold.test.js— "excludes demoted at -Infinity and keeps conflict finite".conflictis deliberately left finite, and the reason is written at the call site with its numbers: the detector is "an unvalidated LLM", a 16 August 2026 live probe found 4,017 newest-revision records carryingconflict(2,505 on one agent) "with no resolve path that clears the status", and a twenty-row sample was not pairwise contradiction. The split the code now draws — withhold on a state a person set, rank on a state a model guessed — is a better answer than closing both.
Also new: PLUR1BUS_SKIP_HOST_PATCH=1 is honoured by
scripts/setup-feature-crons.mjs and
scripts/install-memory-system.sh, with its own test, so the
install can complete "without writing into the OpenClaw dist
tree" — the patch is still the default, and the objection now has a
switch rather than a fork. A global injection budget lands at
index.js:12249 (recall.globalInjectMaxChars,
default 17,000 characters across the joined prompt block). Tombstone
coverage extends across the bulk writers, with
tests/tombstone-bulk-writers.test.js and
tests/light-dream-injection-guard.test.js asserting that a
dream rewrite cannot resurrect forgotten text. index.js is
10,867 lines, lib/ 61,178, across 361 test files.
One fact about the repository is worth recording
plainly.
docs/superpowers/specs/2026-08-17-atlas-remaining-gaps-design.md
is a design document titled "Remaining Atlas Gaps" that cites
this report by URL and by pin (b550a2d8, v7.3.0) as its
input, lists what a prior pull request closed — including "Neo
demoted ranked instead of withholding" — and plans
eight further workstreams against it, one of which is to "document
the Atlas objection at the patch callsite". Every claim above was
verified against the code and its tests rather than against that
document.
2026-08-15 — b550a2d8…
— re-pinned at release 7.3.0 ("audit fixes, epistemic status,
bi-temporal memory"). Screened again before reading: the same
postinstall host patch, both manifests inside the seven-day
cooldown, four floating ranges with the lockfile present; nothing was
installed or run, and the new behaviour was read from the source and its
committed tests. Three new load-bearing modules close two gaps and add a
hard-filtering trust state:
- Bi-temporal memory (
lib/valid-time.js, columns atdb-adapter.js:404) adds a real-world validity window (validFrom/validUntil) separate from record time, queryable as-of through avalidAtrecall parameter, with validity caller-supplied rather than guessed. That earnsbitemporal. - A value-keyed tombstone
(
lib/tombstone.js) writes a content-fingerprint denial record on/forget— SHA-256 of the normalized text, never the plaintext — to an append-only registry that survives restore, migration and re-embedding, checked as step zero of every capture (index.js:6411,:10667) and gated on a binding audit. That earnstombstoneand supersedes the record-keyedtombstonedneo status.d25e101f…stops a correction from reviving a tombstoned card. - A claim-level epistemic status
(
lib/epistemic-status.js) whoseinvalidatedvalue hard-filters on the read path (recall-pipeline.js:157,neo-arch.js:1464,db-adapter.js:562) — the first doubt-adjacent state in the system that withholds rather than ranks. Transitions intotrusted/invalidatedrequire an authorized actor, and a conservative merge rule refuses to launder a weak memory up to a higher tier.
Two scope fixes land in the same release. 09a5254c…
repairs the REM-dream candidate loader, whose scope partition was built
as user/workspace only and so rejected every
agent-private candidate — measured disabling the dream job entirely on
two live agents (70/70 and 49/49 candidates agent-private);
buildRemPartitions now runs agent-private
first. 90ced8cb…
adds a per-card ACL to the /critical review surface
(lib/critical-review.js), which had gated only on a
destructive-channel check. index.js is 10,289 lines,
lib/ 57,345, across 339 test files. No paper or citation
file exists in the tree.
2026-08-11 — 3efedcd4…
— second reading the same day, at release 7.2.6, twelve commits past the
first pin. Screened again before reading: 0 auto-run surfaces, the same
postinstall, both manifests inside the cooldown; nothing
was installed. Three regression files were executed with
node --test and pass (27 tests); restoring
lib/neo-arch.js from the previous pin on a scratch copy
fails 5 of 7 in the dedup file.
A published claim was wrong, and wrong in the system's
favour. This report stated that a record marked
conflict or demoted was ranked down by 0.3 and
injected anyway. The penalty was not being applied at all. The JSONL
stores are append-only, so transitionRecordStatus appends a
second line under the same id; routeNeoRecall deduplicated
by first appearance and therefore scored the pre-transition copy, with
its active status. 20cf0fe7…
changes the deduplication to keep the newest revision by
updatedAt, preserving first-appearance order so the
tiebreak stays stable. The error in this report was one of mechanism
rather than of outcome — the observable behaviour was as described — and
it came from reading the scorer without reading what the scorer is
handed.
The same commit renders status on each
<memory-record> line, closing a gap this report did
not find: the memory prompt supplement instructs the model to prefer
active and promoted over conflicting cards,
and the template emitted lane, category, trust, id and score but not
status, so the instruction asked for a distinction the payload did not
carry. The reading that would have caught it is one this report did not
perform — checking every distinction a prompt instruction demands
against the fields the renderer actually emits.
It also corrects /correct. The confirmation dialog named
an 80-character title while safeUpdate replaced the full
text against a fuzzily-resolved target, and payload.oldText
carried the user's search term rather than the stored content, so
updateEvidence recorded the query instead of the value it
replaced. Both are fixed, and skipDriftGate is retained
with its rationale written at the call site. That answers the open
question this report carried about why the gate is disabled.
35852e8e…
repairs the timestamps the operational guard depends on: canonical
KNOWLEDGE.md hits carried no age and, containing
operational keywords, permanently demanded live verification; they now
take the file mtime and are marked authoritative and
exempt. A probe over the live namespaces is recorded in that commit as
25,550 rows with none missing createdAt, placing the defect
in the read path's mapping layer rather than in the store.
The unreferenced plur1bus/ directory described in the
previous entry is deleted. Its index.js imported
./lib/categorize.js, which never existed inside that
directory, so the copy could not have run.
2026-08-11 — 241aac28…
— first reading, at release 7.2.3. Screened before reading: 0 auto-run
surfaces, 1 build-time exec (postinstall runs
scripts/setup-feature-crons.mjs, which patches the host
OpenClaw dist directory), 1 unpinned manifest, and both
package.json and package-lock.json changed
inside the seven-day cooldown; nothing was installed and nothing was
executed.