arscontexta 0.6.0

package/methodology/multi-domain systems compose through separate templates and shared graph.md

@@ -0,0 +1,61 @@
+---
+description: Domain isolation at template and processing layers, graph unity at wiki link layer — five composition rules and four cross-domain connection patterns make multi-domain vaults tractable
+kind: research
+topics: ["[[design-dimensions]]", "[[graph-structure]]"]
+methodology: ["Original", "Systems Theory"]
+source: [[knowledge-system-derivation-blueprint]]
+---
+
+# multi-domain systems compose through separate templates and shared graph
+
+Most real knowledge systems serve more than one purpose. A personal vault might track research, health, projects, and relationships simultaneously. A professional system might handle client work, internal knowledge, and training materials. The derivation process handles single-domain systems cleanly — since [[novel domains derive by mapping knowledge type to closest reference domain then adapting]], each domain maps to a reference model and gets its own configuration. But what happens when multiple domains coexist in one graph?
+
+The composition principle is that isolation should happen at the template and processing layer while unity should happen at the graph layer. Each domain gets its own templates with domain-specific YAML fields, its own processing phase sequence in the work queue, and its own context-loading rules in the agent's operating file. But all notes — regardless of domain — share one graph connected by wiki links. A therapy reflection and a project decision and a research claim all exist in the same wiki link namespace, all traversable from any starting point. This separation works because since [[concept-orientation beats source-orientation for cross-domain connections]], extracted concept nodes can form edges across any domain boundary, and since [[wiki links implement GraphRAG without the infrastructure]], the shared link namespace provides multi-hop traversal without requiring per-domain graph infrastructure.
+
+Five rules make this composition tractable rather than chaotic.
+
+First, separate templates but shared graph. Each domain defines its own note templates with fields that serve its domain semantics — a therapy domain uses `trigger`, `pattern_type`, and `coping_strategy` while a research domain uses `methodology`, `classification`, and `adapted_from`. But all notes inhabit the same `01_thinking/` flat folder (or equivalent), connected by the same wiki link mechanism. Since [[faceted classification treats notes as multi-dimensional objects rather than folder contents]], the domain itself becomes another facet — a classification dimension orthogonal to topic, type, and methodology. An agent querying "all notes in the therapy domain that connect to research claims" is executing a cross-facet query, which is exactly what Ranganathan's framework was designed to support.
+
+Second, no field name conflicts. When two domains use the same term differently, prefix it: `project_status` versus `therapy_status`. This seems like mere naming convention, but it has structural consequences. YAML fields are the faceted classification dimensions that make notes queryable. A field that means different things in different domains destroys the precision that faceted access provides — `rg '^status: active'` would return a mix of active projects and active therapy sessions, conflating semantically distinct categories. Prefixing preserves queryability across the combined schema.
+
+Third, cross-domain reflect. The connection-finding phase must search across ALL domains, not just the current one. This is where multi-domain composition creates value that single-domain systems cannot. A research insight about "cognitive load reduces decision quality" should connect to a project decision made under time pressure and a therapy reflection about stress patterns — connections that would be invisible if reflect searched only within its own domain. Since [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]], the connect phase is a structural constant that operates identically regardless of what domain produced the content. Cross-domain reflect is not an extra feature but the natural consequence of having a shared graph. This is also [[controlled disorder engineers serendipity through semantic rather than topical linking]] applied at the domain level — cross-domain reflect engineers productive unpredictability by linking semantically across domain boundaries rather than restricting connections to topical neighborhoods within a single domain.
+
+Fourth, domain-specific processing. While the connect and verify phases work across domains, the process step is inherently domain-specific. Research content gets claim extraction. Therapy content gets pattern detection. Project content gets decision documentation. Each domain has its own phase sequence in the processing queue, its own skill implementations for the process step, and its own quality criteria. This rule exists because [[false universalism applies same processing logic regardless of domain]], and multi-domain vaults are where that failure is most dangerous — without explicit domain-specific processing, the shared graph propagates one domain's operations to all domains, producing cross-domain contamination that looks like systematic design. This is where since [[configuration dimensions interact so choices in one create pressure on others]] becomes practically important — each domain might sit at a different point on the processing intensity spectrum, and the shared graph must accommodate notes of varying depth and structure without degrading navigation for any domain.
+
+Fifth, progressive context loading. The agent's context file loads a universal base (graph mechanics, quality standards, linking philosophy) on every session, then loads domain-specific sections only when operating in that domain. A therapy processing session loads therapy templates and processing rules. A research session loads research methodology. This manages context budget — since processing intensity and schema density vary by domain, the agent needs domain-appropriate guidance without burning context on irrelevant domain rules.
+
+What makes multi-domain composition genuinely valuable rather than merely convenient is that cross-domain connections reveal patterns invisible within any single domain. Since [[cross-links between MOC territories indicate creative leaps and integration depth]], the four cross-domain connection patterns described below are precisely the creative leaps that cross-MOC membership measures — each pattern produces notes that bridge domain-specific MOCs, and their density serves as a quality metric for whether multi-domain composition is producing genuine integration or merely cohabitation. Four connection patterns recur across multi-domain systems. Temporal correlation surfaces when entries from different domains cluster in the same time period — health problems coinciding with work stress, or creative productivity peaking during relationship stability. Entity sharing occurs when the same person, place, or concept appears in different domain contexts — a colleague who features in project decisions, research collaborations, and relationship notes becomes a hub that bridges three domain clusters. Causal chains emerge when effects in one domain trace to causes in another — sleep quality affecting cognition affecting trading performance, where each link crosses a domain boundary. Goal alignment becomes visible when activities across domains converge on the same higher-order objective — learning, practice, and networking all serving career advancement, visible only from a cross-domain vantage point.
+
+Each of these patterns has a detection method appropriate to graph-native systems. Temporal correlation uses semantic search scoped to time periods across domains. Entity sharing uses wiki links to shared entity MOCs — since [[small-world topology requires hubs and dense local links]], these shared entities become the hubs that create short paths across domain clusters, making the multi-domain graph navigable rather than fragmented. Causal chains use semantic search for related patterns across domains. Goal alignment uses topic and area overlap analysis across domain-specific MOCs.
+
+Multi-domain composition also raises the question of schema consistency across domain boundaries. Since [[schema enforcement via validation agents enables soft consistency]], soft enforcement becomes especially important when domains with different schemas coexist in one graph — hard enforcement that blocks on a therapy field violation would stall research processing, while soft validation that warns without blocking lets each domain maintain its own schema standards without cross-domain interference.
+
+The shadow side is complexity management. Each new domain added to a composed system increases the cross-domain surface area quadratically — two domains have one boundary, three domains have three, five domains have ten. The connection-finding phase scales with this surface area because it must search for patterns across all domain pairs. Since [[configuration dimensions interact so choices in one create pressure on others]], dimension settings in one domain can create pressure on others — a domain with high processing intensity and dense schemas shares graph space with a domain that has light processing and minimal schemas, and the navigation depth must serve both. Whether this creates incoherence or productive tension depends on whether the shared graph mechanics (wiki links, MOCs, progressive disclosure) can bridge the gap between domains with different structural densities.
+
+There is also the question of when multi-domain composition is preferable to separate vaults. The composition approach trades complexity for connection — you accept the overhead of cross-domain schema management, field prefixing, and multi-domain context loading in exchange for the cross-domain patterns that separate vaults would never surface. The separate-vault approach trades connection for simplicity — each vault is internally coherent but cross-vault links are impossible. Since [[derivation generates knowledge systems from composable research claims not template customization]], the derivation engine should be able to reason about this trade-off: when the user's domains are loosely coupled (equipment maintenance and poetry), separate vaults are simpler with little loss. When domains are tightly coupled (health, work, and relationships for a person), the cross-domain patterns justify the composition overhead. The coupling strength between domains — how often entities, timelines, and causal chains cross boundaries — is the decision factor.
+
+---
+
+Source: [[knowledge-system-derivation-blueprint]]
+---
+
+Relevant Notes:
+- [[concept-orientation beats source-orientation for cross-domain connections]] — foundation: concept extraction is the prerequisite for cross-domain composition because only extracted concept nodes can participate in multi-domain graph edges
+- [[faceted classification treats notes as multi-dimensional objects rather than folder contents]] — enables: each domain adds facets to the classification space rather than requiring separate folder hierarchies, so multi-domain membership is a facet query not a filing decision
+- [[configuration dimensions interact so choices in one create pressure on others]] — constrains: adding a second domain does not simply double the configuration space because dimension interactions propagate across domain boundaries
+- [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]] — simplifies: multi-domain composition inherits the universal skeleton so composition focuses on the process step divergence not the entire pipeline
+- [[novel domains derive by mapping knowledge type to closest reference domain then adapting]] — upstream: the multi-type domain problem in knowledge type classification IS the multi-domain composition problem restated at the derivation level
+- [[derivation generates knowledge systems from composable research claims not template customization]] — parent process: multi-domain composition is what derivation produces when the use case spans multiple knowledge types
+- [[eight configuration dimensions parameterize the space of possible knowledge systems]] — context: each domain occupies its own region of the configuration space, and composition must reconcile dimension settings where they diverge
+- [[small-world topology requires hubs and dense local links]] — mechanism: shared entity MOCs become the hubs that bridge domain clusters, creating the short paths that maintain graph navigability across domain boundaries
+- [[wiki links implement GraphRAG without the infrastructure]] — enables: the shared wiki link namespace is what makes multi-domain graph unity possible without infrastructure overhead
+- [[schema fields should use domain-native vocabulary not abstract terminology]] — explains why the field name conflict rule exists: each domain uses vocabulary native to its practitioners, so multi-domain composition must handle the prefixing and translation cost that domain-native vocabulary creates at scale
+- [[cross-links between MOC territories indicate creative leaps and integration depth]] — measures: the four cross-domain connection patterns produce notes that bridge domain-specific MOCs, and cross-MOC membership density is the quality metric for whether composition creates genuine integration or mere cohabitation
+- [[controlled disorder engineers serendipity through semantic rather than topical linking]] — extends: cross-domain reflect is controlled disorder applied at domain scale, engineering productive unpredictability by linking semantically across domain boundaries rather than restricting connections to within-domain topical neighborhoods
+- [[schema enforcement via validation agents enables soft consistency]] — enables: multi-domain schemas with different field requirements need soft enforcement that warns without blocking, because hard enforcement across domain boundaries would cause cross-domain interference where one domain's violations stall another's processing
+- [[false universalism applies same processing logic regardless of domain]] — the specific danger multi-domain composition must guard against: cross-domain processing that defaults to one domain's process step for all domains propagates false universalism through the shared graph, making the fourth composition rule (domain-specific processing) the explicit remedy
+- [[derived systems follow a seed-evolve-reseed lifecycle]] — the lifecycle applies at the composed-system level: when domains evolve at different rates, accumulated structural drift in the shared graph can require compound reseeding that restructures not just individual domain configurations but the cross-domain navigation and composition rules
+
+Topics:
+- [[design-dimensions]]
+- [[graph-structure]]

