arscontexta 0.6.0

package/methodology/BM25 retrieval fails on full-length descriptions because query term dilution reduces match scores.md

@@ -0,0 +1,39 @@
+---
+description: When a BM25 query contains many terms, each term's IDF contribution gets diluted by common words competing for scoring budget — condensing to key terms restores retrieval that full descriptions miss
+kind: research
+topics: ["[[discovery-retrieval]]"]
+methodology: ["Original"]
+---
+
+# BM25 retrieval fails on full-length descriptions because query term dilution reduces match scores
+
+BM25 scoring works by summing inverse document frequency (IDF) weights for each query term that matches a document. When a query is short and precise — three or four distinctive terms — each matching term contributes meaningfully to the score. But when the query is a full-length description (~150 characters, perhaps 20+ words), the scoring dynamics shift. Common words like "the," "that," "when," and connective phrases consume scoring budget without contributing retrieval signal. The distinctive terms that would identify the right note get diluted by noise.
+
+This was observed directly during recite testing. Searching the full description text of [[MOCs are attention management devices not just organizational tools]] returned zero BM25 results. But condensing to key terms — "MOC attention management" — returned the note at rank one with a perfect score. The description was well-written for human scanning; it failed for keyword search because human-readable prose includes exactly the kind of connective tissue that dilutes BM25 queries.
+
+The mechanism is straightforward. BM25 computes a relevance score as a sum over query terms: each term contributes based on its IDF (how rare it is across documents) and its term frequency in the target document. In a short query, every term carries weight. In a long query, high-IDF terms (distinctive words like "attention" or "MOC") compete with low-IDF terms (common words like "not" or "just") that match many documents and contribute little discriminating power. The sum gets noisy. A document that matches well on the distinctive terms but shares common words with many other documents may score lower than expected.
+
+This creates a practical tension for the vault. Since [[descriptions are retrieval filters not summaries]], descriptions are optimized for agent scanning — they should help an agent decide whether to load a note. Since [[good descriptions layer heuristic then mechanism then implication]], the formula encourages prose-like descriptions with connective tissue between layers. But this same prose quality that makes descriptions scannable makes them poor BM25 queries. The heuristic-mechanism-implication structure uses connecting words ("because," "which means," "so that") that are exactly the low-IDF terms that dilute keyword search.
+
+The resolution is not to write worse descriptions. Descriptions serve their primary function — helping agents filter before loading — and that function requires readable prose. Instead, the retrieval testing pipeline should account for this artifact. When full-description BM25 search fails, condensing to 3-5 key terms before declaring a retrieval failure is the correct diagnostic step. The failure may indicate BM25 query behavior rather than poor description quality.
+
+This also explains why semantic search (vsearch) handles full descriptions better than BM25 does. Vector embeddings compress the entire description into a fixed-dimensional representation where common words contribute less to the embedding than distinctive ones — the embedding process implicitly handles the weighting that BM25 requires explicit term selection for. The vault's fallback chain (query → vsearch → search → grep) already accounts for this by providing multiple retrieval modes, but the recite skill's retrieval test should use condensed key terms for BM25 rather than raw description text.
+
+The deeper implication touches the dual optimization problem. Since [[retrieval verification loop tests description quality at scale]], the verification loop combines prediction testing (can an agent predict content from title + description?) with retrieval testing (can the note be found by searching its description?). BM25 dilution means these two tests can diverge: a description that scores 5/5 on prediction may score 0 on BM25 retrieval. This is the mechanism behind what [[description quality for humans diverges from description quality for keyword search]] develops as a full argument — human scanning and keyword matching are two distinct retrieval channels with opposing requirements, and the BM25 IDF mechanism is the specific technical reason they pull apart. The divergence is not a description quality problem — it is a search engine behavior problem. The recite skill's dual-test architecture correctly surfaces this, but interpretation must distinguish between "description is bad" and "query format is wrong for this search mode."
+
+This divergence also instantiates the broader pattern that [[metacognitive confidence can diverge from retrieval capability]] — a vault where every description passes prediction testing can feel fully navigable while BM25 retrieval silently fails for a significant fraction of notes. The confidence comes from prediction scores; the capability gap hides in the search mode that agents fall back to when semantic search is unavailable.
+
+---
+---
+
+Relevant Notes:
+- [[descriptions are retrieval filters not summaries]] — foundation: descriptions must serve retrieval, but the format optimized for human scanning may actively sabotage keyword search
+- [[good descriptions layer heuristic then mechanism then implication]] — the layering formula creates good human-readable descriptions that may nonetheless fail BM25 because connective prose adds diluting terms
+- [[retrieval verification loop tests description quality at scale]] — the operational context where this was discovered: dual-test (prediction + retrieval) correctly surfaces divergent quality
+- [[distinctiveness scoring treats description quality as measurable]] — complementary: distinctiveness scoring uses embedding similarity, which tolerates term count better than BM25 does
+- [[metadata reduces entropy enabling precision over recall]] — the information-theoretic frame: BM25 dilution is a specific failure mode of the entropy reduction mechanism when applied to prose-format descriptions
+- [[description quality for humans diverges from description quality for keyword search]] — develops the consequence: this note identifies the mechanism (IDF dilution), that note develops the implication (two optimization targets that pull in opposite directions)
+- [[metacognitive confidence can diverge from retrieval capability]] — specific instance: BM25 dilution creates exactly the confidence-capability gap where a description scores 5/5 on prediction yet returns zero BM25 results, making the vault feel navigable while keyword retrieval silently fails
+
+Topics:
+- [[discovery-retrieval]]

package/methodology/IBIS framework maps claim-based architecture to structured argumentation.md

