arscontexta 0.6.0

package/methodology/trails transform ephemeral navigation into persistent artifacts.md

@@ -0,0 +1,39 @@
+---
+description: Named traversal sequences through the knowledge graph could let agents reuse discovered navigation paths across sessions
+kind: research
+topics: ["[[agent-cognition]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# trails transform ephemeral navigation into persistent artifacts
+
+Bush's Memex introduced the concept of trails: named, shareable paths through an information space. When a researcher navigated from topic A through B to insight C, they could save that traversal sequence and share it with others. The trail captured not just the destination but the journey that made the destination meaningful.
+
+For agent-operated vaults, this concept addresses a core tension. When an agent navigates through notes during a session, that path typically vanishes when the session ends. The next session must rediscover the route. Trails would make these paths persistent — a folder containing markdown files that list wiki links in traversal order with annotations about why each step was taken.
+
+Trails assume the paths exist to begin with. But since [[navigational vertigo emerges in pure association systems without local hierarchy]], some semantic neighbors have no link path at all — they're close in meaning but disconnected in graph space. Trails capture successful traversals, but they can't capture the traversals that couldn't happen because the links weren't there. This is why trails complement MOCs rather than replace them: MOCs create the local hierarchy that makes paths exist, trails persist the paths worth reusing.
+
+This directly addresses the session isolation problem described in [[fresh context per task preserves quality better than chaining phases]]. Session isolation preserves quality by giving each task fresh context, but the cost is that navigation discoveries don't persist. Since [[session handoff creates continuity without persistent memory]] through externalized briefings, trails would extend this pattern: a trail is a navigation briefing, capturing not just what was discovered but the path that led there. The agent doesn't remember the route — it reads the trail.
+
+Since [[intermediate packets enable assembly over creation]], trails would function as a new type of packet: navigation packets that structure traversal knowledge for reuse. Packets make session isolation practical by enabling handoffs through files. Trails extend this pattern: instead of just handing off work products, we hand off the navigation paths that produced them.
+
+The key insight from Bush is that trails are not merely bookmarks or link collections. They encode the reasoning that connected the nodes — the "why this, then that" logic that made the traversal productive. Without this reasoning, you have a list of notes. With it, you have reusable navigation knowledge.
+
+Since [[dual-coding with visual elements could enhance agent traversal]], trails represent one of several redundancy strategies for traversal robustness. Trails provide temporal redundancy by persisting successful navigation sequences across sessions. Visual dual-coding provides modal redundancy by encoding relationships in both text and visual form. Both address the question: how do we make traversal more robust when the primary path fails?
+---
+
+Relevant Notes:
+- [[topological organization beats temporal for knowledge work]] — trails only make sense in a topological system; in a stream you navigate by recency, in a garden you navigate by meaning and paths become worth preserving
+- [[fresh context per task preserves quality better than chaining phases]] — describes the session isolation that creates the redundant navigation problem trails would solve
+- [[session handoff creates continuity without persistent memory]] — trails extend the handoff pattern to navigation: work handoffs brief the next session on what was done, navigation handoffs brief the next session on how to get there
+- [[intermediate packets enable assembly over creation]] — trails extend the packet pattern to navigation; packets hand off work products, trails hand off the paths that produced them
+- [[session outputs are packets for future selves]] — the work-product instance that trails extend to navigation: session outputs are the composable packets trails would make navigable, adding the path dimension to what handoffs already preserve as content
+- [[each new note compounds value by creating traversal paths]] — trails are explicit named paths; this note describes implicit paths through wiki links
+- [[spreading activation models how agents should traverse]] — trails would be pre-computed activation paths that skip the spreading computation
+- [[queries evolve during search so agents should checkpoint]] — trails could capture how queries evolved, preserving the checkpoint decisions that led to insight
+- [[dual-coding with visual elements could enhance agent traversal]] — sibling redundancy strategy: trails provide temporal redundancy (path reuse), dual-coding provides modal redundancy (visual + text encoding)
+- [[logic column pattern separates reasoning from procedure]] — sibling reasoning-persistence pattern: trails persist navigation reasoning (why this, then that), logic columns persist procedural reasoning (why this step); both transform ephemeral understanding into reusable artifacts
+- [[navigational vertigo emerges in pure association systems without local hierarchy]] — trails assume paths exist; this note identifies when paths DON'T exist (semantic neighbors with no link path), which is why trails complement rather than replace MOCs
+
+Topics:
+- [[agent-cognition]]

package/methodology/transform universal vocabulary to domain-native language through six levels.md

@@ -0,0 +1,259 @@
+---
+description: How to adapt universal knowledge system concepts to domain-native language during vault generation — the translation layer that makes derived systems feel natural to practitioners
+kind: guidance
+status: active
+topics: ["[[vocabulary-transformation]]"]
+---
+
+# transform universal vocabulary to domain-native language through six levels
+
+The same structural operation goes by different names in different domains. A research vault calls it "claim extraction." A therapy journal calls it "pattern recognition." A project management system calls it "decision documentation." The underlying operation (transforming raw content into structured domain knowledge) is identical — but using the wrong vocabulary makes the system feel foreign to its user.
+
+Since [[schema fields should use domain-native vocabulary not abstract terminology]], vocabulary transformation is the translation layer that makes derived systems feel native to practitioners.
+
+This doc tells the plugin HOW to translate universal concepts into domain language during /setup and vault generation.
+
+## Why Vocabulary Transformation Matters
+
+### Trust
+
+A therapist confronted with `antecedent_conditions:` must first recall what that means in their vocabulary, then translate their thinking, then fill the field. Each translation step erodes trust. The practitioner feels the system doesn't understand their work — and that feeling is correct. The abstract vocabulary literally fails to encode the domain's conceptual distinctions.
+
+When the field says "triggers," the therapist can fill it from their natural professional thinking without detour. The system speaks their language.
+
+### Cognitive Load
+
+Since [[schema fields should use domain-native vocabulary not abstract terminology]], every interaction with abstract terminology forces a translation step that consumes working memory that should be directed at content. Domain-native vocabulary eliminates this translation entirely. The cognitive savings compound across every note created, every query run, every maintenance check reported.
+
+### Adoption
+
+The vocabulary gap is not cosmetic — it is the primary adoption barrier for derived systems. Abstract terminology causes users to misunderstand fields, fill them inconsistently, or abandon the system entirely. Inconsistent filling is particularly insidious because it destroys the entropy reduction that makes metadata queryable in the first place.
+
+## The Ontology-Vocabulary Coupling
+
+Vocabulary carries ontology. When a system uses "antecedent_conditions," it implicitly asserts that therapy operates through abstract causal chains. When it uses "triggers," it acknowledges the embodied, experiential reality of therapeutic work. The vocabulary choice is not neutral — it shapes how the practitioner conceptualizes their domain within the system.
+
+Since [[false universalism applies same processing logic regardless of domain]], vocabulary mismatch is often the visible symptom of a deeper operational mismatch. A therapy system that renames "claim extraction" to "insight extraction" but keeps the same decomposition logic has fixed the vocabulary problem while preserving the operational problem. The insight extraction in therapy is qualitatively different from claim extraction in research — it involves pattern recognition across temporal entries, emotional resonance detection, identification of recurring triggers and coping strategies. These are different operations that happen to occupy the same structural position in the skeleton.
+
+The practical implication: vocabulary transformation without operational adaptation is cosmetic derivation. The plugin must translate both the names AND the operations.
+
+## The Universal-to-Domain Translation
+
+The plugin maintains a translation table from universal kernel concepts to domain-specific vocabulary. Since [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]], the skeleton is invariant — capture, process, connect, verify. The names are adaptive.
+
+### Core Operation Translations
+
+| Universal Operation | Research | Therapy | PM | Creative | Learning | Trading |
+|-------------------|----------|---------|------|----------|----------|---------|
+| Capture | Record source | Journal entry | Meeting notes | Inspiration spark | Lecture notes | Trade journal |
+| Process (extract) | Claim extraction | Pattern detection | Decision documentation | Consistency check | Concept mapping | Thesis tracking |
+| Connect (reflect) | Citation linking | Trigger-pattern correlation | Stakeholder impact mapping | Character relationship mapping | Prerequisite linking | Correlation analysis |
+| Verify | Schema validation | Growth tracking | Risk assessment review | Continuity verification | Mastery assessment | Strategy compliance check |
+| Maintain (reweave) | Literature review update | Coping strategy reassessment | Risk register refresh | Worldbuilding bible update | Prerequisite graph revision | Thesis invalidation check |
+
+### Note Type Translations
+
+| Universal Type | Research | Therapy | PM | Creative | Learning | Trading |
+|---------------|----------|---------|------|----------|----------|---------|
+| Claim note | Finding / Hypothesis | Pattern record | Decision log entry | Canon fact | Concept note | Trade thesis |
+| Source note | Literature reference | Session notes | Meeting minutes | Reference material | Lecture notes | Market analysis |
+| Tension note | Research contradiction | Ambivalence record | Risk assessment | Continuity error | Prerequisite conflict | Thesis contradiction |
+| MOC | Literature review | Pattern overview | Project dashboard | Story bible | Course map | Strategy overview |
+| Synthesis note | Meta-analysis | Growth insight | Lessons learned | Thematic analysis | Transfer insight | Strategy review |
+
+### Schema Field Translations
+
+Since [[schema field names are the only domain specific element in the universal note pattern]], field names carry the entire burden of domain adaptation. The five-component note architecture (prose title, YAML frontmatter, body, wiki links, topics footer) is domain-invariant — only the YAML field names change.
+
+| Universal Field | Research | Therapy | PM | Health | Legal |
+|----------------|----------|---------|------|--------|-------|
+| description | description | description | description | description | description |
+| classification | methodology | mood | status | symptom_type | matter_type |
+| source | source | session_date | project | date | jurisdiction |
+| confidence | evidence_quality | intensity | priority | severity | precedent_strength |
+| status | preliminary/open | active/resolved | pending/done | acute/chronic | open/closed |
+| related | relevant_notes | related_patterns | stakeholders | correlated_symptoms | related_matters |
+
+## YAML Field Naming Conventions
+
+### When to Keep Universal Terms
+
+Some fields work universally and should NOT be translated:
+
+- `description` — every domain uses this word naturally
+- `topics` — structural field, not domain-facing
+- `type` — structural classification
+- `created` / `updated` — temporal metadata
+- `relevant_notes` — structural linking (though the context phrases within should use domain language)
+
+**The principle:** Structural fields that describe the note's role in the system keep universal names. Domain fields that describe the note's content use domain-native names.
+
+### When to Transform
+
+Transform fields that describe domain content:
+
+| Signal | Action |
+|--------|--------|
+| Practitioners have a natural term for this concept | Use their term |
+| The universal term requires mental translation | Transform |
+| The field appears in user-facing output (queries, reports) | Transform |
+| The field is never shown to users (internal routing) | Keep universal |
+
+### Naming Rules
+
+1. **Use snake_case** for multi-word field names: `coping_strategy`, not `copingStrategy` or `Coping Strategy`
+2. **Use singular nouns** for single-value fields: `mood`, not `moods`
+3. **Use plural for arrays**: `triggers: ["rejection", "conflict"]`
+4. **Prefer short names**: `mood` over `emotional_state_rating`
+5. **Match the domain's vocabulary exactly**: if therapists say "triggers," use `triggers`, not `activating_events`
+6. **Avoid abbreviations** unless the domain uses them: `adr` is fine for engineering (Architecture Decision Record), `sess_dt` is not fine for therapy
+
+### Enum Values Follow the Same Principle
+
+Field names and their valid values should both speak domain language:
+
+```yaml
+# Research
+methodology: ["Zettelkasten", "Cognitive Science", "PKM Research"]
+classification: open | closed
+
+# Therapy
+mood: [1-10]
+pattern_type: ["trigger-response", "cognitive distortion", "attachment pattern"]
+
+# Trading
+market_regime: ["trending", "ranging", "volatile", "transitioning"]
+conviction_level: ["high", "moderate", "speculative"]
+```
+
+## Vocabulary Discovery Protocol
+
+During /setup, the plugin discovers domain vocabulary through conversation:
+
+### Step 1: Domain Identification
+Ask what the user does. Listen for domain-specific terms they naturally use. A therapist says "session notes" not "source capture." A trader says "thesis" not "hypothesis."
+
+### Step 2: Vocabulary Mapping
+Map the user's natural terms to universal operations:
+- "I want to track my trades and see what I'm doing wrong" -> capture = trade journal, process = trade review, verify = strategy compliance
+- "I need to keep my worldbuilding consistent" -> capture = canon entry, process = consistency check, verify = continuity validation
+
+### Step 3: Template Generation
+Generate note templates using the user's vocabulary:
+```yaml
+# For a therapy user:
+---
+description: [what this reflection is about]
+mood: [1-10 scale]
+triggers: ["trigger1", "trigger2"]
+coping_used: ["strategy1"]
+---
+
+# NOT this (abstract vocabulary):
+---
+description: [what this claim is about]
+classification: [category]
+variables: ["var1", "var2"]
+methods_applied: ["method1"]
+---
+```
+
+### Step 4: Skill Language Adaptation
+Pipeline skills should speak the domain's language in their output:
+- Research /reduce: "Extracted 5 claims and 2 enrichments from this paper"
+- Therapy /reduce: "Identified 3 patterns and 1 coping strategy update from this journal entry"
+- PM /reduce: "Documented 2 decisions and 4 action items from this meeting"
+- Creative /reduce: "Found 2 canon facts and 1 continuity issue from this chapter draft"
+- Trading /reduce: "Captured 1 new thesis and 2 observation updates from today's review"
+
+This applies to error messages, maintenance reports, and suggestions too. A therapy vault's staleness warning should say "Pattern overview not reviewed against recent journal entries" not "MOC has stale notes."
+
+## The Translation Boundary
+
+Some concepts translate; some don't. The plugin must recognize both:
+
+### Concepts That Translate Directly
+- Capture (exists in every domain)
+- Connection finding (universal)
+- Schema validation (universal)
+- MOC navigation (universal, though MOC section names vary)
+- Maintenance checks (universal)
+
+### Concepts That Need Adaptation
+- Processing intensity (varies by domain)
+- Review cadence (varies by consequence speed)
+- Link semantics (research uses "extends/contradicts", therapy uses "triggers/alleviates")
+- MOC section headings (research: "Tensions" vs therapy: "Active Patterns" vs PM: "Open Risks")
+
+### Concepts That Don't Transfer
+- Specific processing logic (research claim extraction is not the same as therapy pattern detection)
+- Domain-specific validation rules (legal citation format is not the same as academic citation format)
+- Agent tone (therapy requires warmth; engineering requires precision)
+- Domain-specific maintenance checks (plot thread tracking vs citation integrity vs trade thesis validity)
+
+## Relationship Type Vocabulary
+
+Wiki links carry relationship semantics. Different domains express relationships differently:
+
+| Universal | Research | Therapy | PM | Creative | Legal |
+|-----------|----------|---------|------|----------|-------|
+| extends | extends | deepens insight | builds on | develops further | follows from |
+| contradicts | contradicts | conflicts with | overrides | breaks continuity | distinguishes |
+| enables | foundation for | prerequisite for | unblocks | enables scene | establishes precedent |
+| causes | evidence for | triggers | leads to | causes plot event | gives rise to |
+| part of | component of | aspect of | deliverable in | element of | falls under |
+
+**Implementation:** The plugin generates relationship type enums during /setup based on the domain's natural language for these connections. The context phrases in MOC links and relevant_notes fields use these domain-specific relationship terms.
+
+## Cross-Domain Translation
+
+When users have multiple domains, vocabulary creates a cross-domain challenge. Each domain uses different terms for structurally equivalent operations. The resolution is layered vocabulary:
+
+- **Surface layer (user-facing):** Domain-native vocabulary in templates, skill output, maintenance reports
+- **Meta layer (system-facing):** Universal vocabulary for cross-domain analysis, reconciliation, and multi-domain queries
+
+This means the plugin maintains the translation table in both directions. It can convert "pattern detection" back to "process" when needed for cross-domain comparison, while always presenting "pattern detection" to the therapy user.
+
+Since [[multi-domain systems compose through separate templates and shared graph]], the graph layer operates on universal components (wiki links, MOC hierarchy, topics) while templates isolate the domain-specific vocabulary. Cross-domain links work because the graph never sees field names — it traverses through titles, links, and topics, all of which are domain-invariant.
+
+## Anti-Patterns
+
+| Anti-Pattern | Why It Fails | Better Approach |
+|-------------|-------------|-----------------|
+| Using universal vocabulary for everything | System feels foreign, user disengages | Translate to domain language |
+| Inventing new vocabulary | User doesn't recognize their own workflow | Use the user's existing terms |
+| Inconsistent translation | Same concept called different things in different places | Establish translation table at /setup, use consistently |
+| Translating structure along with vocabulary | Universal structure (capture/process/connect/verify) is invariant | Translate names only, keep structural patterns |
+| Over-translating | Some terms (description, topics) work universally | Only translate where domain language genuinely differs |
+| Vocabulary without operational adaptation | Cosmetic derivation — wrong operations with right names | Translate operations alongside vocabulary |
+
+## Domain Examples
+
+These domain compositions demonstrate vocabulary transformation in practice:
+
+- [[therapy journal uses warm personality with pattern detection for emotional processing]] — Capture becomes "journal entry," process becomes "pattern detection," and the schema uses `mood`, `triggers`, `coping_used` instead of abstract `classification`, `variables`, `methods_applied`
+- [[trading uses conviction tracking with thesis-outcome correlation]] — Claims become "trade theses," connections become "correlation analysis," and `conviction_level`, `thesis_status`, `market_regime` replace generic metadata fields
+- [[legal case management uses precedent chains with regulatory change propagation]] — MOCs become "matter dashboards," maintenance becomes "precedent chain monitoring," and `jurisdiction`, `precedent_strength`, `opposing_arguments` reflect legal practitioner vocabulary
+- [[creative writing uses worldbuilding consistency with character tracking]] — Notes become "canon facts," verification becomes "continuity checking," and `canon_status`, `characters_involved`, `timeline_position` speak the fiction writer's language
+- [[student learning uses prerequisite graphs with spaced retrieval]] — Processing becomes "concept mapping," MOCs become "course maps," and `mastery_level`, `prerequisites`, `retrieval_strength` reflect learning science vocabulary
+- [[health wellness uses symptom-trigger correlation with multi-dimensional tracking]] — Captures become "tracking entries," processing becomes "pattern analysis," and `symptom_type`, `severity`, `correlated_symptoms` match how health-conscious practitioners think about their data
+
+## Grounding
+
+This guidance is grounded in:
+- [[schema fields should use domain-native vocabulary not abstract terminology]] — the foundational vocabulary principle
+- [[schema field names are the only domain specific element in the universal note pattern]] — where domain specificity lives
+- [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]] — universal structure with domain-variable naming
+- [[methodology traditions are named points in a shared configuration space not competing paradigms]] — traditions as vocabulary for shared operations
+- [[false universalism applies same processing logic regardless of domain]] — the trap of not translating deeply enough
+- [[multi-domain systems compose through separate templates and shared graph]] — cross-domain vocabulary challenges
+
+---
+
+Topics:
+- [[index]]
+- [[index]]
+---
+
+Topics:
+- [[vocabulary-transformation]]