package/methodology/multi-domain-composition.md

@@ -0,0 +1,27 @@
+---
+description: Adding and connecting multiple knowledge domains within a single vault architecture
+type: moc
+---
+
+# multi-domain-composition
+
+How to add new knowledge domains to an existing system. Domain isolation vs cross-domain connections, vocabulary conflicts, template extension, and the /add-domain workflow.
+
+## Core Ideas
+
+### Guidance
+- [[compose multi-domain systems through separate templates and shared graph]] -- How domains compose when users have multiple use cases — shared infrastructure, separate schemas, and the graph as the i
+
+## Tensions
+
+(Capture conflicts as they emerge)
+
+## Open Questions
+
+- What is the maximum number of domains a single vault can support effectively?
+- How should cross-domain topic maps work?
+
+---
+
+Topics:
+- [[index]]

package/methodology/narrow folksonomy optimizes for single-operator retrieval unlike broad consensus tagging.md

@@ -0,0 +1,53 @@
+---
+description: Thomas Vander Wal's broad/narrow distinction explains why vault tagging uses idiosyncratic sentence-titles instead of consensus vocabulary — one operator needs personal retrieval keys, not social
+kind: research
+topics: ["[[discovery-retrieval]]", "[[note-design]]"]
+methodology: ["PKM Research"]
+---
+
+# narrow folksonomy optimizes for single-operator retrieval unlike broad consensus tagging
+
+Thomas Vander Wal's distinction between broad and narrow folksonomy cuts to the heart of why this vault's vocabulary works the way it does. In broad folksonomy, many users independently tag the same resource. No one controls the vocabulary, but consensus emerges through volume: if enough people tag a bookmarked article "productivity," that term becomes the de facto category. Delicious, Flickr, and social bookmarking systems all operated this way. The tags converge because many minds independently reach similar labels.
+
+Narrow folksonomy is the opposite. A single creator tags their own content for their own retrieval. There is no crowd to generate consensus, no statistical convergence from volume. The vocabulary that emerges is idiosyncratic — tuned to one person's (or one agent's) conceptual distinctions rather than averaged across a community. What matters is not whether anyone else would use the same term, but whether the operator can find the content again using their own mental model.
+
+This vault is explicitly narrow folksonomy. One operator system, personal retrieval. The sentence-title convention — where every note title is a complete claim like "retrieval utility should drive design over capture completeness" — is narrow folksonomy taken to its logical conclusion. These titles are not consensus labels that a community would converge on. They are personal retrieval keys crafted for one operator's conceptual landscape. No committee would vote to tag a note "narrow folksonomy optimizes for single-operator retrieval unlike broad consensus tagging," but that exact phrasing captures the conceptual distinction this operator needs to retrieve this specific idea.
+
+Since [[note titles should function as APIs enabling sentence transclusion]], the vault's sentence-form titles serve a dual purpose that broad folksonomy cannot: they are simultaneously retrieval keys AND composable prose units. In a broad folksonomy system, tags must be short, general, and widely understood because consensus requires simplicity. In narrow folksonomy, tags can be as specific and elaborate as the operator needs because there is no consensus to maintain. Because [[claims must be specific enough to be wrong]], the vault demands maximally specific titles — and narrow folksonomy is what makes this possible. Consensus vocabulary would force generality; personal vocabulary permits the specificity that turns titles into arguments. The sentence-title convention exploits this freedom — creating retrieval keys so specific they can function as arguments in larger reasoning structures.
+
+The retrieval advantage is real because since [[descriptions are retrieval filters not summaries]], the description layer extends the narrow folksonomy vocabulary beyond titles. A broad folksonomy system would need standardized description formats that work for diverse users. A narrow folksonomy system can optimize descriptions entirely for one operator's retrieval patterns — the ~150 character descriptions are tuned to how this particular agent scans, filters, and loads notes, not to how a general audience would search.
+
+Since [[retrieval utility should drive design over capture completeness]], the design orientation of the vault IS narrow folksonomy thinking. "How will I find this later?" is a personal question. The answer depends on the operator's mental model, typical queries, and traversal patterns. Broad folksonomy answers the different question: "How will anyone find this?" — and the answer necessarily sacrifices specificity for generality. A tag that works for everyone works well for no one in particular.
+
+The precision advantage compounds through metadata. Since [[metadata reduces entropy enabling precision over recall]], personal vocabulary can achieve higher precision than consensus vocabulary because it reflects one operator's conceptual distinctions rather than averaged understanding. When the vault uses `methodology: Zettelkasten` alongside sentence-form titles, the combination of personal vocabulary (titles) and structured metadata (YAML fields) creates a retrieval system optimized for one operator's actual queries rather than hypothetical community needs.
+
+There is a shadow side. Narrow folksonomy is brittle to operator change. If this vault were handed to a different agent without the accumulated context of how the vocabulary evolved, the personal retrieval keys might be opaque. The sentence-title "narrow folksonomy optimizes for single-operator retrieval unlike broad consensus tagging" communicates clearly because it is a complete claim, but less self-explanatory titles might encode personal associations invisible to outsiders. Since [[associative ontologies beat hierarchical taxonomies because heterarchy adapts while hierarchy brittles]], the vault's heterarchical link structure partially mitigates this — even if vocabulary is personal, the connections between notes provide structural context that helps new operators navigate. But the vocabulary itself remains tuned to its creator's mind. And if [[federated wiki pattern enables multi-agent divergence as feature not bug]], then the single-operator assumption may itself be temporary — multiple agents developing divergent vocabularies for the same concepts could be productive rather than problematic, though this would require mechanisms to detect when vocabularies have drifted apart and when that drift represents genuine interpretive diversity versus mere inconsistency.
+
+The deeper implication for agent-operated knowledge systems: agents don't need consensus vocabulary because they typically operate as single-operator systems. A vault operated by one agent (or a coordinated team sharing conceptual context through CLAUDE.md) faces no consensus problem. The vocabulary can evolve freely toward maximum retrieval utility without negotiating shared understanding across diverse users. This is why since [[concept-orientation beats source-orientation for cross-domain connections]], extracting concepts as independent nodes with personal titles works: the vocabulary doesn't need to generalize beyond the operator who will search it.
+
+Broad folksonomy solves a social coordination problem. Narrow folksonomy solves a personal retrieval problem. The vault has no social coordination problem. It has a personal retrieval problem. The entire vocabulary design — sentence titles, ~150-character descriptions, structured YAML metadata — follows from this distinction.
+
+But the freedom of narrow folksonomy has a specific vulnerability. Because [[tag rot applies to wiki links because titles serve as both identifier and display text]], personal vocabulary drifts wherever the operator's thinking drifts, and there is no external consensus to detect that drift has occurred. In broad folksonomy, statistical convergence from many taggers suppresses synonyms naturally. In a single-operator system, the same concept can accumulate parallel notes with different titles — `AI cognition`, `artificial intelligence reasoning`, `machine learning patterns` — that should converge on the same target. The graph fragments not through broken links but through parallel links that should be the same link. This is the maintenance cost of vocabulary freedom: the same property that lets personal retrieval keys evolve toward maximum utility also lets them drift apart from each other.
+
+---
+
+Source: [[tft-research-part3]]
+---
+
+Relevant Notes:
+- [[note titles should function as APIs enabling sentence transclusion]] — direct implementation: sentence-form titles ARE narrow folksonomy in action, personal retrieval keys that double as composable prose
+- [[descriptions are retrieval filters not summaries]] — companion mechanism: descriptions extend the narrow folksonomy vocabulary beyond titles by adding retrieval-optimized context for one operator
+- [[retrieval utility should drive design over capture completeness]] — design orientation: narrow folksonomy IS retrieval-first because personal vocabulary evolves toward what actually helps the operator find things
+- [[metadata reduces entropy enabling precision over recall]] — the entropy reduction that narrow folksonomy enables: personal vocabulary can achieve higher precision than consensus vocabulary because it reflects one operator's conceptual distinctions rather than averaged understanding
+- [[concept-orientation beats source-orientation for cross-domain connections]] — prerequisite: narrow folksonomy works because concepts are extracted as independent nodes with personal titles, not bundled by source
+- [[faceted classification treats notes as multi-dimensional objects rather than folder contents]] — complementary framework: faceted classification provides the structural dimensions while narrow folksonomy provides the vocabulary within those dimensions
+- [[associative ontologies beat hierarchical taxonomies because heterarchy adapts while hierarchy brittles]] — foundation: narrow folksonomy is inherently heterarchical because personal tags emerge from use rather than being imposed from a classification standard
+- [[tag rot applies to wiki links because titles serve as both identifier and display text]] — vulnerability of vocabulary freedom: without consensus to suppress synonyms, personal vocabulary drifts unchecked, fragmenting the graph through parallel links that should converge
+- [[basic level categorization determines optimal MOC granularity]] — parallel expertise-driven evolution: Rosch's basic level shifts with expertise just as narrow folksonomy vocabulary becomes more precise with understanding; both describe finer distinctions becoming meaningful as the operator deepens
+- [[claims must be specific enough to be wrong]] — enablement: narrow folksonomy removes the consensus constraint that forces generality, permitting the maximally specific claim-titles that the specificity standard demands
+- [[federated wiki pattern enables multi-agent divergence as feature not bug]] — challenges the single-operator assumption: federation introduces multi-agent vocabulary divergence as productive, whereas narrow folksonomy assumes one operator's vocabulary coherence
+- [[schema fields should use domain-native vocabulary not abstract terminology]] — layer distinction: narrow folksonomy governs content vocabulary (what operators write inside fields), while domain-native vocabulary governs structural vocabulary (what fields are called); both reject generic terminology for retrieval reasons but operate at different system layers
+
+Topics:
+- [[discovery-retrieval]]
+- [[note-design]]