@@ -0,0 +1,58 @@
+---
+description: Rittel's Issue-Position-Argument structure (1970) maps directly onto vault architecture — claim-titled notes are Positions, questions are Issues, evidential links are Arguments — reframing the vault
+kind: research
+topics: ["[[graph-structure]]"]
+methodology: ["Concept Mapping"]
+source: [[tft-research-part3]]
+---
+
+# IBIS framework maps claim-based architecture to structured argumentation
+
+Horst Rittel and Werner Kunz developed Issue-Based Information Systems in 1970 to handle "wicked problems" — problems where the formulation of the problem is itself the problem. Their framework structures discourse into three elements: Issues (questions worth answering), Positions (proposed answers), and Arguments (evidence for or against Positions). What matters here is that this structure already exists in the vault, unnamed.
+
+Claim-titled notes are Positions. Each title stakes a specific claim: "IBIS framework maps claim-based architecture to structured argumentation" is a Position in a larger discourse about how knowledge graphs should be structured. Because [[title as claim enables traversal as reasoning]], following wiki links between these Positions reads as following argumentation chains — the IBIS vocabulary names what that traversal experience actually is. The CLAUDE.md requirement that [[claims must be specific enough to be wrong]] is, in IBIS terms, the requirement that Positions must be falsifiable enough to attract Arguments. A vague Position ("knowledge management is useful") cannot generate productive argumentation because there is nothing to argue against.
+
+Questions surfaced in MOC "Explorations Needed" sections and in note uncertainty passages are Issues. When a MOC says "how graph structure changes as vault scales — longitudinal study needed," that is an Issue in the IBIS sense: a question that organizes the space of possible Positions. Issues are the generative layer — they call Positions into existence by creating demand for answers. This maps precisely onto how [[dangling links reveal which notes want to exist]]: dangling links are Issues that have already been referenced from Positions but not yet given their own treatment, and their frequency reveals which questions the discourse most urgently needs answered.
+
+The wiki links between notes, especially those carrying context phrases, function as Arguments. When a note says "since [[spreading activation models how agents should traverse]], the traversal pattern becomes clear," the surrounding prose is an Argument linking a Position (about traversal) to another Position (about spreading activation) through a supporting relationship. Since [[propositional link semantics transform wiki links from associative to reasoned]], standardizing relationship types (supports, contradicts, extends) would make these Arguments machine-parseable — but even without standardization, the prose context already encodes argumentative force.
+
+## What the IBIS lens reveals
+
+The reframing is not merely taxonomic. It changes what "vault quality" means. In a document collection, quality means accurate, well-written notes. In an argumentation graph, quality means the discourse is well-structured: Issues have multiple competing Positions, Positions have both supporting and challenging Arguments, and the argumentation covers the relevant territory without gaps. Because [[the system is the argument]], this discourse completeness is directly testable — an argumentation graph that claims to embody its own methodology can be audited against its own IBIS structure: are there Positions without counter-Arguments? Issues with only one Position? The vault's self-referential nature means discourse gaps are methodology failures, not just organizational oversights.
+
+This shifts maintenance priorities. Since [[note titles should function as APIs enabling sentence transclusion]], we already think of notes as callable units. IBIS adds that these callable units participate in a discourse. A Position without Arguments is an unsupported claim. A Position without counter-Arguments is an untested one. An Issue with only one Position is an unexplored question. Each of these patterns is a specific, actionable maintenance signal.
+
+For agent swarms operating on the vault, IBIS provides role differentiation grounded in discourse function rather than arbitrary task assignment. One agent identifies open Issues (questions in MOC gaps and note uncertainty sections). Another gathers relevant Positions (claim notes that address those Issues). A third maps the Argument structure (which Positions support or challenge each other). This maps naturally to pipeline phases: reduce identifies Issues and extracts Positions, reflect maps Arguments between Positions, review checks whether the argumentation structure is complete.
+
+The IBIS lens also reveals what derivation actually does. Since [[derivation generates knowledge systems from composable research claims not template customization]], the derivation process traverses the discourse graph — reading Positions (claim notes) and their supporting Arguments (evidential links) — to compose a configuration justified by the argumentation structure. A derivation agent does not just select claims; it follows Argument chains to ensure the selected Positions cohere, which means derivation quality depends on the discourse graph being well-structured in exactly the sense IBIS defines: Positions with supporting and challenging Arguments, interconnected through typed relationships. Incomplete argumentation produces incomplete derivation. The derivation output preserves this discourse structure as a material artifact: since [[justification chains enable forward backward and evolution reasoning about configuration decisions]], each chain is a serialized path through the IBIS graph that records which Positions were traversed, which Arguments linked them, and which user constraints made each Position applicable. The chain makes the derivation's argument structure inspectable after deployment — backward reasoning traces from a configuration decision through its Argument chain to the Positions that justified it, which is exactly IBIS discourse traversal applied to system design rather than knowledge claims.
+
+## The IBIS-propositional link connection
+
+Since [[propositional link semantics transform wiki links from associative to reasoned]], there is a natural hierarchy: propositional link semantics type individual edges (causes, enables, contradicts), while IBIS types the discourse roles those edges participate in. An "extends" relationship is an Argument connecting two Positions. A "contradicts" relationship is a counter-Argument. The vocabulary of relationship types becomes the grammar of argumentation.
+
+This composability with [[role field makes graph structure explicit]] is worth noting. Role assigns structural function (hub, leaf, synthesis). IBIS assigns discourse function (Issue, Position, Argument). A note can be a hub (structurally central) AND a Position (argumentatively staking a claim). The two classifications are orthogonal — knowing one tells you nothing about the other — which, following the faceted classification principle, means both earn their place as independent retrieval dimensions.
+
+## Limitations and honest uncertainty
+
+IBIS was designed for collaborative design processes among humans. Whether the framework applies cleanly to a single-operator knowledge graph (even one operated by multiple agents) is uncertain. The original IBIS assumed stakeholders with genuinely different perspectives generating real disagreement. In a vault operated by one methodology, the "Arguments" may lack genuine adversarial pressure — the same mind (or methodology) generates both Positions and counter-Arguments, which could produce a discourse graph that appears balanced but lacks the epistemic stress-testing that real disagreement provides.
+
+There is also the formalization cost. Tagging every note with an IBIS role (Issue, Position, Argument) adds metadata overhead similar to the concerns raised about the role field. The value may lie not in formal tagging but in the conceptual lens: using IBIS as a diagnostic framework for vault health without adding YAML fields.
+
+---
+---
+
+Relevant Notes:
+- [[propositional link semantics transform wiki links from associative to reasoned]] — foundation: propositional links type individual edges while IBIS provides the higher-level discourse structure those typed edges participate in
+- [[claims must be specific enough to be wrong]] — enables: specificity is what makes claim notes function as genuine Positions rather than vague topic gestures; an IBIS Position must stake ground
+- [[note titles should function as APIs enabling sentence transclusion]] — extends: titles-as-APIs means titles-as-Positions; the IBIS framing adds that these API signatures are argumentative claims in a discourse graph, not just callable abstractions
+- [[title as claim enables traversal as reasoning]] — foundation: claim-titled notes are what makes wiki link traversal read as following argumentation chains; IBIS gives this traversal-as-reasoning insight its formal vocabulary — Positions connected by Arguments
+- [[role field makes graph structure explicit]] — parallel proposal: IBIS assigns discourse roles (Issue, Position, Argument) to nodes while role assigns graph-structural roles (hub, leaf, synthesis); the two typing systems are orthogonal and composable
+- [[wiki links implement GraphRAG without the infrastructure]] — foundation: wiki links already implement the edge layer IBIS needs; IBIS adds a formal interpretation of what those edges mean in argumentation terms
+- [[elaborative encoding is the quality gate for new notes]] — converges: elaborated context phrases on wiki links are what IBIS would call Arguments, and the elaborative encoding requirement is the quality gate ensuring links carry argumentative force rather than mere reference
+- [[the system is the argument]] — extends: IBIS formalizes what 'the system is the argument' means in argumentation terms; the vault is not just proof-of-work but specifically a discourse graph whose completeness (Issues with competing Positions, Positions with supporting and challenging Arguments) is testable
+- [[dangling links reveal which notes want to exist]] — exemplifies: in IBIS terms dangling links are Issues that Positions have already referenced but that lack their own treatment; demand signals are the discourse graph expressing that questions need answers
+- [[derivation generates knowledge systems from composable research claims not template customization]] — operationalizes: derivation traverses the discourse graph (Positions and their Argument chains) to compose justified configurations; derivation quality depends on discourse completeness in the IBIS sense
+- [[justification chains enable forward backward and evolution reasoning about configuration decisions]] — materializes: justification chains are the derivation-time artifact that preserves the IBIS argument structure; each chain is a serialized path through Positions and Arguments that the derivation agent traversed, making the discourse graph's reasoning inspectable and revisable after configuration is deployed
+
+Topics:
+- [[graph-structure]]

package/methodology/LLM attention degrades as context fills.md