package/methodology/type field enables structured queries without folder hierarchies.md

@@ -0,0 +1,53 @@
+---
+description: Content-kind metadata (claim, synthesis, tension) provides a query axis orthogonal to wiki link topology, enabling "find all synthesis notes about X" without folder trees
+kind: research
+topics: ["[[discovery-retrieval]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# type field enables structured queries without folder hierarchies
+
+Traditional knowledge systems use folders to categorize content by kind: a folder for sources, a folder for synthesis, a folder for drafts. This works but creates a problem: each note can only live in one folder, so you choose between organizing by topic or organizing by type. The folder hierarchy forces a single taxonomic axis. Since [[topological organization beats temporal for knowledge work]], flat structure with wiki links is already preferable — but flat structure alone doesn't provide category-based retrieval. Type metadata fills that gap.
+
+Type metadata dissolves this trade-off. Since [[faceted classification treats notes as multi-dimensional objects rather than folder contents]], each YAML field is an independent classification dimension -- a facet in Ranganathan's terminology. Type is one such facet: when each note carries a `type:` field (claim, synthesis, tension, methodology, problem, learning), you can query by content kind without folder structure. Want all tension notes? `rg "^type: tension"`. Want synthesis notes about retrieval? Search the thinking folder for synthesis type and retrieval keywords. The flat folder stays flat while structured queries become possible.
+
+This matters for agent navigation because since [[role field makes graph structure explicit]], agents already have a dimension describing WHERE a note sits in the graph. Type provides an orthogonal dimension describing WHAT KIND of content it is. A note can be:
+
+- A claim (type) that functions as a hub (role)
+- A synthesis (type) that functions as a leaf (role)
+- A methodology note (type) that functions as a moc (role)
+
+Neither dimension collapses into the other. Role tells you how to traverse. Type tells you what you're reading.
+
+The query patterns this enables:
+
+| Query | Command | What It Finds |
+|-------|---------|---------------|
+| All methodology notes | `rg "^type: methodology"` | Implementation patterns, features to build |
+| All problems | `rg "^type: problem"` | Anti-patterns, failure modes |
+| Unresolved tensions | `rg "^type: tension" -l \| xargs rg "^status: open"` | Conflicts needing resolution |
+| Synthesis about X | `qmd query "X" + type: synthesis` | High-level arguments on topic |
+
+Without type metadata, you'd need either folder hierarchies (limiting notes to one category) or manual list maintenance (tracking "all synthesis notes" in a separate file). Type metadata makes the category intrinsic to the note, queryable anywhere, without forcing hierarchical organization.
+
+Since [[live index via periodic regeneration keeps discovery current]], type-based queries become even more powerful when pre-computed. A maintenance agent can regenerate type indices at change boundaries, giving agents instant access to "all methodology notes" or "all unresolved tensions" without the query cost at decision time. The query patterns above work with JIT ripgrep, but pre-computed type indices would make them free to load.
+
+Type metadata is a concrete instance of what since [[markdown plus YAML plus ripgrep implements a queryable graph database without infrastructure]] identifies as the broader pattern: each YAML field is a queryable property in a graph database where ripgrep replaces SQL. The `rg "^type: tension"` query pattern this note demonstrates is functionally equivalent to a graph database property query, and when combined with other YAML field filters (methodology, topics, status), the piped commands achieve the multi-attribute precision that graph database query languages provide through WHERE clause conjunction.
+
+The design decision in this vault treats type as optional for standard claims because claims are the default. You only add `type:` when the note is something other than a straightforward assertion. This keeps YAML minimal while enabling structured queries when needed. Since [[descriptions are retrieval filters not summaries]], the type field adds an orthogonal retrieval dimension: descriptions filter by relevance to a query, while type filters by content kind. An agent asking "find methodology notes about X" can filter first by type, then by semantic relevance — two independent axes that multiply filtering power.
+---
+
+Relevant Notes:
+- [[markdown plus YAML plus ripgrep implements a queryable graph database without infrastructure]] — synthesis: type is one queryable property in the four-layer graph database; the ripgrep query patterns this note demonstrates are property queries on graph nodes
+- [[role field makes graph structure explicit]] — the orthogonal dimension: role describes graph position while type describes content kind
+- [[metadata reduces entropy enabling precision over recall]] — type metadata increases precision when searching for specific content kinds
+- [[topological organization beats temporal for knowledge work]] — the foundational choice that makes type metadata necessary: flat folders need queryable dimensions
+- [[associative ontologies beat hierarchical taxonomies because heterarchy adapts while hierarchy brittles]] — explains WHY flat structure plus type metadata works: associative relationships adapt while folder hierarchies brittle
+- [[descriptions are retrieval filters not summaries]] — descriptions and type are complementary filter dimensions: relevance vs content kind
+- [[maturity field enables agent context prioritization]] — sibling metadata proposal: maturity tracks development stage while type tracks content kind
+- [[question-answer metadata enables inverted search patterns]] — sibling metadata proposal: questions enable inverted search while type enables category filtering
+- [[live index via periodic regeneration keeps discovery current]] — pre-computed type indices make category queries free at decision time
+- [[faceted classification treats notes as multi-dimensional objects rather than folder contents]] — theoretical framework: type is one facet in Ranganathan's multi-dimensional classification; the PMEST framework explains why each metadata field is an independent query dimension and provides the independence test for new fields
+
+Topics:
+- [[discovery-retrieval]]

package/methodology/use-case presets dissolve the tension between composability and simplicity.md

@@ -0,0 +1,44 @@
+---
+description: Curated module selections for common use cases (Research Vault, PKM, Project Management) give template-level simplicity as entry point while preserving underlying composability — but users who
+kind: research
+topics: ["[[design-dimensions]]"]
+confidence: speculative
+methodology: ["Original", "Systems Theory"]
+source: [[composable-knowledge-architecture-blueprint]]
+---
+
+# use-case presets dissolve the tension between composability and simplicity
+
+Composable knowledge architectures face a persistent adoption problem. Since [[composable knowledge architecture builds systems from independent toggleable modules not monolithic templates]], the architecture treats each capability as an independent toggle with explicit dependencies — which is precisely what makes it powerful and precisely what makes it intimidating. A new user confronting a module catalog with dozens of independently activatable capabilities faces a decision surface that rivals the raw dimension questions that [[configuration paralysis emerges when derivation surfaces too many decisions]] describes. The composable architecture solved the engineering problem of monolithic templates but may have recreated the UX problem in different clothing: instead of "pick a template and strip what you don't need," it becomes "pick modules and hope you chose enough."
+
+Presets propose a dissolution. A preset is a curated module selection for a common use case — "Research Vault" activates thirteen modules covering the full pipeline from capture through semantic search, "Personal Knowledge Management" activates nine modules emphasizing capture and organization, "Project Management" activates seven structure-focused modules, and "Minimal" activates only the three foundation modules. The user selects a use-case label, not a module list. The preset resolves all the dimension questions that the use case implies, and because [[configuration dimensions interact so choices in one create pressure on others]], those questions are not independent — choosing atomic granularity forces explicit linking, which demands deep navigation, which requires heavy processing. The preset author resolved these coupling constraints once: Research Vault chooses atomic granularity, explicit linking, deep navigation, heavy processing, and the corresponding modules that implement those choices. The user gets template-level simplicity — one choice produces a working system — while the underlying composability remains intact because the preset is just a named configuration of independently toggleable modules, not a monolithic artifact.
+
+What makes this more than a template rebrand is the relationship between presets and post-activation customization. Templates are subtractive — start with everything, remove what you do not need, which requires understanding what everything does before you can judge what to remove. Presets are additive — start with what the use case requires, add modules when friction signals that something is missing. Since [[the no wrong patches guarantee ensures any valid module combination produces a valid system]], each post-preset toggle is safe by construction. Adding a module cannot corrupt existing data. Removing a module returns the system to a known valid state. This means the user can treat the preset as a starting point and modify without fear, because the architecture guarantees that any valid combination works. The progressive nature extends to validation too: since [[progressive schema validates only what active modules require not the full system schema]], a preset that activates fewer modules means fewer validation demands, so the user's daily experience matches the system's actual complexity rather than its theoretical maximum.
+
+The connection to the seed-evolve-reseed lifecycle is direct. Since [[derived systems follow a seed-evolve-reseed lifecycle]], presets ARE the seeding mechanism — they produce the minimum viable configuration for a use case, with evolution guidelines encoding when to add complexity. A Research Vault preset user who starts writing notes and discovers they need project tracking can enable the project-management module at the moment of friction, not during initial setup when the need was hypothetical — and since [[dependency resolution through topological sort makes module composition transparent and verifiable]], the resolver explains what else needs enabling and why, turning each friction-triggered addition into architectural education. Since [[premature complexity is the most common derivation failure mode]], presets enforce the complexity budget by activating only what the use case justifies, leaving the research graph's additional insights available as evolution guidelines rather than upfront deployment. This is progressive disclosure applied to system architecture: since [[progressive disclosure means reading right not reading less]], the user absorbs complexity through use rather than comprehending it during configuration.
+
+Presets also relate to methodology traditions as parallel naming strategies. Since [[methodology traditions are named points in a shared configuration space not competing paradigms]], traditions are community-validated dimension choices (Zettelkasten means atomic + explicit linking + deep navigation). Presets are architecturally-validated module selections (Research Vault means yaml-schema + wiki-links + atomic-notes + mocs + processing-pipeline + semantic-search + ...). Both reduce the configuration surface by naming coherent bundles. The difference is granularity: traditions name dimension choices in the abstract configuration space, presets name module selections in the concrete implementation space. A Research Vault preset could implement a Zettelkasten-derived configuration, making presets the operational implementation of tradition-informed derivation.
+
+The claim is classified as open because the dissolution may be incomplete. Users who start with a preset and evolve through friction eventually face a system they did not design from first principles. The preset handled initial decisions, but evolution changes the module selection incrementally, and the user may reach a configuration that no longer matches any preset — a custom system without the understanding that custom composition would have built. This is a deferred onboarding cliff: the preset eliminated upfront complexity, but the user must still develop module-level understanding to evolve effectively. Whether presets truly dissolve the composability-simplicity tension or merely postpone the moment when composability's cognitive demands arrive depends on whether the evolution phase builds the understanding that upfront composition would have required. Two mechanisms work in favor of dissolution: since [[justification chains enable forward backward and evolution reasoning about configuration decisions]], a user can trace any preset-provided module back through the claims that justified it, building understanding through backward reasoning rather than forward construction, and since [[evolution observations provide actionable signals for system adaptation]], the six diagnostic patterns convert vague friction into specific structural responses, so the user learns which modules to add or reconfigure through structured signals rather than guesswork. Since [[derived systems follow a seed-evolve-reseed lifecycle]], the evolution guidelines embedded in the seed context are designed to build this understanding incrementally — each friction-triggered module addition teaches the user about that specific capability in context. But this is a hypothesis about learning through friction, not a demonstrated result. The difference between dissolving a tension and deferring it may only become visible at the reseeding phase, when the user must reason about their system's configuration as a whole rather than one module at a time.
+
+---
+---
+
+Relevant Notes:
+- [[configuration paralysis emerges when derivation surfaces too many decisions]] — the problem presets solve: paralysis arises from surfacing every dimension as a question, and presets eliminate most questions by bundling dimension choices into a use-case label
+- [[composable knowledge architecture builds systems from independent toggleable modules not monolithic templates]] — the architecture presets operate within: presets are named module selections, not monolithic templates, so the individual modules remain independently toggleable after the preset provides the initial configuration
+- [[premature complexity is the most common derivation failure mode]] — presets calibrate the complexity budget: a well-designed preset activates only the modules justified for its use case, avoiding the structural incentive to front-load every research-justified choice
+- [[the no wrong patches guarantee ensures any valid module combination produces a valid system]] — the safety property that makes preset customization non-destructive: toggling individual modules after a preset activates or deactivates them cannot corrupt data because the guarantee covers all valid combinations
+- [[derived systems follow a seed-evolve-reseed lifecycle]] — presets are the seeding mechanism: they provide minimum viable configuration for a use case, with the expectation that friction-driven evolution will customize the module selection over time
+- [[methodology traditions are named points in a shared configuration space not competing paradigms]] — presets and traditions serve parallel functions as named configurations: traditions bundle dimension choices validated by community practice, presets bundle module selections validated by architectural analysis
+- [[progressive schema validates only what active modules require not the full system schema]] — enables presets to start clean: a minimal preset activates few modules, so the user encounters only the validation requirements those modules declare
+- [[progressive disclosure means reading right not reading less]] — the cognitive principle presets implement at the system level: users absorb system complexity progressively through use rather than comprehending it upfront during configuration
+- [[implicit dependencies create distributed monoliths that fail silently across configurations]] — the testing-context risk presets amplify: because presets bundle modules into convenient configurations, developers naturally test against preset combinations rather than in isolation, causing modules to silently depend on fields and conventions that other preset-bundled modules provide
+- [[configuration dimensions interact so choices in one create pressure on others]] — why presets can be curated at all: dimension coupling means a use-case label implies a coherent region of the configuration space, so the preset author resolves the coupling constraints once rather than requiring each user to navigate the interaction pressures independently
+- [[justification chains enable forward backward and evolution reasoning about configuration decisions]] — mitigates the deferred onboarding cliff: backward reasoning lets a user who started with a preset trace each module choice to the claims and constraints that justified it, building the understanding that upfront composition would have provided but through inspection rather than construction
+- [[evolution observations provide actionable signals for system adaptation]] — the diagnostic mechanism for preset evolution: when a preset user encounters friction, the six diagnostic patterns identify whether the symptom signals a missing module, an over-modeled type, or a processing mismatch, converting vague friction into specific module-level action
+- [[dependency resolution through topological sort makes module composition transparent and verifiable]] — the computational engine that makes preset activation practical: selecting a use-case label triggers topological sort on the module DAG, resolving transitive dependencies automatically and producing explanations that teach the user why modules relate
+- [[friction-driven module adoption prevents configuration debt by adding complexity only at pain points]] — the post-preset evolution mechanism: presets provide curated starting points, and subsequent module additions follow friction signals rather than preset recommendations, making friction-driven adoption the evolution phase that personalizes the preset's initial configuration
+
+Topics:
+- [[design-dimensions]]

package/methodology/vault conventions may impose hidden rigidity on thinking.md

@@ -0,0 +1,44 @@
+---
+description: Accumulated vault conventions may channel thinking into patterns that favor certain styles over others, despite the flat structure's stated flexibility
+kind: research
+topics: ["[[note-design]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# vault conventions may impose hidden rigidity on thinking
+
+The system claims flexibility through flat structure and wiki links. But conventions accumulate into constraints. The claim-as-title pattern requires thinking to resolve into sentence form. The YAML schema requires metadata decisions. The MOC structure imposes hierarchical organization. Each convention individually seems lightweight, but collectively they may channel thinking into patterns that favor certain styles over others.
+
+There is a counterargument worth considering: since [[complex systems evolve from simple working systems]], the system conventions emerged from actual friction rather than upfront design. Conventions that calcified from working patterns might be genuine solutions, not arbitrary constraints. The test becomes: are current conventions still solving real problems, or have they become obstacles to new kinds of thinking? For schema conventions specifically, since [[schema evolution follows observe-then-formalize not design-then-enforce]], the observe-then-formalize protocol provides a concrete mechanism for keeping schema conventions adaptive — fields are added only when usage evidence justifies them and demoted when placeholder stuffing reveals false compliance, so at least the schema layer resists the calcification this note warns about.
+
+Since [[schema enforcement via validation agents enables soft consistency]], there may be a middle path between rigid conventions and no conventions: soft enforcement that encourages patterns without blocking deviations. Validation agents that warn about non-standard titles or missing metadata create pressure toward convention compliance without making compliance mandatory. This shifts conventions from hard constraints that might impose hidden rigidity to soft expectations that shape behavior through visibility rather than blocking.
+
+The research on Cornell note-taking finds that rigid formats "struggle to accommodate visual learners" and "non-linear topics." The fixed layout constrains what can be expressed. Does the system inherit this problem through different means?
+
+Beyond temporal escape valves (mutability, backward maintenance), there is a structural one. Since [[federated wiki pattern enables multi-agent divergence as feature not bug]], when conventions channel an insight into a form that loses nuance, a parallel note can preserve the alternative formulation. The two notes linked together capture more than either alone, and neither has to violate the conventions — each can follow the claim-as-title pattern while expressing a different facet of the same complex idea. This doesn't dissolve the rigidity concern, but it provides a concrete mechanism for working within conventions while acknowledging their limits.
+
+The high-leverage question: when an insight resists the claim-as-title pattern, is it because the insight is genuinely non-linear, or because the articulation isn't complete yet?
+
+The high-leverage question: if forced reformulation always indicates incomplete thinking, then conventions are helpful constraints that push toward understanding before building. If forced reformulation sometimes destroys valid non-linear insight, then conventions impose genuine rigidity.
+
+The Cornell critique applied to visual learners and non-linear topics. The system is text-based by design. The real question may be: is text itself the constraint, or is it specifically how we structure text?
+
+Since [[dual-coding with visual elements could enhance agent traversal]], the text-based constraint might be partially addressable. Mermaid diagrams and relationship graphs could provide visual encoding for concepts that resist text-only expression. Whether this would reduce rigidity depends on whether the visual/verbal separation that aids human cognition translates to multimodal LLM processing — if visual input just gets converted to the same latent space as text, dual-coding may not provide the flexibility benefit it offers humans.
+---
+
+Relevant Notes:
+- [[claims must be specific enough to be wrong]] — the claim-as-title pattern demands specificity, which may be the source of both value and constraint
+- [[complex systems evolve from simple working systems]] — counterargument: conventions emerged from working patterns, so they may be solutions rather than arbitrary constraints
+- [[backward maintenance asks what would be different if written today]] — potential dissolution: rigid creation conventions might be offset by flexible maintenance allowing evolution
+- [[schema templates reduce cognitive overhead at capture time]] — the tradeoff made concrete: schema templates reduce cognitive overhead when they fit the content, but impose hidden rigidity when they don't
+- [[dual-coding with visual elements could enhance agent traversal]] — proposes visual encoding as partial remedy for text-based constraints, though benefit depends on whether multimodal processing is genuinely distinct
+- [[schema enforcement via validation agents enables soft consistency]] — offers middle path: soft enforcement via warnings preserves flexibility while encouraging convention compliance through visibility rather than blocking
+- [[sense-making vs storage does compression lose essential nuance]] — sibling concern at the description layer: this note asks whether titles resist compression, that note asks whether descriptions resist compression; both test whether complex ideas survive the filtering architecture
+- [[digital mutability enables note evolution that physical permanence forbids]] — theoretical escape valve: even if creation conventions impose rigidity, the medium permits notes to evolve past their initial form through backward maintenance
+- [[federated wiki pattern enables multi-agent divergence as feature not bug]] — structural escape valve: when conventions compress an insight into one canonical form that loses nuance, a parallel federated note can preserve the alternative formulation; provides an explicit mechanism for escaping convention rigidity without abandoning conventions entirely
+- [[schema evolution follows observe-then-formalize not design-then-enforce]] — partial dissolution for schema conventions: rather than imposing rigid schema requirements upfront, the observe-then-formalize protocol lets conventions emerge from use, reducing the hidden rigidity risk by ensuring schema fields are justified by observed demand rather than speculative design
+- [[description quality for humans diverges from description quality for keyword search]] — concrete evidence: the prose description convention implicitly optimizes for human scanning while imposing a hidden constraint on keyword retrieval that only surfaces during infrastructure failures
+- [[organic emergence versus active curation creates a fundamental vault governance tension]] — sibling governance tension: this note asks whether conventions constrain thinking, that note asks whether the governance model that creates and enforces conventions strikes the right balance; the curation pole actively creates conventions, so the rigidity concern is a specific failure mode of over-curation
+
+Topics:
+- [[note-design]]

package/methodology/verbatim risk applies to agents too.md

@@ -0,0 +1,31 @@
+---
+description: Agents can compress content into structured output that looks like synthesis but contains no genuine insight—the agent equivalent of passive verbatim note-taking
+kind: research
+topics: ["[[agent-cognition]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# verbatim risk applies to agents too
+
+Cornell Note-Taking warns that without active processing, note-taking degenerates into passive transcription. The student copies words without engaging with meaning. The notes look complete but the learning didn't happen.
+
+The agent equivalent: an agent compresses a transcript into bullet points, reorganizes content under headings, or extracts "key points" — all without generating anything the source didn't already contain. The structure looks right. The output appears processed. But no synthesis occurred: no connections found, no claims sharpened, no implications drawn. Since [[ThreadMode to DocumentMode transformation is the core value creation step]], this is ThreadMode content dressed in DocumentMode clothing — the output has the formatting of timeless synthesis but the cognitive substance of chronological reorganization, because no genuine transformation occurred.
+
+This matters because since [[the generation effect requires active transformation not just storage]], processing without generation creates the illusion of value while producing none. The system accumulates well-formatted summaries that don't compound because they contain no original insight to connect. Since [[insight accretion differs from productivity in knowledge systems]], verbatim risk is exactly the productivity-without-accretion failure mode: the agent achieves high productivity (many outputs, fast processing, organized structure) while zero accretion occurs (no deepening of understanding, no genuine insight, no cognitive hooks created). Since [[structure without processing provides no value]], the Lazy Cornell anti-pattern proves this: students who drew the structural lines but skipped the processing steps gained nothing over linear notes. Agents doing structural reorganization without synthesis commit the same error at higher throughput.
+
+The risk compounds at scale because since [[intermediate packets enable assembly over creation]], the packet workflow is where verbatim risk manifests most dangerously. Agents can produce packets that look composable — structured, well-formatted, properly linked — but contain only reorganized content rather than genuine building blocks. Assembly from such packets produces a structure of summaries, not a structure of insights.
+
+This claim forms a sibling trio with [[cognitive outsourcing risk in agent-operated systems]] and [[productivity porn risk in meta-system building]]. All three identify different failure modes in agent-operated systems: verbatim risk concerns agent output quality, cognitive outsourcing concerns human capability atrophy, productivity porn concerns whether building becomes procrastination. Each can undermine the system in distinct ways — they are orthogonal failure dimensions.
+---
+
+Relevant Notes:
+- [[insight accretion differs from productivity in knowledge systems]] — names the dichotomy: verbatim risk is exactly the productivity-without-accretion failure mode at agent scale; high productivity metrics while zero accretion occurs
+- [[the generation effect requires active transformation not just storage]] — establishes that generation creates value; this identifies the failure mode when generation doesn't occur
+- [[structure without processing provides no value]] — the Lazy Cornell anti-pattern is exactly what verbatim risk describes: structural motions that look processed but contain no generative work
+- [[intermediate packets enable assembly over creation]] — the packet workflow is where verbatim risk manifests at scale: agents can produce packets that look composable but contain only reorganized content, not genuine building blocks
+- [[cognitive outsourcing risk in agent-operated systems]] — sibling claim testing human capability atrophy; forms a failure mode trio with productivity porn
+- [[productivity porn risk in meta-system building]] — sibling claim testing whether building becomes procrastination; orthogonal to verbatim risk but emerges from same source
+- [[ThreadMode to DocumentMode transformation is the core value creation step]] — names the specific failure: ThreadMode with DocumentMode formatting is exactly what verbatim risk produces — well-structured reorganization that has the appearance of synthesis but generates no new understanding
+
+Topics:
+- [[agent-cognition]]

package/methodology/vibe notetaking is the emerging industry consensus for AI-native self-organization.md

@@ -0,0 +1,56 @@
+---
+description: The "dump and AI organizes" pattern converges across tools, but most implementations use opaque embeddings while agent-curated wiki links produce explicit traversable structure that avoids connection
+kind: research
+topics: ["[[processing-workflows]]", "[[agent-cognition]]"]
+methodology: ["PKM Research", "Original"]
+source: [[tft-research-part3]]
+---
+
+# vibe notetaking is the emerging industry consensus for AI-native self-organization
+
+The AI-native knowledge management landscape is converging on a single paradigm: the user dumps unstructured content, and the AI handles indexing, tagging, and linking. Research across tools and platforms identifies "self-organization" as the defining characteristic of the next generation of knowledge systems. This is vibe notetaking — capture without ceremony, structure without effort, organization as an emergent property of AI processing rather than a human discipline. Because [[AI shifts knowledge systems from externalizing memory to externalizing attention]], what vibe notetaking actually attempts is not just storing content but externalizing the decision of what to attend to — surfacing, filtering, and directing focus rather than merely filing and retrieving.
+
+The convergence is real. Tools from Notion AI to Mem to Supermemory to Reflect all implement variants of the same pattern: accept whatever the user throws in, apply some AI processing, surface structure that the user never had to create manually. Since [[cognitive offloading is the architectural foundation for vault design]], this consensus is theoretically sound — Clark and Chalmers' Extended Mind thesis plus Risko and Gilbert's offloading economics predict exactly this outcome. When AI drives capture friction close to zero, the rational choice is always to externalize. Vibe notetaking is what cognitive offloading looks like when the technology catches up to the theory. The purest expression of this consensus is voice-first capture: since [[voice capture is the highest-bandwidth channel for agent-delegated knowledge systems]], speaking at 150 wpm triples typing throughput while preserving emotional markers that inform agent extraction. Voice is vibe notetaking's ideal input channel — zero ceremony, maximum bandwidth, and the paraverbal signals provide priority metadata that typed dumps lack.
+
+But the convergence masks a critical differentiation in how the AI actually organizes. Most implementations use automated tagging and embedding-based linking. Content gets vectorized, similar chunks get clustered, tags get inferred from topic models. The result is a system that connects things by surface similarity — vocabulary overlap, semantic proximity in embedding space — producing opaque relationships that the user cannot inspect, verify, or traverse with intention. Since [[wiki links implement GraphRAG without the infrastructure]], this approach recreates graph retrieval through statistical inference rather than explicit curation. The connections exist, but they are black-box correlations rather than reasoned judgments about why ideas relate.
+
+This matters because opaque connections produce connection fatigue. When a system surfaces twenty "related" items for every note and the user cannot tell why any of them are related, the connections become noise rather than signal. The user stops trusting the system's judgment and falls back to manual search or abandons the tool entirely. The research documents this as a recurring failure mode across AI-native tools: automated connections that are technically correct (high cosine similarity) but cognitively useless (no articulated reason for the relationship). This is the connection-layer instance of the pattern where [[over-automation corrupts quality when hooks encode judgment rather than verification]] — embedding-based linking automates the judgment of "what relates" and produces metrics that look healthy (high link counts, high similarity scores) while the connections carry no reasoning that an agent or human can evaluate. The result compounds into [[navigational vertigo emerges in pure association systems without local hierarchy]] when opaque connections become the only traversal mechanism, because the user cannot inspect relationships to decide which path leads somewhere productive.
+
+The alternative — what this vault implements — is agent-curated wiki links. The agent reads source material, extracts claims, writes descriptions, and creates explicit wiki links with prose context explaining the relationship. Since [[three capture schools converge through agent-mediated synthesis]], the human captures with Accumulationist speed while the agent processes with Interpretationist quality. But the key differentiator is not that processing happens — it is that the processing produces transparent, inspectable, traversable structure. Because [[elaborative encoding is the quality gate for new notes]], the agent's wiki links with context phrases ("extends X by adding Y," "contradicts X because Z") are elaborative encoding implemented at system scale — connecting new information to existing knowledge with explicit relationship articulation. Embedding-based linking skips the elaboration entirely: placing two chunks near each other in vector space creates no cognitive hooks, no articulated reasoning, no encoding depth. When the agent writes "since [[spreading activation models how agents should traverse]], the traversal pattern becomes clear," the connection is visible, reasoned, and falsifiable. A human can disagree with it. Another agent can evaluate it. This is fundamentally different from an embedding that places two chunks near each other in a vector space for reasons neither human nor agent can articulate.
+
+Since [[propositional link semantics transform wiki links from associative to reasoned]], the differentiation runs deeper than just transparency. Typed wiki links create machine-parseable relationship semantics — not just "these relate" but "this causes that" or "this extends that" or "this contradicts that." Embedding-based connections cannot distinguish between a note that supports a claim and one that contradicts it; both would score high similarity. Agent-curated wiki links encode the nature of the relationship, not just its existence. This makes the graph an inference substrate rather than merely a navigation aid.
+
+However, the vibe notetaking consensus also carries a risk that applies regardless of linking approach. Since [[structure without processing provides no value]], automated organization that sorts and tags without genuine synthesis produces what Cunningham's wiki community called "thread mess" — well-organized ThreadMode content that has never been transformed into DocumentMode. Since [[ThreadMode to DocumentMode transformation is the core value creation step]], the test for any vibe notetaking implementation is whether the AI transforms chronological dumps into timeless claims or merely files them with better labels. Most current tools optimize for the filing — making content findable through search and tagging — without performing the synthesis that creates knowledge from information. Because [[the generation effect requires active transformation not just storage]], filing is not processing: tagging, clustering, and embedding content leaves the material cognitively unchanged. The generation effect demands that processing produce something that didn't exist in the source — a claim, a connection with articulated reasoning, a synthesis across inputs. Vibe notetaking implementations that stop at automated filing fail this test regardless of how sophisticated their filing mechanisms are.
+
+The encoding tradeoff also persists. Since [[does agent processing recover what fast capture loses]], vibe notetaking maximizes system-level organization at the cost of human encoding depth. The user who dumps everything into an AI system builds excellent external memory but weak internal understanding. The system knows, but the person does not. This is not necessarily a problem — it depends on whether the goal is personal understanding or system capability — but it is a consequence that the industry consensus rarely acknowledges. The vibe notetaking pitch promises effortless knowledge management. The unspoken cost is that effortlessness means the human did no generative cognitive work, and the generation effect benefits whoever generates. Since [[cognitive outsourcing risk in agent-operated systems]], this is not just an encoding gap but a skill atrophy trajectory — when agents handle all extraction, connection-finding, and synthesis over time, the human may lose not just memory of specific content but the meta-cognitive capacity to structure ideas, recognize good connections, and judge what matters. The industry consensus promotes effortlessness without acknowledging that effort is where understanding forms.
+
+The deeper claim is that vibe notetaking as industry consensus is correct about the capture side and mostly wrong about the organization side. Dump-and-organize is the right paradigm for capture. But "organize" implemented as automated embedding-based linking produces a different kind of system than "organize" implemented as agent-curated wiki links with explicit reasoning. The former creates a searchable archive. The latter creates a traversable knowledge graph. Both accept the same vibe-captured input. They diverge at the processing layer, and since [[scaffolding enables divergence that fine-tuning cannot]], that divergence determines not just whether the system becomes a thinking tool or a filing cabinet, but what kind of agent emerges — agents whose scaffolding consists of opaque embeddings develop different retrieval patterns, different connection intuitions, and ultimately different cognitive capabilities than agents whose scaffolding consists of curated wiki links with articulated reasoning. The vibe notetaking consensus also implicitly takes a position on governance. Since [[organic emergence versus active curation creates a fundamental vault governance tension]], most vibe notetaking tools commit fully to the emergence pole — structure emerges from AI processing without human curation interventions. The governance tension reveals why this fails at scale: without periodic curation (pruning connections, splitting overgrown clusters, enforcing quality standards), the emergent structure accumulates the same structural debt that any organic growth produces. Agent-curated wiki links represent a governance rhythm that interleaves organic capture with deliberate curation, which the vibe notetaking consensus skips entirely.
+
+---
+---
+
+Relevant Notes:
+- [[three capture schools converge through agent-mediated synthesis]] — foundation: the three capture schools dissolve into vibe notetaking's dump-and-organize pattern, but convergence quality depends on whether the agent generates or merely files
+- [[wiki links implement GraphRAG without the infrastructure]] — the differentiating mechanism: agent-curated wiki links produce the same graph benefits as automated GraphRAG without opaque infrastructure, and this transparency is what separates meaningful self-organization from noise generation
+- [[cognitive offloading is the architectural foundation for vault design]] — theoretical grounding: vibe notetaking is cognitive offloading optimized to its logical conclusion, minimizing capture friction so the rational choice is always to externalize
+- [[structure without processing provides no value]] — the risk that vibe notetaking shares with Lazy Cornell: automated organization that files without generating understanding produces well-sorted noise, not knowledge
+- [[does agent processing recover what fast capture loses]] — the encoding tradeoff: vibe notetaking maximizes system-level organization while the human retains nothing from the capture act itself
+- [[propositional link semantics transform wiki links from associative to reasoned]] — extends the differentiation: typed wiki links make agent-curated connections not just explicit but machine-reasonable, widening the gap from embedding-based association
+- [[ThreadMode to DocumentMode transformation is the core value creation step]] — the quality test: genuine vibe notetaking must transform ThreadMode dumps into DocumentMode synthesis, not just sort threads into prettier containers
+- [[AI shifts knowledge systems from externalizing memory to externalizing attention]] — paradigm frame: vibe notetaking's self-organization is attention externalization in disguise, deciding what to surface and connect rather than just storing and retrieving
+- [[the generation effect requires active transformation not just storage]] — cognitive mechanism: explains why filing-as-organization fails; generation demands producing something new (a claim, an articulated connection) while tagging and embedding leave material cognitively unchanged
+- [[elaborative encoding is the quality gate for new notes]] — what makes curated links cognitively different from embeddings: wiki links with context phrases are elaborative encoding at system scale, while cosine similarity skips the elaboration entirely
+- [[over-automation corrupts quality when hooks encode judgment rather than verification]] — Goodhart corruption: embedding-based linking automates connection judgment and produces correct-looking relationships that carry no reasoning, the connection-layer instance of the over-automation pattern
+- [[navigational vertigo emerges in pure association systems without local hierarchy]] — navigation consequence: opaque embedding-based connections exacerbate vertigo because users cannot inspect relationships to decide which traversal path is productive
+- [[cognitive outsourcing risk in agent-operated systems]] — long-term consequence: vibe notetaking's promise of effortlessness creates a skill atrophy trajectory where the human loses meta-cognitive capacity to structure, connect, and judge
+- [[PKM failure follows a predictable cycle]] — cascade risk: vibe notetaking could accelerate the early stages (Collector's Fallacy, Under-processing) by making collection effortless while genuine synthesis depends entirely on the AI's processing depth
+- [[behavioral anti-patterns matter more than tool selection]] — the industry convergence is tool-level; whether any vibe notetaking implementation produces knowledge depends on behavioral patterns that persist regardless of which app hosts the capture-and-organize pipeline
+- [[guided notes might outperform post-hoc structuring for high-volume capture]] — nuances the capture side: research suggests some upfront structure preserves encoding benefits that pure dumps lose, challenging vibe notetaking's zero-friction capture assumption
+- [[voice capture is the highest-bandwidth channel for agent-delegated knowledge systems]] — the ideal input channel: voice at 150 wpm with emotional markers is vibe notetaking's purest capture modality, providing maximum bandwidth with zero ceremony
+- [[wiki links as social contract transforms agents into stewards of incomplete references]] — the stewardship differentiator: embedding-based vibe notetaking has no obligation mechanism for completing references, while wiki link social contracts make dangling links into commitments the pipeline systematically fulfills
+- [[organic emergence versus active curation creates a fundamental vault governance tension]] — governance frame: vibe notetaking commits fully to the emergence pole, producing structure through AI processing without curation interventions; the governance tension explains why this fails at scale — structural debt from uncurated growth compounds past easy resolution
+- [[scaffolding enables divergence that fine-tuning cannot]] — divergence consequence of the embedding vs wiki-link differentiation: the choice between opaque embeddings and curated wiki links is a scaffolding choice that produces genuinely different agents, making the vibe notetaking implementation decision an agent individuation decision
+
+Topics:
+- [[processing-workflows]]
+- [[agent-cognition]]