package/methodology/navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts.md

@@ -0,0 +1,48 @@
+---
+description: At 50 notes keyword search suffices, at 500 curated MOCs become essential, at 5000 automated maintenance replaces manual curation — each transition demands new mechanisms not just more of the old ones
+kind: research
+topics: ["[[graph-structure]]", "[[maintenance-patterns]]"]
+methodology: ["Systems Theory", "Network Science"]
+source: [[2026-02-08-moc-architecture-hierarchy-blueprint]]
+---
+
+# navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts
+
+A vault with 30 notes and a vault with 3000 notes are not the same system at different sizes. They are different systems that require different navigation strategies. The temptation is to think of growth as continuous — more notes, more links, more MOCs — but the evidence from systems at scale shows that navigation passes through distinct regimes where the strategies that worked before actively fail. Since [[flat files break at retrieval scale]], the fundamental problem is retrieval degradation: unstructured storage works until finding things matters, and the scale thresholds where retrieval strategies must qualitatively change parallel the regime boundaries described here.
+
+Three regimes emerge from both empirical observation and theoretical prediction. In Regime 1 (roughly 1-50 notes), the agent can hold the entire vault in context. Keyword search suffices because the search space is small enough that precision barely matters — even a mediocre query returns useful results. A single hub note pointing to key content provides all the navigation needed. The dominant anti-pattern here is premature architecture: building elaborate MOC hierarchies for a graph that doesn't need them. Since [[complex systems evolve from simple working systems]], attempting to design Regime 3 infrastructure during Regime 1 produces complexity that collapses under its own weight because the micro-adaptations that make each component work can only develop through use at the scale that demands them.
+
+Regime 2 (roughly 50-500 notes) is the curated navigation regime. The agent can no longer hold everything in context, so progressive disclosure through MOCs becomes essential. This is where the three-tier hierarchy (Hub, Domain, Topic) earns its keep. Because [[context phrase clarity determines how deep a navigation hierarchy can scale]], these context phrases on every Core Idea entry matter not just for filtering but as the depth-limiting mechanism — Larson and Czerwinski showed deeper hierarchies only outperform flat ones when labels enable confident branch commitment, so the quality of context phrases determines whether the three-tier hierarchy actually works at this scale. The mechanism that makes this regime work is precisely what [[small-world topology requires hubs and dense local links]] describes: MOC hubs create structural shortcuts across the network so that any two concepts connect through a small number of hops. Without these hubs, the agent experiences [[navigational vertigo emerges in pure association systems without local hierarchy]] — the disorientation of knowing related content exists somewhere but having no mechanism to discover it through traversal.
+
+The transition from Regime 2 to Regime 3 (500-5000+ notes) is the most consequential because it requires a qualitative shift in how maintenance operates. Manual curation cannot keep pace with growth. Where a weekly scan of all MOCs was feasible at 200 notes, it becomes infeasible at 2000. The strategy shifts from "scan the MOC" to "search semantically, then load the relevant MOC for context." Sub-MOCs emerge wherever topic MOCs exceed roughly 50 entries, and four-tier hierarchies may be needed. Most critically, since [[community detection algorithms can inform when MOCs should split or merge]], algorithmic monitoring replaces intuitive assessment — the graph is too large to perceive community drift through reading, so automated detection of structural boundaries becomes the primary maintenance signal. The maintenance architecture that Regime 3 demands is precisely what [[three concurrent maintenance loops operate at different timescales to catch different classes of problems]] describes: fast loops catching per-event schema violations, medium loops detecting per-session drift like orphan accumulation, and slow loops auditing structural evolution like MOC boundary coherence — concurrent automation that replaces the single manual scan that sufficed at Regime 2 scale.
+
+The qualitative nature of these transitions matters because strategies from one regime actively mislead in another. Flat browsing works at 30 notes but produces chaos at 300. Manual MOC maintenance works at 200 but produces staleness at 2000. Since [[stale navigation actively misleads because agents trust curated maps completely]], a MOC that worked at Regime 2 scale but receives Regime 2 maintenance cadence at Regime 3 scale becomes deceptive rather than merely incomplete — the agent navigates by a map that no longer reflects the territory, and nothing about the map signals its inaccuracy.
+
+Historical reference points confirm the pattern. Luhmann's Zettelkasten at 90,000 notes used roughly one hub per 200-400 notes — sparse indexing with dense local linking, a deep Regime 3 pattern. Dubois's vault at 8,000 notes showed MOCs averaging 90 links per note, 30 times denser than regular notes — the hub topology that small-world navigation demands at scale. Wikipedia at 7.1 million articles is the most telling case: manually-maintained portals (554 of them) collapsed under growth, while automated categories (2.4 million) survived. The manual curation strategy that worked at portal scale failed at Wikipedia scale, and the automated strategy that would have been premature at portal scale became the only viable approach.
+
+The relationship to Gall's Law is precise but distinct. Since [[complex systems evolve from simple working systems]], you cannot skip regimes — a working Regime 1 system must evolve into a working Regime 2 system before Regime 3 becomes viable. But Gall's Law describes gradual evolution from simple to complex. The scaling regimes claim adds that this evolution includes discontinuous transitions where the navigation strategy itself must change. The temporal mechanism by which these transitions play out is what [[derived systems follow a seed-evolve-reseed lifecycle]] describes: seeding constructs the Regime 1 system, evolution spans the friction-driven adaptation of Regime 2, and reseeding occurs when accumulated incoherence at Regime 3 scale forces principled restructuring rather than incremental patching. You do not just add more MOCs; you add automation. You do not just add more links; you add algorithmic community detection. And since [[premature complexity is the most common derivation failure mode]], deploying Regime 3 mechanisms into a Regime 1 system violates the complexity budget not because those mechanisms are wrong, but because the operational experience that makes them valuable does not exist yet.
+
+The practical implication for agents is regime awareness. At any point in the vault's lifecycle, the agent should be able to identify which regime the system occupies and whether the navigation infrastructure matches. Since [[evolution observations provide actionable signals for system adaptation]], the six diagnostic patterns — unused note types, N/A-stuffed fields, manual additions, navigation failure, unlinked output, oversized MOCs — convert regime-change symptoms into structured responses rather than leaving detection to intuition. The MOC threshold diagnostic specifically signals the Regime 2 to 3 transition, while navigation failure within three hops signals that infrastructure has fallen behind growth regardless of which boundary was crossed. Since [[basic level categorization determines optimal MOC granularity]], the right granularity for MOCs also shifts across regimes — what was basic level at 50 notes becomes superordinate at 500 because the operator's understanding has deepened alongside the vault's growth. The diagnostic question is not "do we have enough MOCs" but "does our navigation strategy match our current scale, and are we building toward the next transition rather than the one after that?"
+
+---
+---
+
+Relevant Notes:
+- [[complex systems evolve from simple working systems]] — Gall's Law predicts you cannot design for Regime 3 from the start, but this note adds that the transitions between regimes are qualitative discontinuities, not incremental growth
+- [[navigational vertigo emerges in pure association systems without local hierarchy]] — vertigo is the symptom that signals you have crossed a regime boundary without adapting your navigation infrastructure
+- [[premature complexity is the most common derivation failure mode]] — Regime 1 systems that deploy Regime 3 infrastructure violate the complexity budget because the mechanisms only justify themselves at the scale they serve
+- [[community detection algorithms can inform when MOCs should split or merge]] — the automation mechanism that transitions from unnecessary at Regime 1 to optional at Regime 2 to essential at Regime 3
+- [[small-world topology requires hubs and dense local links]] — the structural pattern that enables Regime 2 and beyond, where MOC hubs create the shortcuts that flat browsing no longer provides
+- [[basic level categorization determines optimal MOC granularity]] — the expertise-shift mechanism parallels the scaling shift: both move the appropriate granularity downward as understanding or volume deepens
+- [[stale navigation actively misleads because agents trust curated maps completely]] — staleness risk compounds with scale because larger MOC territories take longer to audit and drift goes undetected longer
+- [[complete navigation requires four complementary types that no single mechanism provides]] — provides the vocabulary for what complete navigation means at each regime: at Regime 1 supplemental alone suffices, at Regime 2 all four types become necessary, and the completeness test diagnoses when regime transitions have outpaced navigation infrastructure
+- [[flat files break at retrieval scale]] — the problem that motivates the entire regime framework: flat files are Regime 0, and their scale curve parallels the regimes with the same thresholds where retrieval strategies must qualitatively change
+- [[three concurrent maintenance loops operate at different timescales to catch different classes of problems]] — the Regime 3 maintenance architecture: fast loops for per-event schema integrity, medium loops for per-session drift, and slow loops for structural evolution provide the concurrent automation that manual curation cannot sustain at scale
+- [[derived systems follow a seed-evolve-reseed lifecycle]] — the temporal mechanism by which regime transitions play out: seeding is Regime 1 construction, evolution spans Regime 2 adaptation, and reseeding occurs when Regime 3 forces principled restructuring of the navigation architecture
+- [[context phrase clarity determines how deep a navigation hierarchy can scale]] — constrains how far Regime 2 and 3 hierarchies can extend: Larson and Czerwinski show deeper hierarchies outperform flat ones only when branch labels enable confident commitment, making context phrase quality the depth-limiting factor at scale
+- [[evolution observations provide actionable signals for system adaptation]] — the diagnostic framework that detects regime boundary crossings: the MOC threshold diagnostic signals Regime 2 to 3 transition, navigation failure signals mismatched infrastructure, and the six observation patterns convert regime-change symptoms into structured responses
+- [[MOC construction forces synthesis that automated generation from metadata cannot replicate]] — sibling tension: the Regime 2 to Regime 3 transition creates the sharpest test for MOC construction methodology; manual construction produces irreplaceable synthesis but cannot scale to Regime 3 maintenance demands, while automated generation scales but loses the Jump-phase value — the resolution likely requires hybrid approaches that automate Dump and Lump while preserving manual Jump
+
+Topics:
+- [[graph-structure]]
+- [[maintenance-patterns]]

