Docs truth: every statement that claims materialization or incremental maintenance (D1) #306

Part of epic #305.

Problem. Sixty-plus statements in the docs, README, SDK docs, marketing content, examples and Rust doc comments claim that persistent rules are materialized, cached, incrementally maintained or "kept up to date", and the internal architecture doc describes a materialization subsystem marked "Done". None of that runs (report Section 3). Until V20 ships, the docs must describe recompute-on-read and re-evaluate-and-diff subscriptions; after V20 the same list is re-edited to describe maintained views (second pass tracked in V20).

Target. Each statement below corrected as noted; generated copies regenerated; the two hand-maintained mirrors (docs/*.md legacy tree and docs/README.md) corrected or deleted in the same PR. Keep the statements listed under "already true".

Acceptance. grep -rniE "materializ|incrementally maintained|kept up to date|recomputed incrementally|only affected conclusions" docs README.md BENCHMARKS.md packages content front examples src returns only the entries in the "already true" list or sentences that describe recomputation explicitly; gui/lib/docs-bundle.ts and front/lib/content-bundle.ts regenerated; a reviewer confirms the corrections against report Section 3.

Size M. Dependencies none. Order slot 1.

Statements to correct (file:line | verdict | correction). F = false, M = misleading, T+ = true but needs context, S = internal doc stale

Canonical docs docs/content/docs/:

• index.mdx:7 | M | "keeps every conclusion current ... pushes the exact changes" -> re-derives conclusions on each read; re-evaluates standing queries after each relevant commit
• guides/core-concepts.mdx:11 | M | "a rule-derived relation the engine keeps current ... retracted" -> computed from the facts whenever read; nothing stored or retracted
• guides/core-concepts.mdx:13 | T+ | add "by re-evaluating the query after each relevant commit and diffing"
• guides/core-concepts.mdx:297 | F | retitle/remove "Use Persistent Rules for Automatic Materialization"
• guides/core-concepts.mdx:299 | F | "automatically materialized and updated when base data changes" -> stored in the catalog, evaluated from base facts on every query
• guides/core-concepts.mdx:301,306 | F | "Persistent rules materialize and cache results" -> both kinds compute fresh each query
• guides/first-program.mdx:168 | M | "See Incremental Updates" -> "See the derived relation reflect new facts"
• guides/first-program.mdx:193 | T+ | recomputed when you queried, not when you inserted
• guides/first-program.mdx:226 | F | "Incremental - derived data updates automatically" -> computed from current facts at query time
• guides/quickstart.mdx:117,145 | T+ | add "computed on each query"; the standing query is re-run per commit
• guides/python-sdk.mdx:422; guides/js-sdk.mdx:432 | F | "keeps up to date automatically ... recomputed incrementally" -> recomputed from the facts on every query
• guides/python-sdk.mdx:492; guides/js-sdk.mdx:504 | F | "Clear a rule's materialized data" -> remove every clause of the rule
• guides/python-sdk.mdx:641; guides/js-sdk.mdx:652 | T+ | "temporary views" = session rules evaluated per query
• guides/langchain.mdx:5,329 | M | "keeps up to date" / "maintains automatically" -> evaluated on every query
• guides/langgraph.mdx:330,399 | T+ | rules evaluated when recall queries them, not when store writes
• guides/what-it-replaces.mdx:11 | T+ | push = re-evaluation + diff per relevant commit
• guides/what-it-replaces.mdx:12,79 | M | "views the engine keeps current" / "the engine maintains it" -> recomputed on every read / derived on demand
• guides/what-it-replaces.mdx:92,130,146 | T+ | follows from recomputation; no support counting or stored view
• guides/where-it-sits.mdx:40 | T+ | delta from re-evaluation + diff
• guides/where-it-sits.mdx:72 | M | "keeps the conclusions current" -> derives them on demand
• reference/syntax-cheatsheet.mdx:7-12 | T+ | "DD Semantics" column implies maintained state; facts go to the store/WAL
• reference/syntax-cheatsheet.mdx:136 | F | "saved to disk and incrementally maintained by Differential Dataflow" -> saved to rules/catalog.json, evaluated on every query that reads them
• reference/syntax-cheatsheet.mdx:364-372 | F/M | "+fact sends (fact,time,+1) to DD ... rules incrementally maintained using iterate() ... efficient incremental updates" -> DD is the per-query execution engine; the triple is the persist format
• spec/basic-concepts.mdx:48 | M | "rule results update automatically" -> the next query sees the new facts
• spec/basic-concepts.mdx:57 | F | delete "Updates are incremental (only changed parts recompute)"
• spec/rules.mdx:3 | T+ | view = relation computed on read
• guides/persistence.mdx:420-445 | M/F | "Differential Updates ... Incremental computation" -> triples are the WAL/Parquet format; no long-lived dataflow
• guides/persistence.mdx:291; configuration.mdx:64-67; installation.mdx:153; deployment.mdx:687 | T+ | "DD-native persist layer" is a name for the WAL + Parquet layer
• guides/deployment.mdx:562 | M | "holds the active working set in memory via Differential Dataflow" -> facts live in the relation store; dataflows exist per query
• guides/deployment.mdx:619 | T+ | per-query workers
• guides/query-profiling.mdx:34 | T+ | shared subplans inside one evaluation, not stored views
• guides/query-profiling.mdx:79-83; guides/web-ui.mdx:34,64-76 | T+ | "derived view" = rule evaluated when displayed
• guides/rest-api.mdx:103,139 | T+ | views = rule count
• guides/verified-completions.mdx:3 | F | "rules evaluate them incrementally" -> re-evaluated over the conversation's facts on each request
• guides/verified-completions.mdx:195,237,254 | T+ | watch views evaluated per request
• internals/type-system.mdx:198 | F | "stored and incrementally maintained" -> stored in the catalog, evaluated on each query
• internals/type-system.mdx:226-230 | F | drop the "DD Materialization" column
• internals/type-system.mdx:249,287,292 | F/M | both kinds computed on query
• internals/type-system.mdx:210,218 | T+ | "non-materialized view"
• internals/architecture.mdx:11 | M/S | "incremental database engine built on DD" -> a Datalog engine executing each query as a DD dataflow over snapshot data
• internals/architecture.mdx:13,84,103,482-498,597,805,846 | S | DDComputation/shadow-write sections: base-relation mirror only, off on the server path
• internals/architecture.mdx:15,123,169-191,218-226,256,268-294,367,600-601,849 | F/S | materialization flow, cascade invalidation, "auto-materialize ... Done": no materialization on the server path; auto_materialize has no config key and recomputes fully per publish
• internals/architecture.mdx:380-381 | M | persistent rules are also computed fresh
• internals/validation.mdx:7 | S | facts enter the relation store; DD runs per query
• internals/roadmap.mdx:140-141,151 | T+ | execution backend, not maintenance

Legacy mirrors (hand-maintained; docs/README.md:7 names docs/content as the source of truth; fix or delete):

• docs/README.md:3 | M | as index.mdx:7
• docs/guides/core-concepts.md:259-268 | F | as core-concepts.mdx:297-306
• docs/guides/first-program.md:162,185,223 | M/T+/F | as first-program.mdx
• docs/reference/syntax-cheatsheet.md:112,339-349 | F | as syntax-cheatsheet.mdx
• docs/reference/commands.md:383 | F | ".load --replace ... Re-materialize dependent views": no such step exists
• docs/reference/commands.md:400 | T+ | "incrementally" = one at a time
• docs/spec/basic-concepts.md:48,57 | M/F | as mdx
• docs/internals/type-system.md:198,226-230,249,287,292 | F/M | as mdx
• docs/internals/architecture.md (whole) | S | as mdx
• docs/internals/validation.md:7; docs/guides/persistence.md:416-441 | S/M | as mdx
• docs/guides/recursion.md:124 | T+ | per-query execution
• docs/guides/python-sdk.md:167 | T+ | computed views
• docs/blog/consistency-ontology.md:169 | F | "handles retraction natively; nothing recomputed" -> the next evaluation recomputes from remaining facts
• docs/blog/consistency-ontology.md:193 | F | drop "incrementally"
• docs/spec/openapi.yaml:195 | T+ | views = rule count
• docs/rfc-verified-completions.md:18,33,314,318,322,360 | F/M | "incremental evaluation", "The engine is incremental", "ms (incremental)" -> each request re-evaluates the watch rules
• docs/ontology.md:252-254 | F | "each new fact re-derives only what it touches" -> full re-evaluation per request
• docs/internals/verified-completions/extraction/fact-lifecycle-prompt.md:230 | M | conflict absent from the next evaluation
• docs/internals/verified-completions/PLAN.md:130 | T+ | session resolution incremental; engine not

README.md, BENCHMARKS.md, TESTING.md:

• README.md:8,10,172 | M | "keeps every conclusion current" / "retracted" / "a rule the engine keeps current" -> derives on demand; disappears from the next evaluation; evaluated on each relevant commit
• README.md:139-141,161-162 | T+ | deltas by re-evaluation + diff; no support counting
• README.md:173 | M | InputLayer also re-runs the query; the difference is the diff/derived rows
• README.md:174 | T+ | Materialize maintains views incrementally; InputLayer does not; avoid implying parity
• README.md:208 | T+ | correctly labelled: bound Magic-Sets re-query vs full re-query
• README.md:324 | T+ | DD used as per-query execution engine
• BENCHMARKS.md:3 | T+ | Magic Sets vs full closure
• BENCHMARKS.md:57 | M | InputLayer also recomputes, only the demanded slice
• BENCHMARKS.md:65 | M | re-query recomputes from remaining facts; nothing retracted from maintained state
• BENCHMARKS.md:67 | F | "TC rules materialized" -> registered
• BENCHMARKS.md:77 | M | correctness comes from recomputation
• BENCHMARKS.md:205-206,216 | T+ | refresh = re-evaluation
• BENCHMARKS.md:229-232 | T+ | bench names "incremental_*" measure re-query after a change
• TESTING.md:228 | T+ | "rule maintenance" = catalog changes

SDK packages:

• packages/inputlayer-py/README.md:5; packages/inputlayer-js/README.md:5 | M | as README.md:8
• packages/inputlayer-py/README.md:7; js:7 | T+ | "queries the derived views"
• packages/inputlayer-py/README.md:100 | M | "keeps derived data up to date automatically" -> computed from the facts on every query
• packages/inputlayer-py/README.md:466 | F | "Clear materialized rule data" -> remove every clause of a rule
• packages/inputlayer-js/src/knowledge-graph.ts:685 | F | "/** Clear a rule's materialized data. /" -> "/* Clear a rule's clauses. */"
• packages/api-client/README.md:52 | T+ | client.views manages rules

content/ (marketing, bundled into front/lib/content-bundle.ts):

• blog/why-we-built-on-differential-dataflow.mdx:16,89,91 | M | derived on demand
• blog/why-we-built-on-differential-dataflow.mdx:34,57,71,81 | F | "every operation is naturally incremental", "Incremental maintenance: only the affected derivations recompute ... 6.83ms", "memory grows with maintained results": InputLayer builds a fresh dataflow per query; 6.83 ms is a bound Magic-Sets re-query
• blog/benchmarks-1587x-faster-recursive-queries.mdx:2,8,41,51-55,66-84,88,98,106 | F/M | "Incremental Computation", "Identifies affected relationships, updates only those", "tracks what changed", "started from the change" -> bound query computes only the demanded slice
• blog/why-agents-use-stale-data.mdx:28-30,56 | F | "maintain a dependency graph between facts and conclusions ... only the paths affected", "maintains its conclusions incrementally"
• blog/why-agents-use-stale-data.mdx:34,50 | T+ | true by recomputation
• blog/inputlayer-in-10-minutes.mdx:12,92,110,124,149 | M/F | "updates them the moment facts change", "without re-running the query", "didn't recompute everything from scratch", "Incremental updates" -> the query is re-run
• blog/correct-retraction-why-delete-should-actually-delete.mdx:86-88,113,123,159 | M/F | support counting applies inside one evaluation only; "each retraction only touches the affected portion ... graph size barely matters" is false
• blog/explainable-ai-data-layer.mdx:48 | F | "only the affected conclusions recompute"
• blog/why-vector-search-alone-fails.mdx:62 | F | drop "incrementally"
• blog/fraud-detection-entity-chain-reasoning.mdx:120,127 | M/T+ | InputLayer is recompute-on-read
• blog/langgraph-agent-memory.mdx:18 | F | "only the conclusions touched by that turn get recomputed"
• blog/building-product-recommendation-engine.mdx:33,122 | M/T+ | "incremental computation" -> recomputed on query
• compare/vs-vector-databases.mdx:13,23,54,64 | M/F | "tracks which conclusions depend on which facts and updates only what's affected ... 6.83ms"
• compare/vs-graph-databases.mdx:9,17,25-26,47,51 | M/F | "maintains those conclusions incrementally", "Recompute per query | Automatic, incremental", "weight-based retraction": InputLayer is also recompute-per-query
• compare/vs-all-in-one-ai-data.mdx:22,55,58 | F | "Incremental (milliseconds)", "All affected conclusions recompute - nothing else does"
• customers/warehouse-optimization.mdx:35,41,47 | F | "Only affected routes recompute" (mechanism claim in a customer story)
• customers/semantic-image-knowledge-graph.mdx:53,57 | M | "incremental computation engine keeps the knowledge graph current"

front/ and gui/:

• front/app/layout.tsx:12; front/app/page.tsx:149 | M | as README.md:8
• front/app/page.tsx:403,423,682 | M | "keeps it current" / "a view the engine keeps current, retracted when ..." -> derived on demand / re-evaluated per commit
• front/app/page.tsx:462 | M | "InputLayer: Yes, only affected ones" -> InputLayer also recomputes; it reports which rows changed
• front/app/page.tsx:516,520 | F | "6.83ms incremental update" / "11.3s full recompute" -> "bound query (Magic Sets)" vs "full closure"
• front/app/page.tsx:678-679 | T+ | "Full refreshes became incremental views" implies InputLayer is one
• gui/lib/ws-types.ts:304 | true | keep

examples/:

• examples/iql/LEARNING_PATH.md:94 | M | "Rules automatically update when facts change" -> evaluated against current facts on every query
• examples/iql/README.md:58,67 | T+ | "Persistent Rules (Views)"
• examples/retail/README.md:13-15 | T+/M | drop "Incremental derivation"
• examples/iql/18_advanced_patterns/121_materialized_view.iql:1,8; 24_rel_schemas/03_schema_with_views.iql:2,17 | F | "Materialized view" -> persistent rule
• examples/iql/50_landing_page/02_incremental.iql:1-2; 05_manufacturing.iql:3 | F | "updates incrementally", "retracts incrementally"
• examples/ingestion/adapter/ingest/rules.iql:3 | M | "keeps the join current"

Rust doc comments (deleted or rewritten by V0/V2):

• src/incremental.rs:1-6 | S | "Incremental Materialization Engine ... coordinates derived relation materialization" -> mirrors base relations; off on the server path; no rule dataflow
• src/derived_relations.rs:3-5,31,36-37 | F/S | "maintaining persistent materialized views that update incrementally", "results cached across queries" -> unused on the server path
• src/storage_engine/mod.rs:218 | T+ | optional, off
• src/lib.rs:3 | T+ | per-query execution

Already true, keep: websocket-api.mdx:416,456-463,485-493; where-it-sits.mdx:59; backup.mdx:136-137; commands.mdx:171,269,311-318,460; ingestion.mdx:145; repl.mdx:71; syntax.mdx:382; spec/rules.mdx:40,79; syntax-cheatsheet.mdx:45,159; spec/basic-concepts.mdx:55-56; spec/errors.mdx:66-76; recursion.mdx:88-103,297; indexing.mdx:220-229; README.md:161,208; TESTING.md:50,172-174; content/blog/building-a-voice-agent-that-knows.mdx:427,441,745; docs/spec/asyncapi.yaml:501,527,677,709; src/storage_engine/mod.rs:220-221,2338-2341,2511-2514; BENCHMARKS.md:50-59,205-216; py knowledge_graph.py:959, program.py:282, js program.ts:229.

Generated copies to regenerate: gui/lib/docs-bundle.ts (from docs/content/docs, gui/scripts/bundle-docs.mjs), front/lib/content-bundle.ts (from content/, front/scripts/bundle-content.mjs); front/lib/docs-bundle.ts is gitignored and rebuilt on build.