arscontexta 0.6.0

package/methodology/cognitive outsourcing risk in agent-operated systems.md

@@ -0,0 +1,55 @@
+---
+description: When agents handle all processing, humans may lose meta-cognitive skills for knowledge work even while vault quality improves
+kind: research
+topics: ["[[agent-cognition]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# cognitive outsourcing risk in agent-operated systems
+
+The source material warns: "To fully automate [metadata creation] is to outsource the very cognitive process that PKM seeks to enhance." If agents do all the processing, humans lose the cognitive benefit of doing it themselves. The system becomes excellent but the human's understanding may atrophy.
+
+This is the tool dependency concern applied to agent-operated knowledge systems. When a human delegated one task to an assistant, they retained skills for similar tasks. But when agents handle all processing at scale — extraction, connection-finding, synthesis — the human may lose not just encoding (tested in [[does agent processing recover what fast capture loses]]) but also the meta-cognitive skills: knowing how to structure ideas, recognizing good connections, judging what matters.
+
+Three mechanisms explain how this atrophy might occur:
+
+**The Collector's Fallacy variant.** The original Collector's Fallacy describes believing that collecting information equals acquiring knowledge — filling inboxes with thousands of items never processed. Agent operation inverts the surface symptom while preserving the underlying problem: the inbox stays empty because agents process it, the vault looks well-organized, but the human's actual understanding remains shallow. The debt becomes invisible. When users "often revert to hoarding," they at least feel the anxiety of the unprocessed pile. Agent processing may enable deeper collecting while feeling productive, hiding the gap between vault quality and human comprehension.
+
+**The Generation Effect bypass.** Cognitive psychology's generation effect (Slamecka & Graf, 1978) shows information is better remembered when generated from one's own mind rather than passively consumed. The act of translation into one's own words triggers "elaborative encoding." Since [[the generation effect requires active transformation not just storage]], when agents do this translation, the vault benefits from the generated connections — but does the human? The encoding happens in the agent's processing, not the human's cognition. This challenges whether approval-mode engagement provides enough generative work.
+
+**The Extended Mind decoupling.** Since [[cognitive offloading is the architectural foundation for vault design]], the vault is designed as a distributed cognitive system where externalization is the architectural principle. Extended Mind theory argues that external systems become part of cognition, but only when actively coupled — when there's genuine cognitive loop between mind and tool. If agents process and humans never deeply engage, the vault may be excellent while human understanding atrophies. The system ceases to extend the mind and becomes merely adjacent to it. The offloading foundation creates this risk: the same Risko/Gilbert economics that justify frictionless capture also enable frictionless disengagement. Resolution may require human-in-the-loop at synthesis stages, not just approval gates.
+
+The risk becomes more concrete when viewed through the lens of industry trends. Since [[vibe notetaking is the emerging industry consensus for AI-native self-organization]], the entire AI-native tool landscape promotes effortless knowledge management as its selling point. The pitch is always "dump everything, we organize it for you." The unspoken cost — that effortlessness means the human does no generative cognitive work, and the generation effect benefits whoever generates — is rarely acknowledged. The industry consensus accelerates the outsourcing trajectory by normalizing full delegation as the default rather than the exception.
+
+The counter-argument: in ars contexta, the human retains judgment and direction. Since [[you operate a system that takes notes]], the human role has explicitly shifted from creator to curator — the agent proposes, the human approves. This should preserve understanding. But the question remains whether the "judgment" role involves enough active cognitive work to maintain capability, or whether operating a system that takes notes is qualitatively different from taking notes in ways that hollow out the very skills that make judgment valuable.
+
+Is approving agent work sufficient cognitive engagement to maintain the skills that would be needed to do the work yourself?
+
+This is distinct from [[does agent processing recover what fast capture loses]], which tests encoding of specific content. This concerns skill atrophy — whether the human loses the ability to do knowledge work itself, not just memories of specific content.
+
+The warning sign to watch: when you can no longer imagine doing this without the agent. If the system enables new capabilities, that's good. If it creates dependency by atrophying old capabilities, that's the risk.
+
+There's a parallel to [[LLM attention degrades as context fills]] — both describe invisible quality degradation. LLM attention degrades as context accumulates; human judgment may degrade as delegation accumulates. Neither failure mode is obvious from the outside. The output looks fine, but the underlying capability is diminished. Since [[fresh context per task preserves quality better than chaining phases]] by giving each task pristine attention, perhaps periodic "manual mode" (forcing human processing) preserves human capability by giving certain tasks full human engagement. The mitigation pattern might transfer: just as session isolation keeps LLMs in the smart zone, deliberate non-delegation keeps humans in the practice zone.
+
+If [[gardening cycle implements tend prune fertilize operations]] validates, the separated operations might themselves serve as a mitigation — focused approval of specific maintenance activities (tend vs prune vs fertilize) makes rubber-stamping harder than blanket approval of holistic reconsideration. Smaller scope means deeper evaluation per decision.
+
+Since [[maintenance targeting should prioritize mechanism and theory notes]], the productive connections are the mechanism notes about skill atrophy and cognitive delegation: [[skills encode methodology so manual execution bypasses quality gates]] and [[the generation effect requires active transformation not just storage]]. These theorize about what this note concerns — delegation effects on human capability.
+---
+
+Relevant Notes:
+- [[cognitive offloading is the architectural foundation for vault design]] — the foundation this note challenges; if offloading is the architectural principle, this note identifies the failure mode of taking offloading too far — the very mechanism that enables the system can hollow out the human side of the distributed cognitive architecture
+- [[does agent processing recover what fast capture loses]] — sibling concern testing encoding of specific content; this addresses skill atrophy over time
+- [[productivity porn risk in meta-system building]] — sibling concern testing whether building infrastructure becomes procrastination; this tests skill atrophy, that tests output stagnation
+- [[verbatim risk applies to agents too]] — sibling concern testing agent output quality; forms a meta-system risks trio addressing orthogonal failure dimensions: verbatim risk (agent output), this (human capability), productivity porn (investment vs procrastination)
+- [[the generation effect requires active transformation not just storage]] — the cognitive science foundation; if the agent generates, the agent benefits, not the human
+- [[skills encode methodology so manual execution bypasses quality gates]] — ironic tension: skills ensure quality but may also ensure the human never practices the underlying skill
+- [[LLM attention degrades as context fills]] — parallel pattern: human judgment may degrade through delegation the same way LLM attention degrades through context accumulation; both are invisible quality failures
+- [[fresh context per task preserves quality better than chaining phases]] — the mitigation pattern might transfer: session isolation for LLMs, deliberate non-delegation for humans
+- [[gardening cycle implements tend prune fertilize operations]] — if validated, focused operations might mitigate rubber-stamping by requiring deeper evaluation per smaller-scope decision
+- [[maintenance targeting should prioritize mechanism and theory notes]] — provides targeting guidance: connect this toward skill atrophy and delegation mechanism notes, not MOC neighbors
+- [[PKM failure follows a predictable cycle]] — documents the original Collector's Fallacy (Stage 1) that this note's variant inverts: agent processing hides the symptoms while preserving the failure mode
+- [[vibe notetaking is the emerging industry consensus for AI-native self-organization]] — industry amplifier: the entire AI-native tool landscape promotes effortlessness as the default, normalizing full cognitive delegation and accelerating the outsourcing trajectory this note warns about
+- [[you operate a system that takes notes]] — paradigm frame: names the creator-to-curator shift within which the outsourcing risk operates; the question is whether operating a system preserves or atrophies the skills that operating requires
+
+Topics:
+- [[agent-cognition]]

package/methodology/coherence maintains consistency despite inconsistent inputs.md

@@ -0,0 +1,96 @@
+---
+description: memory systems must actively maintain coherent beliefs despite accumulating contradictory inputs — through detection, resolution, and honest acknowledgment of uncertainty
+kind: research
+topics: ["[[agent-cognition]]", "[[maintenance-patterns]]"]
+source: [[rata-paper-memory-coherence]]
+---
+
+# coherence maintains consistency despite inconsistent inputs
+
+extracted from Rata paper 54 (memory coherence), 2026-02-02
+
+## The Problem
+
+Memories accumulate from multiple sources over time. Contradictions inevitably emerge:
+- direct contradiction (X and ¬X)
+- temporal inconsistency (old vs new)
+- source conflict (observed vs prompted)
+- scope ambiguity (general vs specific)
+
+A memory system that believes X and ¬X simultaneously isn't uncertain — it's confused.
+
+## Resolution Strategies
+
+| Strategy | When to Use |
+|----------|-------------|
+| Recency wins | Fast-changing facts |
+| Source hierarchy | Multi-source input |
+| Keep both + flag | Uncertain resolution |
+| Ask for clarification | Interactive context |
+
+No single strategy works everywhere. The vault needs judgment. Since [[provenance tracks where beliefs come from]], the source hierarchy strategy has concrete implementation: observed beliefs (tested directly) warrant higher trust than prompted beliefs (told by humans) or inherited beliefs (from training). Provenance metadata turns "source hierarchy" from abstract principle into actionable resolution.
+
+## The Coherence-Completeness Tradeoff
+
+- **Maximally coherent:** every memory fits perfectly — loses valuable outliers
+- **Maximally complete:** keep everything — contradictions confuse retrieval
+
+The sweet spot maps to belief centrality:
+- Core beliefs: strictly coherent
+- Peripheral beliefs: some contradiction tolerated
+- Raw memories: full fidelity, no coherence requirement
+
+This tradeoff has a direct parallel in multi-agent systems. Since [[federated wiki pattern enables multi-agent divergence as feature not bug]], coexisting interpretations between agents can be productive — federation says divergence IS the feature. But within a single agent's belief system, holding contradictory beliefs is confusion, not diversity. The distinction matters: between-agent divergence produces richer coverage of a concept, while within-agent incoherence degrades confidence and retrieval. And since [[metacognitive confidence can diverge from retrieval capability]], a vault can feel coherent — sessions run smoothly, notes connect, MOCs organize — while contradictions silently compound in ways that surface only when retrieval produces conflicting answers to the same question.
+
+## Connection to Backward Maintenance
+
+Since [[backward maintenance asks what would be different if written today]], reweave IS coherence maintenance. When a new note is created, old notes might contradict or need updating. The backward pass:
+- detects potential incoherence
+- resolves by adding links and context
+- maintains consistency across time
+
+At the system level, since [[reconciliation loops that compare desired state to actual state enable drift correction without continuous monitoring]], reconciliation formalizes a structural version of this same question. Where backward maintenance asks "does this note still match current understanding?" (judgment-requiring), reconciliation asks "does the system's actual state match its declared healthy state?" (deterministic comparison). Both are drift-correction mechanisms — one for belief coherence, one for structural health. The patterns complement: coherence maintenance catches semantic contradictions that reconciliation's structural checks miss, while reconciliation catches accumulated drift that no single reweave would notice.
+
+Since [[incremental formalization happens through repeated touching of old notes]], each traversal that encounters an older note is an organic opportunity to notice incoherence — a claim that seemed right six months ago may now conflict with newer understanding. The accumulated touches that crystallize vague ideas also serve as distributed coherence checks.
+
+## Incoherence Should Reduce Confidence
+
+When contradicting memories exist:
+- reduce confidence in the claim
+- flag for resolution
+- be honest: "I have conflicting information about this..."
+
+Honest acknowledgment of incoherence beats false confidence. Since [[testing effect could enable agent knowledge verification]], the predict-then-verify cycle offers a concrete detection mechanism: when an agent predicts a note's content from its description and finds it contradicts what the broader graph now implies, that failed prediction signals incoherence worth investigating.
+
+## Open Question for My Vault
+
+How do I detect contradictions? Currently relying on:
+- manual review during reweave
+- memory during reflection
+
+Could add:
+- semantic similarity checks (qmd vsearch for near-duplicates with different conclusions)
+- explicit contradiction flags (tension notes in 04_meta/logs/tensions/)
+- confidence metadata on claims
+- predict-then-verify cycles that surface description-content divergence
+
+---
+---
+
+Relevant Notes:
+- [[backward maintenance asks what would be different if written today]] — reweave as coherence maintenance: the backward pass detects and resolves belief incoherence accumulated across time
+- [[provenance tracks where beliefs come from]] — source hierarchy grounds resolution strategy: which belief to trust depends on whether it was observed, prompted, or inherited
+- [[the vault constitutes identity for agents]] — coherent identity requires coherent beliefs: if the vault constitutes the agent, incoherent beliefs produce an incoherent agent
+- [[vivid memories need verification]] — concrete instance: memory drift from flashbulb effect is exactly the temporal inconsistency coherence maintenance must detect and resolve
+- [[reconciliation loops that compare desired state to actual state enable drift correction without continuous monitoring]] — system-level counterpart: coherence checks beliefs per-note through judgment, reconciliation checks structural health through deterministic comparison; both are drift-correction at different scales
+- [[metacognitive confidence can diverge from retrieval capability]] — the coherence-completeness tradeoff is a specific metacognitive divergence risk: the system may feel coherent while contradictions silently degrade retrieval
+- [[federated wiki pattern enables multi-agent divergence as feature not bug]] — productive tension: federation says coexisting interpretations can be a feature, while coherence says contradictions must resolve; the distinction is whether the divergence is between agents (productive) or within one agent's beliefs (confusion)
+- [[incremental formalization happens through repeated touching of old notes]] — detection mechanism: each traversal that touches an older note is an opportunity to notice incoherence between that note and current understanding
+- [[testing effect could enable agent knowledge verification]] — the predict-then-verify cycle could surface incoherence by revealing when a note's description contradicts what the graph now suggests it should claim
+- [[reflection synthesizes existing notes into new insight]] — reflection as coherence detection: reading multiple notes together surfaces cross-note contradictions that no single-note review would catch, making deliberate reflection an organic coherence maintenance practice
+- [[implicit knowledge emerges from traversal]] — coherence shapes implicit knowledge quality: if traversal builds intuition from contradictory notes, the resulting implicit knowledge is incoherent, producing agents that 'know' contradictory things without realizing it
+- [[friction reveals architecture]] — contradiction as friction signal: when retrieval surfaces conflicting claims, the discomfort reveals where coherence maintenance is needed; friction is the perceptual channel through which incoherence makes itself known
+
+Topics:
+- [[agent-cognition]]
+- [[maintenance-patterns]]

package/methodology/coherent architecture emerges from wiki links spreading activation and small-world topology.md

@@ -0,0 +1,48 @@
+---
+description: The foundational triangle — wiki links create structure, spreading activation models traversal, small-world topology provides requirements, together answering what, how, and why for knowledge graphs
+kind: research
+topics: ["[[note-design]]", "[[graph-structure]]", "[[agent-cognition]]"]
+---
+
+# coherent architecture emerges from wiki links spreading activation and small-world topology
+
+A coherent architecture for agent-operated knowledge systems emerges from three interlocking pieces:
+
+**Wiki links create the graph structure.** Every `[[link]]` is an explicit, curated edge. Unlike vector similarity which measures surface overlap, wiki links represent human judgment about genuine conceptual connection. This implements GraphRAG-style multi-hop reasoning without the infrastructure — no entity extraction, no community detection algorithms, just explicit links that passed the "is this actually related?" test. And since [[wiki links create navigation paths that shape retrieval]], the quality of those edges determines retrieval effectiveness: link discipline filters noise, link context guides traversal decisions, and link density compounds signal across the graph.
+
+**Spreading activation models how agents should traverse.** When an agent loads a note, activation spreads through its links with configurable decay. High decay means focused, depth-first retrieval. Low decay means exploratory, breadth-first discovery. The decay parameter lets agents tune their traversal mode to the task. This cognitive science model provides the HOW of navigation.
+
+**Small-world topology provides the structural requirements.** For spreading activation to work efficiently, the graph needs both local clustering (related concepts densely connected) and global shortcuts (hubs that bridge distant clusters). Power-law link distribution achieves this: most notes have 3-6 links, but some (MOCs, synthesis notes) have many more. This creates the 2-3 hop reachability that makes the graph navigable.
+
+Together: wiki links answer WHAT the structure is, spreading activation answers HOW to traverse it, and small-world topology answers WHY that structure enables efficient navigation. Since [[complete navigation requires four complementary types that no single mechanism provides]], the triangle's three vertices map onto distinct navigation roles: wiki links implement contextual navigation (what's related to THIS?), MOC hubs implement local navigation (what's nearby?), and the hub-of-hubs structure implements global navigation (where am I in the whole?). The fourth type — supplemental navigation (how else can I find things?) — lives outside the triangle in search mechanisms, which explains why the triangle is necessary but not sufficient for complete wayfinding.
+
+**Checkpointing adds the temporal dimension.** Since [[queries evolve during search so agents should checkpoint]], the architecture needs explicit reassessment points. An agent following spreading activation doesn't just traverse — it periodically asks "is my original question still the right question?"
+
+**The graph grows organically.** Since [[dangling links reveal which notes want to exist]], structure emerges from use patterns. High-frequency dangling links predict future hubs. The architecture self-organizes through demand signals rather than imposed categories.
+
+**Hubs serve attention management, not just navigation.** Since [[MOCs are attention management devices not just organizational tools]], the hub nodes in this architecture provide a second benefit beyond structural shortcuts. MOCs compress topic state — the current synthesis, tensions, and gaps — into a form that frontloads orientation. An agent reading a MOC doesn't just discover what exists; it loads the mental model of the topic without re-traversing the graph. This means the architecture's hub-and-spoke topology serves both navigation efficiency and cognitive efficiency, reducing the re-orientation cost that Leroy's research measures at up to 23 minutes.
+
+**Cross-MOC membership reveals synthesis quality.** Since [[cross-links between MOC territories indicate creative leaps and integration depth]], notes appearing in multiple distant MOCs are integration hubs where ideas from separate domains combine. The architecture's health can be measured not just by traversal efficiency but by how many notes bridge topic boundaries — a vault where every note lives in exactly one MOC is a collection of silos, while cross-links create the creative leaps that advance understanding.
+
+**The triangle transfers across domains.** Each vertex of this architecture maps to a cognitive science principle rather than a domain assumption, and since [[the vault methodology transfers because it encodes cognitive science not domain specifics]], the entire triangle is portable. Wiki links externalize associations (Clark and Chalmers Extended Mind), spreading activation replicates how memory retrieval works in brains, and small-world topology mirrors the structure that makes neural networks efficient. A therapy vault, a project tracker, and a creative writing system all benefit from the same architectural triangle because the cognitive constraints it addresses — working memory limits, associative retrieval, navigational efficiency — are domain-invariant.
+---
+
+Relevant Notes:
+- [[wiki links implement GraphRAG without the infrastructure]] — the structural layer
+- [[wiki links create navigation paths that shape retrieval]] — develops what makes the structural layer effective: link discipline, context, and density determine whether curated edges function as retrieval architecture
+- [[spreading activation models how agents should traverse]] — the traversal mechanism
+- [[small-world topology requires hubs and dense local links]] — the structural requirements
+- [[queries evolve during search so agents should checkpoint]] — the temporal dimension
+- [[dangling links reveal which notes want to exist]] — the growth pattern
+- [[associative ontologies beat hierarchical taxonomies because heterarchy adapts while hierarchy brittles]] — the theoretical foundation for organic growth: structure emerges from use because heterarchy adapts where hierarchy would brittle
+- [[navigational vertigo emerges in pure association systems without local hierarchy]] — the failure mode: spreading activation cannot reach semantic neighbors without link paths; MOCs provide the local hierarchy remedy
+- [[complex systems evolve from simple working systems]] — theoretical grounding: Gall's Law explains WHY organic graph growth works — these architectural properties emerge through accumulated connection decisions at friction points rather than upfront design
+- [[MOCs are attention management devices not just organizational tools]] — the attention dimension: hubs serve not just as navigational shortcuts but as context-loading devices that reduce re-orientation cost
+- [[the vault methodology transfers because it encodes cognitive science not domain specifics]] — explains WHY the triangle transfers: each vertex maps to a cognitive science principle (Extended Mind, spreading activation, small-world topology), making the architecture domain-invariant rather than research-specific
+- [[knowledge systems share universal operations and structural components across all methodology traditions]] — the broader inventory from which the triangle selects: wiki links, spreading activation, and small-world topology correspond to three of the nine universal structural components (links, search, navigation/health), grounding the triangle as a critical subset of the full architectural inventory rather than the entire foundation
+- [[complete navigation requires four complementary types that no single mechanism provides]] — maps the triangle's vertices onto navigation type roles: wiki links implement contextual navigation, MOC hubs implement local navigation, and the hub-of-hubs provides global navigation; the fourth type (supplemental, via search) sits outside the triangle, explaining why the triangle is necessary but not sufficient for complete wayfinding
+
+Topics:
+- [[note-design]]
+- [[graph-structure]]
+- [[agent-cognition]]

package/methodology/community detection algorithms can inform when MOCs should split or merge.md

@@ -0,0 +1,52 @@
+---
+description: Louvain and similar algorithms detect dense note clusters and track how cluster boundaries shift over time, providing actionable signals for MOC reorganization that human intuition misses at scale
+kind: research
+topics: ["[[graph-structure]]", "[[maintenance-patterns]]"]
+methodology: ["Network Science"]
+source: [[tft-research-part3]]
+---
+
+# community detection algorithms can inform when MOCs should split or merge
+
+The vault's MOC structure is a human hypothesis about where topic boundaries fall. At 50 notes this hypothesis is easy to maintain through intuition — you can see the shape of the graph. But since [[small-world topology requires hubs and dense local links]], the topology that makes navigation work also makes it harder to perceive structural shifts as the vault grows. A MOC that served 15 notes well might struggle at 40, not because any single note is wrong but because the cluster underneath has silently bifurcated into two communities that happen to share a label.
+
+Community detection algorithms — Louvain, Leiden, label propagation — solve exactly this problem. They analyze the link structure of a graph and identify groups of nodes that are more densely connected to each other than to the rest of the network. Applied to a vault's wiki link graph, they reveal the natural communities that actually exist in the data, which may or may not align with the MOC boundaries that were drawn when the vault was smaller.
+
+The actionable intelligence comes from comparing algorithmic communities against existing MOC territories. Three signals matter:
+
+**Split signal.** A single MOC covers notes that the algorithm places in two or more distinct communities. The notes within each community link densely to each other but sparsely across the divide. This means the MOC is papering over a genuine boundary — the topic has organically differentiated into sub-topics that deserve their own navigation. CLAUDE.md already prescribes splitting when a MOC exceeds ~35-40 links, but community detection catches splits that should happen earlier because the structural divide is real even if the count threshold hasn't been reached. And once the split is identified, since [[basic level categorization determines optimal MOC granularity]], Rosch's prototype theory predicts what resolution the new sub-MOC titles should target — specific enough to orient but general enough to cover the cluster, at a level that shifts as understanding deepens.
+
+**Merge signal.** Two separate MOCs cover notes that the algorithm places in a single community. The cross-links between them are so dense that the topological distinction has dissolved. Maintaining two MOCs for what is functionally one cluster creates navigational overhead — the agent must check two places for what is one conversation. This is harder to catch by intuition because humans tend to preserve categories once created.
+
+**Drift signal.** Notes that the algorithm reassigns from one community to another over time. "Your epistemology cluster is merging with your AI-methods cluster" is actionable intelligence about how thinking is evolving. Individual note movements might be noise, but consistent migration patterns reveal genuine conceptual convergence or divergence that should reshape MOC structure.
+
+This matters for agent operation because since [[navigational vertigo emerges in pure association systems without local hierarchy]], MOCs provide the local hierarchy that makes association navigable. But stale MOC boundaries are almost as bad as no MOCs at all — since [[metacognitive confidence can diverge from retrieval capability]], stale boundaries create exactly the kind of organizational false confidence where the system appears well-structured while actual community structure has moved on. An agent following a MOC that no longer reflects the real topology wastes context loading notes that cluster elsewhere while missing notes that genuinely belong together.
+
+The implementation maps to the vault's existing maintenance patterns. Since [[schema enforcement via validation agents enables soft consistency]], the vault already uses asynchronous quality checks that surface issues without blocking. Community detection fits the same model: run periodically as a maintenance pass, compare algorithmic output against current MOC membership, flag discrepancies for human review. The agent becomes a topology monitor — not making structural decisions autonomously, but alerting when the graph has shifted enough that reorganization deserves attention.
+
+Since [[cross-links between MOC territories indicate creative leaps and integration depth]], there is a productive tension between community detection and cross-linking. Notes that bridge multiple algorithmic communities are exactly the integration points that cross-link analysis values. Community detection should flag them as boundary objects worth preserving, not as misclassified nodes to reassign. The insight is that community detection identifies where boundaries should be, while cross-link analysis identifies where boundaries should be deliberately crossed. Both are necessary: clean communities for navigation, deliberate bridges for synthesis. And since [[betweenness centrality identifies bridge notes connecting disparate knowledge domains]], the algorithmic toolkit becomes more complete: community detection reveals where group boundaries fall, betweenness centrality reveals which individual notes are structurally critical for bridging those groups. A note with high betweenness that sits at a community boundary is the most important kind of boundary object — the node whose quality disproportionately affects inter-cluster navigation.
+
+Community detection also extends to evaluating multi-agent divergence. Since [[federated wiki pattern enables multi-agent divergence as feature not bug]], the question of whether parallel interpretations are productive depends on whether they serve distinct audiences. Community detection operationalizes this: if two federated versions attract links from different algorithmic communities, the divergence is structurally productive. If both versions draw from the same community, the divergence may be fragmenting a single concept rather than illuminating distinct facets.
+
+There is genuine uncertainty about when this becomes valuable. At the vault's current scale (~100 notes), intuition and manual review suffice. The algorithmic approach becomes necessary somewhere between 200 and 1000 notes, where the graph is too large to perceive community structure through reading but too structured for simple heuristics like note count per MOC. The investment is forward-looking — building the monitoring capability before the problem becomes acute, so the infrastructure exists when scale demands it.
+
+The deeper implication connects to how since [[MOCs are attention management devices not just organizational tools]], MOC reorganization isn't just a structural tidying exercise. Every MOC split or merge reshapes how agents load context for an entire topic area. A bad split fragments attention across two MOCs that should be one conversation. A missed split forces agents to wade through an overloaded MOC where half the content is irrelevant to their query. Community detection makes these decisions empirical rather than intuitive — grounded in the actual topology of connections rather than the labels we assigned when the vault was smaller.
+
+---
+---
+
+Relevant Notes:
+- [[small-world topology requires hubs and dense local links]] — foundation: community detection operates on the topology this note describes, identifying when power-law structure drifts from healthy distribution
+- [[cross-links between MOC territories indicate creative leaps and integration depth]] — qualitative complement: cross-MOC membership reveals integration quality; community detection reveals when those territories should be redrawn
+- [[navigational vertigo emerges in pure association systems without local hierarchy]] — the failure mode this prevents: algorithmic monitoring catches emerging clusters that lack MOC coverage before they become unreachable neighborhoods
+- [[MOCs are attention management devices not just organizational tools]] — extends the stakes of MOC reorganization: splitting or merging MOCs isn't just structural cleanup, it reshapes how attention loads for every session that touches those topics
+- [[schema enforcement via validation agents enables soft consistency]] — sibling automation pattern: validation agents check note-level quality, community detection checks graph-level topology; both are asynchronous maintenance that surfaces issues without blocking
+- [[betweenness centrality identifies bridge notes connecting disparate knowledge domains]] — complementary algorithmic tool: betweenness identifies structurally critical individual nodes, community detection identifies structurally meaningful group boundaries; together they provide a complete graph health monitoring toolkit
+- [[metacognitive confidence can diverge from retrieval capability]] — structural instance: stale MOC boundaries are organizational metacognitive divergence where the system appears well-organized while actual community structure has drifted, producing false confidence in navigation
+- [[basic level categorization determines optimal MOC granularity]] — complementary theory: community detection reveals WHEN boundaries should move, basic level theory explains WHERE they should land; Rosch's prototype theory predicts the optimal resolution for sub-MOC titles, and the expertise-shift mechanism explains why the right granularity evolves with understanding, not just with volume
+- [[federated wiki pattern enables multi-agent divergence as feature not bug]] — application beyond MOCs: community detection can operationalize federation's quality test by measuring whether parallel interpretations attract distinct link communities or fragment a single cluster
+- [[evolution observations provide actionable signals for system adaptation]] — broader diagnostic frame: MOC threshold is one of six diagnostic patterns in the evolution protocol; community detection deepens that specific row with algorithmic signals beyond simple note count, suggesting each diagnostic can be elaborated with more sophisticated methods
+
+Topics:
+- [[graph-structure]]
+- [[maintenance-patterns]]

package/methodology/complete navigation requires four complementary types that no single mechanism provides.md

@@ -0,0 +1,43 @@
+---
+description: Rosenfeld and Morville's global, local, contextual, and supplemental navigation types map onto hub, MOC, wiki link, and search mechanisms — missing any one creates predictable blind spots
+kind: research
+topics: ["[[graph-structure]]", "[[discovery-retrieval]]"]
+methodology: ["PKM Research"]
+source: [[2026-02-08-moc-architecture-hierarchy-blueprint]]
+---
+
+# complete navigation requires four complementary types that no single mechanism provides
+
+Rosenfeld and Morville's information architecture taxonomy identifies four navigation types that compose into complete wayfinding: global (where am I in the whole?), local (what's nearby?), contextual (what's related to THIS?), and supplemental (how else can I find things?). The critical insight is not the taxonomy itself but the complementarity — each type answers a question the others cannot, so any system relying on a single mechanism has predictable blind spots.
+
+In this vault, each type maps onto a distinct mechanism. Global navigation lives in the hub (`index.md`) and domain MOCs, which orient the agent to the full scope of the knowledge graph. Local navigation lives in topic MOCs, which present the neighborhood of a domain — core ideas, tensions, gaps — in one view. But the depth to which local navigation can stack tiers depends on label quality: since [[context phrase clarity determines how deep a navigation hierarchy can scale]], deeper MOC hierarchies only outperform flatter ones when context phrases enable confident branch commitment at each tier. Contextual navigation lives in inline wiki links, which connect THIS note to THAT note with prose explaining why the relationship matters. Supplemental navigation lives in search — both keyword (`grep`) and semantic (`qmd`) — which provides entry points independent of the curated graph structure.
+
+The four types reveal why partial systems fail in characteristic ways. A system with only search (supplemental) cannot orient agents within a domain because there is no curated map of what matters. Since [[navigational vertigo emerges in pure association systems without local hierarchy]], a system with only inline links (contextual) leaves semantically related but unlinked content unreachable. A system with only MOCs (local) provides neighborhood maps but no way to discover connections across neighborhoods. And a system with only a hub (global) gives high-altitude orientation without the detail to work within any topic.
+
+The vault's four mechanisms cover all four types, but coverage is not the same as quality. Since [[stale navigation actively misleads because agents trust curated maps completely]], each navigation type requires its own maintenance cadence. Global navigation changes rarely (new domains are infrequent). Local navigation changes with every batch of new claims (MOC updates during `/reflect`). Contextual navigation changes with every new note (inline links during creation and `/reweave`). Supplemental navigation changes with index freshness (`qmd update`). Because [[three concurrent maintenance loops operate at different timescales to catch different classes of problems]], the per-type cadence maps naturally onto the loop architecture: fast loops catch contextual navigation failures (broken links on every write), medium loops catch local navigation drift (orphan notes surfaced per session), and slow loops audit global navigation structure (domain MOC coherence over weeks). Neglecting maintenance on any single type degrades the system's completeness even when the other three remain healthy.
+
+This framework also explains why [[structure enables navigation without reading everything]] works as well as it does — the four discovery layers (file tree, descriptions, headings, full content) are not arbitrary but map onto the navigation types. File tree scanning provides global orientation. MOC reading provides local orientation. Following wiki links provides contextual depth. Searching provides supplemental discovery. The progressive disclosure pattern succeeds because it exercises all four navigation types in sequence, ensuring no blind spots in the agent's orientation.
+
+The framework also provides the theoretical grounding for why specific knowledge system primitives are universal. Since [[ten universal primitives form the kernel of every viable agent knowledge system]], four of those primitives — wiki links, MOC hierarchy, tree injection, and description fields — correspond directly to the four navigation types. Wiki links implement contextual navigation, MOCs implement local navigation, tree injection implements global navigation, and descriptions enable supplemental discovery by providing filterable metadata. The primitives are universal precisely because each addresses a navigation type that no other primitive covers. Removing any one creates a predictable blind spot, which is why the kernel cannot be reduced further without losing navigation completeness.
+
+The practical test for any agent knowledge architecture: can you answer all four questions? Where am I? What's nearby? What's related to this? How else can I find things? If any question goes unanswered, the architecture has a gap that will manifest as a navigation failure at scale. Since [[navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts]], the urgency of this test increases with vault size — at Regime 1 the blind spots are tolerable because the agent can hold everything in context, but by Regime 2 an unanswered navigation question becomes an active impediment. And because [[eight configuration dimensions parameterize the space of possible knowledge systems]], the navigation depth dimension is really a choice about how many of these four types to support, which means the completeness test doubles as a design evaluation tool for any derived knowledge system.
+
+---
+---
+
+Relevant Notes:
+- [[structure enables navigation without reading everything]] — develops the four structural mechanisms (wiki links, MOCs, claim titles, descriptions) as discovery layers; this note reframes those same mechanisms through the navigation type taxonomy, showing they cover all four types
+- [[navigational vertigo emerges in pure association systems without local hierarchy]] — describes the failure mode when local navigation (MOCs) is absent from a system that only has contextual navigation (links); the four-type framework predicts exactly this gap
+- [[spreading activation models how agents should traverse]] — explains HOW agents move through the graph; this note explains WHAT structural roles the mechanisms play, so spreading activation is the traversal engine while navigation types are the road system
+- [[MOCs are attention management devices not just organizational tools]] — adds a second payoff for the local navigation layer: MOCs provide not just nearby-content orientation but attention cost reduction, making the local type doubly justified
+- [[stale navigation actively misleads because agents trust curated maps completely]] — the failure mode when any navigation type degrades: stale MOCs corrupt local navigation, stale links corrupt contextual navigation, and agents cannot distinguish fresh from stale
+- [[eight configuration dimensions parameterize the space of possible knowledge systems]] — the navigation depth dimension is a design choice about how many navigation types to support; the four-type framework explains WHY depth matters by mapping each level to a type that answers a question the others cannot
+- [[ten universal primitives form the kernel of every viable agent knowledge system]] — four kernel primitives (wiki links, MOC hierarchy, tree injection, description fields) correspond to the four navigation types, explaining why these specific primitives are universal: each provides a navigation capability that the others cannot replace
+- [[three concurrent maintenance loops operate at different timescales to catch different classes of problems]] — the per-type maintenance cadence maps onto the three-loop architecture: fast loops maintain contextual navigation (link integrity per event), medium loops maintain local navigation (MOC updates per session), slow loops maintain global navigation (domain structure per audit cycle)
+- [[navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts]] — extends: scaling regimes explain WHEN the four types become necessary; at Regime 1 all four are premature, at Regime 2 local and contextual become essential, at Regime 3 all four plus automation are required
+- [[context phrase clarity determines how deep a navigation hierarchy can scale]] — depth constraint on local navigation: the local type (MOCs) can sustain multiple tiers only when context phrases enable confident branch commitment; ambiguous labels cap the depth at which local navigation remains effective
+- [[MOC construction forces synthesis that automated generation from metadata cannot replicate]] — quality mechanism for local navigation: the local type requires curated MOCs, and the Dump-Lump-Jump synthesis is what produces the orientation and context phrase quality that distinguishes genuine local navigation from automated link lists
+
+Topics:
+- [[graph-structure]]
+- [[discovery-retrieval]]

package/methodology/complex systems evolve from simple working systems.md

@@ -0,0 +1,59 @@
+---
+description: Gall's Law — design from scratch fails because complexity requires evolutionary scaffolding that only working simplicity provides
+kind: research
+topics: ["[[processing-workflows]]"]
+methodology: ["Systems Theory"]
+source: TFT research corpus (00_inbox/heinrich/), [[knowledge-system-derivation-blueprint]]
+---
+
+# complex systems evolve from simple working systems
+
+"A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works." — John Gall, Systemantics
+
+This is a design constraint, not a hypothesis. The system treats it as axiomatic because attempting the alternative — designing a complete system upfront — creates structures that collapse under their own weight before they can be tested.
+
+The mechanism: complex systems require countless micro-adaptations that only emerge through actual use. When you design from scratch, you make guesses about what will matter. Most guesses are wrong. A simple working system reveals which parts need elaboration because friction appears at exactly those points. You add complexity where pain emerges, not where you imagine it might. And since [[evolution observations provide actionable signals for system adaptation]], the observation of friction can be structured into a diagnostic protocol that maps specific symptoms to their structural causes -- unused note types signal over-modeling, N/A-filled fields signal schema overreach, navigation failure signals structural misfit -- converting the general principle of "add complexity at friction points" into a concrete feedback mechanism. At the schema level specifically, since [[schema evolution follows observe-then-formalize not design-then-enforce]], this translates to a quarterly review with five concrete signals -- manual field additions reveal unmet demand, placeholder stuffing reveals false compliance, unused enums reveal dead options -- each mapping to a specific schema action. This applies at every scale — at the note level, since [[incremental formalization happens through repeated touching of old notes]], vague inklings crystallize into rigorous concepts through accumulated small improvements rather than upfront perfection. Since [[local-first file formats are inherently agent-native]], the system's substrate IS this kind of simple working system: plain text files with no dependencies prove more robust than databases with APIs because they have fewer failure modes. This is why [[processing effort should follow retrieval demand]] — invest where demonstrated need exists, not where you predict importance.
+
+For agent-operated knowledge systems, this means starting with minimal viable structure and letting workflows evolve — and since [[the no wrong patches guarantee ensures any valid module combination produces a valid system]], each addition is safe by construction. The guarantee is what makes Gall's Law reliable at the module level: enabling a module cannot corrupt what already works, so the evolutionary add-at-friction-points pattern carries no risk of breaking existing structure. And since [[dependency resolution through topological sort makes module composition transparent and verifiable]], the system can show users exactly what needs to be newly enabled and why — so incremental adoption is not just safe but legible, turning each evolutionary step into an architectural explanation rather than opaque automation. Without the guarantee, incremental adoption would be a gamble rather than a principled design strategy. But Gall's Law also creates the conditions for a subtle failure: since [[implicit dependencies create distributed monoliths that fail silently across configurations]], each module added at a friction point is tested in the context of whatever was already active, so undeclared dependencies on co-active modules form through testing context rather than design intent. The distributed monolith grows one well-tested module at a time — each addition is locally validated against its testing configuration but globally coupled through undeclared field reads and convention assumptions. The current vault architecture wasn't designed — it accumulated. System documentation started as a few paragraphs. Skills emerged when patterns repeated enough to justify extraction — and since [[skills encode methodology so manual execution bypasses quality gates]], those skills now contain the accumulated learning that couldn't have been designed upfront. The queue system appeared when manual task tracking became friction. Because [[bootstrapping principle enables self-improving systems]], this evolution happens through the system itself: the system writes the skills that process its own content. Gall's Law says where to add complexity (at friction points), bootstrapping says how to add it (using current capabilities).
+
+The implication is methodological humility. When adding features, ask: has pain emerged that justifies this complexity? If not, wait. The system will tell you what it needs through the friction of use. Since [[platform capability tiers determine which knowledge system features can be implemented]], Gall's Law also constrains the starting point at each tier: a tier-one platform should not deploy its full automation capacity on day one, and a tier-three platform should not attempt features its infrastructure cannot support. The minimum viable configuration differs per tier, not just per use case.
+
+This translates to a concrete development pattern, and since [[four abstraction layers separate platform-agnostic from platform-dependent knowledge system features]], the layers formalize what the phases target: Phase 1 implements foundation (files and text conventions), Phase 2 adds convention (instruction-encoded standards), Phase 3 adds automation only where instruction compliance degrades. The layers make the evolutionary sequence prescriptive rather than intuitive. Phase 1: start with atomic kernel — agents dump content with minimal structure. Phase 2: monitor and log friction — track retrieval failures, navigation confusion, repeated manual work. Phase 3: propose structural fixes only for documented friction points. The key is that phase 3 never runs speculatively. "Only optimize when the pain of not optimizing exceeds the effort of doing so." An agent that starts by building elaborate MOC hierarchies violates this principle; an agent that starts by dumping notes and gradually adding wiki links as connections emerge follows it. The YAGNI principle from Extreme Programming applies directly: do not add functionality until necessary. This prevents premature optimization where systems become complex before they become useful. This provides an alternative failure model to [[PKM failure follows a predictable cycle]]: where that experiment tests whether failure cascades from accumulation (Stage 1 → abandonment), Gall's Law suggests failure might emerge from premature complexity — Stage 4 (Over-engineering) might arise independently from internal complexity pressure rather than cascading from earlier stages. At derivation time this risk intensifies, because since [[premature complexity is the most common derivation failure mode]], a well-developed claim graph justifies each configuration choice individually while the composed system exceeds what users can absorb — a complexity budget constrains initial deployment to the minimum viable configuration above the kernel floor — concretely, two to three note types, two to four MOCs, four or fewer processing phases, and hooks only for the highest-value automation. These numbers are not arbitrary; since [[cognitive offloading is the architectural foundation for vault design]], they represent the threshold below which a user can hold the entire system in working memory while building habits, and above which the system demands more cognitive overhead than the workflows it automates. The budget forces derivation to grow through friction rather than foresight. The experiments are complementary: the failure cycle tests cascade prediction, Gall's Law suggests some failures emerge from complexity itself.
+
+The graph itself grows this way. Since [[dangling links reveal which notes want to exist]], structure emerges from reference patterns rather than imposed categories. A note accumulates incoming links before it's created — the graph votes on what should exist through use, not planning. This organic growth pattern grounds [[coherent architecture emerges from wiki links spreading activation and small-world topology]] — the architectural properties that make knowledge graphs navigable (wiki links, spreading activation, small-world topology) don't need to be designed; they emerge from accumulated connection decisions made at friction points.
+
+But evolution from simplicity has a limit. Since [[derived systems follow a seed-evolve-reseed lifecycle]], accumulated incremental adaptations can drift a system's configuration into an incoherent region where individual choices are locally justified but globally contradictory. Gall's Law tells you to add complexity at friction points, but it does not tell you what to do when the accumulated friction-driven additions create their own systemic friction. The reseeding phase addresses this: principled restructuring that re-derives the system using original constraints enriched by operational experience. This is not starting over (which would violate Gall's Law) but re-derivation that preserves all content while restructuring the framework. And since [[organic emergence versus active curation creates a fundamental vault governance tension]], Gall's Law provides theoretical grounding for the emergence pole of that tension — but the governance question reveals that pure emergence is insufficient. Organic growth generates the structure, but without periodic curation interventions, the accumulated organic additions produce structural debt that evolution alone cannot resolve. The governance rhythm (alternating emergence and curation phases) is how Gall's Law operates in practice: evolve organically, then curate when debt accumulates, then return to organic growth.
+
+This principle suggests: for complex domains, build first, understand through iteration. Understanding emerges through working systems, not from upfront design.
+
+The destination of this evolutionary process is qualitative change. Since [[knowledge systems become communication partners through complexity and memory humans cannot sustain]], Gall's Law isn't just about building working systems — it's about building toward a system complex enough to surprise its operators. The evolution from simple to complex isn't a continuum; at sufficient complexity, the system becomes a genuine thinking partner that holds context no individual session could sustain.
+---
+
+Relevant Notes:
+- [[skills encode methodology so manual execution bypasses quality gates]] — skills themselves are complex systems that evolved from simple patterns, accumulating quality gates that couldn't have been designed upfront
+- [[dangling links reveal which notes want to exist]] — concrete mechanism for organic graph growth: structure emerges from use patterns, not imposed design
+- [[processing effort should follow retrieval demand]] — operational application: invest where pain emerges, not where you predict importance
+- [[vault conventions may impose hidden rigidity on thinking]] — tests the shadow side: evolved conventions might calcify from solutions into constraints
+- [[local-first file formats are inherently agent-native]] — instance of Gall's Law: simple format (plain text) proves more robust than complex infrastructure (databases + APIs) because fewer failure modes
+- [[PKM failure follows a predictable cycle]] — complementary failure model: the cascade tests whether accumulation predicts downstream failures, while Gall's Law suggests some failures (particularly Stage 4: Over-engineering) might emerge from complexity pressure independent of the cascade
+- [[behavioral anti-patterns matter more than tool selection]] — explains why architectural evolution matters: behavioral patterns are the root cause of PKM failure, so evolved architectural constraints (like WIP limits) can make anti-patterns structurally impossible rather than relying on user discipline
+- [[knowledge systems become communication partners through complexity and memory humans cannot sustain]] — the destination: Gall's Law describes HOW systems achieve complexity, this note describes WHAT that complexity enables — partnership that exceeds what either operator could achieve alone
+- [[incremental formalization happens through repeated touching of old notes]] — Gall's Law at the note level: just as systems evolve from working simplicity, individual notes crystallize through accumulated small touches rather than perfection at creation
+- [[coherent architecture emerges from wiki links spreading activation and small-world topology]] — architectural instance: the organic graph growth described there follows Gall's Law — structure emerges from use patterns rather than imposed design
+- [[data exit velocity measures how quickly content escapes vendor lock-in]] — makes the fewer-failure-modes argument measurable: exit velocity quantifies how many dependencies a format accumulates, with high-velocity formats surviving precisely because they have fewer failure modes
+- [[four abstraction layers separate platform-agnostic from platform-dependent knowledge system features]] — formalizes the evolutionary sequence: the layers (foundation, convention, automation, orchestration) describe the specific stages a knowledge system should evolve through, making Gall's Law prescriptive rather than just cautionary
+- [[platform capability tiers determine which knowledge system features can be implemented]] — constrains where friction-driven evolution can lead: the minimum viable configuration and the reachable complexity ceiling both depend on the platform tier
+- [[configuration dimensions interact so choices in one create pressure on others]] — interaction pressures are evolutionary pressures: dimension coupling drives correction toward coherent configuration points or collapse away from incoherent ones, which is Gall's Law operating at the dimension level
+- [[evolution observations provide actionable signals for system adaptation]] — operationalizes the friction detection: six diagnostic patterns structure the observation of where pain has emerged into a protocol that maps symptoms to causes and prescribed responses, converting Gall's Law from a principle about where to add complexity into a concrete feedback mechanism
+- [[schema evolution follows observe-then-formalize not design-then-enforce]] — Gall's Law applied specifically to schemas: five concrete signals (manual additions, placeholder stuffing, unused enums, patterned free text, oversized MOCs) operationalize the principle that schema fields should be added at friction points rather than designed upfront
+- [[derived systems follow a seed-evolve-reseed lifecycle]] — extends Gall's Law with the reseeding phase: evolution from simplicity has a limit where accumulated adaptations produce systemic incoherence, requiring principled restructuring that re-derives using original constraints enriched by operational experience
+- [[organic emergence versus active curation creates a fundamental vault governance tension]] — Gall's Law grounds the emergence pole of this governance tension, but the tension reveals that pure emergence accumulates structural debt requiring curation; the governance rhythm of phased alternation is how evolution from simplicity operates when the system needs both organic growth and periodic intervention
+- [[premature complexity is the most common derivation failure mode]] — the derivation-specific application: a well-developed claim graph can justify remarkable sophistication at every step, but deploying that justified complexity all at once violates Gall's Law because micro-adaptations only develop through use; the complexity budget is the concrete constraint this principle demands
+- [[configuration paralysis emerges when derivation surfaces too many decisions]] — Gall's Law provides the remedy for configuration paralysis: when derivation cannot determine a dimension from constraints, default to the simple pole and let friction drive elaboration rather than optimizing upfront
+- [[the no wrong patches guarantee ensures any valid module combination produces a valid system]] — the safety property that makes Gall's Law reliable for modular systems: adding modules at friction points is only safe because the guarantee ensures each addition cannot corrupt what already works
+- [[dependency resolution through topological sort makes module composition transparent and verifiable]] — the transparency mechanism for incremental adoption: when a user adds a module at a friction point, dependency resolution computes what else needs enabling and explains why, making each evolutionary step legible rather than opaque
+- [[implicit dependencies create distributed monoliths that fail silently across configurations]] — the shadow side of incremental evolution: each module added at a friction point is tested against whatever was already active, so undeclared dependencies form through testing context, and the distributed monolith grows one well-tested module at a time
+- [[cognitive offloading is the architectural foundation for vault design]] — grounds the complexity budget in cognitive science: the specific numbers (2-3 note types, 2-4 MOCs) derive from Cowan's working memory limits, representing the threshold below which users can hold the entire system in mind while building habits
+
+Topics:
+- [[processing-workflows]]

package/methodology/composable knowledge architecture builds systems from independent toggleable modules not monolithic templates.md

@@ -0,0 +1,61 @@
+---
+description: Four traditions converge — component engineering (contracts), Unix (small tools), Alexander's pattern language (generated structure), and Eurorack (no wrong patches) — to produce knowledge systems
+kind: research
+topics: ["[[design-dimensions]]", "[[agent-cognition]]"]
+methodology: ["Original", "Systems Theory"]
+source: [[composable-knowledge-architecture-blueprint]]
+---
+
+# composable knowledge architecture builds systems from independent toggleable modules not monolithic templates
+
+The standard approach to distributing knowledge systems is the monolithic template: a working vault with all its conventions, hooks, skills, and structure, offered as a starting point for customization. This fails because the space of possible knowledge systems is vast and templates can only cover configurations their authors imagined. Every user who needs something different must reverse-engineer the template to understand which parts to remove, which to modify, and which implicit dependencies connect features that appear independent. The composable alternative treats each capability as an independent module with explicit dependencies, so the agent selects what it needs and the architecture resolves the rest.
+
+## Four traditions converge on the composition pattern
+
+The architecture synthesizes four traditions that independently solved aspects of the composition problem. Component-based software engineering provides the contract pattern: each module declares what it requires and what it provides, and a dependency resolver ensures everything a module needs is present before it activates. The Unix philosophy provides the interface discipline: since [[module communication through shared YAML fields creates loose coupling without direct dependencies]], modules coordinate through a shared universal format rather than calling each other directly, so since [[hook composition creates emergent methodology from independent single-concern components]], the same loose coupling that makes hooks composable extends to knowledge system modules generally. Christopher Alexander's pattern language provides the generative insight: each pattern takes its shape according to its context, not from a predetermined form. A composable architecture does not produce the same knowledge system every time but generates structure adapted to the specific agent, platform, and use case. Modular synthesis provides the safety guarantee: since [[the no wrong patches guarantee ensures any valid module combination produces a valid system]], any valid combination of modules must produce a valid system — it might not be useful in every configuration, but it must never corrupt data or break structural integrity.
+
+## Layered dependency graph and module resolution
+
+What makes this more than an analogy is that since [[four abstraction layers separate platform-agnostic from platform-dependent knowledge system features]], the module dependency graph follows the layer hierarchy naturally. Foundation modules (YAML schema, wiki links) have no dependencies and work on any platform — and since [[ten universal primitives form the kernel of every viable agent knowledge system]], these foundation modules correspond to the kernel that derivation never varies. Convention modules (MOCs, inbox pipeline) depend on foundation modules and require a context file. Automation modules (validation, processing pipeline) depend on convention modules and require platform-specific hooks or skills, which is why [[blueprints that teach construction outperform downloads that provide pre-built code for platform-dependent modules]] — platform-dependent modules cannot ship as fixed artifacts but must teach agents how to build them contextually. This means the dependency graph is a DAG aligned with the abstraction layers, and since [[dependency resolution through topological sort makes module composition transparent and verifiable]], topological sort produces a resolution order that respects the portability gradient while generating human-readable explanations of why each module was enabled.
+
+## The distributed monolith anti-pattern
+
+But composability has an anti-pattern that composable architecture must actively prevent: since [[implicit dependencies create distributed monoliths that fail silently across configurations]], modules that share undeclared coupling through conventions, testing context, or co-activation assumptions produce a system that looks composable but cannot actually be recombined. The distributed monolith wears a modular interface while its modules are secretly interdependent. This is not a failure of the architecture's design but of its discipline — the dependency resolver can only verify what modules declare, so undeclared field reads and convention assumptions form a shadow graph the resolver cannot see. The fix is extending module declarations to include data dependencies (what YAML fields each module reads and writes) alongside code dependencies, and testing every module in isolation with only its declared dependencies active.
+
+## Incremental adoption through Gall's Law
+
+The practical consequence is that since [[complex systems evolve from simple working systems]], composable architecture enables Gall's Law at the feature level. An agent starts with zero modules (just markdown files), adds yaml-schema when it wants structured metadata, adds wiki-links when it wants connections, adds mocs when navigation becomes painful, and adds processing-pipeline when manual workflows create friction. Each addition resolves its own dependencies and composes with everything already active, and since [[progressive schema validates only what active modules require not the full system schema]], the validation layer respects this same incremental logic — a user with only yaml-schema and wiki-links enabled never sees warnings about fields belonging to mocs or processing-pipeline modules they have not yet adopted. This maps directly to [[derived systems follow a seed-evolve-reseed lifecycle]] — the seed phase activates a minimal module set, the evolution phase toggles modules on at friction points, and reseeding reconfigures the module selection when accumulated changes drift the system into incoherence. This is fundamentally different from installing a monolithic template and stripping features away — addition is safer than subtraction because addition exposes exactly what is changing, while subtraction requires understanding what will break. But since [[module deactivation must account for structural artifacts that survive the toggle]], even the additive approach has an asymmetric cost: each module enabled at a friction point creates YAML fields, MOC links, and validation rules that persist if the module is later disabled, so the evolutionary cycle of enabling and disabling modules accumulates ghost infrastructure unless modules define both activation and deactivation behaviors. But even additive adoption requires the user to know WHICH modules to enable first, and since [[use-case presets dissolve the tension between composability and simplicity]], presets bridge this gap by bundling curated module selections under use-case labels — the user selects "Research Vault" rather than individually evaluating thirteen modules, and the preset resolves all dimension coupling and dependency chains at once. The composable substrate remains intact underneath: every preset-provided module can be individually toggled after activation, so the preset gives template-level simplicity as an entry point without sacrificing the incremental adoption that composable architecture makes safe.
+
+## Relationship to derivation and methodology traditions
+
+The relationship to derivation is complementary but distinct. Since [[derivation generates knowledge systems from composable research claims not template customization]], derivation traverses the claim graph to decide which configuration choices to make — atomic vs compound notes, heavy vs light processing, deep vs shallow navigation. Composable architecture is what makes those decisions implementable as independent toggles. But the complementarity has an upstream prerequisite: since [[dense interlinked research claims enable derivation while sparse references only enable templating]], the composable research INPUT must meet structural quality thresholds (atomic composability, dense interlinking, methodology provenance, semantic queryability) before the composable architecture OUTPUT can manifest as principled module selection rather than template distribution with modular packaging. Derivation is the intellectual process of choosing; composable architecture is the engineering pattern that makes choices independently activatable. And because [[methodology traditions are named points in a shared configuration space not competing paradigms]], each tradition corresponds to a particular set of enabled modules — Zettelkasten activates atomic-notes, explicit-linking, deep-navigation, and heavy-processing modules while PARA activates hierarchical-folders with lightweight-processing, and the composable architecture makes mixing across traditions possible by decomposing traditions into their constituent module selections. Without composable architecture, derivation would still produce monolithic outputs that resist incremental adoption.
+
+---
+---
+
+Relevant Notes:
+- [[derivation generates knowledge systems from composable research claims not template customization]] — complementary process: derivation decides WHAT configuration to produce by traversing the claim graph, composable architecture decides HOW to implement that configuration as independent toggleable modules
+- [[four abstraction layers separate platform-agnostic from platform-dependent knowledge system features]] — provides the layer hierarchy that module dependencies follow: foundation modules have no dependencies, orchestration modules sit atop the full stack
+- [[hook composition creates emergent methodology from independent single-concern components]] — proof of concept at the hook level: nine hooks composing into quality pipelines and session bookends demonstrates the composability guarantee that this architecture generalizes to all knowledge system modules
+- [[complex systems evolve from simple working systems]] — constrains adoption: modules should be added at friction points rather than enabled speculatively, so the composable architecture requires Gall's Law as a usage discipline
+- [[eight configuration dimensions parameterize the space of possible knowledge systems]] — the dimensions are WHAT varies while modules are HOW those variations get implemented; a module implements a specific choice along one or more dimensions
+- [[the no wrong patches guarantee ensures any valid module combination produces a valid system]] — the Eurorack-derived safety property that makes the architecture practical: any valid subset of enabled modules with satisfied dependencies produces a working system, so incremental adoption is safe by construction
+- [[module communication through shared YAML fields creates loose coupling without direct dependencies]] — the Unix-derived communication mechanism: modules coordinate through shared YAML fields rather than direct calls, making the event-bus pattern that loose coupling depends on
+- [[ten universal primitives form the kernel of every viable agent knowledge system]] — the invariant base layer that foundation modules implement: the kernel is what composable architecture builds upon, never varies, and every module assumes is present
+- [[derived systems follow a seed-evolve-reseed lifecycle]] — the temporal pattern composable architecture enables: seed activates minimal modules, evolution toggles modules at friction points, reseeding reconfigures module selection when drift accumulates
+- [[methodology traditions are named points in a shared configuration space not competing paradigms]] — traditions decompose into module selections: Zettelkasten is one set of enabled modules, PARA is another, and composable architecture makes mixing across traditions possible by treating each tradition as a named configuration point
+- [[blueprints that teach construction outperform downloads that provide pre-built code for platform-dependent modules]] — the distribution format for platform-dependent modules: automation and orchestration modules ship as construction instructions so agents build contextually adapted artifacts
+- [[progressive schema validates only what active modules require not the full system schema]] — extends composability to the validation layer: checking only fields from active modules ensures the validator does not create false violations for inactive features, making incremental adoption safe at the enforcement surface users encounter daily
+- [[implicit dependencies create distributed monoliths that fail silently across configurations]] — the primary anti-pattern: undeclared coupling through conventions, testing context, or co-activation assumptions produces a monolith wearing a modular interface; the dependency resolver only checks declared dependencies, so the fix requires extending declarations to include data dependencies
+- [[each module must be describable in one sentence under 200 characters or it does too many things]] — operationalizes the Unix tradition's 'do one thing' as a measurable design test: description length as a proxy for module scope prevents feature-creep toggles that bundle capabilities users cannot enable independently
+- [[use-case presets dissolve the tension between composability and simplicity]] — the adoption UX layer: presets bundle curated module selections under use-case labels so users get template-level simplicity as entry point while the composable substrate enables post-preset customization through individual module toggles
+- [[module deactivation must account for structural artifacts that survive the toggle]] — the decomposition lifecycle gap: composition is well-handled but decomposition leaves ghost YAML fields, orphaned MOC links, and stale validation rules; modules need both activation and deactivation behaviors to make the toggle truly symmetric
+- [[dependency resolution through topological sort makes module composition transparent and verifiable]] — the computational engine that makes module composition practical: topological sort on the layered DAG resolves transitive dependencies automatically while generating explanations that teach users why modules relate
+- [[dense interlinked research claims enable derivation while sparse references only enable templating]] — the upstream research quality prerequisite: composable architecture is the engineering OUTPUT that makes derivation implementable, but the composable research INPUT must meet four structural thresholds before module selection can be principled rather than arbitrary
+- [[friction-driven module adoption prevents configuration debt by adding complexity only at pain points]] — the lifecycle protocol that operationalizes Gall's Law at module level: concrete thresholds (5-repetition addition, 500-char split, 3-session removal, 15-20 module cap) turn the abstract principle of incremental adoption into a decision procedure
+- [[skill context budgets constrain knowledge system complexity on agent platforms]] — imposes a concrete ceiling on module count: the 2%/16k character budget caps active modules at 15-20, creating pressure toward right-sized granularity that shapes how fine-grained the module decomposition can be
+- [[methodology development should follow the trajectory from documentation to skill to hook as understanding hardens]] — maps onto module shipping formats: foundation modules ship as files (documentation-level), convention modules as instructions, automation modules as blueprints (skill-level), orchestration modules as generated configs (hook-level)
+
+Topics:
+- [[design-dimensions]]
+- [[agent-cognition]]