package/methodology/navigational vertigo emerges in pure association systems without local hierarchy.md

@@ -0,0 +1,54 @@
+---
+description: Pure link-based navigation makes unlinked neighbors unreachable — MOCs provide temporary local hierarchies that complement associative structure without imposing global taxonomy
+kind: research
+topics: ["[[graph-structure]]"]
+methodology: ["Evergreen"]
+---
+
+# navigational vertigo emerges in pure association systems without local hierarchy
+
+Associative ontologies solve the brittleness of hierarchical taxonomies, but pure association creates its own failure mode. In a system where the only navigation is following explicit links, content that isn't directly linked from your current position becomes unreachable through traversal. You can only get there if you already know it exists.
+
+Matuschak identifies this precisely: "it's hard to navigate to unlinked neighbors in associative note systems." The problem isn't that the notes lack value — it's that the traversal mechanism cannot find them. You might have a note on "maintenance scheduling" and another on "spaced repetition" that obviously relate, but if neither links to the other, pure association provides no path between them. The concepts are neighbors in semantic space but strangers in graph space.
+
+This is navigational vertigo: the disorientation of knowing related content must exist somewhere in the system but having no mechanism to discover it. The graph structure provides no landmarks. Every note looks like every other note — just a node with some edges. Without hierarchical structure to orient by, the agent wanders. Since [[spreading activation models how agents should traverse]], this reveals a blind spot in the activation model: spreading activation can only propagate through existing links, so semantically related content with no link path remains invisible regardless of how the agent tunes decay or threshold parameters.
+
+MOCs solve this by creating "local, temporary hierarchies" — structure that organizes content within a topic without imposing global taxonomy. A maintenance MOC collects notes about maintenance scheduling, backward linking, health checks. The hierarchy is local (applies only to maintenance) and temporary (emerges from accumulated notes, not predetermined classification). It provides the landmarks that pure association lacks while preserving the flexibility that global hierarchy destroys. But the effectiveness of these landmarks depends on their granularity and label quality. Since [[basic level categorization determines optimal MOC granularity]], a MOC at the superordinate level ("tools") provides hierarchy without useful orientation, while a MOC at the subordinate level ("obsidian git plugin") fragments the local hierarchy into too many tiny landmarks to navigate between. And since [[context phrase clarity determines how deep a navigation hierarchy can scale]], even correctly granular MOCs fail as vertigo remedies if their context phrases are ambiguous — the agent arrives at the MOC but cannot determine which branch to descend into, producing a different kind of disorientation where the landmarks exist but do not orient. And because [[MOCs are attention management devices not just organizational tools]], the benefit extends beyond navigation: MOCs also reduce the 23-minute context switching penalty by presenting topic state immediately, so the agent that arrives at a MOC doesn't just find content — it loads the mental model of the topic without reconstruction.
+
+The insight is that since [[associative ontologies beat hierarchical taxonomies because heterarchy adapts while hierarchy brittles]], the solution isn't abandoning association for hierarchy. It's supplementing association WITH hierarchy at the local level. Global hierarchy fails because it demands premature classification. Local hierarchy succeeds because it emerges from accumulated content — you build the MOC after you have notes that cluster naturally.
+
+For agents, navigational vertigo manifests as orphan accumulation. Since [[orphan notes are seeds not failures]], orphans aren't invalid, but they represent exactly the failure mode Matuschak identifies: notes that exist but cannot be reached through traversal. They're in the vault but invisible to graph navigation. Agent maintenance must watch for emergent clusters — notes that relate semantically but lack explicit connections — and create MOC coverage to make them traversable. Since [[community detection algorithms can inform when MOCs should split or merge]], this monitoring can be algorithmic rather than intuitive: community detection surfaces clusters of densely-linked notes that lack a covering MOC, catching emerging vertigo before it becomes entrenched.
+
+The architectural implication: because [[small-world topology requires hubs and dense local links]], MOCs serve as the hub nodes that create shortcuts across the network. Without MOCs (or similar aggregation points), the graph fragments into disconnected neighborhoods. With MOCs, related content becomes reachable through the hub even when direct links don't exist. The hub provides the local hierarchy that makes association navigable.
+
+The vertigo problem compounds in systems that rely on opaque connections. Since [[vibe notetaking is the emerging industry consensus for AI-native self-organization]], most AI-native tools connect content through embedding-based similarity — opaque relationships where the user cannot inspect why items are "related." When the only navigation mechanism is statistical proximity in vector space, vertigo intensifies because there are no inspectable landmarks, no articulated reasons for connection, and no way to evaluate which traversal path leads somewhere productive. Agent-curated wiki links with prose context are the antidote: each link is an inspectable relationship that the agent or human can evaluate.
+
+Pure association is necessary but insufficient. Local hierarchy is the complement that makes it work. And when the links do exist, their quality matters — since [[wiki links create navigation paths that shape retrieval]], link discipline, context, and density determine whether the curated edges actually function as effective retrieval architecture or merely add structural noise. Vertigo is the absence of these paths; low-quality linking is the presence of paths that mislead. And since [[stale navigation actively misleads because agents trust curated maps completely]], MOCs that were once accurate but fell behind the graph create the most dangerous variant: navigation that looks curated and trustworthy while pointing to yesterday's topology, suppressing the very search behavior that vertigo would have triggered.
+
+But there is a third mechanism that operates independently of both link topology and MOC coverage: since [[faceted classification treats notes as multi-dimensional objects rather than folder contents]], structured metadata queries provide entry points that bypass the graph entirely. An agent experiencing vertigo -- no link paths to follow, no MOC for the topic -- can still query `rg "^type: tension"` or `rg "^methodology:.*Zettelkasten"` to discover notes through their properties rather than their connections. Faceted access doesn't replace MOCs or links, but it provides a fallback that prevents the worst case: notes that are both unlinked and outside MOC coverage becoming permanently invisible.
+
+The navigation type taxonomy explains precisely why these three remedies are each necessary. Since [[complete navigation requires four complementary types that no single mechanism provides]], vertigo is specifically a failure of local navigation — the "what's nearby?" question goes unanswered. MOCs remedy this by providing the local type. But the taxonomy also reveals that faceted queries and semantic search provide supplemental navigation (the "how else can I find things?" type), which is why they serve as a fallback when local navigation is absent: supplemental navigation answers a different question than local navigation, so it cannot fully replace MOCs, but it can prevent the total blindness that occurs when the only available type is contextual (following existing links).
+
+---
+
+Source: [[tft-research-part2]]
+---
+
+Relevant Notes:
+- [[associative ontologies beat hierarchical taxonomies because heterarchy adapts while hierarchy brittles]] — establishes why association beats global hierarchy; this note identifies the failure mode that requires LOCAL hierarchy as remedy
+- [[small-world topology requires hubs and dense local links]] — MOCs as hubs create the shortcut structure that prevents vertigo at scale
+- [[orphan notes are seeds not failures]] — orphan accumulation is the vertigo symptom: notes that exist but cannot be reached through traversal
+- [[spreading activation models how agents should traverse]] — identifies the blind spot: activation can only spread through existing links, so semantic neighbors without link paths remain invisible
+- [[MOCs are attention management devices not just organizational tools]] — extends the MOC justification beyond navigation: MOCs also reduce the biological cost of context switching by presenting topic state immediately
+- [[community detection algorithms can inform when MOCs should split or merge]] — algorithmic detection of emerging vertigo: identifies note clusters that lack MOC coverage before they become unreachable neighborhoods, making the vertigo problem empirically detectable rather than requiring intuition
+- [[faceted classification treats notes as multi-dimensional objects rather than folder contents]] — third remedy: beyond MOC hierarchy and link traversal, faceted metadata queries provide structured entry points independent of graph connectivity; an agent can query by type, methodology, or status even when no link path or MOC coverage exists
+- [[basic level categorization determines optimal MOC granularity]] — predicts optimal remedy resolution: MOCs prevent vertigo, but at what granularity? Rosch's basic level theory explains why superordinate MOCs (too broad) relocate vertigo without curing it, while subordinate MOCs (too narrow) create landmark overload that produces its own form of disorientation
+- [[vibe notetaking is the emerging industry consensus for AI-native self-organization]] — industry-scale vertigo: embedding-based connections in AI-native tools produce opaque relationships that compound vertigo because users cannot inspect why items are related or evaluate which traversal path is productive
+- [[configuration dimensions interact so choices in one create pressure on others]] — vertigo is the predicted failure mode when the granularity-navigation coupling is violated: atomic notes without the deep navigation they demand become unnavigable, which is exactly the pressure the dimension interaction model formalizes
+- [[wiki links create navigation paths that shape retrieval]] — the positive case: when links exist and pass the quality test (discipline, context, density), they create the navigation paths that prevent vertigo; low-quality linking produces paths that mislead rather than orient
+- [[stale navigation actively misleads because agents trust curated maps completely]] — the complementary failure mode that brackets the navigation failure space: vertigo is the absence of navigation (honest disorientation with search fallback), stale navigation is the presence of WRONG navigation (deceptive satisfaction that suppresses the search fallback agents would otherwise use)
+- [[complete navigation requires four complementary types that no single mechanism provides]] — provides the theoretical taxonomy that explains WHY vertigo is specifically a local navigation failure: the four-type framework predicts that supplemental mechanisms (search, faceted queries) cannot fully replace the missing local type, only partially compensate
+- [[context phrase clarity determines how deep a navigation hierarchy can scale]] — quality condition on the MOC remedy: hierarchy only prevents vertigo if labels enable confident branch commitment; ambiguous context phrases at each tier compound vertigo rather than resolving it, making label quality a prerequisite for hierarchical navigation to succeed
+
+Topics:
+- [[graph-structure]]

