arscontexta 0.6.0

package/methodology/design-dimensions.md

@@ -0,0 +1,66 @@
+---
+description: The 8 configuration axes and their interaction constraints -- granularity, processing, automation, and more
+type: moc
+---
+
+# design-dimensions
+
+The 8 dimensions that define a knowledge system's configuration space. Granularity, organization, linking, processing, navigation, maintenance, schema, automation. How they interact and constrain each other.
+
+## Core Ideas
+
+### Research
+- [[blueprints that teach construction outperform downloads that provide pre-built code for platform-dependent modules]] -- Platform-dependent modules ship as construction instructions so agents build contextually adapted artifacts — but bluepr
+- [[composable knowledge architecture builds systems from independent toggleable modules not monolithic templates]] -- Four traditions converge — component engineering (contracts), Unix (small tools), Alexander's pattern language (generate
+- [[configuration dimensions interact so choices in one create pressure on others]] -- Atomic granularity forces explicit linking, deep navigation, and heavy processing — the valid space is far smaller than 
+- [[configuration paralysis emerges when derivation surfaces too many decisions]] -- Presenting every dimension as a question produces analysis paralysis — sensible defaults and inference should reduce the
+- [[controlled disorder engineers serendipity through semantic rather than topical linking]] -- Luhmann's information theory insight — perfectly ordered systems yield zero surprise, so linking by meaning rather than 
+- [[decontextualization risk means atomicity may strip meaning that cannot be recovered]] -- Extracting claims from source discourse strips argumentative context, and Source footers plus wiki links may not reconst
+- [[dense interlinked research claims enable derivation while sparse references only enable templating]] -- Four structural properties of TFT research — atomic composability, dense interlinking, methodology provenance, and seman
+- [[dependency resolution through topological sort makes module composition transparent and verifiable]] -- Topological sort on a module DAG resolves dependencies automatically while producing human-readable explanations that te
+- [[derivation generates knowledge systems from composable research claims not template customization]] -- Templates constrain to deviation from fixed starting points while derivation traverses a claim graph to compose justifie
+- [[derived systems follow a seed-evolve-reseed lifecycle]] -- Minimum viable seeding, friction-driven evolution, principled restructuring when incoherence accumulates — reseeding re-
+- [[each module must be describable in one sentence under 200 characters or it does too many things]] -- The single-sentence test operationalizes Unix "do one thing" as a measurable constraint — if the description exceeds 200
+- [[eight configuration dimensions parameterize the space of possible knowledge systems]] -- Granularity, organization, linking, processing intensity, navigation depth, maintenance cadence, schema density, and aut
+- [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]] -- Capture, connect, and verify are domain-invariant operations while the process step (extract claims, detect patterns, bu
+- [[evolution observations provide actionable signals for system adaptation]] -- Six diagnostic patterns map operational symptoms to structural causes and prescribed responses, converting accumulated o
+- [[false universalism applies same processing logic regardless of domain]] -- The derivation anti-pattern where the universal four-phase skeleton is exported without adapting the process step — "ext
+- [[friction-driven module adoption prevents configuration debt by adding complexity only at pain points]] -- Concrete thresholds — add after 5 manual repetitions, split above 500-char descriptions, remove after 3 unused sessions,
+- [[goal-driven memory orchestration enables autonomous domain learning through directed compute allocation]] -- Define a persona and goal, allocate compute budget, get back a populated knowledge graph — the pattern shifts knowledge 
+- [[implicit dependencies create distributed monoliths that fail silently across configurations]] -- When modules share undeclared coupling through conventions, environment, or co-activation assumptions, the system looks 
+- [[justification chains enable forward backward and evolution reasoning about configuration decisions]] -- Traces each configuration decision to research claims, enabling forward (constraints to decisions), backward (decisions 
+- [[knowledge systems share universal operations and structural components across all methodology traditions]] -- Eight operations and nine structural components recur across Zettelkasten, PARA, Cornell, Evergreen, and GTD — implement
+- [[maintenance operations are more universal than creative pipelines because structural health is domain-invariant]] -- Structural health checks (validation, orphans, links, MOC coherence) transfer across domains and platforms while creativ
+- [[methodology traditions are named points in a shared configuration space not competing paradigms]] -- Zettelkasten, PARA, Cornell, Evergreen, and GTD each make different choices along the same dimensions (granularity, link
+- [[module communication through shared YAML fields creates loose coupling without direct dependencies]] -- YAML frontmatter functions as an event bus where one module writes a field and another reads it, so modules never call e
+- [[module deactivation must account for structural artifacts that survive the toggle]] -- Enabling a module creates YAML fields, MOC links, and validation rules that persist after deactivation — ghost infrastru
+- [[multi-domain systems compose through separate templates and shared graph]] -- Domain isolation at template and processing layers, graph unity at wiki link layer — five composition rules and four cro
+- [[novel domains derive by mapping knowledge type to closest reference domain then adapting]] -- Six knowledge type categories identify which reference domain's processing patterns transfer to unfamiliar domains, then
+- [[orchestrated vault creation transforms arscontexta from tool to autonomous knowledge factory]] -- The shift from "plugin that helps you set up a vault" to "system that builds domain knowledge for you" — init creates st
+- [[organic emergence versus active curation creates a fundamental vault governance tension]] -- Curation prunes possible futures while emergence accumulates structural debt — the question is not which pole to choose 
+- [[premature complexity is the most common derivation failure mode]] -- Derivation can produce systems with 12 hooks and 8 processing phases because the claim graph justifies them, but users a
+- [[progressive schema validates only what active modules require not the full system schema]] -- Each module declares its required YAML fields and validation checks only active modules — otherwise disabling modules do
+- [[scaffolding enables divergence that fine-tuning cannot]] -- agents with identical weights reach different conclusions when their external memory differs — scaffolding is the differ
+- [[schema evolution follows observe-then-formalize not design-then-enforce]] -- Five signals (manual additions, placeholder stuffing, dead enums, patterned text, oversized MOCs) drive a quarterly prot
+- [[schema field names are the only domain specific element in the universal note pattern]] -- The five-component note architecture (prose-title, YAML frontmatter, body, wiki links, topics footer) is domain-invarian
+- [[schema fields should use domain-native vocabulary not abstract terminology]] -- When schema field names match how practitioners naturally think — "triggers" not "antecedent_conditions" — adoption succ
+- [[storage versus thinking distinction determines which tool patterns apply]] -- PARA and Johnny.Decimal optimize for filing and retrieval ("where did I put that?") while Zettelkasten and ACCESS/ACE op
+- [[ten universal primitives form the kernel of every viable agent knowledge system]] -- Markdown files, YAML frontmatter, wiki links, MOC hierarchy, tree injection, description fields, topics footers, schema 
+- [[the derivation engine improves recursively as deployed systems generate observations]] -- Each deployed knowledge system is an experiment whose operational observations enrich the claim graph, making every subs
+- [[the no wrong patches guarantee ensures any valid module combination produces a valid system]] -- Borrowed from Eurorack where any patch produces sound without damage, enabled modules with satisfied dependencies must n
+- [[the vault methodology transfers because it encodes cognitive science not domain specifics]] -- Each vault structural pattern maps to a cognitive science principle — Cowan's limits, spreading activation, attention ma
+- [[use-case presets dissolve the tension between composability and simplicity]] -- Curated module selections for common use cases (Research Vault, PKM, Project Management) give template-level simplicity 
+
+## Tensions
+
+(Capture conflicts as they emerge)
+
+## Open Questions
+
+- Which dimension cascades have the strongest pressure effects?
+- Can dimension positions be inferred from observable vault behavior?
+
+---
+
+Topics:
+- [[index]]

package/methodology/digital mutability enables note evolution that physical permanence forbids.md

@@ -0,0 +1,54 @@
+---
+description: Physical index cards cannot be edited without destruction, so Luhmann designed for permanence — digital files have no such constraint, making continuous revision the natural mode
+kind: research
+topics: ["[[maintenance-patterns]]"]
+methodology: ["Evergreen"]
+source: [[tft-research-part2]]
+---
+
+# digital mutability enables note evolution that physical permanence forbids
+
+Luhmann wrote his Zettelkasten notes on paper index cards. Once written, a card could not be easily edited — you would need to scratch out text, write over existing content, or create a new card and somehow integrate it into the physical sequence. The medium imposed permanence as a design constraint. Luhmann adapted by designing for notes that would be written once and remain fixed, with new thinking expressed through new cards that referenced old ones rather than modifying them.
+
+Matuschak identifies this as a constraint of the medium, not a feature of the method. In digital systems, files can be edited indefinitely without degradation. There is no scratched-out text, no overflow into margins, no need to maintain physical card sequences. A note can be rewritten completely while maintaining all its incoming links. The file itself has no memory of what it used to say.
+
+This changes what notes can be. Luhmann's cards were snapshots — a thought captured at a moment in time, frozen by the medium. Digital notes can be living documents that evolve as understanding deepens. The research frames this as notes being "refactored" like code: renamed, restructured, split, merged, improved continuously. The metaphor is apt because code refactoring assumes the artifact will change many times over its lifetime, with each change improving without destroying.
+
+The philosophical shift is from permanence to evolution. Matuschak explicitly rejects permanence as a goal: notes should be "written and organized to evolve, contribute, and accumulate over time." This is not a small adjustment to the Zettelkasten method — it is a fundamental reorientation. Where Luhmann's system accumulated fixed records that created value through cross-reference, the evergreen approach accumulates living documents that create value through continuous improvement.
+
+For agent-operated vaults, this reorientation is liberating. Because [[backward maintenance asks what would be different if written today]], the answer can actually be implemented. An agent can rewrite prose, sharpen claims, add connections discovered later, even challenge the original argument with new evidence. None of this requires creating parallel documents or tracking versions manually — the note simply becomes what it should be today.
+
+The mechanism through which evolution occurs varies. Since [[incremental formalization happens through repeated touching of old notes]], many small touches during traversal can accumulate into significant improvement without any single moment of deliberate revision. But the deeper point is that the medium permits this. Analog cards could not accumulate small improvements — each improvement would degrade the card. Digital files absorb unlimited improvements invisibly.
+
+This creates a different relationship between notes and time. A Zettelkasten card is dated implicitly by when it entered the system and by the vocabulary and thinking patterns of that moment. An evergreen note has no single date — it might have been created three years ago but rewritten last week, and its prose reflects current understanding regardless of creation timestamp. The note's age becomes irrelevant; only its quality matters.
+
+The constraint relaxation has a shadow side. Physical permanence forced Luhmann to think carefully before writing — once inked, a card could not be taken back. Digital mutability can enable sloppiness: capture fast, fix later, except "later" never comes. The discipline that the medium once imposed must now be self-imposed or encoded in workflows. This is why skills like reweave exist — they create the maintenance pressure that physical cards didn't need because they couldn't decay through neglect; they simply existed.
+
+The mutability principle operates at the infrastructure level too, not just at the content level. Since [[context files function as agent operating systems through self-referential self-extension]], read-write context files are to read-only context files what digital notes are to physical cards: the medium either permits evolution or freezes instructions at creation. A read-only context file on a platform that forbids modification is functionally a Zettelkasten card -- the agent cannot improve its own operating instructions regardless of what it learns through use. The permanence constraint that Luhmann adapted to at the note level reappears at the system level whenever the infrastructure prevents self-modification.
+
+There is also a semantic constraint that emerges from graph structure itself. Since [[backlinks implicitly define notes by revealing usage context]], a note with many incoming links has accumulated meaning beyond its explicit content — other notes depend on what it claims. This creates a counterweight to pure mutability: the medium permits any revision, but the accumulated backlinks represent commitments from elsewhere in the graph that shouldn't be disrupted casually. Evolution is possible, but must respect what the note has come to mean through use.
+
+The parallel to [[wiki links are the digital evolution of analog indexing]] is instructive. Just as wiki links extend Cornell's cue columns from single-page to cross-document scope, digital mutability extends notes from frozen snapshots to living documents. Both are constraints of analog media that digital removes, and both removals enable qualitatively different knowledge work: graphs that span entire domains, notes that reflect today's understanding regardless of when they were created.
+
+There is a further dimension: mutability within a tool means little if the tool itself traps the content. Since [[data exit velocity measures how quickly content escapes vendor lock-in]], the mutability promise is only as real as the format's portability. Notes in a high-velocity format (plain text, markdown) can evolve across tool transitions — the note survives the death of Obsidian and keeps evolving in whatever comes next. Notes in a low-velocity format (sharded database) are functionally as immutable as Luhmann's paper cards: not because the medium forbids editing, but because the tool forbids leaving. Exit velocity turns the abstract concern about tool longevity into an auditable metric for whether mutability actually persists across the note's lifetime.
+
+Mutability also has a dimension beyond time. Since [[federated wiki pattern enables multi-agent divergence as feature not bug]], digital notes can not only evolve sequentially (version 1 becomes version 2) but coexist simultaneously across perspectives (agent A's version alongside agent B's version, both linked). This is a form of mutability Luhmann's system could not express: not just "this card could become something different" but "this concept supports multiple legitimate formulations right now." Where sequential mutability changes a note's content over time, federation extends mutability into a spatial dimension — multiple concurrent versions, each evolving independently, linked by their shared concept. The medium that permits revision also permits coexistence.
+
+What's remarkable is that since [[knowledge systems become communication partners through complexity and memory humans cannot sustain]], Luhmann's system achieved this partnership status despite physical permanence constraints. His Zettelkasten could "surprise" him with connections he had forgotten — the communication partner phenomenon emerged from density and cross-reference alone. Digital mutability doesn't create the partnership possibility; it amplifies it. Where Luhmann could only reference old cards, we can rewrite them — which means the system can evolve its own thinking, not just accumulate fixed snapshots. The partner becomes more intelligent over time, not just more extensive.
+---
+
+Relevant Notes:
+- [[backward maintenance asks what would be different if written today]] — the operational expression of this principle: if notes can evolve, the maintenance question becomes what should change, not whether change is allowed
+- [[backlinks implicitly define notes by revealing usage context]] — provides a counterweight to mutability: accumulated backlinks represent semantic commitments from other parts of the graph that constrain how aggressively a note should be rewritten
+- [[incremental formalization happens through repeated touching of old notes]] — one mechanism by which evolution actually occurs: many small touches accumulating into crystallized thinking
+- [[wiki links are the digital evolution of analog indexing]] — parallel evolution: just as wiki links extend Cornell's cue columns beyond single-page scope, note mutability extends beyond Luhmann's card constraints
+- [[local-first file formats are inherently agent-native]] — the substrate that makes mutability possible: plain text files can be edited directly without APIs or authentication, enabling the revision that physical cards forbade
+- [[bootstrapping principle enables self-improving systems]] — mutability enables bootstrapping: systems can improve their own notes only because the medium permits revision; Luhmann's Zettelkasten couldn't bootstrap content
+- [[vault conventions may impose hidden rigidity on thinking]] — mutability provides the escape valve: even if creation conventions are rigid, notes can evolve past their initial form through backward maintenance
+- [[knowledge systems become communication partners through complexity and memory humans cannot sustain]] — the partnership thesis: mutability amplifies but doesn't create the communication partner phenomenon — Luhmann achieved partnership through density alone, but digital mutability allows the partner to become more intelligent over time, not just more extensive
+- [[data exit velocity measures how quickly content escapes vendor lock-in]] — extends mutability across tool boundaries: high exit velocity ensures notes can evolve regardless of which software reads them, while low velocity makes notes functionally immutable when locked in a dying tool
+- [[federated wiki pattern enables multi-agent divergence as feature not bug]] — adds a spatial dimension to mutability: not just revision over time, but coexistence across perspectives at the same time; federation extends the evolution principle from sequential revision to parallel interpretation
+- [[context files function as agent operating systems through self-referential self-extension]] — infrastructure-level parallel: just as digital notes evolve past their creation moment, read-write context files evolve past their initial configuration; read-only platforms impose the same permanence constraint on context files that physical cards imposed on Zettelkasten notes
+
+Topics:
+- [[maintenance-patterns]]

package/methodology/discovery-retrieval.md

@@ -0,0 +1,48 @@
+---
+description: Progressive disclosure, description quality, findability -- how notes get discovered by agents and humans
+type: moc
+---
+
+# discovery-retrieval
+
+How notes get found. Description quality, title composability, semantic search, topic map navigation. The discovery-first design principle applied across the system.
+
+## Core Ideas
+
+### Research
+- [[BM25 retrieval fails on full-length descriptions because query term dilution reduces match scores]] -- When a BM25 query contains many terms, each term's IDF contribution gets diluted by common words competing for scoring b
+- [[complete navigation requires four complementary types that no single mechanism provides]] -- Rosenfeld and Morville's global, local, contextual, and supplemental navigation types map onto hub, MOC, wiki link, and 
+- [[description quality for humans diverges from description quality for keyword search]] -- Descriptions that pass prediction tests (5/5) can fail BM25 retrieval because human-scannable prose uses connective voca
+- [[descriptions are retrieval filters not summaries]] -- Note descriptions function as lossy compression enabling agents to filter before loading full content, which is informat
+- [[distinctiveness scoring treats description quality as measurable]] -- NLP-based validation tool that computes pairwise description similarity to flag retrieval confusion risk, operationalizi
+- [[faceted classification treats notes as multi-dimensional objects rather than folder contents]] -- Ranganathan's 1933 PMEST framework formalizes why each YAML field should be an independent classification dimension — fa
+- [[flat files break at retrieval scale]] -- unstructured storage works until you need to find things — then search becomes the bottleneck, and for agents, retrieval
+- [[good descriptions layer heuristic then mechanism then implication]] -- Structure descriptions as three layers — lead with actionable heuristic, back with mechanism, end with operational impli
+- [[live index via periodic regeneration keeps discovery current]] -- A maintenance agent regenerating index files on note changes bridges static indices that go stale with dynamic queries t
+- [[markdown plus YAML plus ripgrep implements a queryable graph database without infrastructure]] -- Wiki link edges, YAML metadata, faceted query dimensions, and soft validation compose into graph database capabilities w
+- [[maturity field enables agent context prioritization]] -- A seedling/developing/evergreen maturity field could help agents prefer mature notes when context is tight and surface s
+- [[metadata reduces entropy enabling precision over recall]] -- Without metadata agents rely on full-text search which returns many irrelevant matches; YAML frontmatter pre-computes lo
+- [[narrow folksonomy optimizes for single-operator retrieval unlike broad consensus tagging]] -- Thomas Vander Wal's broad/narrow distinction explains why vault tagging uses idiosyncratic sentence-titles instead of co
+- [[progressive disclosure means reading right not reading less]] -- The efficiency framing misses the point — tokens are free, quality requires depth, so the goal is a dense relevant conte
+- [[question-answer metadata enables inverted search patterns]] -- An 'answers' YAML field listing questions a note answers could enable question-driven search rather than keyword-driven 
+- [[retrieval utility should drive design over capture completeness]] -- System architecture choices should optimize for "how will I find this later" not "where should I put this" — a design or
+- [[retrieval verification loop tests description quality at scale]] -- Systematic scoring across all vault notes turns description quality from subjective judgment into measurable property, e
+- [[sense-making vs storage does compression lose essential nuance]] -- The vault bets that titles plus descriptions plus full content available preserves enough, but very subtle or contextual
+- [[structure enables navigation without reading everything]] -- Four structural mechanisms — wiki links, MOCs, claim titles, and YAML descriptions — compose into discovery layers that 
+- [[the AgentSkills standard embodies progressive disclosure at the skill level]] -- The same metadata-then-depth loading pattern that governs note retrieval in the vault also governs skill loading in the 
+- [[type field enables structured queries without folder hierarchies]] -- Content-kind metadata (claim, synthesis, tension) provides a query axis orthogonal to wiki link topology, enabling "find
+- [[wiki links create navigation paths that shape retrieval]] -- wiki links are curated graph edges that implement GraphRAG-style retrieval without infrastructure — each link is a retri
+
+## Tensions
+
+(Capture conflicts as they emerge)
+
+## Open Questions
+
+- What description quality threshold maximizes retrieval accuracy?
+- How does semantic search interact with explicit wiki-link navigation?
+
+---
+
+Topics:
+- [[index]]

package/methodology/distinctiveness scoring treats description quality as measurable.md

@@ -0,0 +1,69 @@
+---
+description: NLP-based validation tool that computes pairwise description similarity to flag retrieval confusion risk, operationalizing the distinctiveness criterion as automated quality assurance
+kind: research
+topics: ["[[discovery-retrieval]]"]
+---
+
+# distinctiveness scoring treats description quality as measurable
+
+The insight that [[descriptions are retrieval filters not summaries]] implies a validation criterion: a description is good if it uniquely identifies its note among all notes in the system. This is testable. Compute pairwise similarity between all descriptions, flag pairs above a threshold. High-similarity pairs represent retrieval confusion risk — an agent searching might return the wrong note because the descriptions don't distinguish them. The threshold itself follows the pattern that [[confidence thresholds gate automated action between the mechanical and judgment zones]] -- rather than a single binary cutoff, a three-tier response (auto-flag above 0.8, suggest review between 0.6 and 0.8, ignore below 0.6) would graduate the system's response based on its confidence in the confusion risk.
+
+This transforms description quality from subjective judgment ("does this feel distinct enough?") to measurable property ("what's the similarity score with the most similar other description?"). The scoring mechanism makes the quality gate enforceable.
+
+## Implementation Pattern
+
+The algorithm:
+
+1. Extract all description strings from YAML frontmatter
+2. Embed each description (or use simpler TF-IDF/BM25 similarity)
+3. Compute pairwise similarity matrix
+4. Flag pairs exceeding threshold (perhaps 0.8 cosine similarity)
+5. Output: pairs of notes whose descriptions are confusingly similar
+
+```bash
+# Sketch: extract descriptions, compute similarity
+rg "^description:" thinking/*.md | # get all descriptions
+  # [pipe to similarity computation]
+  # [flag high-similarity pairs]
+```
+
+The output enables targeted revision: for each flagged pair, at least one description needs sharpening to distinguish the notes.
+
+## The Quality Assurance Pattern
+
+This is NLP-based linting applied to knowledge system metadata. The scoring should integrate into health check operations or run as a separate validation pass. Automated checks catch problems that human scanning misses — particularly at scale where manually comparing 50+ descriptions becomes impractical.
+
+The pattern generalizes: any metadata field with a "distinctiveness matters" semantic can be validated this way. Titles could be scored similarly. The underlying principle is that knowledge graph elements that serve retrieval should be measurable against retrieval criteria.
+
+## Connection to Testing Effect Experiment
+
+The [[testing effect could enable agent knowledge verification]] experiment tests description quality through prediction: can an agent predict note content from title + description? Distinctiveness scoring offers a complementary approach: instead of testing retrieval success, test retrieval ambiguity. A note might pass the testing effect check (description enables prediction) while still being confusable with another note if both descriptions are similar.
+
+The two validations catch different failure modes:
+- Testing effect catches: descriptions too vague to enable prediction
+- Distinctiveness scoring catches: descriptions that distinguish from title but not from other notes
+
+Together they form a more complete quality assurance layer. Since [[schema enforcement via validation agents enables soft consistency]], these validation mechanisms share a common operational pattern: async checking that accumulates results for batch maintenance rather than blocking creation. Distinctiveness scoring runs as a periodic validation pass, flagging high-similarity pairs for attention during maintenance cycles — exactly the soft enforcement model that preserves creation flow while surfacing quality drift. Since [[retrieval verification loop tests description quality at scale]], both approaches can now be systematized: the loop runs prediction scoring across all notes and adds actual retrieval testing to verify search ranking. A note might pass prediction (description makes sense to humans) but fail retrieval (description lacks searchable keywords), or vice versa. The combined signal from distinctiveness scoring, prediction verification, and retrieval testing provides a comprehensive quality surface for the description layer.
+
+## Why This Matters
+
+At scale, description quality determines filtering efficiency. Since [[throughput matters more than accumulation]], filtering speed directly impacts processing velocity. Every confusing description that causes wrong-note retrieval or multiple-note scanning adds friction. Automated detection of confusion risk enables proactive improvement before retrieval failures occur.
+
+The pattern also inverts the typical quality control direction: instead of checking each description against abstract criteria, check descriptions against each other. The corpus itself defines what "distinct enough" means — your description must distinguish from every other description in the system. But since [[description quality for humans diverges from description quality for keyword search]], distinctiveness itself splits across channels. Two descriptions might be easily distinguished by an agent reading them sequentially (different logical structure, different implications) while being confusingly similar to BM25 (shared common vocabulary, same connective words). The pairwise similarity measurement needs to account for which retrieval channel it targets — embedding similarity measures scanning-channel distinctiveness, while keyword overlap measures search-channel distinctiveness.
+---
+
+Relevant Notes:
+- [[descriptions are retrieval filters not summaries]] — provides the theoretical foundation: descriptions should maximize distinctiveness within corpus, not comprehensiveness
+- [[good descriptions layer heuristic then mechanism then implication]] — complements distinctiveness with structure: layered descriptions are more likely to be distinctive because each layer adds differentiating information
+- [[testing effect could enable agent knowledge verification]] — complementary validation approach: testing effect catches vagueness, distinctiveness scoring catches ambiguity
+- [[retrieval verification loop tests description quality at scale]] — the scaled implementation: systematic prediction-then-verify cycles with scoring, combined with actual retrieval testing, forming a complete quality surface alongside distinctiveness scoring
+- [[skills encode methodology so manual execution bypasses quality gates]] — grounds why this should be automated in health checks rather than manual checking
+- [[throughput matters more than accumulation]] — connects to success metric: filtering efficiency determines processing velocity, confusion risk slows filtering
+- [[metadata reduces entropy enabling precision over recall]] — provides the information-theoretic grounding: distinctiveness is entropy reduction applied to descriptions; high similarity means redundant information
+- [[metacognitive confidence can diverge from retrieval capability]] — tests the gap this methodology addresses: structural metrics (descriptions exist) may not correlate with retrieval success; distinctiveness scoring helps close that gap by measuring description effectiveness, not just existence
+- [[schema enforcement via validation agents enables soft consistency]] — shared operational pattern: both are async validation mechanisms that flag rather than block, accumulating results for maintenance rather than preventing creation
+- [[description quality for humans diverges from description quality for keyword search]] — complicates the measurement target: distinctiveness scoring measures inter-note confusion but the score may apply differently across retrieval channels; descriptions can be distinctive for human scanning while being indistinct for keyword matching if the distinguishing features are connective prose rather than keyword vocabulary
+- [[confidence thresholds gate automated action between the mechanical and judgment zones]] -- the 0.8 similarity threshold is itself a confidence-gated pattern: pairs above 0.8 are auto-flagged (high confidence of confusion risk), pairs between 0.6 and 0.8 could be suggested for review (medium confidence), and pairs below 0.6 are ignored (low confidence); the three-tier response pattern generalizes the binary threshold into graduated action
+
+Topics:
+- [[discovery-retrieval]]

package/methodology/does agent processing recover what fast capture loses.md

@@ -0,0 +1,43 @@
+---
+description: Agent processing can recover practical benefits of slow capture for the system, but the human loses encoding benefits because the agent generates, not the human
+kind: research
+topics: ["[[processing-workflows]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# does agent processing recover what fast capture loses
+
+Research consistently shows handwriting produces better encoding than typing. The mechanism: slowness forces real-time summarization. You can't write as fast as you think, so you must compress, select, and transform. This is [[the generation effect requires active transformation not just storage]] at capture time — the human's brain does the generative work during the act of recording.
+
+Agent-delegated capture inverts this. Capture is fast and verbatim. The human speaks, the system transcribes. No compression at capture time. The generative work happens later, when agents process the transcript: extracting claims, writing descriptions, finding connections.
+
+Agent processing can recover the practical benefits of slow capture — a high-quality vault representation emerges from the agent's extraction and synthesis work. But it cannot recover the human encoding benefits. The human doesn't remember and understand the content deeply because the human didn't do the generative work. The system gets the generation effect. The human doesn't.
+
+This tradeoff is now the unspoken cost of an entire industry movement. Since [[vibe notetaking is the emerging industry consensus for AI-native self-organization]], the "dump and AI organizes" paradigm promotes effortless capture without acknowledging that effortlessness means the human did no generative cognitive work. The industry consensus promises frictionless knowledge management. The unaddressed question is whether frictionless capture with AI processing builds understanding in anyone but the AI.
+
+This creates a fundamental tradeoff: fast capture + agent processing builds excellent external memory but weak internal understanding. Slow capture + human summarization builds strong personal memory but may not need vault help at all. The human must choose what to optimize for. But the tradeoff is not purely a loss: since [[voice capture is the highest-bandwidth channel for agent-delegated knowledge systems]], voice capture triples speed beyond typing while preserving emotional metadata — tone, emphasis, hesitation — that text capture strips away. These paraverbal signals give the agent extraction heuristics that partially compensate for what fast capture loses in encoding depth. The human does not deeply encode the content, but the emotional channel provides priority signals the agent would not otherwise have.
+
+But there may be a middle path. Since [[guided notes might outperform post-hoc structuring for high-volume capture]], research on Guided Notes suggests that lightweight structure at capture time — skeleton outlines or prompts like "main point, evidence, questions" — preserves generation effects without the friction of full manual structuring. The agent could provide capture scaffolding rather than post-hoc processing alone, prompting the human during capture in ways that trigger generation ("What's the main claim here?") without requiring the human to design the structure themselves.
+
+The practical implication: agent-delegated capture excels at building searchable, retrievable knowledge infrastructure. But heavy reliance on it may create externalized cognition dependency — ideas exist in the system but not in the human's recall. When you read a note that an agent processed from your raw capture, it can feel like someone else's note about your ideas rather than your own thinking. And since [[decontextualization risk means atomicity may strip meaning that cannot be recovered]], even the system's representation may be contextually impoverished — the agent recovers structural quality (well-formed claims, proper connections) but may lose the argumentative scaffolding that made the original ideas compelling. The human loses encoding; the vault may lose context. Both are costs of the delegation pattern.
+
+This tradeoff takes on a different character in light of the broader capture landscape. Since [[three capture schools converge through agent-mediated synthesis]], the "fundamental divergence" between Accumulationist speed, Interpretationist quality, and Temporal urgency dissolves into a division of labor: human for speed, agent for quality. At the system level, this convergence is real — the vault gets the best of all three schools. But at the human level, this note's concern persists: the convergence delivers Interpretationist quality to the vault while leaving the human with Accumulationist encoding. The system-level resolution does not resolve the human-level cost. The capture schools converge for the knowledge graph, but the encoding question remains open for the person.
+
+This parallels what [[random note resurfacing prevents write-only memory]] addresses for the system: content that accumulates but never gets revisited becomes write-only. Fast capture may create write-only memory in the human's brain — ideas captured but not encoded, existing only in the system.
+---
+
+Relevant Notes:
+- [[the generation effect requires active transformation not just storage]] — the cognitive science foundation; encoding benefits accrue to whoever does the generating
+- [[temporal separation of capture and processing preserves context freshness]] — argues for separating capture from processing, which enables this delegation pattern
+- [[random note resurfacing prevents write-only memory]] — parallel concept for the system; fast capture may create write-only memory in the human
+- [[guided notes might outperform post-hoc structuring for high-volume capture]] — proposes a middle path: lightweight scaffolding at capture time preserves human generation benefits without requiring full manual structuring
+- [[capture the reaction to content not just the content itself]] — concrete implementation of the middle path: prompting what is your reaction? at capture time preserves human encoding (the reaction is generative work) while maintaining fast capture's low friction
+- [[cognitive outsourcing risk in agent-operated systems]] — sibling experiment addressing skill atrophy rather than encoding loss; this tests whether humans remember specific content, that tests whether humans retain meta-cognitive capability to do knowledge work at all
+- [[cognitive offloading is the architectural foundation for vault design]] — the motivating framework; this experiment tests the limit of the offloading thesis — if frictionless capture is optimal for offloading economics, what does the human lose?
+- [[three capture schools converge through agent-mediated synthesis]] — reframes this tradeoff: the capture schools converge at the system level (vault gets Interpretationist quality), but the human encoding gap this note describes persists as the shadow side of that convergence
+- [[voice capture is the highest-bandwidth channel for agent-delegated knowledge systems]] — intensifies the tradeoff by tripling capture speed, but also partially mitigates it: voice preserves emotional metadata (tone, emphasis, hesitation) that gives agents extraction heuristics text capture cannot provide
+- [[vibe notetaking is the emerging industry consensus for AI-native self-organization]] — industry context: the encoding tradeoff this note explores is the unspoken cost of the entire vibe notetaking movement, which promotes effortless capture without acknowledging that effortlessness means the human retains nothing
+- [[decontextualization risk means atomicity may strip meaning that cannot be recovered]] — compounds the delegation cost: the human loses encoding, and the vault may also lose argumentative context that gave claims their original force during extraction
+
+Topics:
+- [[processing-workflows]]

package/methodology/domain-compositions.md

@@ -0,0 +1,37 @@
+---
+description: Worked examples of derived vaults across 12 domains -- therapy, research, PM, trading, and more
+type: moc
+---
+
+# domain-compositions
+
+Worked domain examples showing how the 8 dimensions, vocabulary, and personality combine for specific use cases. Each example demonstrates a complete derived system.
+
+## Domains
+
+- [[therapy journal uses warm personality with pattern detection for emotional processing]] -- therapeutic journaling with mood-trigger correlation, ethical constraints, and growth tracking
+- [[academic research uses structured extraction with cross-source synthesis]] -- literature reviews, claim extraction, methodology-comparable synthesis
+- [[trading uses conviction tracking with thesis-outcome correlation]] -- trade journaling, strategy drift detection, conviction-outcome feedback loops
+- [[creative writing uses worldbuilding consistency with character tracking]] -- worldbuilding consistency graphs, character tracking, timeline management
+- [[project management uses decision tracking with stakeholder context]] -- decision documentation, stakeholder management, cross-project learning
+- [[product management uses feedback pipelines with experiment tracking]] -- feedback-to-feature pipelines, experiment tracking, customer voice intelligence
+- [[engineering uses technical decision tracking with architectural memory]] -- ADR tracking, dependency graphs, architectural memory across team members
+- [[student learning uses prerequisite graphs with spaced retrieval]] -- prerequisite graph construction, mastery tracking, spaced retrieval scheduling
+- [[personal assistant uses life area management with review automation]] -- life area management, goal tracking, habit formation, review automation
+- [[health wellness uses symptom-trigger correlation with multi-dimensional tracking]] -- symptom-trigger correlation, training optimization, multi-dimensional wellness tracking
+- [[legal case management uses precedent chains with regulatory change propagation]] -- precedent chain tracking, regulatory change propagation, cross-matter intelligence
+- [[people relationships uses Dunbar-layered graphs with interaction tracking]] -- Dunbar-layered relationship graphs, interaction tracking, personal CRM
+
+## Cross-Domain Patterns
+
+(Patterns that recur across multiple domain compositions)
+
+## Open Questions
+
+- Which domain compositions stress-test the derivation engine most?
+- What domain-specific failure modes need documentation?
+
+---
+
+Topics:
+- [[index]]

package/methodology/dual-coding with visual elements could enhance agent traversal.md

@@ -0,0 +1,55 @@
+---
+description: Cognitive science shows text+visuals create independent memory traces that reinforce each other — multimodal LLMs could use diagrams as alternative traversal cues alongside wiki links
+kind: research
+topics: ["[[agent-cognition]]"]
+methodology: ["Cornell"]
+source: [[3-3-cornell-note-taking-system]]
+---
+
+# dual-coding with visual elements could enhance agent traversal
+
+Cognitive science documents that combining visual and verbal representations creates two independent memory traces that reinforce each other. This is called dual-coding theory. In human knowledge work, the sketchnoting variation of Cornell Notes exploits this by putting diagrams in the Notes column while keeping text-based keywords in the Cue column — a pattern that significantly boosts human retention. The agent translation question: does multimodal processing (text + diagrams) give agents alternative traversal pathways, or does everything collapse into the same latent space?
+
+The question is whether this pattern translates to agent-operated knowledge systems. Current vaults are text-heavy — markdown files with prose, wiki links, and YAML metadata. Could visual representations provide alternative traversal cues that text misses?
+
+## What Visual Elements Could Offer
+
+Wiki links create textual connection points. But some relationships are easier to see than to say. A Mermaid diagram showing the dependency structure between concepts makes patterns visible that would require multiple paragraphs to describe. An auto-generated relationship graph showing note clusters reveals structural properties (isolation, density, hub status) that individual wiki links can't surface.
+
+Since [[spreading activation models how agents should traverse]], traversal works through semantic connections between concepts. Visual representations could function as a parallel activation network — the diagram activates related concepts through spatial proximity and visual grouping, not just through explicit links. This would provide redundancy: if the textual path fails (agent doesn't recognize the connection), the visual path might succeed. This is a different kind of redundancy than what [[trails transform ephemeral navigation into persistent artifacts]] proposes. Trails provide temporal redundancy by persisting successful navigation sequences. Visual dual-coding provides modal redundancy — two encoding formats for the same relationships. Both address the question of how to make traversal more robust.
+
+Since [[each new note compounds value by creating traversal paths]], the value question is whether visual elements create new paths or just restate existing ones. If a Mermaid diagram in a MOC only visualizes what the wiki links already express, it adds no new traversal options — it's decoration. But if the visual reveals structural patterns that the link list obscures, it creates genuinely new navigation affordances.
+
+## The Multimodal Question
+
+Modern LLMs are multimodal — they can process images alongside text. This capability is underexploited in current knowledge management. A vault could include relationship diagrams, concept maps, or even hand-drawn sketches that carry structural information. The agent would process both the prose and the visual, potentially finding connections that neither alone would surface.
+
+The open question is whether current multimodal capabilities are good enough for this to work. Human dual-coding works because the visual and verbal systems are genuinely distinct in the brain. LLM multimodal processing may not have the same separation — the visual input gets converted to the same latent space as text, which might mean no dual benefit.
+
+## Implementation Considerations
+
+If dual-coding does provide benefit, implementation would require:
+
+1. Mermaid diagrams in MOCs showing concept relationships
+2. Auto-generated graph visualizations (via scripts) showing vault topology
+3. Conventions for when visual representation adds value vs. when it's noise
+4. Image attachments in markdown notes where spatial relationships matter
+
+The risk is complexity without benefit. Since [[progressive disclosure means reading right not reading less]], adding visual layers only makes sense if they enable better curation, not if they just add more content to process. A diagram that takes 500 tokens to describe and another 500 tokens to visually encode costs 1000 tokens. If both paths lead to the same conclusion, you've paid double for no additional insight.
+
+This note explores one direction of the modality question — whether spatial-visual can supplement spatial-textual. The inverse direction is equally important: since [[temporal media must convert to spatial text for agent traversal]], content that exists in temporal formats (audio, video, podcasts) must first become spatial text before it can participate in any traversal, let alone benefit from visual supplementation. The modality conversation has two halves: converting temporal to spatial (mandatory, lossy but necessary) and enriching spatial-textual with spatial-visual (optional, benefit uncertain). This note addresses the second half; the temporal media note addresses the first.
+
+This remains a research question rather than a settled claim. The theoretical basis from human cognition is solid. The translation to agent cognition is unverified. Since [[testing effect could enable agent knowledge verification]] proposes prediction-based verification as a way to test whether descriptions actually work, a parallel experiment could test whether visual elements provide verifiable benefit — can agents using visual+text outperform agents using text-only on connection-finding tasks?
+---
+
+Relevant Notes:
+- [[spreading activation models how agents should traverse]] — visual elements would function as parallel activation pathways alongside textual links
+- [[each new note compounds value by creating traversal paths]] — the test: do visuals create new paths or restate existing ones?
+- [[progressive disclosure means reading right not reading less]] — visual layers only add value if they enable better curation, not just more content
+- [[trails transform ephemeral navigation into persistent artifacts]] — sibling proposal for traversal redundancy: trails are temporal (path reuse), dual-coding is modal (visual + text)
+- [[testing effect could enable agent knowledge verification]] — sibling Cornell-derived experiment: both propose alternative verification/enhancement channels for agent cognition
+- [[wiki links are the digital evolution of analog indexing]] — methodological lineage: Cornell cue columns became wiki links; sketchnoting variations could become visual traversal cues
+- [[temporal media must convert to spatial text for agent traversal]] — the inverse modality question: this note asks whether spatial-visual can supplement spatial-textual, while temporal media conversion addresses the prerequisite of getting temporal content into spatial text at all
+
+Topics:
+- [[agent-cognition]]

package/methodology/each module must be describable in one sentence under 200 characters or it does too many things.md

@@ -0,0 +1,45 @@
+---
+description: The single-sentence test operationalizes Unix "do one thing" as a measurable constraint — if the description exceeds 200 characters, the module bundles capabilities that should be separate toggles
+kind: research
+topics: ["[[design-dimensions]]", "[[note-design]]"]
+methodology: ["Original", "Systems Theory"]
+source: [[composable-knowledge-architecture-blueprint]]
+---
+
+# each module must be describable in one sentence under 200 characters or it does too many things
+
+The Unix philosophy says "do one thing well," but without a concrete test the principle degrades into aspiration. Developers agree their module does one thing — they just define "one thing" broadly enough to include three capabilities bundled under a unifying label. The single-sentence description test provides a measurable operationalization: if you cannot describe what a module does in one sentence under 200 characters, it does too many things and should be split.
+
+The test works because description length is a reliable proxy for scope. A module that manages YAML schema validation is describable in a sentence: "Validates frontmatter fields against template-defined schemas." A module that manages YAML schema validation AND migration AND format conversion requires qualifiers, conjunctions, and subordinate clauses that push the description past the threshold. The length is not arbitrary — it tracks the same cognitive load that makes compound note titles unwieldy. Since [[claims must be specific enough to be wrong]], the specificity constraint on note titles and the brevity constraint on module descriptions share a mechanism: both use conciseness as evidence that the underlying concept is singular rather than bundled. A vague note title hides multiple claims; an overlong module description hides multiple capabilities.
+
+This connects directly to how [[descriptions are retrieval filters not summaries]]. Note descriptions function as filters that help agents decide whether to load full content — brevity forces precision, and precision enables filtering. Module descriptions serve an analogous but distinct function: they help agents and human operators decide whether to enable a module, and they serve as a design-time constraint that prevents scope creep before it reaches the user. The note description is a retrieval heuristic; the module description is a design test. Both exploit the same insight — that conciseness forces clarity — but in different phases of the lifecycle.
+
+The constraint has practical teeth beyond aesthetics. Since [[composable knowledge architecture builds systems from independent toggleable modules not monolithic templates]], the composability guarantee depends on modules being independently toggleable. A module that bundles capabilities A, B, and C forces users who want only A to accept B and C as well, breaking the granular control that composability promises. The feature-creep toggle anti-pattern emerges: enabling a module implicitly enables capabilities the user did not request, and those capabilities may interact with other modules in ways the dependency graph does not capture. This is precisely how [[implicit dependencies create distributed monoliths that fail silently across configurations]] — bundled capabilities multiply the channels through which undeclared coupling forms, because each capability within the unfocused module can independently develop phantom dependencies on fields or conventions from other modules. The single-sentence test prevents this upstream: if the description cannot fit in one sentence, the module's interaction surface is too large for the dependency resolver to track. Since [[the no wrong patches guarantee ensures any valid module combination produces a valid system]], unfocused modules threaten the safety guarantee because their hidden internal interactions expand the test surface combinatorially — you must verify not just that the module composes with others, but that each of its bundled capabilities composes independently.
+
+The description test also connects to platform constraints. Since [[skill context budgets constrain knowledge system complexity on agent platforms]], skill descriptions consume limited context space. A module whose description exceeds 200 characters because it does too many things also consumes disproportionate budget. The design principle and the platform constraint converge: even without a philosophical commitment to focused modules, the resource allocation problem of limited context space would force conciseness. But the design principle is stronger than the budget constraint — even on a platform with unlimited context, a module that cannot be described in one sentence does too many things because the problem is scope, not space.
+
+The test also has downstream consequences for module lifecycle. Since [[module deactivation must account for structural artifacts that survive the toggle]], a focused module that writes two YAML fields and creates one MOC convention has a tractable deactivation profile — the cleanup is proportional to the scope. An unfocused module that bundles three capabilities writes six fields, touches three types of structural artifacts, and leaves ghost infrastructure distributed across multiple concerns. The single-sentence test constrains this at design time: modules that pass the test tend to have deactivation costs that users can understand and accept. Similarly, since [[dependency resolution through topological sort makes module composition transparent and verifiable]], the transparency of dependency explanations depends on modules being narrowly scoped. "Processing-pipeline requires atomic-notes because pipeline phases operate on single-claim units" is an explanation that teaches architecture. A bundled module's dependency rationale would require subordinate clauses for each capability's requirements — the explanation becomes as unfocused as the module.
+
+There is a shadow side. The 200-character threshold is a heuristic, and heuristics have failure modes. Some genuinely singular capabilities require nuanced description because the capability itself is conceptually complex. A module for "semantic search with BM25 plus vector embeddings and LLM reranking" does one thing (search) but the implementation requires mentioning three mechanisms. The test might flag this as unfocused when it is actually focused but technically layered. The mitigation is that the test should trigger investigation, not automatic splitting. When a description exceeds the threshold, the question is: "Does this module bundle independent capabilities that users might want separately?" If yes, split. If the length comes from describing one capability with inherent complexity, the description may need tightening rather than the module needing splitting. Since [[complex systems evolve from simple working systems]], the default should favor splitting — it is easier to compose two focused modules than to manage one unfocused one — but the test is a signal, not a verdict.
+
+The parallel to note-level design is instructive. Since [[enforcing atomicity can create paralysis when ideas resist decomposition]], atomicity is to notes what the single-sentence test is to modules — both use conciseness as evidence that the underlying concept is singular rather than bundled, and both face the same failure mode when genuinely complex singular things resist the constraint. A note that resists decomposition because the relational structure IS the insight parallels a module whose single capability requires mentioning three mechanisms. The mitigations diverge, however: note-level atomicity has no mechanical test (whether an idea "resists decomposition because it's fuzzy" versus "resists because it's genuinely relational" requires judgment), while the single-sentence test provides at least a threshold that triggers investigation. The module-level constraint is more operationalizable precisely because modules have descriptions that can be measured, while notes have claims that must be evaluated.
+
+---
+---
+
+Relevant Notes:
+- [[composable knowledge architecture builds systems from independent toggleable modules not monolithic templates]] — parent architecture: this note provides one of the design principles that makes module boundaries enforceable rather than advisory
+- [[descriptions are retrieval filters not summaries]] — extends the description-as-constraint pattern from notes to modules: both use brevity as a forcing function, but notes use it for retrieval filtering while modules use it for scope enforcement
+- [[claims must be specific enough to be wrong]] — shared mechanism: specificity tests work because vagueness hides bundled concerns, whether in note titles that gesture at topics or module descriptions that paper over feature creep
+- [[skill context budgets constrain knowledge system complexity on agent platforms]] — platform pressure reinforces the constraint: even if the single-sentence test were not a design principle, skill description budgets would force conciseness as a resource allocation problem
+- [[the no wrong patches guarantee ensures any valid module combination produces a valid system]] — depends on: focused modules with clear boundaries are what makes the combinatorial safety guarantee tractable, because unfocused modules create hidden interactions that expand the test surface
+- [[complex systems evolve from simple working systems]] — enables: Gall's Law requires that each addition is understandable in isolation, and the single-sentence test ensures modules remain simple enough to evaluate independently
+- [[implicit dependencies create distributed monoliths that fail silently across configurations]] — prevents upstream: unfocused modules multiply the channels through which implicit dependencies form, because bundled capabilities interact with other modules through undeclared conventions that escape the dependency resolver
+- [[module deactivation must account for structural artifacts that survive the toggle]] — reduces deactivation cost: a focused module writes fewer fields and creates fewer structural commitments, so its deactivation footprint is proportionally smaller and cleanup is tractable
+- [[dependency resolution through topological sort makes module composition transparent and verifiable]] — enables legibility: focused modules produce dependency explanations that teach architecture rather than obscure it, because a single-capability module's dependency rationale is expressible in one sentence
+- [[enforcing atomicity can create paralysis when ideas resist decomposition]] — parallel constraint at note level: atomicity is to notes what the single-sentence test is to modules, both using conciseness as evidence of singularity, and both facing the same failure mode when genuinely complex singular things resist the constraint
+- [[friction-driven module adoption prevents configuration debt by adding complexity only at pain points]] — applies the single-sentence test as a lifecycle threshold: the 500-char split trigger and 15-20 module cap are direct consequences of the describability constraint operating as a resource allocation mechanism during friction-driven evolution
+
+Topics:
+- [[design-dimensions]]
+- [[note-design]]

package/methodology/each new note compounds value by creating traversal paths.md

@@ -0,0 +1,55 @@
+---
+description: Unlike folders where 1000 documents is just 1000 documents, a graph of 1000 connected nodes creates millions of potential paths — the marginal note increases value of all existing notes
+kind: research
+topics: ["[[graph-structure]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# each new note compounds value by creating traversal paths
+
+A folder of documents has linear value. Add a document, the value increases by one. The hundredth document is worth no more than the first. Documents sit next to each other without affecting each other. Since [[associative ontologies beat hierarchical taxonomies because heterarchy adapts while hierarchy brittles]], the folder hierarchy not only fails to compound — it actively constrains future organization by requiring upfront classification decisions.
+
+A graph of connected notes has compounding value. Add a note with three connections, and you've created three new paths between previously unconnected ideas. The hundredth note doesn't just add one more thing to know — it creates dozens of new traversal paths that make the first ninety-nine notes more reachable.
+
+## The Mechanism
+
+When you create a link, you create a path in both directions. Note A linking to Note B means someone traversing from A can reach B, but it also means someone exploring outward from B can discover A. Each bidirectional link creates options that didn't exist before.
+
+The math compounds quickly. In a flat folder, N documents means N items. In a connected graph, N nodes with an average of K links creates O(N × K) direct paths, but the indirect paths grow much faster. The path from any note to any other note typically exists through 2-4 hops, meaning the graph functions as if everything were connected to everything — without the cognitive overhead of actually maintaining N² links.
+
+This is why since [[small-world topology requires hubs and dense local links]], the structure matters as much as the content. The right topology multiplies the reachability effect. Hub nodes act as highway interchanges, creating shortcuts that keep path lengths short even as the network grows. And since [[betweenness centrality identifies bridge notes connecting disparate knowledge domains]], we can measure which specific nodes contribute most to this reachability — the notes whose removal would most increase average path length are the structural load-bearers that disproportionately drive compounding.
+
+## Why This Matters for Knowledge Work
+
+Traditional document management treats notes as inventory. More notes means more stuff to organize, more overhead, diminishing returns. The hundredth document is slightly harder to find than the tenth.
+
+This inventory mindset comes from temporal organization — documents filed by date or project, understood by WHEN they appeared. Since [[topological organization beats temporal for knowledge work]], the system rejects this model entirely. Graph-structured knowledge inverts this. More notes means more connection opportunities, more paths for serendipitous discovery, increasing returns. The hundredth note makes the tenth easier to find because it creates new routes to reach it.
+
+This explains why link density matters more than note count. A knowledge system of 1000 poorly-linked notes functions worse than 100 richly-linked ones. The value comes from paths, not nodes. The consequence extends beyond navigation: because [[dense interlinked research claims enable derivation while sparse references only enable templating]], density is not just a usability property but a functional threshold — below it, the graph can only support template customization, while above it, agents can derive novel configurations by traversing the claim network. Since [[structure without processing provides no value]], creating nodes (notes) without edges (processed connections) produces no compounding — unprocessed notes are isolated points that cannot participate in the traversal network. But since [[orphan notes are seeds not failures]], this doesn't condemn orphan creation — it condemns orphan abandonment. An orphan is locked potential awaiting integration, not a failure state. The gardening framing: seeds planted now may bloom later when connection-finding or backward maintenance discovers their connections. And since [[inline links carry richer relationship data than metadata fields]], the quality of the link itself affects compounding: a typed inline link ("since X, therefore Y") creates a higher-quality path than a bare reference, because the traverser can judge whether to follow based on the relationship type. Dense typing compounds more than dense linking.
+
+## The Investment Logic
+
+Digital gardening research names this the "compound interest effect on knowledge" — old work supports new work. The financial metaphor is precise: notes are appreciating assets, not depreciating inventory. A note created today will be discovered through paths that don't exist yet — paths created by notes written tomorrow. Unlike documents that grow stale in folders, connected notes gain value over time as the network they participate in grows denser.
+
+Every note you create is an investment that pays dividends as long as it's connected. The implication: time spent on connections isn't overhead. It's the value-generating activity. A note without links is potential value locked away. A note with three well-reasoned links has already multiplied its worth threefold.
+
+Because value compounds through connections, the success metric should be connection velocity rather than archive size. Since [[throughput matters more than accumulation]], processing velocity from capture to synthesis matters more than how much you've accumulated — and this note explains why: each synthesis creates new traversal paths that increase the value of everything already synthesized.
+
+The paths this note describes are what [[spreading activation models how agents should traverse]] moves through. Compounding creates the paths; spreading activation is how agents use them. The richer the path network, the more options for focused retrieval (high decay) or exploratory synthesis (low decay).
+---
+
+Relevant Notes:
+- [[topological organization beats temporal for knowledge work]] — the foundational choice that makes compounding possible: concept-based organization enables traversal paths while date-based organization cannot
+- [[small-world topology requires hubs and dense local links]] — explains HOW to structure for this effect, while this note explains WHY the effect exists
+- [[wiki links implement GraphRAG without the infrastructure]] — the practical mechanism that makes traversal paths work
+- [[throughput matters more than accumulation]] — the operational consequence: if value compounds through connections, success metrics should emphasize connection velocity over archive size
+- [[spreading activation models how agents should traverse]] — compounding creates the paths; spreading activation is how agents traverse them
+- [[dangling links reveal which notes want to exist]] — shows how notes enter the graph with pre-accumulated value: high-frequency dangling links mean the note starts with hub-level connectivity
+- [[structure without processing provides no value]] — the inverse case: notes created without processing produce no compounding because they lack the edges (connections) that create paths
+- [[inline links carry richer relationship data than metadata fields]] — link quality affects compounding: typed inline links create higher-quality paths than bare references
+- [[orphan notes are seeds not failures]] — provides the gardening framing: orphans are locked potential awaiting integration, not failure states; creation is valid, abandonment is the failure
+- [[betweenness centrality identifies bridge notes connecting disparate knowledge domains]] — measures exactly WHICH notes contribute most to path creation: high-betweenness notes are the ones whose removal would most reduce reachability across the graph
+- [[dense interlinked research claims enable derivation while sparse references only enable templating]] — the derivation consequence: compounding value through traversal paths is not just a navigation benefit but a functional threshold that determines whether the graph can support principled derivation or only template customization
+
+Topics:
+- [[graph-structure]]