1. Executive Summary
Loom is a self-hosted memory server for teams of agents, from ClickHouse, Inc. It stores keyed facts, documents and a code index in ClickHouse and serves them over a streamable-HTTP MCP endpoint, an HTTP API and two SDKs. Plugins wire it into Claude Code, Codex, Cline and Cursor, and a dashboard shows memories, reviews, the audit log and code links.
What is notable is how much of the correctness work happens at write
time. Each memory.set is judged against its nearest peers
before the insert, and the verdict is one of merge, duplicate, conflict
or refines. Every change is a new version, and every retirement the
background LLM resolver makes can be undone. A memory can point at files
and symbols, and it leaves search when that code is removed. All seven
marks rest on mechanisms with a producer on a reachable path, each with
limits stated in section 9.
What is weak sits at the seams between those mechanisms. The blacklist refuses a matching value on every intake and restore path, and no delete, forget or erasure writes a pattern, so a removed value can be extracted again. The verb that accepts a proposed fact is an agent's to call, and audit rows are best-effort.
Licence. Apache-2.0, with a NOTICE and a THIRD_PARTY_NOTICES file that agree with the manifests. No clause restricts use or analysis.
2. Mental Model
A memory is a row identified by its key under an identity tuple: org,
namespace, agent, user and session
(schemas/schema.sql:2447-2527). The table is a
ReplacingMergeTree on a nanosecond version,
and a materialized view copies every insert into
memory_versions, so the current row is the newest version
and the old ones stay readable through memory.history
(schemas/schema.sql:3161-3232,
server/memory/store/history.py:127).
A value becomes a belief through a judgement. memory.set
fetches the live row, refuses a blacklisted value, embeds, and reads the
closest active peers of the same type
(docs/architecture/memory-architecture.md
§memory.set). A canonical match merges, a close peer with
the same content words is a duplicate, a templated substitution under
newest_wins refines and retires the peer, and any other
close peer marks both rows conflicted. No verdict on the
write calls a model. A write marked proposed lands outside
the served set until a writer accepts it
(server/memory/domain/temporal_sql.py:38-47).
A belief stops being served in five ways: a same-key or resolver
supersession, a writer's reject, a delete
tombstone, an expiry, or an erasure. Each writes a new version row,
never an in-place edit, except memory.clear and the
redaction, which update rows in place
(server/memory/store/lifecycle.py:935-953,
server/memory/store/redaction.py:89-92).
Diagram source
%% caption: a write is checked against the blacklist and its peers before the insert, every version is kept, a restore is checked again, and a delete leaves no pattern behind
flowchart TD
subgraph writers["Writers"]
direction TB
SET["memory.set, update<br/>the agent over MCP"]
EXT["set_from_messages<br/>LLM extraction"]
IMP["bulk_set, import,<br/>observe, profiles"]
SET ~~~ EXT ~~~ IMP
end
writers --> BL{"value matches a<br/>blacklist pattern?"}
BL -->|"yes"| REF["422 BLACKLISTED<br/>nothing written"]
BL -->|"no"| PEER{"peer verdict:<br/>merge, duplicate,<br/>refines, conflict"}
PEER --> ROW["new version row,<br/>active or proposed"]
ROW --> VER["memory_versions keeps it;<br/>hash-only audit row"]
VER --> RES["LLM conflict resolver<br/>retires at 0.98,<br/>Undo restores"]
ROW --> DEL["memory.delete:<br/>tombstone version"]
DEL --> RST["memory.restore within<br/>14 days: blacklist<br/>checked again"]
DEL --> NOP["no pattern written:<br/>a later extraction<br/>can bring it back"]3. Architecture
Loom runs as three containers in the shipped Compose file:
ClickHouse, the server and a document extractor
(compose.yaml:14-152). The server is one Python process
with workers elected to a leader. The default storage authority is
ClickHouse (server/settings/catalog.py:5557). The
postgres authority moves current heads, revisions, locks
and idempotency to Postgres and publishes ClickHouse rows as
projections; vectors and every search leg stay in ClickHouse
(docs/architecture/storage-authority.md:20-34).
There is no vector index. The fact leg sorts by exact
cosineDistance over loom.memory_embeddings,
optionally a quantized shortlist rescored at full precision
(server/memory/app/retrieval/fact_sql.py:87,
:138-153). The embedding mirror carries the columns search
filters on, so no leg joins back to loom.memory. An
embedding server and a chat model are external; the conflict resolver
defaults to a strong model, one call per row with its peers.
Deployment and ergonomics
install.sh or loom up starts the stack and
mints a writer token for the agent
(server/cli/up.py:397-410). A Codespaces definition starts
the released stack for a try-out. Single-user mode runs with auth off,
which the authorizer treats as allow-all
(server/auth/authz.py:205-206). An operator stands up
ClickHouse, an embedder and a model, and about 3 GB of images.
4. Essential Implementation Paths
- The write.
_handle_memory_setruns named phases over one request state (server/memory/app/write.py,server/memory/app/set_commit.py): resolve type, fetch the live row, guard lock and pin, expiry, prepare and blacklist (write.py:402-412), proposal and precondition checks, build the version row, embed, conflict verdict, dual write, then supersession and the audit row. - Extraction.
set_from_messagesruns the model over a transcript and hands the facts tobulk_set(server/memory/app/pipeline.py). The Claude Code and Codex SessionEnd hooks senddefer=true, which queues the run on theextraction_queueworker (integrations/claude-code-plugin/lib/session-memory.mjs:7,:220). - Search.
vector_searchruns the fact leg with BM25 in the same SQL, then chunk, record, graph, summary, anchor, key-match and definition legs (server/memory/app/retrieval/search.py:374-418). RRF scores1/(60+sem_rank) + w_lex/(60+lex_rank)(server/memory/app/retrieval/fusion.py:47-72). - Ask.
memory.askruns the same retrieval and an LLM answers with cited keys, dropping superseded rows and masking chunk sentences that restate them (server/memory/app/ask/synthesis.py:601,server/memory/app/ask/supersession.py:249-266). - Delete.
memory.deletewrites a tombstone version and_retire_derivedretires embeddings, chunks, procedure runs, decision records and consolidated summaries (server/memory/app/handlers.py:605-664,:1108-1200). - The resolver.
memory/workers/conflict_resolver.pyjudges flagged rows on the leader, re-reads each row under its key lock, and writes amemory.auto_supersedeaudit row for every retirement (server/memory/app/auto_resolution.py:31,:154-188). - Erasure. A saga of about thirty steps per scope
reaches memory, embeddings, chunks, shared copies, summaries, graph
links, evidence, code links, caches and the webhook outbox
(
server/erasure/app/saga_steps.py:265-400).
5. Memory Data Model
loom.memory carries status with seven
values: active, conflicted, tombstoned, duplicate, superseded, rejected
and proposed (schemas/schema.sql:2470). The served set is
active and conflicted
(server/memory/domain/temporal_sql.py:38). Provenance is
server-stamped: actor from the token and
source_class from the server, which a caller may only
downgrade (server/memory/app/write.py:547-552,
:569-570). verified_by and
verified_sha256 hold an attestation, and
memory.verify takes its actor from the token
(server/memory/app/verify.py:52-55).
Time has two axes, which the project's own table states
(docs/concepts/memory.md §Time). valid_at,
valid_to and temporal_anchor are world time.
memory.set takes them from the caller and stores NULL when
none is given (write.py:576-577). Extraction takes the date
the model read from the text, then the fact's anchor, then the
observation date, which defaults to the request's day
(server/memory/app/pipeline.py:926-937).
created_at, version,
tombstoned_at and expires_at are record time,
and memory_versions keeps each version's record time.
invalid_at is documented as record time, and intra-batch
supersession writes the newer row's valid_at into it
(server/memory/domain/conflicts.py:325-329).
Sensitivity is a tier. A high row gets no embedding row,
so no search leg sees it, and a key read of it is audited as
memory.sensitive_read
(server/memory/domain/memory_types.py:72-79,
server/memory/app/handlers.py:459-472).
loom.blacklist holds patterns, substring or RE2, scoped
to a namespace, an org or the whole server, matched against the stored
value text (schemas/schema.sql:332-348,
server/memory/app/blacklist_guard.py:378-390).
6. Retrieval Mechanics
The fact leg filters tombstoned_at IS NULL, expiry,
valid_to and the served statuses, and leaves episodic,
profile and reflection types out unless named
(server/memory/domain/search_sql.py:50-163). It
over-fetches max(4*top_k, 60) and ranks by the mode: RRF,
or a hybrid of BM25 and cosine at alpha 0.5
(server/memory/app/retrieval/fact_rank.py:425-434). A
correctness tail follows: demoted tags, a conflict penalty, a 0.1
sensitivity demotion, a capped reinforcement term and trust
(fact_rank.py:185-239, :524-570). The wire
default is rrf; an unpinned call is filled from the
deployment default, semantic
(server/settings/catalog.py:3746-3751).
Search explains itself. _finalize_abstain returns
no_match, below_threshold or
low_calibrated_confidence, and calibration reports a
retrieval risk (server/memory/app/search/verdict.py:81-142,
server/memory/domain/retrieval_calibration.py:46-51).
The chunk leg drops a chunk whose known parent is not served. On
every read, both stages and the neighbour windows exclude chunks whose
parent row under the same identity fails the fact leg's tombstone,
status and as_of predicates, and hard tags additionally
require a matching searchable parent
(server/memory/app/retrieval/chunks.py:98-131). A chunk
with no parent row stays eligible as session evidence. Session summaries
carry no parent and filter only their own tombstone
(server/memory/app/retrieval/summaries.py:130-137), so a
summary that restated a superseded fact reaches search; the ask module
masks such restatements at synthesis, and its comment names the summary
plane (server/memory/app/ask/supersession.py:17-22).
Memories linked to code surface through memory.for_file,
which reads loom.memory FINAL by path, basename or code
link with tombstone, expiry, sensitivity and status filters, and no
valid_to predicate
(server/memory/app/for_file.py:67-91). Under the default
retire_removed policy, a memory whose links are all missing
leaves search, ask and the pack.
7. Write Mechanics
A tool write blocks the agent for one embedding call, a peer read and
the insert. An embed failure fails the call and writes nothing; writers
that can wait write a zero-vector stub the embedding_worker
fills (docs/architecture/memory-architecture.md
§memory.set). A point write is readable on the next call,
search included. Deferred extraction lags until the
extraction_queue worker reaches the session. The resolver
judges after the write, on the leader, at one model call per flagged
row. No pass rewrites the whole store.
The write guards stack. A byte-identical value is a restatement that
raises reinforcement_count. A lock answers 423, a pin 409,
an if_match_sha256 mismatch 409, a value over the char
limit 422, a blacklisted value 422, and a proposal over an established
fact 409 KEY_HOLDS_FACT (write.py:92-135,
:389-412, :464-507,
:808-821).
Operational cost
Every version is a row in memory_versions, with no TTL
on that table, so storage grows with every restatement
(server/storage/retention_overrides.py:50-98). ClickHouse
merges ReplacingMergeTree parts in the background, and
every read of current state uses FINAL. The resolver's cost
is one strong-model call per flagged row; a row is judged once per
version.
8. Agent Integration
The MCP server exposes toolsets. core carries
memory.set, pin, update,
delete, get, history,
apply, lock, blacklist.add and
context.pack, and memory.search is reached
through a synthetic loom_search tool
(server/operations/toolsets.py:98, :147-169).
coding adds working memory and code-intelligence ops
(:185-204). Any write op that is not hidden is callable by
name through loom_op
(server/transport/mcp_op.py:100-102).
The Claude Code plugin's hooks run the loop
(integrations/claude-code-plugin/hooks/hooks.json):
- SessionStart packs context;
UserPromptSubmit recalls on the first prompt only when
memory is not abstaining and confidence is at least 0.5, capped at 1,200
characters (
hooks/loom-prompt-recall.mjs:35,:80-84). - PreToolUse on Edit and Write calls
memory.for_fileover the person's namespace and the repository's team-rules namespace (lib/file-context.mjs:160-183). - PostToolUse records each call with
observe.record; SessionEnd sends the transcript to deferred extraction.
9. Reliability, Safety, and Trust
The blacklist holds at intake and at restore, and nothing writes one for you
A pattern refuses a matching value on memory.set,
update, bulk_set and so on every extraction
and import, on observe, decisions, evidence import and
copy_to
(server/memory/app/bulk_rows.py:252-276). The agent can add
one mid-conversation, and only an admin can lift one. Adding a pattern
sweeps the live rows it matches, whatever their status, into tombstones
(server/memory/app/blacklist_sweep.py:1-21,
:63).
The paths that put a value back check it too.
enforce_rows runs the same match over every live row a
restore, a namespace snapshot, a rollback or a consolidation is about to
write, before any write, and under the Postgres authority binds the
commit to the policy generation it checked
(server/memory/app/blacklist_guard.py:479-506).
memory.restore, a WRITER op with a 14-day window, refuses a
value blacklisted after the delete
(server/memory/app/restore.py:109, :375,
:647-692); namespace.rollback checks every
reinstated slice before writing the first
(server/memory/app/namespace_rollback.py:89-98);
namespace.restore checks the payload before it creates the
namespace or its grants
(server/identity/app/namespace_snapshot.py:163-181); and a
model-written summary that matches is dropped and its sources kept
(server/memory/app/consolidate.py:488-491,
:612). Other writers that write a version row over an
existing head carry a value already in the store. Delete, forget and
erasure never add a pattern, so a deleted value can be extracted
again.
What a proposal and a conflict wait for
proposed keeps a fact out of every default read.
memory.proposal_decide accepts it, a WRITER op with no
actor check whose docstring says "a person or an agent decides"
(server/memory/api/ops_proposals.py:28-37). A conflicted
row is served, and memory.update, on the core toolset,
resets it to active when the new value checks clear
(server/memory/app/update.py:549-552). The LLM resolver
retires at 0.98, flags at 0.95 and clears at 0.90 with no person
(server/memory/domain/conflict_resolution.py:37-38,
:288-321).
What the reads leave out
- Session summaries filter only their own tombstone,
so one that restated a superseded fact reaches search;
memory.askmasks it (section 6). - The entity-graph leg reads edges and triples by
namespace only, and its names and keys boost rows the fact leg already
scoped (
server/memory/app/retrieval/graph.py:43-84,:290-293). Another user's facts can shape a caller's ranking without being served. memory.listexcludes proposed rows and not rejected ones (server/memory/store/reads.py:1117-1125).
Marks
tombstone— awarded onloom.blacklist: keyed on the value text, consulted by every intake writer, extraction included, and by every restore path. Its limit is that no delete, forget or erasure writes one.trust_state— awarded onproposedandrejected, excluded by every default read, the chunk leg through the parent row.memory.listis the gap.bitemporal— awarded on world-time validity beside record time and the kept versions. The project calls it "valid time plus a retirement stamp, not a bi-temporal model", meaning supersession, not date, decides which row is current; the rubric asks only that the axes be tracked apart.scope_enforced— awarded on org, namespace and user predicates on every served leg, with the graph leg as the weak arm.audit_log— awarded onloom.audit_log. Rows are hash-only and best-effort, the plain-row receipt for a non-embedded orhighset on the ClickHouse authority included: it is emitted after the insert and a failure only logs (server/memory/app/set_commit.py:436-464,:502-509). A per-namespaceretention_daysapplies to the audit table like every managed table (server/storage/retention_overrides.py:15,:50-56).human_review— awarded on the learnings queue: drafted definitions and assistant rules no read serves untillearnings.review, ADMIN and hidden from MCP, promotes them. With default settings only an admin's draft request fills it. Proposals and conflicts are not on it.negative_eval— awarded; see section 10.
Other risks
- The memory.clear tombstone is an in-place
ALTER UPDATEthat the materialized view does not copy, somemory_versionsdoes not record it (server/memory/store/lifecycle.py:935-953). - Erasure without purge keeps the value in the
tombstoned row, and
memory.restorecan revive it within 14 days; a running saga re-tombstones it (server/erasure/store/mutations.py:414-435).loom.blacklistsurvives erasure, and a pattern can itself hold the person's data (server/erasure/store/census.py:763).
10. Tests, Evals, and Benchmarks
tests/ holds 27,617 pytest functions. CI runs the unit
suite in random order with a 40% coverage floor,
pytest bench, and the integration suite in four parts
against a real ClickHouse with a fake embedder and model, plus auth-on
isolation gates (.github/workflows/ci.yml:603-858). Locally
the integration suite skips without LOOM_BASE_URL or
LOOM_CH_HOST
(tests/integration/conftest.py:83-97). I ran none of
it.
negative_eval rests on populated cases:
tests/integration/test_graded_runs_proposals.py:70-76: the proposal is served underinclude_proposed, then absent from the default read of the same query.tests/integration/test_read_scope_isolation.py:1278-1317: a token pinned to user U must return U's rows and none of V's nonce or ids, beside a namespace-wide control. The op walk at:373-423re-runs each body with a namespace token; that set leaves outmemory.searchandmemory.ask.tests/integration/test_memory_code_links.py:1117-1136: top-1 is the linked memory, and after its code is removed the result is exactly the sibling, not an abstention.tests/integration/test_knowledge_delete.py:66-93: a deleted document is absent while an identical-text document is served.tests/integration/test_chunk_parent_status.py:165-166: the chunk read returns exactly the active, conflicted, session-only and point-write chunks, with rejected, superseded, proposed and duplicate parents populated beside them. It runs the leg's predicate against ClickHouse rather than through the search service.
No case asserts that a deleted or forgotten value re-extracted in a
later session is refused; nothing writes the pattern that would refuse
it. tests/integration/test_blacklist.py:133-178 refuses a
restore of a value blacklisted after its delete, checks that the refusal
changed no persisted memory or search row, and restores an unrelated
value beside it; the rollback, snapshot and consolidation checks are
unit-tested against stubs
(tests/unit/test_blacklist_restore_paths.py). The
superseded-row exclusion of the memory plane is tested at the predicate
level only (tests/unit/test_superseded_served.py).
bench/fama_forgetting.py is a paired forgetting check run
outside CI with no committed result.
Benchmarks are committed with per-question CSVs under
bench/results/. I recomputed the headlines from them:
LongMemEval-S at 96.6%, 483 questions right across the 500-question set,
through memory.ask and 92.0% with an external reader over
the top 200, and LoCoMo categories 1–4 at 89.6% through
memory.ask and 79.7% with an external reader. The judges
are models. The Recall@30 of 98.6% comes from
longmemeval_s_ingest.csv; the recalled column
of longmemeval_s.csv is all zero. No paper is associated
with the project; CITATION.cff cites the software.
11. For Your Own Build
Steal
- Judge a write against its peers before the insert. A cheap cosine read with canonical, duplicate and refines rules catches most of what a background resolver would otherwise have to undo, and it calls no model.
- Make every automatic retirement undoable, and audit the Undo strictly. Loom's resolver writes a record per retirement, and the Undo fails if its own audit row cannot be written.
- Link memories to code and retire them when the code goes. A fact about a function that no longer exists is the stalest kind; a fingerprinted link with moved, changed and missing states turns that into a filter.
- Carry the filter columns on the vector row. Search never joins back, so a status or scope predicate cannot be forgotten in a join.
- Check every path that puts a value back, not only the ones that take values in. Loom runs one guard over restore, rollback, snapshot restore and consolidation before any of them writes, and binds the commit to the policy it checked.
Avoid
- A forget that leaves no refusal behind. Delete, forget and erasure retire the row and write no pattern, so the next extraction of the same sentence stores it again.
- A derived plane with no parent. A session summary that restated a superseded fact has no row to inherit a status from, and only the answer path masks it.
- A review verb on the reviewed party's surface.
proposal_decideas a WRITER op makes a proposal a request the agent can grant.
Fit
This suits a team that wants one memory service for several agents and people, with real scope, version history and audit, and has the operations budget for ClickHouse, an embedder and a strong model for the resolver. The engineering is deep where a shared service fails: identity predicates on every leg, a peer check on every write, a strict Undo, an erasure saga with a census. Walk away if the deployment is one developer on a laptop; the stack is three services and 3 GB of images for a store a SQLite file would hold. Walk away too if a forgotten value must stay forgotten without an administrator writing a pattern for it.
12. Open Questions
- How often search serves a session summary restating a superseded fact; the plane is read, not measured.
- Whether
proposal_decideis meant to be callable by the agent that proposed. - What the agent sign-up flow mints;
loom upmints a writer, and the security document says sign-up tokens are writer-only.
Appendix: File Index
- Write:
server/memory/app/write.py,server/memory/app/set_commit.py,server/memory/app/bulk_set.py,server/memory/app/bulk_rows.py,server/memory/app/pipeline.py,server/memory/app/update.py - Schema:
schemas/schema.sql,server/memory/store/rows.py,server/memory/store/inserts.py - Lifecycle:
server/memory/app/handlers.py,server/memory/store/lifecycle.py,server/memory/app/restore.py,server/memory/app/key_supersession.py,server/memory/app/auto_resolution.py,server/memory/domain/conflict_resolution.py - Blacklist:
server/memory/app/blacklist.py,server/memory/app/blacklist_guard.py,server/memory/app/blacklist_sweep.py - Retrieval:
server/memory/app/retrieval/,server/memory/domain/search_sql.py,server/memory/domain/temporal_sql.py,server/memory/app/search/verdict.py,server/memory/app/ask/,server/memory/app/for_file.py,server/memory/app/context_pack.py - Scope and review:
server/auth/authz.py,server/identity/domain/read_scope.py,server/transport/gates.py,server/operations/toolsets.py,server/memory/api/ops_learnings.py,server/memory/api/ops_proposals.py - Audit and retention:
server/observability/audit.py,server/transport/post_rows.py,server/storage/retention_overrides.py - Erasure:
server/erasure/ - Integration:
integrations/claude-code-plugin/hooks/,integrations/claude-code-plugin/lib/ - Tests:
tests/integration/test_graded_runs_proposals.py,tests/integration/test_read_scope_isolation.py,tests/integration/test_memory_code_links.py,tests/integration/test_knowledge_delete.py,tests/integration/test_blacklist.py,tests/unit/test_namespace_rollback_unembedded.py
Recorded searches
Run from the repository root at the pinned commit with
/usr/bin/git grep.
- Which writers consult the blacklist.
git grep -n -E 'enforce_on_insert\(|enforce_rows\(|find_match\(' -- serverlists the guard calls in fifteen files: write, bulk rows, update, copy, decisions, evidence transfer, learnings, assistant learnings, observe, restore, rollback, snapshot rows, namespace restore, consolidate and the guard itself.git grep -n -E 'insert_memory_versions\(|insert_versions_over_heads\(' -- serverlists the row writers; the rest write a version over an existing head. - No delete, forget or erasure path writes a pattern.
git grep -n 'blacklist' -- server/erasure server/memory/app/handlers.py server/memory/domain/forget_requests.pymatches only the two census descriptions inserver/erasure/store/census.py. - Nothing outside the guard reads the blacklist on a read
path.
git grep -n -E 'loom\.blacklist' -- server/memory/app/retrieval server/memory/app/search server/memory/domain/search_sql.pyreturns nothing; the same pattern overserver/memory/storematches the blacklist store. - No server statement deletes or alters the audit
table.
git grep -n -i -E '(DELETE FROM|ALTER TABLE)[[:space:]]+loom\.audit_log' -- serverreturns nothing;git grep -n 'loom.audit_log' -- server/storage/retention_overrides.pymatches line 53, the retention target. - The summary plane reads no status.
git grep -n -E 'status|superseded' -- server/memory/app/retrieval/summaries.pyreturns nothing;git grep -n 'tombstoned_at IS NULL' -- server/memory/app/retrieval/summaries.pymatches lines 136, 264 and 313. - The review verbs' roles.
git grep -n -E 'required_role' -- server/memory/api/ops_learnings.py server/memory/api/ops_proposals.pygives ADMIN forlearnings.reviewand WRITER formemory.proposal_decide;git grep -n -E '"learnings\.review"|"blacklist\.remove"|"blacklist\.add"' -- server/operations/toolsets.pymatches lines 65 and 82 in the hidden set and 159 in the core toolset. - No paper.
git grep -n -i -E 'arxiv|doi\.org' -- CITATION.cff README.md docsreturns nothing; the onlyarxivin the tree is a test forbidding paper citations in public copy,tests/unit/test_public_copy.py:144.
History
2026-11-19 — fc930e0c…
— re-read at the tip of main, 79 commits past the first
pin. Three findings of the first reading were fixed upstream: pull
request 923 (06775eb) puts the blacklist check on
memory.restore, namespace.rollback,
namespace.restore and consolidation, with an integration
case; pull request 922 (9522b2b) gives plain-row writes
their audit receipt; and the release 1.3.0 squash (08eeb3d)
excludes chunks whose known parent is not served, the change pull
request 924 proposes. The tombstone's remaining limit is that no delete,
forget or erasure writes a pattern, and session summaries are the plane
that reads no status (section
9). Marks unchanged. Screened again: the same ten auto-run surfaces;
nothing installed, built or run. Every line citation was re-checked
against the new tree.
2026-11-18 — 39243b17…
— first reading, from a depth-one clone of main with
history from the GitHub API, scoped to server/memory/, the
identity, auth, erasure and transport paths it relies on, the Claude
Code plugin and the tests. Screened first: ten auto-run surfaces, each
read (harness permissions, a reviewer subagent's read-only command hook,
a Codespaces try-out, a localhost MCP manifest, the plugin's hooks);
eleven build-time execution points, among them two Makefiles, two
conftest.py files and an npm prepublishOnly;
FRESH findings on every manifest, inflated by the shallow clone.
Apache-2.0, no rider. Nothing installed, built or run; benchmark
headlines recomputed from the committed CSVs. Seven marks, each with its
limits in section 9.