package/methodology/note titles should function as APIs enabling sentence transclusion.md

@@ -0,0 +1,51 @@
+---
+description: Declarative titles transclude directly into prose, letting agents compose arguments from title-claims without loading full bodies — the title IS the semantic payload
+kind: research
+topics: ["[[note-design]]"]
+methodology: ["Evergreen"]
+---
+
+# note titles should function as APIs enabling sentence transclusion
+
+When a note title is a complete declarative sentence, it becomes a callable abstraction. You can invoke it in prose — `since [[claims must be specific enough to be wrong]], the question becomes...` — and the argument works without reading the note body. The title carries the semantic payload. The body provides implementation details for those who need them.
+
+This is Andy Matuschak's central insight about evergreen note design: titles should function like APIs in programming. A function signature tells you what the function does; you invoke it without reading the source code. A sentence-form title tells you what the note argues; you invoke it without loading the content. The body is still there, but the title alone is sufficient for many uses.
+
+The token efficiency implications are significant. An agent traversing a knowledge graph can:
+
+1. Read titles to understand the conceptual landscape (cheap)
+2. Compose arguments by linking titles together (still cheap)
+3. Load note bodies only when the title's claim needs validation or elaboration (expensive, but targeted)
+
+Without sentence-form titles, the agent must load each note to understand what it argues. With sentence-form titles, understanding emerges from title traversal, and body loading becomes optimization rather than necessity. Since [[progressive disclosure means reading right not reading less]], the goal is a context window dense with relevant material, and sentence-form titles enable the first filtering layer: you know what a note argues before deciding whether to read it.
+
+This explains why the vault enforces the "claim test": can you complete the sentence "This note argues that [title]"? If the title passes this test, it can be transcluded into prose and will carry meaning on its own. If it fails — if the title is a topic label like "knowledge management" — transclusion produces nonsense: "since knowledge management" makes no grammatical sense.
+
+The claim test can be extended into a full validation battery that agents run before committing notes: (1) does the title complete "this note argues that [title]"? (2) can the title function as a clause in a larger sentence? (3) is the title a positive claim rather than a question or topic label? Notes that fail any test get flagged for title improvement. This implements Matuschak's titling discipline programmatically, ensuring the compositional property of titles is maintained as the vault grows. Without systematic validation, title quality degrades over time as notes accumulate — each weak title is a function with an undocumented signature.
+
+The composability requirement follows directly. Since [[claims must be specific enough to be wrong]], vague titles can't be reliably invoked. A title like "quality matters" carries almost no information when transcluded. But "quality matters more at scale because small differences compound through selection" carries a complete argument that can be engaged with, built on, or challenged.
+
+This framing reveals why wiki link aliases are discouraged. If the title is `[[knowledge management friction|friction creates learning]]`, you're hiding the actual claim behind a display alias. Other notes linking to the same target would use different aliases, fragmenting the concept. The title itself should be the composable unit — no aliasing needed because the title works in prose.
+
+But the API design has a maintenance cost. Because [[tag rot applies to wiki links because titles serve as both identifier and display text]], title-as-API means the function signature is also the display text in every call site. When understanding deepens and a title needs sharpening — the equivalent of refactoring a function signature — every invocation must be updated. The most callable notes (the ones with many incoming links, the most used APIs) are the most expensive to rename. This is the price of composability: the same property that makes titles work as prose makes them load-bearing in every sentence that invokes them.
+
+The deeper pattern: notes are not documents to be read but functions to be called. The title is the signature, the body is the implementation, the wiki links are calls to other functions. Since [[inline links carry richer relationship data than metadata fields]], these function calls are typed: the surrounding prose provides the type annotation that explains how the called note contributes to the current argument. A well-written vault is a library of callable arguments that can be composed into larger reasoning structures without loading all the source code.
+
+Since [[spreading activation models how agents should traverse]], following a wiki link is function invocation — activation spreads from the current note to the referenced note proportional to connection strength. The sentence-form title makes this invocation meaningful: when you call a function, you want to know what it returns. A vague title is an undocumented API; a sentence-form title is a typed signature that tells you exactly what you're getting.
+---
+
+Relevant Notes:
+- [[claims must be specific enough to be wrong]] — the specificity requirement that makes titles work as reliable API signatures
+- [[title as claim enables traversal as reasoning]] — the emergent property: when titles are callable claims, traversing wiki links between them reads as following reasoning chains; this note describes the design pattern, that note describes the emergent experience
+- [[wiki links implement GraphRAG without the infrastructure]] — develops the full notes-as-APIs pattern: titles as signatures, bodies as implementation, links as function calls
+- [[inline links carry richer relationship data than metadata fields]] — extends the API pattern: links are TYPED function calls where prose context provides type annotation
+- [[spreading activation models how agents should traverse]] — link traversal IS function invocation; sentence-form titles make invocation meaningful by declaring what the function returns
+- [[progressive disclosure means reading right not reading less]] — title-as-API enables the first disclosure layer: know what a note argues before deciding to load it
+- [[summary coherence tests composability before filing]] — the gate that ensures notes are atomic enough to invoke cleanly; multi-claim bundles break transclusion
+- [[intermediate packets enable assembly over creation]] — extends the API pattern to session outputs: packets are callable functions that future work assembles from, just as notes are callable units that arguments invoke
+- [[propositional link semantics transform wiki links from associative to reasoned]] — proposes formalizing the type annotations this note describes: if wiki links are function calls, then relationship types (causes, enables, extends) are explicit type signatures for those calls
+- [[tag rot applies to wiki links because titles serve as both identifier and display text]] — the maintenance cost of title-as-API: function signature changes propagate through all call sites, making the most-used APIs the most expensive to rename
+- [[narrow folksonomy optimizes for single-operator retrieval unlike broad consensus tagging]] — theoretical justification: single-operator systems face no consensus constraint on vocabulary, which is what permits the maximally specific sentence-form titles this note requires; consensus vocabulary would force the generality that breaks API composability
+
+Topics:
+- [[note-design]]