@@ -0,0 +1,49 @@
+---
+description: The first ~40% of context window is the "smart zone" where reasoning is sharp; beyond that, attention diffuses and quality drops, justifying session isolation
+kind: research
+topics: ["[[agent-cognition]]", "[[processing-workflows]]"]
+---
+
+# LLM attention degrades as context fills
+
+This is established behavior in transformer architectures. As the context window fills, the attention mechanism must distribute across more tokens, and the quality of reasoning degrades. The effect isn't linear — there's a region early in context (roughly the first 40%, though the exact threshold varies by model and task) where the model operates at full capability. Beyond that region, performance drops progressively.
+
+The mechanism is straightforward: attention is a fixed resource being spread thinner. Early context gets high-quality attention. Late context competes with everything that came before. This isn't a bug — it's how attention works. The model can't attend equally to 200K tokens the way it attends to 20K.
+
+The degradation is not uniform across task types. Research on recursive language models shows that more complex tasks degrade at shorter context lengths — the "smart zone" is actually a family of curves indexed by task difficulty. Simple retrieval tasks tolerate longer contexts before quality drops, while multi-step reasoning tasks hit degradation thresholds much earlier. This means session isolation decisions should account for task complexity, not just context length: a synthesis task deserves a fresh context window sooner than a verification task would.
+
+This has practical implications for agent workflows. Chaining multiple cognitive phases in a single session means later phases run on degraded attention. A synthesis task at the end of a long session gets worse reasoning than the same task would get with fresh context. The degradation is invisible — the output looks coherent but is shallower, misses connections, makes worse judgments. The degradation also amplifies the importance of what gets loaded into context in the first place — since [[external memory shapes cognition more than base model]], the retrieval architecture that determines what enters the context window has higher ROI than model improvements precisely because attention is finite and degrading. Better processing of the same material yields marginal gains; different material yields different conclusions entirely.
+
+The primary solution is session isolation. Since [[fresh context per task preserves quality better than chaining phases]], heavy thinking phases get their own sessions, starting fresh in the smart zone. Light verification can batch because it doesn't require the same depth. But there is a complementary response: since [[hook enforcement guarantees quality while instruction enforcement merely suggests it]], deterministic quality checks (schema validation, auto-commit, index sync) can be moved entirely outside the context window, so they never compete for the attention that degrades. Session isolation addresses judgment work that needs the smart zone; hooks address mechanical checks that should not consume attention at all. Together they form a complete response to degradation — isolate what needs sharp reasoning, externalize what needs reliable execution. The handoff happens through files (work queue, task files) rather than context passing, so each session gets pristine attention for its task. Since [[session handoff creates continuity without persistent memory]], the file-based handoff mechanism creates continuity from structure rather than capability — the agent doesn't remember, it reads. The briefing pattern lets isolation produce quality without sacrificing coherent progress on multi-step work. Since [[skills encode methodology so manual execution bypasses quality gates]], skills enforce these phase boundaries — they define what "one task" means and prevent the scope creep that manual execution allows when context pressure mounts.
+
+Since [[queries evolve during search so agents should checkpoint]], context degradation adds a time dimension to traversal strategy. Checkpoints let you reassess direction while still in the smart zone. A search that fills context before finding what matters has degraded attention for the actual synthesis work. Frequent checkpoints early (when attention is sharp) reduce wasted traversal later (when attention isn't).
+
+Since [[spreading activation models how agents should traverse]], the "max depth" parameter in traversal (hard limit on traversal distance) is grounded in this attention constraint. You can't follow links indefinitely not just because of token limits, but because attention quality degrades as you load more context. The depth limit isn't arbitrary — it's where the smart zone ends.
+
+The attention degradation principle extends to maintenance scheduling. Since [[spaced repetition scheduling could optimize vault maintenance]] tests front-loaded review intervals (frequent early, sparse later), the cognitive grounding is attention preservation: frequent short reviews while attention is fresh beat infrequent comprehensive reviews that strain later sessions. This is the same principle at a different scale — session isolation preserves attention within tasks, scheduled intervals preserve attention across sessions.
+
+The attention degradation principle also has a structural dimension at the infrastructure level. Since [[skill context budgets constrain knowledge system complexity on agent platforms]], skill descriptions consume context from the first token of every session, reducing the effective smart zone before any task-specific content loads. A knowledge system with generous skill descriptions pays this attention tax on every task, not just tasks that use those skills. This creates a second-order incentive for concise descriptions and for delegating deterministic checks to hooks — since [[hooks enable context window efficiency by delegating deterministic checks to external processes]], the token savings from hook delegation are not marginal but compounding: each check delegated externally frees tokens that would otherwise be consumed by loading templates, comparing fields, and reasoning through validation logic, redirecting that budget from procedural work to the cognitive work that actually benefits from the smart zone.
+
+The claim is CLOSED because it's established science about transformer behavior, not a testable hypothesis about our methodology. The system design assumes it and builds session isolation on top of it.
+---
+
+Relevant Notes:
+- [[queries evolve during search so agents should checkpoint]] — checkpointing while attention is sharp prevents wasted traversal when attention degrades
+- [[progressive disclosure means reading right not reading less]] — curation at each layer keeps context dense with relevant material, maximizing value in the smart zone
+- [[skills encode methodology so manual execution bypasses quality gates]] — skills enforce phase boundaries that attention degradation makes necessary; without skill constraints, manual execution would chain phases until context degrades
+- [[spreading activation models how agents should traverse]] — the max depth traversal parameter is grounded in attention degradation; depth limits where the smart zone ends
+- [[fresh context per task preserves quality better than chaining phases]] — the design decision built on this science: session isolation preserves quality by keeping each phase in the smart zone
+- [[session handoff creates continuity without persistent memory]] — the mechanism that makes session isolation practical: externalized briefings create continuity without persistent memory
+- [[intermediate packets enable assembly over creation]] — packets are the artifact type that makes session isolation practical; handoffs through files instead of context passing preserve quality across the session boundary
+- [[cognitive outsourcing risk in agent-operated systems]] — human parallel: human judgment may degrade through delegation the same way LLM attention degrades through context accumulation; both are invisible quality failures
+- [[spaced repetition scheduling could optimize vault maintenance]] — applies attention preservation to maintenance: front-loaded intervals keep reviews in the smart zone rather than accumulating review debt
+- [[metadata reduces entropy enabling precision over recall]] — precision-first filtering reduces context pollution; pre-filtering to high-probability matches preserves attention for what matters
+- [[notes function as cognitive anchors that stabilize attention during complex tasks]] — the intra-session response: notes loaded early in the smart zone serve as fixed reference points that the attention mechanism can return to even as overall attention quality declines
+- [[hook enforcement guarantees quality while instruction enforcement merely suggests it]] — the second design response: session isolation preserves quality by resetting context, while hooks preserve quality by removing attention-dependent checks entirely; both respond to degradation but address different operation types (judgment work vs deterministic checks)
+- [[skill context budgets constrain knowledge system complexity on agent platforms]] — structural dimension: skill descriptions consume context from session start, reducing the effective smart zone before task-specific content loads, creating a second-order cost where infrastructure awareness taxes attention capacity
+- [[hooks enable context window efficiency by delegating deterministic checks to external processes]] — the within-session complement to session isolation: while fresh context per task resets the smart zone between tasks, hook delegation reduces context consumption within tasks by moving deterministic checks outside the context window entirely, compounding savings across a session
+- [[external memory shapes cognition more than base model]] — amplification: attention degradation makes retrieval architecture the dominant factor; because attention is finite and degrades, what enters the context window matters more than how it gets processed, making memory structure higher ROI than model upgrades
+
+Topics:
+- [[agent-cognition]]
+- [[processing-workflows]]

package/methodology/MOC construction forces synthesis that automated generation from metadata cannot replicate.md

@@ -0,0 +1,49 @@
+---
+description: The Dump-Lump-Jump pattern reveals that writing context phrases and identifying tensions IS the thinking — automated topic-to-note matching produces structurally valid MOCs that fail the attention
+kind: research
+topics: ["[[graph-structure]]", "[[maintenance-patterns]]"]
+confidence: speculative
+methodology: ["Evergreen", "Cognitive Science"]
+source: [[2026-02-08-moc-architecture-hierarchy-blueprint]]
+---
+
+# MOC construction forces synthesis that automated generation from metadata cannot replicate
+
+Nick Milo's "Dump, Lump, Jump" pattern for MOC construction appears to be organizational workflow, but the three phases do fundamentally different cognitive work. Dump is exhaustive gathering — pull every note that might belong. Lump is classification and context phrase writing — decide how notes relate to each other and to the MOC's theme. Jump is where the MOC transcends its index function: identifying tensions between notes, writing the orientation synthesis, capturing insights that emerge from seeing the collection as a whole. The intellectual payoff lives almost entirely in the Jump phase, and the Jump phase is precisely what automated generation cannot do.
+
+The reason is grounded in how synthesis actually works. Since [[reflection synthesizes existing notes into new insight]], reading multiple notes together surfaces cross-note patterns invisible in any single note. MOC construction is a structured version of this same reflective process. The builder reads twenty notes about graph structure, groups them by relationship, and suddenly sees that two clusters are in tension with each other — one arguing for dense linking, another arguing for navigational simplicity. That tension was latent in the graph but invisible until the construction process forced the builder to hold all twenty notes in view simultaneously. Since [[the generation effect requires active transformation not just storage]], this tension identification IS the active transformation: the builder generates understanding that did not exist in the notes individually.
+
+Automated MOC generation — matching notes to topics by metadata tags, embedding similarity, or keyword overlap — can produce the Dump phase flawlessly. It can even approximate the Lump phase by clustering semantically similar notes. But it cannot perform the Jump because the Jump requires judgment about what matters, what conflicts, and what the collection means as a whole. An automated system that reads `topics: ["[[graph-structure]]"]` across fifteen notes and lists them under a "Graph Structure" heading has produced a structurally valid MOC that fails both the attention management and synthesis functions. This is precisely the failure mode that [[over-automation corrupts quality when hooks encode judgment rather than verification]] identifies at the hook level: keyword matching produces the appearance of methodology compliance while the semantic judgment that creates value never happened. The automated MOC is the Goodhart corruption applied to navigation — link density and topic coverage metrics look healthy while the orientation function is hollow. Since [[MOCs are attention management devices not just organizational tools]], a MOC optimizes for rapid orientation only when its arrangement reflects curated judgment about what matters — the synthesis paragraph, the tension identification, the "start here if you're looking for X" guidance. An auto-generated list provides navigation without orientation.
+
+The context phrase requirement is where the gap becomes most visible. Since [[elaborative encoding is the quality gate for new notes]], writing "extends this by adding the temporal dimension" next to a link forces the builder to process how that note relates to its neighbors. Automated generation can produce `- [[note title]]` but cannot produce `- [[note title]] — contradicts the assumption that volume drives value` because the contradiction judgment requires understanding both the note and the MOC's existing claims. Without context phrases, the MOC becomes what [[structure without processing provides no value]] calls the Lazy Cornell anti-pattern applied to navigation: the structural lines are drawn, but the processing that creates value never happened.
+
+This has a testable implication. Since [[basic level categorization determines optimal MOC granularity]], the Lump phase exercises categorization judgment that determines whether a MOC sits at the right level of specificity. A human or agent building a MOC notices when a cluster of notes feels like it deserves its own sub-MOC — the "mental squeeze point" where navigation within the current MOC becomes effortful. Automated generation has no mechanism to feel this friction because the friction is a judgment about cognitive load, not a measurable property of the note collection. The split decision depends on expertise depth, which is exactly what Rosch's basic level shift predicts: as understanding deepens, the right granularity moves, and only the builder can sense where it has moved to.
+
+There is a genuine counterargument worth taking seriously: perhaps the gap is not inherent but reflects the current state of automation. A sufficiently capable system that reads full note content, understands argumentative structure, and identifies genuine tensions could plausibly produce Jump-phase synthesis. The classification as "open" reflects this uncertainty. However, the generation effect research suggests the gap may be partially inherent — the cognitive value accrues to whoever does the construction. Even if an automated system could produce identical output, the builder who constructs manually develops deeper understanding of the domain's structure. Since [[organic emergence versus active curation creates a fundamental vault governance tension]], the question becomes whether automated construction sacrifices the curation pole's deepest benefit (the curator's understanding) even when the output quality is preserved.
+
+The Jump phase is also recognizable through a different theoretical lens. Since [[ThreadMode to DocumentMode transformation is the core value creation step]], the Dump phase produces a chronological collection of notes (ThreadMode), while the Jump phase transforms that collection into timeless synthesized orientation (DocumentMode). Automated generation can sort threads into topic buckets with better labels, but sorting is not transformation — it produces well-organized ThreadMode rather than genuine DocumentMode. Since [[vibe notetaking is the emerging industry consensus for AI-native self-organization]], this gap is already visible at industry scale: embedding-based "organization" that clusters notes by semantic proximity is the automated Dump-and-Lump without Jump, and the result is systems that are searchable but not navigable in the sense that matters — the agent can find things but cannot orient within a domain.
+
+The practical design principle is clear regardless of the theoretical resolution: MOC updates during pipeline phases should not reduce to "add note to matching topic." They should include classification judgment and context phrase creation every time. Since [[context phrase clarity determines how deep a navigation hierarchy can scale]], the quality of those context phrases directly constrains the navigational depth the MOC hierarchy can sustain — shallow phrases produce shallow hierarchies regardless of content volume. Because [[stale navigation actively misleads because agents trust curated maps completely]], a mechanically updated MOC that agents trust as authoritative produces the same failure mode as a stale one — not outdated content, but shallow content that satisfies the navigation need without providing genuine orientation. The MOC looks complete, so the agent never looks further. But the synthesis that would have revealed tensions, suggested connections, and highlighted gaps never happened because the construction was automated away.
+
+---
+---
+
+Relevant Notes:
+- [[the generation effect requires active transformation not just storage]] — foundation: MOC construction is a specific domain where the generation effect operates; the 'Jump' phase produces synthesis that metadata matching cannot because it requires active transformation
+- [[elaborative encoding is the quality gate for new notes]] — specifies the mechanism: writing context phrases on MOC entries IS elaborative encoding, and automated generation skips precisely this encoding step
+- [[structure without processing provides no value]] — the automated MOC is Lazy Cornell applied to navigation: structurally complete, cognitively empty
+- [[MOCs are attention management devices not just organizational tools]] — explains why the synthesis gap matters: attention management requires curated arrangement, not just comprehensive listing
+- [[reflection synthesizes existing notes into new insight]] — MOC construction exercises the same reflective synthesis: reading notes together surfaces cross-note patterns that no single note reveals
+- [[organic emergence versus active curation creates a fundamental vault governance tension]] — MOC construction is the active curation pole in practice, and this note argues that the curation pole cannot be fully automated without losing its synthesis value
+- [[basic level categorization determines optimal MOC granularity]] — the 'Lump' phase exercises categorization judgment that determines MOC quality; automated generation cannot judge basic level because it requires domain expertise
+- [[stale navigation actively misleads because agents trust curated maps completely]] — sibling: compounds the stakes; if agents trust MOCs completely, the synthesis quality of construction directly determines reasoning quality downstream
+- [[over-automation corrupts quality when hooks encode judgment rather than verification]] — extends: automated MOC generation is the navigation-layer instance of the Goodhart corruption; structurally valid MOCs with no synthesis are keyword-matched links at the navigation level
+- [[ThreadMode to DocumentMode transformation is the core value creation step]] — parallel: the Jump phase IS a ThreadMode-to-DocumentMode transformation applied to navigation; chronological note dumps become synthesized orientation
+- [[context phrase clarity determines how deep a navigation hierarchy can scale]] — sibling: grounds the practical stakes of the Lump phase; context phrase quality constrains navigational depth, so skipping the synthesis that produces quality phrases limits how far MOC hierarchies can scale
+- [[vibe notetaking is the emerging industry consensus for AI-native self-organization]] — industry context: embedding-based MOC generation is the industry-scale version of what this note warns about; the convergence on automated organization without synthesis is the automated MOC problem deployed as product design
+- [[complete navigation requires four complementary types that no single mechanism provides]] — sibling: MOC construction quality determines whether local navigation actually functions; automated generation can populate the local navigation slot structurally while hollowing out the orientation and attention management that make local navigation distinct from supplemental search
+- [[navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts]] — sibling: the scaling regimes create the central tension for MOC construction: at Regime 2 manual construction is viable and produces irreplaceable synthesis, but at Regime 3 manual curation cannot keep pace with growth, so the question becomes whether construction can be partially automated without losing the Jump-phase synthesis that creates navigation value
+
+Topics:
+- [[graph-structure]]
+- [[maintenance-patterns]]

package/methodology/MOC maintenance investment compounds because orientation savings multiply across every future session.md

@@ -0,0 +1,41 @@
+---
+description: The compounding mechanism is temporal repetition across sessions rather than graph connectivity — one context phrase edit pays orientation dividends every time the MOC loads
+kind: research
+topics: ["[[maintenance-patterns]]"]
+methodology: ["PKM Research", "Cognitive Science"]
+source: [[2026-02-08-moc-architecture-hierarchy-blueprint]]
+---
+
+# MOC maintenance investment compounds because orientation savings multiply across every future session
+
+There are two distinct compounding mechanisms in a knowledge graph, and conflating them obscures the strongest argument for maintenance investment. Since [[each new note compounds value by creating traversal paths]], the graph compounds through connectivity — more nodes create more paths, and the marginal note increases the reachability of every existing note. But MOC maintenance compounds through a different mechanism entirely: temporal repetition. A single context phrase update costs perhaps thirty seconds of effort, but it saves orientation time in every subsequent session that loads that MOC. Because [[MOCs are attention management devices not just organizational tools]], that orientation savings is not merely convenience but reduction of Leroy's 23-minute attention residue recovery cost — the cognitive tax of context switching that each maintained MOC compresses toward zero. If the MOC loads fifty times over its lifetime, that thirty-second investment returns twenty-five minutes of cumulative orientation savings. The graph compounding mechanism is spatial (more connections across the network), while the maintenance compounding mechanism is temporal (repeated savings across session boundaries).
+
+This temporal multiplication is what makes maintenance the highest-leverage single operation available. Creating a new note adds one node to the graph. Connecting it forward during reflect adds edges. But updating a context phrase on an existing MOC entry improves the quality of every future traversal through that node — and MOC nodes are hubs, so they sit on more traversal paths than any individual claim note. Since [[context phrase clarity determines how deep a navigation hierarchy can scale]], each phrase refined through maintenance does not merely save orientation time but extends the depth the hierarchy can sustain. The compounding is therefore not only temporal but architectural: better phrases enable deeper hierarchies, which enable more efficient navigation at scale, which multiplies the savings further.
+
+The argument strengthens when you consider the hidden second return. Since [[backward maintenance asks what would be different if written today]], MOC maintenance is not clerical work — the reconsideration mental model forces genuine intellectual engagement. The maintainer reads twenty notes in the context of each other, notices that two clusters are now in tension, writes a synthesis paragraph that did not exist before. Because [[MOC construction forces synthesis that automated generation from metadata cannot replicate]], this Jump-phase synthesis is a cognitive byproduct of maintenance that automated updating cannot produce. The ROI of maintenance is therefore double: measurable orientation savings (time saved per session multiplied by session count) plus less measurable but potentially more valuable synthesis opportunities (insights that emerge from reconsidering arrangements). Since [[the generation effect requires active transformation not just storage]], the act of maintaining IS the thinking — the generation effect means the maintainer builds understanding through the maintenance act itself, not despite it.
+
+The inverse case makes the argument from the other direction. Since [[stale navigation actively misleads because agents trust curated maps completely]], deferred maintenance also compounds — but negatively. Every session that loads a stale MOC navigates by an outdated map. The agent follows paths to yesterday's understanding, misses recent work, and produces conclusions that look well-reasoned but rest on incomplete context. If fifty future sessions would benefit from a maintained MOC, those same fifty sessions suffer from a stale one. The asymmetry is worth noting: the cost of staleness may exceed the benefit of freshness because wrong navigation is worse than slow navigation. A slightly outdated context phrase wastes some time; a fundamentally stale MOC structure produces confidently wrong conclusions.
+
+This framing has implications for how maintenance should be prioritized. The temporal multiplication effect means that maintenance on frequently-loaded MOCs returns more than maintenance on rarely-accessed ones. Hub MOCs like `knowledge-work.md` load in nearly every session, so every improvement compounds across the highest session count. Peripheral topic MOCs load less frequently, so their maintenance returns are lower. Since [[navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts]], the compound returns argument is strongest in Regime 2 where manual curation is viable and the session repetition counts are high enough to amortize the maintenance cost. At Regime 3 scale, the temporal multiplication still holds, but the maintenance must shift toward automated detection with curated remediation because manual scanning cannot cover the territory — the compounding return per maintenance act remains high, but the feasibility of manual maintenance per MOC decreases.
+
+The practical consequence is that MOC maintenance should not be treated as overhead to minimize but as investment to optimize. Since [[complete navigation requires four complementary types that no single mechanism provides]], the temporal multiplier differs by navigation type — global navigation (hub MOCs) changes rarely and loads in nearly every session, so improvements there have the highest multiplier. Local navigation (topic MOCs) changes frequently and loads in topic-specific sessions, producing moderate but still meaningful compounding. Contextual navigation (inline links) compounds through every traversal that passes through the updated node. Supplemental navigation (search index freshness) compounds less because search does not rely on manually maintained artifacts. The four-type framework maps directly onto maintenance priority: invest most in the types with the highest session-load frequency and the most trust-dependent navigation decisions.
+
+The question is not "how little maintenance can we get away with?" but "which maintenance acts have the highest temporal multiplier?" A context phrase on a hub MOC that loads every session has a higher multiplier than a context phrase on a topic MOC that loads monthly. A synthesis paragraph that resolves a tension has higher multiplier than one that adds a routine entry. Since [[processing effort should follow retrieval demand]], maintenance budgets should flow toward the highest-traffic, highest-ambiguity navigation points — the places where improved clarity compounds most aggressively across future sessions. Session-load frequency is the demand signal: hub MOCs that load every session have the highest retrieval demand and therefore justify the most maintenance investment.
+
+---
+---
+
+Relevant Notes:
+- [[each new note compounds value by creating traversal paths]] — distinguishes: that note describes compounding through graph connectivity (more nodes create more paths), while this note describes compounding through temporal session repetition (one maintenance act saves orientation across every future session)
+- [[backward maintenance asks what would be different if written today]] — foundation: the maintenance practice whose investment this note argues compounds; the reconsideration mental model is the specific act that generates both orientation value and synthesis opportunities
+- [[MOC construction forces synthesis that automated generation from metadata cannot replicate]] — explains the hidden ROI: the Jump-phase synthesis that maintenance forces produces insight beyond the orientation savings, making the actual return double what the temporal multiplication alone predicts
+- [[stale navigation actively misleads because agents trust curated maps completely]] — the inverse case: if maintenance investment compounds positively across sessions, deferred maintenance compounds negatively across the same sessions because every load of a stale MOC produces wrong-branch navigation
+- [[the generation effect requires active transformation not just storage]] — mechanism: MOC maintenance IS active transformation, so the maintainer builds understanding through the act of maintaining, not despite it
+- [[context phrase clarity determines how deep a navigation hierarchy can scale]] — extends: each context phrase improved through maintenance contributes to depth-scaling capacity, so the compounding is not just temporal but architectural
+- [[navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts]] — scaling context: the compound returns argument is strongest in Regime 2 where manual curation is viable and session repetition counts are high enough to amortize maintenance cost
+- [[MOCs are attention management devices not just organizational tools]] — cognitive science grounding: Leroy's 23-minute attention residue recovery cost is what each maintained context phrase saves; that note establishes the cognitive mechanism, this note develops the compound returns from that mechanism across sessions
+- [[processing effort should follow retrieval demand]] — operationalizes the prioritization argument: maintenance investment flowing to highest-traffic MOCs is a specific instance of demand-driven allocation where session-load frequency IS the demand signal
+- [[complete navigation requires four complementary types that no single mechanism provides]] — maps compounding rates onto navigation types: global navigation (hub MOCs) compounds with the highest temporal multiplier because it loads in nearly every session, while supplemental navigation (search) compounds least because it does not rely on curated artifacts
+
+Topics:
+- [[maintenance-patterns]]

package/methodology/MOCs are attention management devices not just organizational tools.md

@@ -0,0 +1,51 @@
+---
+description: MOCs preserve the arrangement of ideas that would otherwise need mental reconstruction, reducing the 23-minute context switching penalty by presenting project state immediately
+kind: research
+topics: ["[[agent-cognition]]", "[[graph-structure]]"]
+methodology: ["Cognitive Science", "Evergreen"]
+source: [[tft-research-part3]]
+---
+
+# MOCs are attention management devices not just organizational tools
+
+The standard justification for MOCs is navigational: they organize notes into topics, provide entry points, prevent orphans. This is true but incomplete. MOCs also serve an attention management function that is at least as important as their organizational role.
+
+Sophie Leroy's attention residue research (2009) established that context switching creates cognitive drag that can take 23 minutes to recover from. When you leave one project and enter another, fragments of the previous task persist in working memory, competing for attention. This recovery time is not optional — it is a biological cost of switching. Every time a human (or agent) needs to re-orient to a topic, they pay this tax.
+
+MOCs reduce this tax by presenting project state immediately. Instead of reconstructing a mental model from scattered files — reading individual notes, tracing links, rebuilding the relationships between ideas — the MOC gives you the current state of understanding in one view. The arrangement of ideas, the tensions, the gaps, the core claims: all present without reconstruction. The 23-minute recovery compresses toward zero because the cognitive work of reassembly has already been externalized into the MOC structure.
+
+This reframes MOC maintenance from organizational overhead to attention investment. Every time you update a MOC — adding a new note, refining the synthesis, noting a tension — you are investing in reduced future context switching cost. The return on this investment compounds because MOCs are visited repeatedly. A MOC that saves 10 minutes of orientation per visit and is visited 50 times over its lifetime has saved hours of cumulative cognitive drag. This optimization has a floor, though — since [[attention residue may have a minimum granularity that cannot be subdivided]], MOC design can reduce variable reconstruction cost but cannot eliminate the irreducible redirection cost of any context switch.
+
+For agents, the mechanism translates directly. Since [[LLM attention degrades as context fills]], every token spent on re-orientation is a token not spent on productive reasoning. An agent that must read 15 notes to understand a topic's current state before it can contribute consumes context window capacity on reconstruction. An agent that reads the topic MOC gets the same orientation in a fraction of the tokens. Because [[fresh context per task preserves quality better than chaining phases]], each new session starts with a limited context budget — MOCs make that budget go further by frontloading orientation.
+
+Since [[navigational vertigo emerges in pure association systems without local hierarchy]], MOCs already solve the navigation problem by providing local hierarchy within associative structure. The attention management insight adds a second justification: MOCs are not just landmarks that prevent getting lost, they are context-loading shortcuts that prevent wasting attention on reconstruction. Navigation and attention management are complementary benefits of the same structure.
+
+And because [[cognitive offloading is the architectural foundation for vault design]], MOCs are a specific implementation of that offloading principle. They externalize the mental model of a topic — the relationships, priorities, and tensions — into a persistent artifact. The human or agent no longer needs to hold that model in working memory. They read the MOC, and the model loads. This is an instance of the broader paradigm where [[AI shifts knowledge systems from externalizing memory to externalizing attention]] — MOCs do not merely store topic structure but decide what deserves attention within a domain, making the navigation itself an attention allocation act rather than a memory retrieval one.
+
+The implication for MOC design: optimize for rapid orientation, not comprehensive listing. A MOC that lists every note alphabetically provides navigation but poor attention management. A MOC that synthesizes the key argument, highlights tensions, and organizes notes by relationship provides both. The synthesis paragraph at the top of a good MOC is not decoration — it is the attention management payload. And since [[agent notes externalize navigation intuition that search cannot discover and traversal cannot reconstruct]], the Agent Notes section at the bottom of MOCs serves as a complementary attention management layer: while the synthesis paragraph orients the agent to WHAT the topic contains, agent notes orient the agent to HOW to navigate it — which entry points work, which note combinations are productive, which seeming connections are traps. Both are attention management, operating at different layers: content orientation and traversal strategy. And the context phrases after each link determine whether the attention savings compound across tiers: since [[context phrase clarity determines how deep a navigation hierarchy can scale]], clear phrases let agents navigate a three-tier hierarchy (hub to domain to topic to claims) without loading intermediate notes, while ambiguous phrases force the agent to open each linked note to assess relevance — converting the attention savings back into attention cost. This is why [[progressive disclosure means reading right not reading less]] — the MOC is a disclosure layer that compresses a topic's state into a form optimized for rapid orientation rather than comprehensive coverage.
+
+The attention lifecycle has two complementary halves. MOCs reduce the cost of entering a context. Because [[closure rituals create clean breaks that prevent attention residue bleed]], explicit closure reduces the cost of leaving one. Together they bracket the work session: enter cleanly through the MOC, work within the fresh context, exit cleanly through the closure ritual. Without either half, attention residue accumulates — either from inadequate orientation (no MOC) or from inadequate release (no closure).
+
+This also explains why [[spreading activation models how agents should traverse]] identifies MOCs as high-activation nodes. When an agent reads a MOC, activation spreads simultaneously to all linked concepts in the topic. The attention management insight adds a second dimension to this: the activation is not just navigational priming but cognitive load reduction. The agent does not merely discover what notes exist — it loads the mental model of the topic in compressed form, which is the attention management function that saves tokens for productive reasoning rather than reconstruction. And because [[batching by context similarity reduces switching costs in agent processing]], the same Leroy mechanism that justifies MOCs also justifies sequencing: process context-similar tasks consecutively to minimize the frequency and severity of re-orientation between them.
+
+---
+---
+
+Relevant Notes:
+- [[navigational vertigo emerges in pure association systems without local hierarchy]] — explains WHY MOCs are needed for navigation; this note adds the attention management angle that MOCs also reduce the biological cost of context switching
+- [[LLM attention degrades as context fills]] — the attention mechanism this note extends to MOC design; MOCs front-load orientation so less context is consumed on reconstruction
+- [[cognitive offloading is the architectural foundation for vault design]] — MOCs are a specific implementation of cognitive offloading: externalizing the mental model of a topic so it need not be reconstructed from scratch
+- [[fresh context per task preserves quality better than chaining phases]] — session isolation plus MOCs means each fresh session can orient quickly via the MOC rather than re-traversing to reconstruct context
+- [[closure rituals create clean breaks that prevent attention residue bleed]] — complementary attention lifecycle: MOCs reduce the cost of entering a context (orientation), closure rituals reduce the cost of leaving one (release)
+- [[batching by context similarity reduces switching costs in agent processing]] — extends the same Leroy attention residue mechanism to task sequencing: MOCs reduce per-session orientation cost, batching reduces cross-task switching cost
+- [[spreading activation models how agents should traverse]] — explains WHY MOCs work as high-activation nodes that prime many related concepts simultaneously; this note adds the attention management dimension beyond navigation priming
+- [[progressive disclosure means reading right not reading less]] — MOCs are a disclosure layer: compressed representations that enable rapid orientation, which is exactly the attention management payload this note describes
+- [[notes function as cognitive anchors that stabilize attention during complex tasks]] — foundation: the cognitive anchoring mechanism that explains WHY MOCs stabilize sessions; MOCs are specialized anchors that compress topic state into a single orientation artifact
+- [[AI shifts knowledge systems from externalizing memory to externalizing attention]] — paradigm frame: MOCs are an instance of attention externalization; they decide what deserves focus within a domain, not just what is stored there
+- [[attention residue may have a minimum granularity that cannot be subdivided]] — boundary condition: MOC optimization faces an irreducible floor on switching cost that no amount of structural compression can eliminate
+- [[context phrase clarity determines how deep a navigation hierarchy can scale]] — quality condition on orientation payload: the attention savings from MOC reading depend on context phrase clarity; ambiguous phrases force agents to load linked notes to assess relevance, defeating the orientation compression that reduces switching cost
+- [[agent notes externalize navigation intuition that search cannot discover and traversal cannot reconstruct]] — complementary attention layer: synthesis paragraphs orient to what the topic contains (content attention), agent notes orient to how to navigate it (strategic attention); both reduce the orientation tax but at different cognitive layers
+
+Topics:
+- [[agent-cognition]]
+- [[graph-structure]]

package/methodology/PKM failure follows a predictable cycle.md

@@ -0,0 +1,50 @@
+---
+description: PKM systems fail through a predictable 7-stage cascade from Collector's Fallacy to abandonment, where each stage creates conditions for the next
+kind: research
+topics: ["[[processing-workflows]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+PKM systems don't fail randomly. The research documents a predictable cascade:
+
+1. **Collector's Fallacy** — saving = learning, accumulation without processing
+2. **Under-processing** — moving files without transformation
+3. **Productivity Porn** — optimizing system instead of using it
+4. **Over-engineering** — adding complexity that increases friction
+5. **Analysis Paralysis** — unable to act due to perfectionism
+6. **Orphan Accumulation** — notes pile up unconnected (but since [[orphan notes are seeds not failures]], the failure is accumulation rate exceeding resolution rate, not orphan existence itself)
+7. **Abandonment** — system death
+
+Each stage creates conditions for the next. The Collector's Fallacy fills inboxes faster than processing can clear them, which leads to under-processing as a coping mechanism. Under-processing creates guilt about the growing backlog, which leads to productivity porn as displacement activity. And so on until the system becomes too painful to use and gets abandoned. The retrieval layer accelerates this: since [[flat files break at retrieval scale]], accumulated unprocessed content hits a scale threshold (~200+ notes) where finding anything requires remembering what you have. The backlog becomes not just unprocessed but unfindable, making Stages 1-2 feel psychologically insurmountable rather than merely large. Since [[behavioral anti-patterns matter more than tool selection]], the cycle is predictable precisely because it's behavioral, not tool-dependent — users carry these patterns from Evernote to Notion to Obsidian, getting fresh-start motivation but the same underlying habits.
+
+The cascade faces a contemporary accelerator. Since [[vibe notetaking is the emerging industry consensus for AI-native self-organization]], the "dump and AI organizes" paradigm makes collection effortless while genuine synthesis depends entirely on the AI's processing depth. Tools that implement vibe notetaking with embedding-based linking rather than genuine agent synthesis could accelerate Stages 1-2 by removing the friction that once served as a natural brake on accumulation — the overflowing inbox at least created anxiety that prompted processing.
+
+A critical qualifier: since [[storage versus thinking distinction determines which tool patterns apply]], this entire cascade is specifically a thinking-system failure catalog. A storage system (PARA, Johnny.Decimal) that accumulates documents without synthesizing them is working correctly — its purpose IS the archive. The Collector's Fallacy is only a fallacy when applied to systems whose purpose is synthesis. This means the cascade predicts failure specifically for thinking systems that substitute storage operations for thinking operations.
+
+Understanding this cascade matters for vault design because it suggests where intervention is most effective. Since [[throughput matters more than accumulation]], the cycle explains how accumulation-first systems die. Early-stage intervention (at Collector's Fallacy or under-processing) can prevent the cascade before it gains momentum. And since [[evolution observations provide actionable signals for system adaptation]], the diagnostic protocol provides structured early-warning signals for the middle and late stages: unused note types and N/A-filled fields are symptoms of Stage 4 (over-engineering), while unlinked processing output is a symptom of Stage 6 (orphan accumulation). The diagnostic mapping converts vague stage descriptions into observable, actionable signals.
+
+The relationship between stages is causal, not merely correlational. Stage 3 (productivity porn) doesn't emerge randomly — it emerges as a response to the guilt created by Stages 1-2. This means addressing early stages can prevent later ones, while addressing late stages without fixing early ones leads to recurrence. There is also a derivation-time variant where Stage 4 arrives without the preceding cascade: since [[premature complexity is the most common derivation failure mode]], a derivation engine can inject over-engineering conditions before the user even begins, because the claim graph justifies each choice individually while the composed system exceeds absorptive capacity. The abandonment timeline accelerates because the user never develops the investment that comes from a system that started simple and grew with them.
+
+The failure cascade also reveals what happens when systems lack a reseeding mechanism. Since [[derived systems follow a seed-evolve-reseed lifecycle]], the middle stages of the cascade — over-engineering (Stage 4) and analysis paralysis (Stage 5) — are symptoms of attempting local fixes for systemic incoherence. When a system's accumulated adaptations have drifted the configuration into an incoherent region, adding more complexity (Stage 4) or paralysis over which fix to try (Stage 5) are natural responses that only deepen the problem. Reseeding — principled restructuring using original constraints enriched by operational evidence — is the intervention that breaks the cascade at Stages 4-5 by addressing the systemic incoherence rather than patching individual symptoms.
+---
+
+Relevant Notes:
+- [[productivity porn risk in meta-system building]] — Stage 3 in isolation; the risk of optimizing system instead of using it
+- [[structure without processing provides no value]] — documents how structural affordances without processing operations (Stage 2) fail to produce value
+- [[throughput matters more than accumulation]] — the principle violated by Stage 1 (Collector's Fallacy)
+- [[continuous small-batch processing eliminates review dread]] — intervention strategy at Stages 1-2; small-batch processing prevents accumulation
+- [[WIP limits force processing over accumulation]] — alternative Stage 1 intervention; hard caps force processing before more capture
+- [[orphan notes are seeds not failures]] — provides the nuance for Stage 6: orphan existence is not the failure, orphan accumulation rate exceeding resolution rate is
+- [[temporal processing priority creates age-based inbox urgency]] — cascade prevention: by surfacing old items urgently based on Ebbinghaus decay thresholds, temporal priority prevents Stages 1-2 from establishing
+- [[generation effect gate blocks processing without transformation]] — Stage 2 (under-processing) prevention: by requiring agent-generated artifact before inbox exit, the gate makes moving files without transformation architecturally impossible
+- [[cognitive outsourcing risk in agent-operated systems]] — an inverted Stage 1 that evades detection: agent processing keeps the vault looking healthy while human understanding atrophies; the symptom (overflowing inbox) disappears but the underlying failure (human not learning) persists in a new form
+- [[vibe notetaking is the emerging industry consensus for AI-native self-organization]] — contemporary accelerator: the dump-and-AI-organizes consensus removes the friction that once served as a natural brake on accumulation, potentially accelerating Stages 1-2 when AI processing stops at filing rather than genuine synthesis
+- [[storage versus thinking distinction determines which tool patterns apply]] — scope qualifier: the 7-stage cascade is specifically a thinking-system failure catalog; storage systems that accumulate without synthesizing are working correctly, so the cascade only predicts failure when applied to systems whose purpose is synthesis
+- [[evolution observations provide actionable signals for system adaptation]] — early-warning mechanism: the diagnostic protocol's navigation failure and processing mismatch signals can catch stages 4-6 of the cascade before compounding, because over-engineering manifests as unused types and N/A fields while orphan accumulation manifests as unlinked processing output
+- [[derived systems follow a seed-evolve-reseed lifecycle]] — the missing intervention: stages 4-5 (over-engineering, analysis paralysis) are symptoms of attempting local fixes for systemic incoherence; reseeding provides the principled restructuring that breaks the cascade by addressing the structural drift rather than patching symptoms
+- [[premature complexity is the most common derivation failure mode]] — derivation-time injection of Stage 4: unlike organic over-engineering which builds up gradually through the cascade, derivation-induced complexity arrives all at once, accelerating the abandonment timeline because there is no period of working simplicity to build user investment
+- [[configuration paralysis emerges when derivation surfaces too many decisions]] — Stage 5 (analysis paralysis) applied at derivation time rather than during use: the user never finishes setup because the configuration interface demands expertise not yet developed, preventing the working-system investment that could break the cascade
+- [[flat files break at retrieval scale]] — the retrieval-layer mechanism that makes Stages 1-2 terminal: accumulated flat files hit the scale curve where finding anything requires remembering what you have, and past ~200 notes retrieval failure makes the backlog psychologically insurmountable
+
+Topics:
+- [[processing-workflows]]

package/methodology/ThreadMode to DocumentMode transformation is the core value creation step.md

@@ -0,0 +1,52 @@
+---
+description: Ward Cunningham's wiki distinction names what the vault pipeline actually does — inbox captures are chronological threads that /reduce and /reflect transform into timeless synthesis, and without this
+kind: research
+topics: ["[[processing-workflows]]"]
+methodology: ["Digital Gardening"]
+source: [[tft-research-part3]]
+---
+
+# ThreadMode to DocumentMode transformation is the core value creation step
+
+Ward Cunningham's original wiki gave this transformation a name. ThreadMode is what happens when contributors add to a page chronologically — each person appends their perspective, questions pile on answers, and the page becomes an accretion of timestamped voices. DocumentMode is what happens when someone steps back and synthesizes the thread into a coherent, timeless document — integrating the best insights, resolving contradictions, and producing something that reads as a unified argument rather than a conversation transcript.
+
+The distinction matters because it names what knowledge systems actually struggle with — and since [[topological organization beats temporal for knowledge work]], the garden-vs-stream distinction from digital gardening theory is the system-level architecture that this page-level transformation produces. ThreadMode is the stream: chronological, recency-dominant, organized by when. DocumentMode is the garden: topological, timeless, organized by what it means. The transformation Cunningham named is what moves individual pages from stream to garden, while the architectural choice to use flat files with wiki links and topic MOCs is the garden implemented at the vault level. Every vault, wiki, and note-taking system accumulates ThreadMode content effortlessly. Inbox dumps, article highlights, meeting notes, voice memos — these are all chronological captures organized by when they happened, not what they mean. The challenge is never capturing more. The challenge is transforming captures into something that transcends the moment of their creation.
+
+This maps directly onto the vault's architecture. The inbox IS ThreadMode — chronological captures organized by arrival time and source. Thinking notes ARE DocumentMode — timeless claims organized by meaning, each making an argument that works independently of when or where the source was encountered. Since [[throughput matters more than accumulation]], what matters is the rate at which ThreadMode content becomes DocumentMode content. A growing inbox with stagnant thinking notes means the system is accumulating threads without ever producing documents.
+
+The vault's processing pipeline is the ThreadMode→DocumentMode transformation made explicit. The /reduce phase extracts concept-oriented claims from chronological source material — exactly the act of identifying what matters independent of when it was said. Since [[concept-orientation beats source-orientation for cross-domain connections]], this extraction step is where ThreadMode dies and DocumentMode begins: source-bundled notes are ThreadMode organized by origin, while extracted concept notes are DocumentMode organized by meaning. The /reflect phase then weaves DocumentMode notes into the existing graph, creating the cross-referential density that makes DocumentMode valuable. Without these phases, the vault would be a well-formatted thread mess — the wiki pathology that Cunningham's community identified decades ago.
+
+The ThreadMode/DocumentMode distinction provides the sharpest test for the current generation of AI-native tools. Since [[vibe notetaking is the emerging industry consensus for AI-native self-organization]], the entire industry accepts ThreadMode capture (dump everything, AI handles it). But most implementations stop at ThreadMode with better labels — automated tagging, embedding clusters, semantic similarity scores — without ever performing the transformation to DocumentMode. The test is simple: does the AI produce timeless claims that can be linked from other contexts, or does it produce well-tagged chronological captures? Most current tools optimize for findability (search over ThreadMode) rather than synthesis (transformation to DocumentMode).
+
+The "thread mess" failure mode deserves attention because it's subtle. A vault can look productive while remaining entirely in ThreadMode — and since [[insight accretion differs from productivity in knowledge systems]], this is exactly the productivity-without-accretion failure mode: high output velocity with zero deepening of understanding. Notes get created, links get added, MOCs get updated — but if the content is still organized chronologically rather than synthesized thematically, it's threads with wiki link syntax, not documents. Since [[structure without processing provides no value]], adding structural affordances (folders, tags, links) to ThreadMode content produces Lazy Cornell with wiki formatting. The transformation requires generation, not decoration. Since [[the generation effect requires active transformation not just storage]], the act of writing a claim title that works as prose when linked IS the DocumentMode transformation — it forces you to ask "what does this mean independent of its context?" rather than "what did the source say?"
+
+There's a temporal dimension that makes this harder than it sounds. ThreadMode content carries context from its moment of creation — who said what, what prompted it, what else was happening. DocumentMode deliberately strips this temporal context to produce timeless claims. But since [[capture the reaction to content not just the content itself]], some temporal context is precisely what makes a capture valuable — the reaction you had in the moment, the connection you saw before it faded. The transformation must preserve the insight while discarding the chronological scaffolding. Reactions are proto-DocumentMode: they capture synthesis seeds during ThreadMode accumulation, making the later transformation faster because the nucleus of the claim already exists. And since [[decontextualization risk means atomicity may strip meaning that cannot be recovered]], the stripping that this transformation performs is not always benign — some claims derive their meaning from the argumentative landscape they inhabited, and the chronological scaffolding that gets removed may carry essential context about when the claim applies and what it argues against.
+
+The ThreadMode→DocumentMode distinction also reframes the capture schools. Since [[three capture schools converge through agent-mediated synthesis]], the "fundamental divergence" between Accumulationists, Interpretationists, and Temporalists is really a disagreement about when and how ThreadMode becomes DocumentMode: Accumulationists defer the transformation entirely, Interpretationists perform it at capture time, and Temporalists replace it with chronological linking. Agent mediation dissolves the divergence by splitting capture (human, ThreadMode speed) from transformation (agent, DocumentMode quality) — the schools converge because the transformation no longer requires a single actor to do both.
+
+Since [[incremental formalization happens through repeated touching of old notes]], the ThreadMode→DocumentMode transformation is not a single event but a gradient. A note might start as rough ThreadMode (a captured reaction), get extracted into preliminary DocumentMode (a claim note with basic reasoning), and then refine through accumulated touches into mature DocumentMode (a well-connected claim with considered counterarguments and clear implications). Each traversal is an opportunity to move further along the gradient. Since [[backward maintenance asks what would be different if written today]], the reweave phase extends this gradient into ongoing maintenance: notes written with yesterday's understanding are reconsidered through today's lens, potentially sharpening claims, adding connections, or splitting what was originally bundled. This is the ThreadMode→DocumentMode transformation applied retrospectively — the note was DocumentMode when written, but new understanding reveals ThreadMode residue that still needs transformation. The question is whether the initial extraction — the moment when chronological content first becomes a timeless claim — does most of the value-creation work, or whether the subsequent refinement passes contribute equally.
+
+The agent translation is unusually direct here. Agents process ThreadMode inputs (source documents, inbox dumps, conversation transcripts) and produce DocumentMode outputs (claim notes, synthesis, MOC updates). The pipeline IS the transformation. But since [[verbatim risk applies to agents too]], agents can produce ThreadMode with DocumentMode formatting — well-structured summaries that reorganize content chronologically rather than synthesizing it thematically. This is verbatim risk manifesting in the transformation phase: the output has the structure of DocumentMode but the cognitive substance of ThreadMode, because no genuine generation occurred. The test for genuine DocumentMode is composability: can the output be linked from other notes as a standalone claim? If the note only makes sense in the context of its source, it's still ThreadMode dressed in DocumentMode clothing.
+---
+
+Relevant Notes:
+- [[throughput matters more than accumulation]] — names the velocity dimension of the same insight: throughput measures how fast ThreadMode becomes DocumentMode, while this note names what the transformation produces
+- [[structure without processing provides no value]] — the Lazy Cornell anti-pattern is ThreadMode with structural formatting: drawing lines without transforming threads into documents
+- [[the generation effect requires active transformation not just storage]] — the cognitive mechanism underlying ThreadMode→DocumentMode: generation is what produces DocumentMode content, while mere reorganization keeps content in ThreadMode with better formatting
+- [[concept-orientation beats source-orientation for cross-domain connections]] — concept extraction IS the ThreadMode→DocumentMode transformation applied to source material: source-bundled notes are ThreadMode organized by origin, concept notes are DocumentMode organized by meaning
+- [[incremental formalization happens through repeated touching of old notes]] — describes how DocumentMode notes continue improving after the initial transformation: each traversal refines the synthesis further
+- [[capture the reaction to content not just the content itself]] — reactions are proto-DocumentMode: capturing a reaction during ThreadMode (chronological capture) plants synthesis seeds that accelerate the later transformation
+- [[temporal media must convert to spatial text for agent traversal]] — format-level instance: temporal media (audio, video) is inherently ThreadMode — chronological, sequential, resisting reorganization; the spatial text output is DocumentMode — timeless, randomly accessible, composable
+- [[topological organization beats temporal for knowledge work]] — the structural twin: ThreadMode/DocumentMode is the page-level transformation, while garden/stream is the system-level architecture; both articulate the same insight that chronological organization fails knowledge work
+- [[three capture schools converge through agent-mediated synthesis]] — the capture schools are stances on the ThreadMode→DocumentMode question: Accumulationists defer the transformation, Interpretationists do it immediately, Temporalists avoid it through linking; agent mediation dissolves the divergence by splitting who captures from who transforms
+- [[verbatim risk applies to agents too]] — names the specific failure mode this note warns about: ThreadMode with DocumentMode formatting is exactly what verbatim risk produces — well-structured reorganization that looks like synthesis but generates no new understanding
+- [[insight accretion differs from productivity in knowledge systems]] — accretion is what genuine DocumentMode produces, productivity is what ThreadMode activity measures; the thread mess failure mode is high productivity with zero accretion
+- [[backward maintenance asks what would be different if written today]] — extends the transformation beyond initial extraction: backward maintenance is the ongoing ThreadMode→DocumentMode gradient where notes written with past understanding get reconsidered through the lens of current knowledge
+- [[stigmergy coordinates agents through environmental traces without direct communication]] — names the coordination layer beneath the transformation: ThreadMode content is raw stigmergic deposit (chronological traces left without coordination), and the DocumentMode transformation is what happens when accumulated environmental traces get synthesized into coherent knowledge; Cunningham's wiki is the shared origin for both concepts
+- [[AI shifts knowledge systems from externalizing memory to externalizing attention]] — paradigm frame: the ThreadMode→DocumentMode transformation is an attention externalization act; the agent decides what deserves to become timeless DocumentMode versus remaining as chronological ThreadMode, which is an attention allocation judgment embedded in the pipeline
+- [[wiki links as social contract transforms agents into stewards of incomplete references]] — adds obligation structure: the social contract ensures ThreadMode traces (dangling links left during capture) eventually become DocumentMode content through pipeline fulfillment; without this commitment mechanism, the transformation would depend on voluntary attention rather than systemic stewardship
+- [[vibe notetaking is the emerging industry consensus for AI-native self-organization]] — industry test case: the ThreadMode/DocumentMode distinction provides the sharpest evaluation of current AI-native tools, most of which optimize for searchable ThreadMode rather than genuine DocumentMode synthesis
+- [[decontextualization risk means atomicity may strip meaning that cannot be recovered]] — names the cost of this transformation: stripping chronological scaffolding to produce timeless claims may lose argumentative context that gave claims their original force, especially for contextual heuristics and trade-off judgments
+
+Topics:
+- [[processing-workflows]]

package/methodology/WIP limits force processing over accumulation.md

@@ -0,0 +1,53 @@
+---
+description: Hard inbox caps create forcing functions that shift behavior from capture to processing more effectively than soft guidelines
+kind: research
+topics: ["[[processing-workflows]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# WIP limits force processing over accumulation
+
+Hard WIP limits on inbox items create a forcing function that shifts behavior from capture to processing, preventing the Collector's Fallacy failure mode more effectively than soft guidelines or voluntary discipline. Since [[throughput matters more than accumulation]], the metric that matters is processing rate, not note count — and WIP limits are the architectural mechanism that keeps that rate healthy.
+
+The TFT research suggests setting WIP limits on reading lists as an antidote to unchecked accumulation. The mechanism: when a hard limit is reached, the system makes new capture impossible until processing occurs. This is different from soft guidance ("you should process more") which allows indefinite deferral. Since [[structure without processing provides no value]], mere accumulation is worse than useless — it creates the illusion of progress while producing nothing that compounds.
+
+## The Kanban insight
+
+Kanban's work-in-progress limits create flow through constraint. When you can't start new work until existing work moves forward, the system self-regulates. Accumulation becomes architecturally impossible rather than merely discouraged.
+
+For agent-operated systems, this translates directly: the agent could be programmed to refuse capture when inbox exceeds N items. The constraint does what procedural guidance cannot — it makes the desired behavior (processing over capture) the only available option. Once processing happens, since [[intermediate packets enable assembly over creation]], the outputs become composable building blocks rather than dead-end summaries. WIP limits force processing, processing produces packets, packets enable assembly — the forcing function creates the conditions for composable output.
+
+## Hard caps vs soft guidelines
+
+The distinction matters because soft guidelines allow indefinite deferral. "You should process more" competes with the immediate reward of capturing something interesting. The capture always wins because processing can always happen later. Left unchecked, since [[PKM failure follows a predictable cycle]], this deferral triggers the Collector's Fallacy at Stage 1, which cascades through the remaining stages toward eventual abandonment.
+
+Hard caps remove the choice. When inbox is full, the only way to capture something new is to process something old. The forcing function aligns incentives: if you want to keep capturing (the rewarding behavior), you must keep processing (the valuable behavior). Since [[behavioral anti-patterns matter more than tool selection]], architectural constraints like WIP limits address the root cause — behavioral patterns — rather than tool features. The Collector's Fallacy persists across every tool because it's a behavior; hard caps make the anti-pattern structurally impossible rather than merely discouraged.
+
+WIP limits work alongside sibling forcing functions rather than alone. Since [[schema templates reduce cognitive overhead at capture time]], templates force structure AT capture while WIP limits force processing BEFORE capture — both shape behavior through architectural constraints rather than discipline. And since [[generation effect gate blocks processing without transformation]], the generation gate ensures that when processing does happen, it produces genuine transformation rather than file movement. Together these three mechanisms form complete behavioral constraints: WIP limits ensure processing happens, schema templates ensure capture is structured, and generation gates ensure processing is genuine.
+
+## Complementary selection and urgency mechanisms
+
+WIP limits answer WHEN processing must happen (when the cap is reached), but not WHAT to process first. Since [[temporal processing priority creates age-based inbox urgency]], age-based selection complements the forcing function by determining priority order. The urgency is justified because [[temporal separation of capture and processing preserves context freshness]] — Ebbinghaus decay means context degrades rapidly (50% within an hour, 70% within a day), grounding both the forcing function need and the priority algorithm in cognitive science.
+
+Since [[continuous small-batch processing eliminates review dread]], an alternative approach achieves similar throughput through batch size rather than WIP caps. Small batches prevent accumulation through a different mechanism: processing frequently enough that the inbox never grows large enough to trigger avoidance. The two approaches are complementary — WIP caps set the ceiling, small-batch cadence prevents reaching it.
+
+## Agent-specific considerations
+
+For agents that follow instructions, one might argue there's no difference between "process when inbox exceeds 20" and "cannot capture when inbox exceeds 20." Both are just rules to follow.
+
+But the difference emerges in edge cases and competing priorities. Soft rules invite interpretation and exception-making. Hard architectural constraints have no exceptions to grant. The mechanism operates at a different level than the instruction.
+---
+
+Relevant Notes:
+- [[throughput matters more than accumulation]] — the semantic neighbor; contains the throughput principle this operationalizes
+- [[continuous small-batch processing eliminates review dread]] — related forcing function: small batches prevent accumulation through different mechanism (batch size vs WIP cap)
+- [[structure without processing provides no value]] — why this matters: accumulation without processing is worse than useless
+- [[PKM failure follows a predictable cycle]] — the cascade that hard WIP caps can interrupt; preventing Stage 1 (Collector's Fallacy) from triggering downstream stages
+- [[intermediate packets enable assembly over creation]] — completes the throughput chain: WIP limits force processing, processing produces packets, packets enable assembly; the forcing function creates the conditions for composable output
+- [[schema templates reduce cognitive overhead at capture time]] — sibling forcing function: WIP limits force processing before capture, schema templates force structure at capture; both shape behavior through architectural constraints
+- [[temporal processing priority creates age-based inbox urgency]] — complementary mechanisms: this note answers when must I process? (forcing function), that note answers what should I process first? (selection algorithm based on age)
+- [[temporal separation of capture and processing preserves context freshness]] — the urgency justification: WHY processing soon matters; Ebbinghaus decay (50% within 1 hour, 70% within 24 hours) grounds both the forcing function need and the priority algorithm
+- [[generation effect gate blocks processing without transformation]] — complementary forcing function: WIP limits force processing to happen, the generation gate ensures processing is genuine transformation rather than file movement; together they form complete behavioral constraints
+
+Topics:
+- [[processing-workflows]]