{"path":"research/latent-scaffolding-and-the-type-token-split.md","content":"# Latent Scaffolding and the Type–Token Split\n\n**Date**: 2026-08-30 · **Type**: founder design proposal (verbatim) + design mapping ·\n**Status: founder-endorsed same day** (*\"the compression and latent-until-touched sounds excellent, wanna implement that quite soon. Oh and maybe this could apply to other classes of future claim/question types as well\"*) — implement-soon, sequenced behind the consumer walk below. Deliberately filed as design rather than a ticket — it touches eight\nconsumer modules.\n\n---\n\n## 1. The founder's proposal, verbatim\n\nOn learning that two thirds of the graph is machine-minted critical-question scaffolding:\n\n> \"Since these will presumably always be reminted dupes, perhaps we could compress their actual\n> presence in the graph to reusable tokens/symbols instead of actually storing hundreds of copies\n> of the same text content etc? The question is posed about different claims and thus about\n> different meaning and different concept-tags or whatever, but we could still track all this\n> transitively, right?\"\n\n## 2. Yes — and the corpus half-ruled it already\n\nThe retrieval-instruments work ruled that **template-generated CQ claims want structural identity,\nno embedding** (their exclusion from search is currently *\"accidentally right\"* — a side effect of\nthe UUID migration, never a decision). The founder's proposal is that ruling carried to its storage\nconclusion: **if a claim's identity is structural — (scheme, CQ id, target) — then its text is\nderivable, and storing thousands of rendered copies stores nothing that the template and the\nbinding do not already contain.** The CQ patterns in `schemes.py` literally are templates with\nslots (*\"There are no relevant differences between {source_case} and {target_case}…\"*); the\ncurrent pipeline renders them at mint time into full claim nodes — measured today: **1,555\n`cq_positive` + 1,555 `cq_negative` of 4,852 total claims (64%)**, against 1,670 extracted, 40\nhuman, 31 implicit.\n\nIn the corpus's own linguistic frame (Saussure, from the self-similar-decomposition doc): the\ntemplate is *langue*, the instance is *parole* — and the proposal is the **type–token split**\napplied to storage. Store the TYPE once (the scheme's CQ pattern, already in code); an instance is\na TOKEN: a reference plus a binding plus whatever per-instance state actually accrued.\n\n**The transitive-semantics half is also right**: an instance's meaning is the template's meaning\ncomposed with its target's — so its concept-tags, topic membership and register all **derive by\ntraversal** (the CQ about claim X inherits X's concepts through the edge) and need no per-instance\nstorage. Anything derivable by composition should not be stored per token; that is the whole\nprinciple.\n\n## 3. Two design options, one recommended\n\n**Option thin-token**: keep per-instance nodes (stable claim ids — *every claim is a link* is\nnon-negotiable) but store only `template_ref + bindings + per-instance state`; render text on\nread; never embed. Cheap, minimally invasive, kills text duplication and makes the\nno-embedding rule deliberate.\n\n**Option latent-until-touched** (recommended): **do not mint the instance at all.** A CQ's\nexistence is derivable from the scheme edge plus the template — it is a *potential* claim, and the\nsorry marker is precisely the display of a potential. Materialize a real node **only when someone\ntouches it**: answers it, votes on it, attacks it, decomposes it. This is *capture immediately,\npublish deliberately* applied to the machine's own output, and it extends the lifecycle ladder\ndownward with a state below `raw`: **latent**. What it buys: the scaffolding fraction (the\ndrowning dashboard's dial) falls from ~64% to near zero *at rest*; `/graph/stats` de-noises toward\nhonest without needing the count-splitting caveats; the agent surface stops wading through\nuntouched polarity stubs (dogfood finding F12 solved at the root rather than filtered); and\nmint-time cost per extraction drops by the ~500-node scaffolding block.\n\nThe self-similar principle even supplies the philosophical frame: everything in the graph is\n*currently-undecomposed, invitable deeper* — a latent CQ is **currently-unmaterialized, invitable\ninto existence**, which is the same lifecycle thought.\n\n## 3b. The generalization the founder pointed at: derivability decides materiality\n\nThe principle is not about CQ scaffolding specifically. **Any claim class whose content is fully\nderivable from a template plus a binding is latent-by-default, materialized on first touch.** The\nnext classes already in view: the **weighing question set** (the fourteen questions opened per\ndetected weighing — the same template-per-target shape), any future scheme's CQs automatically,\nand any daemon output that instantiates a pattern per target (the analogy daemon's\ncounter-analogy questions, for instance). The design-time test is one question: *could this node\nbe re-rendered from code plus references alone?* Yes → latent tier. And it composes with the\nconfession discipline: a `does_not_fit` or an answer is a TOUCH, so confessions always\nmaterialize.\n\n## 4. The consumer inventory (why this is design, not a ticket)\n\n`cq_positive`/`cq_negative` are read by eight modules (`truth_graph`, `reported_speech`, `feed`,\n`api`, `decomposition`, `graph/store`, `graph/badge_inputs`, `graph/maturity`). Every consumer that\ntoday *enumerates* scaffolding must learn to **count potentials instead of nodes** — deterministic,\nsince each scheme's CQ set is fixed in code: potentials per edge = scheme's CQ count minus\nmaterialized. The ones that matter: the needs-help feed's sorry-density (count potentials), the\ncompleteness oracle (same), the hinge's clamp targets (materialize on clamp), badge inputs (only\nanswered CQs move strength today, and answered means touched means materialized — so the strength\npath is naturally unaffected). Per the trace-all-consumers rule, each of the eight gets walked\nbefore any migration; the 3,110 existing scaffolding nodes would be **demoted lazily** (untouched\nones retired to latent; touched ones kept), never bulk-deleted — with the data-freshness directive\nsatisfied because latent CQs regenerate from the current scheme set by construction, which also\nends scaffolding staleness as a category: **a latent claim can never be stale.**\n\n## 5. What this does NOT compress\n\nNothing human, nothing extracted, nothing touched. The moment an instance carries any state that\nis not derivable — an answer, a vote, an attack, an edit — it is a real token and stays one. The\ncompression applies exactly to the region where identity is structural and state is empty, which\nis the region the founder named: the reminted dupes.\n\n---\n\nCross-references: [retrieval-instruments-beyond-cosine.md](retrieval-instruments-beyond-cosine.md)\n(the structural-identity ruling this completes) · [drowning-in-claims.md](drowning-in-claims.md)\n(§ 2's machine door — this is its structural fix) ·\n[self-similar-decomposition-and-claim-ontology.md](self-similar-decomposition-and-claim-ontology.md)\n(langue/parole; currently-undecomposed) · [dogfood-run-1-friction-log.md](dogfood-run-1-friction-log.md)\n(F12) · [saturation-and-the-long-tail.md](saturation-and-the-long-tail.md) (the head held\ncompactly, the tail losslessly — this is the head-compaction mechanism for machine scaffolding)\n"}