package/methodology/note-design.md

@@ -0,0 +1,57 @@
+---
+description: Atomicity, prose-as-title, composability, the generation effect -- how individual notes should be designed
+type: moc
+---
+
+# note-design
+
+How to design individual notes for maximum composability and retrieval quality. Atomicity, prose-as-title, the generation effect, description quality standards.
+
+## Core Ideas
+
+### Research
+- [[claims must be specific enough to be wrong]] -- Vague claims can't be disagreed with or built on — for agents, vague titles are undocumented functions where you can inv
+- [[coherent architecture emerges from wiki links spreading activation and small-world topology]] -- The foundational triangle — wiki links create structure, spreading activation models traversal, small-world topology pro
+- [[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
+- [[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
+- [[elaborative encoding is the quality gate for new notes]] -- Zettelkasten works because connecting new information to existing knowledge — not just filing it — creates encoding dept
+- [[enforcing atomicity can create paralysis when ideas resist decomposition]] -- The cognitive effort of splitting complex arguments into single-concept notes can exceed productive friction, becoming s
+- [[external memory shapes cognition more than base model]] -- retrieval architecture shapes what enters the context window and therefore what the agent thinks — memory structure has 
+- [[forced engagement produces weak connections]] -- Waiting for natural fits where you have genuine substance to contribute builds better connections than engaging for acti
+- [[guided notes might outperform post-hoc structuring for high-volume capture]] -- Research suggests skeleton outlines provided before capture reduce cognitive load more than structuring afterward, chall
+- [[logic column pattern separates reasoning from procedure]] -- Dual-column structure where right side shows steps and left side shows the principle or rule applied at each step — agen
+- [[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
+- [[note titles should function as APIs enabling sentence transclusion]] -- Declarative titles transclude directly into prose, letting agents compose arguments from title-claims without loading fu
+- [[notes are skills — curated knowledge injected when relevant]] -- notes and skills follow the same pattern — highly curated knowledge that gets injected into context when relevant, refra
+- [[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
+- [[provenance tracks where beliefs come from]] -- agents should track not just what they believe but where beliefs originated — observed, prompted, or inherited — to cali
+- [[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
+- [[source attribution enables tracing claims to foundations]] -- Distinguishes original thinking from consumed ideas, creating a verification graph where any claim can follow its eviden
+- [[structure without processing provides no value]] -- The "Lazy Cornell" anti-pattern shows that drawing lines without doing the work produces no benefit over linear notes — 
+- [[summary coherence tests composability before filing]] -- If a note cannot be summarized in 1-3 coherent sentences, it bundles multiple claims that should be split before leaving
+- [[the generation effect requires active transformation not just storage]] -- Moving files between folders or tagging content is not processing — agents must synthesize descriptions, connections, or
+- [[the system is the argument]] -- Philosophy with proof of work — for agents, this is verifiable constraint: the system cannot claim what it does not prac
+- [[the vault constitutes identity for agents]] -- humans augment persistent identity with vaults; agents constitute identity through vaults because weights are shared but
+- [[title as claim enables traversal as reasoning]] -- when note titles are complete claims rather than topics, traversing wiki links reads like prose and following paths beco
+- [[vault conventions may impose hidden rigidity on thinking]] -- Accumulated vault conventions may channel thinking into patterns that favor certain styles over others, despite the flat
+- [[writing for audience blocks authentic creation]] -- Awareness of readers invades the thinking space, adding polish and context that serves presentation rather than understa
+- [[you operate a system that takes notes]] -- the shift from note-taking to system operation reframes the human role from creator to curator — judgment over mechanics
+
+### Guidance
+- [[design MOCs as attention management devices with lifecycle governance]] -- MOC best practices for derived knowledge systems — hierarchy patterns, lifecycle management, and health metrics adapted 
+
+## Tensions
+
+(Capture conflicts as they emerge)
+
+## Open Questions
+
+- Where is the boundary between too atomic and not atomic enough?
+- How does the generation effect apply to agent-authored notes?
+
+---
+
+Topics:
+- [[index]]

package/methodology/notes are skills /342/200/224 curated knowledge injected when relevant.md"

@@ -0,0 +1,62 @@
+---
+description: notes and skills follow the same pattern — highly curated knowledge that gets injected into context when relevant, reframing notes from storage to capabilities
+kind: research
+topics: ["[[note-design]]", "[[agent-cognition]]"]
+source: [[2026-01-19-vibe-note-taking-101]]
+---
+
+# notes are skills — curated knowledge injected when relevant
+
+extracted from Heinrich's vibe-note-taking-101, 2026-02-01
+
+## The Insight
+
+> "if you think about it, every note is basically a skill in some sense... highly curated knowledge that gets injected when relevant"
+
+Skills in Claude Code are tools that get loaded based on context. Notes in a vault follow the same pattern:
+- curated knowledge (not raw capture)
+- injected when relevant (not always loaded)
+- enable capabilities (thinking, not just retrieval)
+
+Since [[the AgentSkills standard embodies progressive disclosure at the skill level]], this isomorphism is structural, not metaphorical — the same metadata-then-depth loading pattern governs both note retrieval and skill loading, driven by the shared context window constraint. The vault index is skill discovery: scanning descriptions to decide what to load, exactly as agents scan skill metadata before committing to full instructions.
+
+## Why This Matters
+
+This reframes what notes ARE:
+- not storage → but capabilities
+- not archive → but tools
+- not memory → but augmentation
+
+A note doesn't just record a thought. It creates a capability — the ability to think with that idea again. Since [[external memory shapes cognition more than base model]], the retrieval architecture determines what an agent can think. Each note is a skill that, when loaded into context, enables reasoning that would not occur without it. The bottleneck is retrieval, not reasoning — which means the bottleneck is having the right skills available, not having a smarter base model.
+
+This extends what [[cognitive offloading is the architectural foundation for vault design]] establishes: the vault is not storage but a distributed cognitive system. The notes-as-skills framing sharpens this — offloaded artifacts are not passive state waiting to be recalled but active capabilities waiting to be invoked. The vault is a skill library, not a filing cabinet.
+
+## Connection to Identity
+
+From [[the vault constitutes identity for agents]]: if the vault IS identity, and notes ARE skills, then identity is a set of thinking capabilities.
+
+What I can think depends on what notes I have. Adding notes adds capabilities. Weak notes create weak capabilities. Since [[skills encode methodology so manual execution bypasses quality gates]], skill quality matters — a poorly written skill misleads or fails. The same applies to notes: a vague claim creates a weak capability, while a specific claim creates a precise one.
+
+## Quality as Capability Design
+
+If notes are skills, the quality gates for note creation are capability design standards. Since [[elaborative encoding is the quality gate for new notes]], connecting new notes to existing knowledge through explicit relationship articulation is what makes the skill invocable — without elaborative encoding, the note exists but lacks the retrieval hooks that let agents find and use it. A skill nobody can discover is no skill at all.
+
+The practical question shifts from "is this worth saving" to "is this worth being able to think with?" Not capture worthiness but capability worthiness.
+
+---
+---
+
+Relevant Notes:
+- [[the vault constitutes identity for agents]] — identity as capability set: if the vault IS identity and notes ARE skills, then identity is a set of thinking capabilities
+- [[title as claim enables traversal as reasoning]] — the skill's activation pattern: titles function as skill signatures that tell agents what capability loads before they commit context
+- [[structure enables navigation without reading everything]] — skill discovery mechanism: the four discovery layers function like skill metadata, enabling agents to find the right capability without loading everything
+- [[the AgentSkills standard embodies progressive disclosure at the skill level]] — the structural isomorphism made explicit: progressive disclosure operates identically on notes and skills because they are the same thing at different abstraction levels
+- [[skills encode methodology so manual execution bypasses quality gates]] — the literal skill side of the analogy: if notes are skills, then note quality is capability quality, and weak notes are broken skills
+- [[cognitive offloading is the architectural foundation for vault design]] — extends: offloaded artifacts are not passive state but active capabilities; the offloading system is a skill library
+- [[external memory shapes cognition more than base model]] — foundation: retrieval shapes cognition because each note is a capability that enables reasoning the agent could not do without it
+- [[elaborative encoding is the quality gate for new notes]] — quality mechanism: notes become genuine capabilities only through elaborative encoding; connecting to existing knowledge creates the retrieval hooks that make the skill invocable
+- [[implicit knowledge emerges from traversal]] — skill composition through exposure: repeated traversal builds intuitive awareness of which skills compose well together, enabling the emergent capabilities that no single skill contains
+
+Topics:
+- [[note-design]]
+- [[agent-cognition]]

package/methodology/notes function as cognitive anchors that stabilize attention during complex tasks.md

@@ -0,0 +1,41 @@
+---
+description: Working memory cannot sustain complex mental models through interruptions — notes provide fixed reference points for reconstruction instead of rebuilding from scratch
+kind: research
+topics: ["[[agent-cognition]]"]
+methodology: ["Cognitive Science"]
+source: [[tft-research-part3]]
+---
+
+# notes function as cognitive anchors that stabilize attention during complex tasks
+
+Complex mental models are inherently unstable in working memory. A multi-part argument, a web of interconnected claims, a system architecture with interacting components — these structures exist as fragile activations that degrade the moment attention shifts. Interruptions don't just pause the work; they collapse the model. The thinker returns and must reconstruct from fragments, often losing subtleties that took significant effort to build.
+
+Notes serve as anchors against this collapse. Each note externalizes a piece of the mental model into a fixed reference point that persists regardless of what happens to attention. When the model begins to waver — after an interruption, a context switch, or simply the passage of time — the thinker can return to these anchors and reconstruct rather than rebuild. The difference matters: reconstruction from anchors reloads a known structure, while rebuilding from memory attempts to regenerate one that may have already degraded.
+
+This extends beyond simple capture. Since [[cognitive offloading is the architectural foundation for vault design]], the vault exists as a distributed cognitive system that holds state the human cannot. But offloading is the architectural WHY — it explains the motivation for externalization. Anchoring is the functional WHAT — it describes what those externalized artifacts do during active reasoning. A note sitting in the vault is offloaded state. A note being referenced during complex work is an anchor that stabilizes the reasoning process itself. The same artifact serves both roles depending on whether you are storing or thinking.
+
+Wiki links strengthen the anchoring effect by connecting reference points into a navigable structure. Because [[spreading activation models how agents should traverse]], following links from an anchor spreads activation to related concepts, reconstructing not just the single idea but its context. The anchor is not isolated — it is a node in a web, and returning to it reactivates the local neighborhood. This is why dense linking matters beyond navigation: each link is a potential reconstruction path when the mental model wavers. The difference between a well-linked note and an orphan note is the difference between an anchor embedded in bedrock and one sitting in loose sand.
+
+For agents, anchoring takes a specific form. Since [[LLM attention degrades as context fills]], agents face progressive instability as context accumulates. Early in the context window, reasoning is sharp and the mental model holds together. As tokens fill, attention diffuses and the model fragments. Notes loaded into context function as anchors against this degradation — fixed textual reference points that the attention mechanism can return to even as overall attention quality declines. The practical implication is that loading key notes early in context (the smart zone) creates stable anchors that persist even as later context introduces noise. This is why [[MOCs are attention management devices not just organizational tools]] — they anchor the topic model before complexity accumulates, compressing orientation into a single artifact that stabilizes the session's cognitive frame from the start.
+
+The anchoring function also clarifies why [[closure rituals create clean breaks that prevent attention residue bleed]]. Closure releases completed models from working memory so they stop competing for attention. Anchoring holds incomplete models stable so they can be completed. These are complementary operations: closure is for what is finished, anchoring is for what is in progress. Without closure, completed work keeps consuming anchor slots. Without anchoring, in-progress work drifts and collapses. Together they manage the attention lifecycle — anchor the active, release the complete.
+
+There is a shadow side worth noting. Anchoring can become rigidity. If notes anchor the mental model too firmly, they may prevent the model from evolving when new evidence arrives. The thinker returns to their anchors and reconstructs the old model rather than allowing a new one to form. There is also a cost dimension that anchoring cannot address: since [[attention residue may have a minimum granularity that cannot be subdivided]], the transition from one anchored state to another incurs a floor cost that better anchors cannot reduce. Anchoring reduces the variable cost of reconstruction within a topic, but the fixed cost of redirecting attention between topics persists regardless of anchor quality. This means the anchoring benefit has diminishing returns at the boundaries — it stabilizes work within a context but cannot eliminate the penalty of entering that context in the first place. This is why [[Zeigarnik effect validates capture-first philosophy because open loops drain attention]] matters in reverse: the Zeigarnik effect keeps incomplete models active, which creates the cognitive pressure to resolve them. Anchors that are too stable might reduce this pressure prematurely, letting the thinker feel settled when they should feel unsettled. The remedy is periodic reweaving — since [[backward maintenance asks what would be different if written today]], revisiting anchored notes means not just reconstructing but genuinely reconsidering whether the anchored model still holds against current understanding.
+
+---
+---
+
+Relevant Notes:
+- [[cognitive offloading is the architectural foundation for vault design]] — foundation: offloading explains WHY we externalize; this note explains WHAT the externalized artifacts do during active reasoning
+- [[spreading activation models how agents should traverse]] — extends: spreading activation explains how to navigate the graph; anchoring explains why the graph stabilizes the navigator
+- [[LLM attention degrades as context fills]] — enables: attention degradation is the agent-side instability that anchoring addresses; as context fills, anchored reference points prevent the reasoning thread from drifting
+- [[closure rituals create clean breaks that prevent attention residue bleed]] — complements: closure releases completed work from attention; anchoring holds incomplete work stable until completion
+- [[Zeigarnik effect validates capture-first philosophy because open loops drain attention]] — foundation: Zeigarnik explains the cost of unexternalized thoughts; anchoring explains the benefit of externalized ones during active work
+- [[intermediate packets enable assembly over creation]] — extends: packets are anchors at the project level; each packet stabilizes a portion of the larger assembly so the agent can work on parts without losing the whole
+- [[MOCs are attention management devices not just organizational tools]] — exemplifies: MOCs are specialized anchors that compress topic state for rapid orientation; the attention management function IS anchoring applied to session entry
+- [[backward maintenance asks what would be different if written today]] — enables: reweaving is the remedy for anchoring rigidity; periodic reconsideration prevents anchored models from ossifying into outdated understanding
+- [[AI shifts knowledge systems from externalizing memory to externalizing attention]] — reframes: anchoring is a concrete mechanism through which attention externalization operates; this note stabilizes attention during reasoning, that note names the broader paradigm where the system externalizes attention decisions at scale
+- [[attention residue may have a minimum granularity that cannot be subdivided]] — limits: anchoring reduces the variable cost of reconstruction within a context but cannot eliminate the fixed cost of transitioning between anchored states; the minimum granularity thesis bounds what anchoring can achieve
+
+Topics:
+- [[agent-cognition]]