arscontexta 0.6.0

package/methodology/summary coherence tests composability before filing.md

@@ -0,0 +1,37 @@
+---
+description: If a note cannot be summarized in 1-3 coherent sentences, it bundles multiple claims that should be split before leaving inbox
+kind: research
+topics: ["[[note-design]]"]
+methodology: ["Cornell"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# summary coherence tests composability before filing
+
+The Cornell system requires a summary section: 1-3 sentences capturing the core claim of a page. This isn't just documentation practice — it's a structural test. If you cannot write a coherent summary, the content isn't coherent enough to be a single composable unit.
+
+The failure mode this catches is multi-claim bundling. A note that covers "how links work, why topology matters, and when to checkpoint" cannot be summarized coherently because it makes three separate arguments. Forcing a summary exposes this incoherence before the note enters the knowledge graph, where bundled notes become linking hazards — you want to reference one claim but drag two others along with it.
+
+This differs from the general quality question of whether [[claims must be specific enough to be wrong]]. Specificity asks whether a single claim has enough stake to be useful. Summary coherence asks whether the unit is actually singular. A note can pass the specificity test while failing the coherence test: "Quality matters more at scale because small differences compound" is specific, but if the note also argues about traversal patterns and session handoffs, no summary can hold it together.
+
+The mechanism is simple: before any note moves from inbox to thinking, attempt to generate a 1-3 sentence summary. If the summary fails to cohere — if it reads as a list of topics rather than a unified argument — the note needs splitting. This implements Cornell's insight that the summary section is not post-processing documentation but a quality gate that catches structural problems early. Because [[structure without processing provides no value]], the summary requirement ensures processing actually happens before content leaves inbox — it's an anti-Lazy-Cornell pattern that forces the generative work.
+
+For agent-operated vaults, this becomes an automated check. An agent attempting to summarize should flag notes where the summary requires "and" as a list connector rather than logical flow. The summary generation pass is cheap; discovering bundled notes through link maintenance is expensive. Since [[backward maintenance asks what would be different if written today]] includes splitting as one of the reconsideration actions, catching bundling at creation time prevents paying the higher cost of detecting and fixing it during maintenance.
+
+But the summary requirement itself is a convention that may constrain. Since [[vault conventions may impose hidden rigidity on thinking]], forcing content into 1-3 coherent sentences assumes that valuable insights can always be expressed in that form. Relational insights, visual thinking, or procedural knowledge may resist sentence-form summary not because they bundle multiple claims but because they operate in a different register. The test becomes: when summary fails, is it bundling (multiple claims) or register mismatch (one insight that resists propositional form)? Since [[enforcing atomicity can create paralysis when ideas resist decomposition]], this diagnostic problem is shared across multiple vault conventions: both atomicity (decomposing into single-concept notes) and summary coherence (compressing into 1-3 sentences) require distinguishing "struggle that reveals incomplete understanding" from "struggle against a format that can't accommodate valid insight." The parallel suggests a deeper pattern: vault conventions that use friction as a diagnostic may systematically misclassify certain kinds of thinking.
+
+This is an instance of [[testing effect could enable agent knowledge verification]] applied to structural quality rather than description quality. Attempting to generate a summary tests whether the content is coherent, just as attempting to predict content from description tests whether the description enables retrieval. Both patterns use attempted generation as a diagnostic — failures reveal structural problems that static inspection misses.
+---
+
+Relevant Notes:
+- [[claims must be specific enough to be wrong]] — complementary quality gate: this note catches bundling, that note catches vagueness
+- [[the generation effect requires active transformation not just storage]] — summary generation is a concrete example of the transformation that separates processing from filing
+- [[structure without processing provides no value]] — the Lazy Cornell anti-pattern: summary requirement is a counter-measure that forces processing before filing
+- [[backward maintenance asks what would be different if written today]] — catching bundling at creation time is cheaper than detecting it during maintenance passes
+- [[testing effect could enable agent knowledge verification]] — sibling pattern: both use attempted generation as diagnostic for structural problems
+- [[descriptions are retrieval filters not summaries]] — Cornell's two compression mechanisms: summary tests coherence at filing, descriptions enable filtering at retrieval
+- [[generation effect gate blocks processing without transformation]] — sibling inbox exit gate: summary coherence catches bundled claims, the generation gate catches lack of transformation; both validate quality at the inbox-to-thinking boundary
+- [[enforcing atomicity can create paralysis when ideas resist decomposition]] — parallel diagnostic problem: both summary coherence and atomicity enforcement face the question of whether friction signals bundling/incomplete thinking or format resistance/valid relational insight
+
+Topics:
+- [[note-design]]

package/methodology/tag rot applies to wiki links because titles serve as both identifier and display text.md

@@ -0,0 +1,50 @@
+---
+description: Unlike opaque identifiers that persist through vocabulary drift, wiki link titles carry semantic content that must stay current — so renaming for clarity cascades maintenance through every incoming
+kind: research
+topics: ["[[graph-structure]]", "[[maintenance-patterns]]"]
+methodology: ["Zettelkasten", "Digital Gardening"]
+source: [[tft-research-part3]]
+---
+
+# tag rot applies to wiki links because titles serve as both identifier and display text
+
+In traditional tagging systems, "tag rot" occurs when vocabulary drifts over time. Early tags use one set of words, later tags use another, and the older content becomes effectively invisible because nobody searches for the outdated terms. The same phenomenon applies to wiki links, but with a structural twist that makes it more consequential.
+
+Tags are lightweight labels. When a tag rots, the cost is a missed search result. Wiki links are heavier — they serve simultaneously as the note's identity, its display text in other notes, and its functional API when transcluded into prose. Because [[note titles should function as APIs enabling sentence transclusion]], a wiki link title like `[[claims must be specific enough to be wrong]]` must read naturally in sentences across the vault. The title does triple duty: it identifies the file, it displays in every note that references it, and it carries semantic content as a clause in other notes' arguments. This triple function is precisely what makes wiki link rot more fragile than tag rot.
+
+When understanding deepens and a title needs sharpening — perhaps `[[knowledge management friction]]` should become `[[curation becomes the work when creation is easy]]` — the rename must propagate through every note that links to it. Every sentence that once read `since [[knowledge management friction]]` must now accommodate the new title. Some of these sentences will break grammatically. Others will lose their argumentative flow. The maintenance burden is proportional to the note's incoming link count, which means the most important notes (the hubs with the most references) are the most expensive to rename.
+
+There is also a synonym proliferation problem. Different authors or sessions might create `[[AI cognition]]`, `[[artificial intelligence reasoning]]`, and `[[machine learning patterns]]` as separate notes that address overlapping concepts. Since [[narrow folksonomy optimizes for single-operator retrieval unlike broad consensus tagging]], the vault's personal vocabulary has no external consensus to anchor against. In broad folksonomy, statistical convergence from many taggers naturally suppresses synonyms. In a single-operator system, the vocabulary drifts wherever the operator's thinking drifts, and there is no crowd signal to detect that drift has occurred. The graph fragments — not through broken links, but through parallel links that should converge on the same target. This is tag rot manifesting as graph fragmentation rather than search failure. And if [[federated wiki pattern enables multi-agent divergence as feature not bug]], the divergence is deliberately embraced rather than treated as a maintenance problem — but distinguishing productive divergence from mere vocabulary drift requires the same kind of monitoring that tag rot demands.
+
+## Why wiki link rot is structurally worse than tag rot
+
+The root cause is that wiki links couple three concerns into one string: addressing (which file to load), display (what text appears in prose), and semantics (what the concept means). Tags only carry addressing and categorization — they don't appear in prose, so renaming them has no grammatical consequences. Wiki links embed in prose as functional arguments, so their text is load-bearing. And because [[backlinks implicitly define notes by revealing usage context]], each incoming link represents not just a reference but a prose commitment where the title functions as a grammatical clause. A note with thirty backlinks has thirty sentences across the vault that depend on its exact title phrasing. The rename cost is proportional to these accumulated commitments — the very property that makes a note important (many backlinks revealing wide usage) is what makes it expensive to improve.
+
+Since [[digital mutability enables note evolution that physical permanence forbids]], the same property that enables notes to evolve also enables the vocabulary drift that causes wiki link rot. Luhmann's physical Zettelkasten didn't have this problem precisely because card titles couldn't change. The trade-off is real: mutability enables crystallization through [[incremental formalization happens through repeated touching of old notes]], but every crystallization that sharpens a title triggers a rename cascade.
+
+## Mitigations in practice
+
+The vault's rename script (`rename-note.sh`) addresses the mechanical problem — finding and replacing all occurrences of the old title with the new one. But it doesn't address the grammatical problem. A sentence crafted around `since [[old title]]` may not read naturally with `since [[new title]]`. This means some renames require not just find-and-replace but re-authoring the surrounding prose in each linking note.
+
+Since [[backward maintenance asks what would be different if written today]], the reweave process naturally surfaces title staleness. When an agent asks "what would be different about this note?" the answer is often "the title would be more precise." This creates a useful diagnostic: notes whose titles feel vague during reweaving are candidates for the rename cascade. The question is whether the improved precision is worth the propagation cost.
+
+One architectural mitigation would be to decouple identifier from display text — using opaque IDs for addressing while allowing display text to change freely. But this sacrifices the core design value: since [[wiki links are the digital evolution of analog indexing]], the title-as-identifier property is what makes wiki links readable as prose. Opaque IDs would turn every link into `[[id-12345|display text]]`, fragmenting the concept across two representations and losing the composability that makes the vault's linking philosophy work.
+
+The practical resolution is accepting the maintenance cost as the price of semantic linking. Rename scripts handle the mechanical propagation. Reweaving handles the prose adjustment. The cost is real but bounded — and the alternative (opaque identifiers or tag-only systems) sacrifices the prose composability that makes the knowledge graph genuinely traversable.
+---
+
+Relevant Notes:
+- [[dangling links reveal which notes want to exist]] — the complementary failure mode: dangling links are absent targets, while wiki link rot is degraded identifiers; both signal graph maintenance needs but through different mechanisms
+- [[note titles should function as APIs enabling sentence transclusion]] — the design choice that creates the fragility: titles must be semantically rich to work as prose, but semantic richness means they need updating as understanding evolves
+- [[incremental formalization happens through repeated touching of old notes]] — the mechanism that triggers renames: as understanding crystallizes through accumulated touches, vague titles sharpen into precise claims, and each sharpening requires propagating the new identifier through all incoming links
+- [[backward maintenance asks what would be different if written today]] — reweaving naturally discovers title staleness: the question 'what would be different?' often answers 'the title would be sharper', which triggers the rename cascade this note describes
+- [[wiki links are the digital evolution of analog indexing]] — historical context: analog cue columns pointed via proximity, so renaming was impossible; wiki links point via text matching, making rename possible but expensive
+- [[propositional link semantics transform wiki links from associative to reasoned]] — a potential mitigation: if relationship types were formalized, link context could survive title changes better because the structural relationship is typed independently of the display text
+- [[digital mutability enables note evolution that physical permanence forbids]] — the double-edged nature of mutability: the same property that enables note evolution also enables the vocabulary drift that causes link rot
+- [[narrow folksonomy optimizes for single-operator retrieval unlike broad consensus tagging]] — amplifies the vulnerability: without consensus vocabulary to anchor terms, personal retrieval keys drift freely as understanding evolves, and there is no external standard to detect that drift has occurred
+- [[backlinks implicitly define notes by revealing usage context]] — explains why rename cost scales with importance: each backlink represents a prose commitment where the title functions as a clause, so accumulated backlinks are accumulated grammatical dependencies that all break on rename
+- [[federated wiki pattern enables multi-agent divergence as feature not bug]] — deliberate divergence: federation intentionally embraces the vocabulary divergence that tag rot warns about, transforming uncontrolled drift into an architectural feature; the question shifts from preventing drift to deciding when divergence is productive
+
+Topics:
+- [[graph-structure]]
+- [[maintenance-patterns]]

package/methodology/temporal media must convert to spatial text for agent traversal.md

@@ -0,0 +1,43 @@
+---
+description: Agents need random access to content but video, audio, and podcasts are time-locked sequences — transcription is lossy but mandatory because no agent can efficiently seek through temporal streams
+kind: research
+topics: ["[[agent-cognition]]"]
+methodology: ["Augmentation Research"]
+source: [[tft-research-part3]]
+---
+
+# temporal media must convert to spatial text for agent traversal
+
+Agents can read a document at any point — jump to paragraph seven, scan a heading, grep for a phrase. They cannot do this with video or audio. A podcast is a time-locked sequence: to reach minute forty-two, you must either know the timestamp in advance or scan linearly. An agent traversing a knowledge graph needs random access to content, and temporal media does not provide random access. The conversion from temporal to spatial is therefore not optional but architecturally necessary.
+
+This is a constraint that emerges from what agents fundamentally are. Since [[spreading activation models how agents should traverse]], knowledge graph traversal works through jumping between connected nodes, following wiki links, loading context from descriptions before deciding whether to read full notes. None of these operations have temporal media equivalents. You cannot wiki-link into minute fourteen of a podcast. You cannot grep an audio file for a concept. You cannot scan the "headings" of a video to decide which section to load. Since [[progressive disclosure means reading right not reading less]], the entire discovery layer architecture — titles through descriptions through outlines through full content — assumes spatial, randomly accessible text. Progressive disclosure cannot function on temporal media because there is no way to "scan headings" or "read the description first" when content is locked inside a time stream.
+
+The practical implication is that every temporal source — podcasts, video lectures, voice memos, meeting recordings — must produce a primary markdown artifact as its first processing step. Since [[voice capture is the highest-bandwidth channel for agent-delegated knowledge systems]], voice capture is the highest-bandwidth temporal channel, producing dumps at 150 wpm that then require exactly this conversion. The transcript-first principle applies: the transcript becomes the working artifact, and the original recording becomes a backup for deeper engagement. Whisper-style transcription produces the raw text. Agent processing structures it with headings, timestamps, and wiki links. But these two steps are qualitatively different: because [[the generation effect requires active transformation not just storage]], transcription is merely format conversion — the raw text is the same content in a different container. The generative transformation happens when the agent adds headings, wiki links, and extracts claims. Transcription makes traversal possible; agent processing makes it valuable. The result enters the vault as a standard markdown file that participates in the knowledge graph like any other note.
+
+The conversion is lossy. Audio carries tone, emphasis, hesitation, emotional texture that flat text discards. Video carries spatial relationships, gestures, visual demonstrations. These losses are real but acceptable because the alternative — leaving content in temporal format — means agents cannot traverse it at all. A lossy transcript that agents can search, link, and synthesize outperforms a perfect recording that sits inert in the filesystem. Since [[local-first file formats are inherently agent-native]], the markdown transcript inherits all the properties that make the vault work: any LLM can read it, wiki links create graph edges, YAML frontmatter enables filtering. The original recording lacks every one of these properties.
+
+The relationship to temporal versus topological organization is instructive. Since [[topological organization beats temporal for knowledge work]], the vault already commits to organizing by concept rather than by date. This note extends the same principle to media format: just as chronological filing buries knowledge under temporal sediment, temporal media buries knowledge inside time-locked sequences. The garden metaphor applies at the format level, not just the organizational level. Text is the garden. Audio and video are the stream. This is why [[ThreadMode to DocumentMode transformation is the core value creation step]] applies at the format level, not just the content level: temporal media is inherently ThreadMode — it accretes sequentially, carries the speaker's chronological context, and resists reorganization. The markdown artifact that emerges from conversion is DocumentMode — timeless, randomly accessible, composable with the rest of the knowledge graph. And since [[three capture schools converge through agent-mediated synthesis]], the temporal-to-spatial conversion is the first step in the convergence pipeline — voice capture at Accumulationist speed, transcription as the format bridge, agent processing with Interpretationist quality.
+
+There is a two-layer graph that emerges from this conversion. The primary layer is the wiki link graph connecting markdown notes. The secondary layer consists of timestamp links that point back into the original temporal source — `youtube.com/watch?v=ID&t=50s` or `recording.mp3#t=14:32`. These timestamp anchors let a human (or a future multimodal agent) dive back into the original medium for the nuance that transcription lost. The two layers serve different functions: the wiki link layer enables agent traversal, the timestamp layer preserves source fidelity for human review.
+
+This also explains why since [[capture the reaction to content not just the content itself]], the human's role during temporal capture shifts. Rather than transcribing in real-time (which voice capture handles), the human marks moments of interest — a tap to capture the last sixty seconds, a verbal annotation that flags significance. These sparse human signals become enrichment metadata that guide the agent's later processing. The human provides judgment about what matters; the agent provides the format conversion and structural integration.
+
+The claim is closed because it follows directly from the agent substrate constraint. If your knowledge system operates on text files with wiki links, then content that is not text files with wiki links must become text files with wiki links before it can participate. The only question is how good the conversion can be, not whether it should happen.
+
+---
+---
+
+Relevant Notes:
+- [[local-first file formats are inherently agent-native]] — the target format: markdown with YAML and wiki links is what temporal media must become to enter the agent-readable substrate
+- [[topological organization beats temporal for knowledge work]] — parallel principle: just as chronological filing loses to topological filing, chronological media loses to spatial text for knowledge traversal
+- [[spreading activation models how agents should traverse]] — the traversal mechanism that temporal media cannot support: spreading activation requires jumping between nodes, which demands random access
+- [[three capture schools converge through agent-mediated synthesis]] — the pipeline this conversion enables: once temporal content becomes text, agent-mediated synthesis can apply Interpretationist quality to Accumulationist speed capture
+- [[capture the reaction to content not just the content itself]] — the human role during temporal capture: marking moments of interest and recording reactions while the agent handles conversion
+- [[dual-coding with visual elements could enhance agent traversal]] — the reverse direction: this note argues temporal must become spatial, dual-coding explores whether spatial-visual could complement spatial-textual
+- [[voice capture is the highest-bandwidth channel for agent-delegated knowledge systems]] — upstream source: voice capture is the highest-bandwidth temporal capture channel, producing the very media this note says must convert; the emotional metadata voice preserves is exactly what transcription loses
+- [[ThreadMode to DocumentMode transformation is the core value creation step]] — parallel pattern: temporal-to-spatial conversion is ThreadMode-to-DocumentMode applied at the format level; temporal media is inherently ThreadMode (chronological, sequential), and the markdown output is DocumentMode (timeless, randomly accessible)
+- [[progressive disclosure means reading right not reading less]] — architectural dependency: the entire discovery layer architecture that progressive disclosure depends on assumes spatial, randomly accessible text; this note explains why that assumption is non-negotiable
+- [[the generation effect requires active transformation not just storage]] — distinguishes two steps: transcription is format conversion (non-generative), while the agent structuring that follows (adding headings, wiki links, extracting claims) is the generative transformation that creates vault value
+
+Topics:
+- [[agent-cognition]]

package/methodology/temporal processing priority creates age-based inbox urgency.md

@@ -0,0 +1,45 @@
+---
+description: Age thresholds convert the Ebbinghaus decay principle into actionable queue logic — notes under 24 hours are standard, 24-72 hours elevated, beyond 72 hours critical
+kind: research
+topics: ["[[processing-workflows]]"]
+methodology: ["Cornell"]
+source: [[3-3-cornell-note-taking-system]]
+---
+
+# temporal processing priority creates age-based inbox urgency
+
+This note operationalizes what [[temporal separation of capture and processing preserves context freshness]] describes as principle. The principle says context fades exponentially in the first 24 hours, which makes timing matter. This note provides the queue algorithm that makes the principle actionable.
+
+The algorithm is straightforward. Every inbox item has an age. Age maps to priority tiers:
+
+| Age | Priority | Rationale |
+|-----|----------|-----------|
+| < 24 hours | Standard | Context still fresh, full processing possible |
+| 24-72 hours | Elevated | Decay accelerating, process before critical threshold |
+| > 72 hours | Critical | Original context likely unrecoverable, salvage what remains |
+
+This creates proactive behavior rather than reactive. Instead of processing inbox items when the operator happens to invoke the skill, the system surfaces what needs attention based on temporal urgency. The agent becomes aware that notes are approaching decay thresholds before they cross them.
+
+The underlying mechanism is Ebbinghaus decay applied to capture context rather than memorized content. When you dump a note during zero-friction capture, you have implicit understanding of why it matters, how it connects to what you were thinking, what prompted the insight. None of that gets written down. It lives in your head. And like any unrehearced memory, it fades according to exponential decay curves. The queue algorithm converts this cognitive science into scheduling logic.
+
+This is distinct from demand-driven processing. Since [[processing effort should follow retrieval demand]] suggests that content which gets retrieved more deserves more processing effort, there's a potential tension: demand-driven processing implies waiting to see what proves useful, while temporal priority implies processing immediately regardless of demonstrated demand. Both are valid. Demand-driven processing makes sense for content whose value is uncertain. Temporal priority makes sense for content whose value depends on context that will decay. The resolution: apply temporal priority to recent captures (where context loss is the risk), then shift to demand-driven prioritization for older content (where utilization signal matters more than faded context).
+
+The implementation gap in current agent systems is that most inbox processing happens on manual trigger. The human decides when to process, and the agent processes whatever is there. This misses the temporal dimension entirely. Adding age-based urgency to the orchestration layer would mean: when the user invokes inbox processing, surface the oldest items first, or proactively notify when items approach critical thresholds.
+
+Since [[continuous small-batch processing eliminates review dread]] argues for frequent small processing passes rather than infrequent large ones, temporal priority provides the selection logic for those passes. If you process 3-5 items per session, which 3-5? The ones closest to crossing decay thresholds. This combines the frequency pattern (continuous small batches) with the selection pattern (oldest first) into a coherent processing discipline.
+
+There is a tension with [[batching by context similarity reduces switching costs in agent processing]]. Age-based priority says process the oldest items first because context decays. Similarity-based batching says process related items together to minimize switching costs. The resolution is layered: age determines which priority TIER items fall into (standard, elevated, critical), and within each tier, context similarity determines the ORDER. An item at 71 hours should not wait because a context-similar item at 2 hours exists. But among five items all in the elevated tier, processing the three graph-structure items before the two note-design items reduces switching overhead without violating temporal urgency.
+---
+
+Relevant Notes:
+- [[temporal separation of capture and processing preserves context freshness]] — the principle this note operationalizes; that note explains WHY timing matters, this note provides the queue algorithm
+- [[processing effort should follow retrieval demand]] — potential tension: demand-driven suggests waiting, temporal priority suggests urgency; resolved by applying temporal logic to recent captures, demand logic to established content
+- [[continuous small-batch processing eliminates review dread]] — complementary: provides the frequency pattern, while this note provides the selection logic for which items to process in each batch
+- [[spaced repetition scheduling could optimize vault maintenance]] — sibling application of Ebbinghaus decay: that note applies age-based scheduling to maintenance intervals, this note applies it to inbox processing priority; same cognitive science foundation targeting different domains
+- [[WIP limits force processing over accumulation]] — complementary mechanisms: WIP limits answer when must I process? (forcing function), this note answers what should I process first? (selection algorithm)
+- [[PKM failure follows a predictable cycle]] — temporal priority prevents the cascade: surfacing old items urgently prevents Stage 1 (Collector's Fallacy) and Stage 2 (Under-processing) from establishing
+- [[generation effect gate blocks processing without transformation]] — orthogonal inbox mechanism: this note answers what to process first (oldest items), the generation gate answers what counts as processed (must have artifact); together they form complete inbox discipline
+- [[batching by context similarity reduces switching costs in agent processing]] — tension: age says process oldest first, similarity says process related items together; resolved by letting age set the priority tier and similarity optimize sequence within each tier
+
+Topics:
+- [[processing-workflows]]

package/methodology/temporal separation of capture and processing preserves context freshness.md

@@ -0,0 +1,39 @@
+---
+description: Dump first then structure within 24 hours — Ebbinghaus decay means capture context fades fast, so inbox processing should be time-prioritized not just manually triggered
+kind: research
+topics: ["[[processing-workflows]]"]
+methodology: ["Cornell"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# temporal separation of capture and processing preserves context freshness
+
+This is a design principle borrowed from Cornell Note-Taking and grounded in memory science. You do not fill in cues during the lecture; you do it immediately after. The reasoning is straightforward: context fades. The understanding you have at capture time — why something matters, how it connects, what sparked the insight — erodes rapidly once you move on to other things. Because [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]], this temporal separation is specifically the gap between phase one (capture) and phase two (process) of a universal pipeline — and the Ebbinghaus constraint governs how long that gap can be before the process step loses the contextual understanding that makes domain-specific transformation effective.
+
+The Ebbinghaus forgetting curve provides the scientific basis. Without reinforcement, memory retention drops exponentially: roughly 50% lost within the first hour, 70% within 24 hours. This means the window for processing captured content is measured in hours, not days. A note dumped this morning and processed tonight retains more of its original meaning than one left in the inbox for a week.
+
+For agent-delegated processing, this means "dump first, structure later" comes with a time constraint. The dump is zero-friction capture — don't interrupt the flow, don't force structure at the moment of insight. But "later" doesn't mean "whenever." Later means soon enough that you still remember why you captured it. There's a middle path between pure dumps and full processing: since [[schema templates reduce cognitive overhead at capture time]], pre-defined fields can enable faster capture than freeform writing while preserving more structure than raw dumps. The schema externalizes structural decisions, so capture becomes "fill these boxes" rather than "design this note" — reducing capture-time overhead while context remains fresh. Research on guided notes extends this insight: since [[guided notes might outperform post-hoc structuring for high-volume capture]], skeleton outlines provided before capture may work even better for streaming content (lectures, conversations) where information arrives faster than you can process it. The schema approach fits discrete content (a book, an article); guided notes may fit flows where real-time categorization would compete with listening. This temporal separation has a potential cost: since [[does agent processing recover what fast capture loses]] tests whether the human loses encoding benefits when capture is fast and generation is delegated, the same Ebbinghaus decay that justifies urgency may mean the human never deeply encodes content that agents process for them. This adds a time dimension to [[throughput matters more than accumulation]] — throughput isn't just about how FAST you process but WHEN, because context freshness decays exponentially within the first day.
+
+The agent implication is temporal triggers for inbox processing. Rather than only processing when manually invoked, inbox agents should prioritize by age. Since [[temporal processing priority creates age-based inbox urgency]] operationalizes this into a queue algorithm: notes under 24 hours are standard priority, 24-72 hours elevated, beyond 72 hours critical. Notes approaching 24 hours are urgent. Notes beyond 24 hours have already lost context — they're still worth processing, but the original understanding may be unrecoverable. This temporal prioritization extends beyond inbox processing: since [[spaced repetition scheduling could optimize vault maintenance]] tests whether newly created notes need more frequent verification than mature notes, the Ebbinghaus principle that grounds this inbox urgency may also ground review scheduling — recently created notes have higher issue rates (weak descriptions, missing connections) than notes that have survived multiple reviews.
+
+There is a complementary urgency at a shorter timescale. Since [[Zeigarnik effect validates capture-first philosophy because open loops drain attention]], the moment a thought occurs and is not externalized, it becomes an open loop consuming working memory. Ebbinghaus governs the processing window — hours before context decays. Zeigarnik governs the capture window — seconds before the open loop begins draining attention. These are complementary urgencies: capture within seconds (close the loop), process within hours (preserve the context). A system that handles both timescales — zero-friction capture for Zeigarnik, temporal processing priority for Ebbinghaus — addresses the full temporal constraint on knowledge work.
+
+This principle operates at a different level than [[fresh context per task preserves quality better than chaining phases]]. That claim addresses LLM context rot within sessions — later phases run on degraded attention, so each task gets isolation. This claim addresses human context decay between sessions — the human who captured the note loses context over time, so processing should happen before that decay sets in. Both principles point toward time-sensitivity, but for different reasons and at different scales.
+
+The practical constraint for agent-operated knowledge systems: while the architecture supports prioritized processing, many implementations lack temporal triggers. Inbox items are processed in whatever order the operator chooses. Adding age-based priority to the orchestration layer or creating an inbox-triage skill that surfaces oldest items first would implement this principle fully. For now, it's a design decision that implementations should consider.
+---
+
+Relevant Notes:
+- [[temporal processing priority creates age-based inbox urgency]] — operationalizes this principle into a queue algorithm: <24h standard, 24-72h elevated, >72h critical; converts the Ebbinghaus decay rationale into actionable scheduling logic
+- [[fresh context per task preserves quality better than chaining phases]] — parallel principle at the agent level; this note addresses human context decay, that note addresses LLM context rot
+- [[processing effort should follow retrieval demand]] — potential tension: demand-driven processing suggests delay, but Ebbinghaus suggests urgency
+- [[throughput matters more than accumulation]] — this note adds the time dimension: throughput requires not just processing velocity but timely processing while context is fresh
+- [[the generation effect requires active transformation not just storage]] — adds a time constraint to when generation must occur; processing after 24 hours generates from degraded context
+- [[continuous small-batch processing eliminates review dread]] — complementary mechanism: this note addresses WHEN to process (urgency), that note addresses HOW OFTEN (continuous small batches prevent the accumulation that triggers dread)
+- [[schema templates reduce cognitive overhead at capture time]] — the middle path between pure dumps and full processing: pre-defined fields enable faster capture than freeform while preserving more structure than raw dumps
+- [[guided notes might outperform post-hoc structuring for high-volume capture]] — extends the middle path to streaming content: skeleton outlines may outperform post-hoc structuring when information flows faster than processing capacity
+- [[Zeigarnik effect validates capture-first philosophy because open loops drain attention]] — complementary urgency at a shorter timescale: Ebbinghaus governs processing urgency (hours), Zeigarnik governs capture urgency (seconds); together they define the full temporal constraint on knowledge capture
+- [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]] — structural frame: temporal separation governs the gap between the skeleton's phase one (capture) and phase two (process); the Ebbinghaus constraint applies universally because the process step always requires contextual understanding regardless of domain
+
+Topics:
+- [[processing-workflows]]

package/methodology/ten universal primitives form the kernel of every viable agent knowledge system.md

@@ -0,0 +1,162 @@
+---
+description: Markdown files, YAML frontmatter, wiki links, MOC hierarchy, tree injection, description fields, topics footers, schema enforcement, semantic search, self space, and session rhythm — the
+kind: research
+topics: ["[[design-dimensions]]"]
+methodology: ["Original"]
+---
+
+# ten universal primitives form the kernel of every viable agent knowledge system
+
+The design space of knowledge systems is vast — since [[eight configuration dimensions parameterize the space of possible knowledge systems]], millions of theoretical configurations exist. But beneath all that variation, every viable system shares the same foundation. These ten primitives are the kernel: the non-negotiable base layer that every agent knowledge system needs to function, regardless of domain, platform, or methodology tradition. They are what [[derivation generates knowledge systems from composable research claims not template customization]] never varies, while everything above them gets derived per use case.
+
+The kernel works because it requires only what every agent platform has: filesystem access and text files. Since [[four abstraction layers separate platform-agnostic from platform-dependent knowledge system features]], these primitives map entirely to the foundation and convention layers. No hooks, no skills, no orchestration, no MCP servers. An LLM that can read and write files can implement every primitive here. This is deliberate — since [[local-first file formats are inherently agent-native]], building on universals rather than platform-specific features means the kernel survives platform changes, migrations, and the death of any particular tool.
+
+## The Ten Primitives
+
+### 1. Markdown files with YAML frontmatter
+
+Notes are plain text files with structured metadata in the header. The file IS the complete artifact — no database, no API, no external service. YAML frontmatter makes each file queryable via regex while remaining human-readable. This is the most fundamental choice: by selecting plain text over a database, the system gains universal portability at the cost of query sophistication.
+
+**Why universal:** Since [[cognitive offloading is the architectural foundation for vault design]], the vault exists because both humans and agents need external structures to think beyond their native capacity. Plain text files are the lowest-friction external structure — any tool can read them, any agent can parse them, and they survive every platform transition because they depend on nothing.
+
+**Minimum viable version:** A markdown file with a `---` delimited YAML block containing at least a `description` field.
+
+**Validation:** Every `.md` file in the working directory has valid YAML frontmatter that parses without error.
+
+### 2. Wiki links as graph edges
+
+`[[note title]]` creates a navigable relationship between notes. Filenames are unique; links resolve by name, not path. Each link is an explicit, curated edge in the knowledge graph. Since [[spreading activation models how agents should traverse]], reading one note activates related notes through these explicit edges, enabling multi-hop reasoning without entity extraction pipelines or embedding infrastructure.
+
+**Why universal:** Since [[each new note compounds value by creating traversal paths]], link density matters more than note count. A folder of unlinked files is a filing cabinet. A graph of linked files is a thinking structure. The difference is wiki links. And since [[inline links carry richer relationship data than metadata fields]], prose-embedded links encode WHY notes connect, not just THAT they connect.
+
+**Minimum viable version:** At least one `[[wiki link]]` per note, either inline or in a footer section.
+
+**Validation:** All wiki links resolve to existing files. No dangling links to non-existent notes.
+
+### 3. MOC hierarchy for attention management
+
+Maps of Content organize notes into navigable topic areas. Hub links to domains, domains link to topics, topics link to notes. Since [[MOCs are attention management devices not just organizational tools]], MOCs reduce context-switching cost by presenting topic state immediately — the agent reads one file and knows what a topic contains, what tensions exist, and what gaps remain. Without MOCs, since [[navigational vertigo emerges in pure association systems without local hierarchy]], a flat sea of linked notes becomes disorienting at scale.
+
+**Why universal:** Every knowledge system, regardless of domain, needs navigation structures that manage attention. A therapy journal needs mood-pattern MOCs. A research vault needs topic MOCs. A relationship tracker needs person MOCs. The domain vocabulary changes; the structural need for curated navigation hubs does not.
+
+**Minimum viable version:** At least one hub MOC that links to all topic areas. Topic MOCs with Core Ideas sections containing context phrases explaining each linked note.
+
+**Validation:** Every note appears in at least one MOC. No orphan notes outside the navigation structure (after initial creation window).
+
+### 4. Tree injection at session start
+
+The agent sees the full file structure immediately upon session start. This provides orientation before action — the agent knows what exists before deciding what to read. For CLI agents, this means a hook or startup script that injects the directory tree. For messaging agents, this means loading a workspace map file.
+
+**Why universal:** Since [[fresh context per task preserves quality better than chaining phases]], each session starts with a limited context budget. Tree injection spends a small fraction of that budget to provide complete structural awareness, which then guides efficient context loading for the rest of the session. Without it, the agent wastes context on discovery that could go toward productive reasoning.
+
+**Minimum viable version:** A file listing (`tree` or equivalent) showing all directories and markdown files, loaded at session start. Maximum three levels deep to stay within reasonable token budgets.
+
+**Validation:** The agent can identify any file's path without searching. Tree is current (no stale entries, no missing files).
+
+### 5. Description field for progressive disclosure
+
+Every note has a `description` in its YAML frontmatter — one sentence (~150 characters) that adds information beyond the title. The title gives the claim; the description gives scope, mechanism, or implication. Since [[descriptions are retrieval filters not summaries]], descriptions enable the agent to decide whether to read a note without loading it. This is progressive disclosure at the note level: title is layer one, description is layer two, content is layer three.
+
+**Why universal:** Since [[flat files break at retrieval scale]], at 50 notes an agent can read everything, but at 500 retrieval becomes the bottleneck. Descriptions become the filter that determines what enters context. Since [[good descriptions layer heuristic then mechanism then implication]], effective descriptions compress a note's value proposition into a single sentence. Without descriptions, every navigation decision requires loading the full note — an O(n) cost that becomes prohibitive as the vault grows.
+
+**Minimum viable version:** Every note has a `description` field in YAML. The description does not merely restate the title.
+
+**Validation:** `description` field present on every note. Description text differs substantively from the title.
+
+### 6. Topics footer linking notes to MOCs
+
+Every note declares which MOC(s) it belongs to via a `topics` field (YAML array of wiki links). This is the bidirectional link that completes the MOC hierarchy: MOCs link down to notes via Core Ideas, notes link up to MOCs via Topics. The two-way connection ensures that neither direction goes stale independently.
+
+**Why universal:** Without Topics, notes can drift away from their MOCs — the MOC links to the note, but there's no record in the note of where it belongs. Adding topics to a second MOC becomes guesswork. More fundamentally, topics enable the query `rg '^topics:.*\[\[topic-name\]\]'` which instantly finds all notes in a topic area without reading any MOC file. This turns a navigation structure into a queryable relationship.
+
+**Minimum viable version:** Every note has a `topics` field containing at least one wiki link to a MOC.
+
+**Validation:** `topics` field present on every non-MOC note. Every wiki link in `topics` resolves to a file with `type: moc`.
+
+### 7. Schema enforcement via validation
+
+Templates define required fields, valid enum values, and constraints. A validation mechanism (script, hook, or manual check) verifies notes against their template. Since [[schema enforcement via validation agents enables soft consistency]], validation catches drift that instruction-following alone cannot prevent — as context fills, compliance with schema instructions degrades, but a validation check is deterministic.
+
+**Why universal:** Schema drift is inevitable without enforcement. An agent that creates 50 notes will forget a required field on the 47th. A validation pass catches it. The enforcement level varies by platform (hooks for Claude Code, manual runs for minimal platforms), but the principle — templates as single source of truth, validation against templates — is universal.
+
+**Minimum viable version:** One template per note type defining required fields. A validation script or procedure that checks all notes against their template.
+
+**Validation:** Running the validation procedure reports zero errors on a healthy vault.
+
+### 8. Semantic search capability
+
+Beyond keyword search, the system needs meaning-based discovery that finds conceptually related content across different vocabularies. A note about "friction in learning systems" should connect to a note about "errors as productive feedback" even though they share no keywords. Since [[spreading activation models how agents should traverse]], structural traversal through wiki links is the primary discovery mechanism, but semantic search catches what the graph misses — notes that should be connected but aren't yet.
+
+**Why universal:** At scale, keyword search misses connections between notes that use different vocabulary for the same concept. Semantic search (via embedding tools like qmd, or even LLM-assisted search) complements structural navigation. The specific implementation varies — some platforms have embedding infrastructure, others use LLM-based similarity — but the capability of finding meaning across vocabularies is necessary for connection density to grow.
+
+**Minimum viable version:** Any mechanism that finds conceptually related notes beyond exact keyword matches. This could be a dedicated embedding tool, an LLM-assisted search pass, or even a periodic manual review informed by topic adjacency.
+
+**Validation:** Given a note, the search mechanism returns at least one related note that shares no significant keywords with the query.
+
+### 9. Self space for agent persistent memory
+
+A dedicated directory where the agent stores identity, methodology, goals, and accumulated memory. Read at session start, updated at session end. Since [[session handoff creates continuity without persistent memory]], the self space is what gives each fresh session a briefing from the previous one. Without it, every session starts blank — the agent doesn't know who it is, what it's working on, or what it learned yesterday.
+
+**Why universal:** Agent continuity across sessions is not optional for knowledge work. Since [[the vault constitutes identity for agents]], losing the self space is not merely inconvenient but identity-erasing — without it, the agent reverts to base weights with no distinguishing characteristics. The self space solves this through structure rather than capability: the agent reads files to remember, rather than requiring persistent memory infrastructure. The pattern mirrors the main knowledge space (atomic notes, MOCs) applied to the agent's own cognition.
+
+**Minimum viable version:** A `self/` directory with at least `identity.md` (who the agent is), `methodology.md` (how it works), and `goals.md` (current threads). Agent reads these at every session start.
+
+**Validation:** Self space exists with core MOCs populated. Session start procedure includes reading self/.
+
+### 10. Session rhythm: orient, work, persist
+
+Every session follows a three-phase rhythm. Orient: read self space and relevant MOCs to understand current state. Work: execute the task, surfacing connections as you go. Persist: update MOCs, capture observations, externalize anything learned. This rhythm is encoded in the context file as a non-negotiable procedure.
+
+**Why universal:** Since [[closure rituals create clean breaks that prevent attention residue bleed]], explicit session boundaries prevent both cold starts (no orientation) and lost work (no persistence). The orient phase ensures the agent doesn't duplicate effort. The persist phase ensures discoveries survive the session. Without this rhythm, knowledge work degrades into disconnected episodes that don't build on each other.
+
+**Minimum viable version:** Context file instructions specifying: (1) read self/ at session start, (2) capture insights during work, (3) update MOCs and push changes at session end.
+
+**Validation:** Session start loads self/ orientation. Session end produces observable state changes (updated files, committed changes).
+
+## What the Kernel Enables
+
+These ten primitives together create a system where:
+- Notes are portable, queryable, and agent-readable (primitives 1, 5)
+- The knowledge graph grows through explicit, reasoned connections (primitive 2)
+- Navigation scales with content through curated attention hubs (primitives 3, 6)
+- Agents orient immediately without wasting context on discovery (primitive 4)
+- Quality is enforced structurally, not just through instructions (primitive 7)
+- Conceptual connections are discoverable across vocabularies (primitive 8)
+- Agent identity and continuity persist across sessions (primitive 9)
+- Every session builds on prior work and preserves new understanding (primitive 10)
+
+The navigation primitives in particular (2, 3, 4, 5) do not merely operate independently — since [[structure enables navigation without reading everything]], wiki links, MOCs, claim titles, and descriptions compose into a discovery layer stack where each mechanism serves a distinct filtering function and the composition turns retrieval from linear scan into targeted traversal. The kernel enables this composition by guaranteeing all four primitives are always present.
+
+Everything above the kernel — the eight configuration dimensions, the processing pipeline phases, the specific methodology tradition, the domain-specific schema extensions, the automation level — varies per use case. The kernel does not. When [[methodology traditions are named points in a shared configuration space not competing paradigms]], Zettelkasten, PARA, Cornell, Evergreen, and GTD all include these ten primitives in their different ways. The kernel is the shared substrate beneath all named configurations.
+
+## The Derivation Constant
+
+For the derivation engine, the kernel is the constant term. Since [[derivation generates knowledge systems from composable research claims not template customization]], derivation decides configuration values for the eight dimensions — but the kernel is always included, never derived. This simplifies derivation considerably: instead of deciding everything from scratch, the engine inherits these ten primitives and focuses design effort on dimension selection and domain adaptation. Since [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]], the processing skeleton sits atop the kernel, using its primitives (notes for capture, links for connection, MOCs for navigation, validation for verification) while adding domain-specific processing logic.
+
+The kernel is also the portability guarantee. Since [[configuration dimensions interact so choices in one create pressure on others]], a system might need heavy processing, deep navigation, and dense schemas — all of which require platform-specific infrastructure. But if the platform changes, the kernel survives intact. The system loses its automation and orchestration layers but retains its intellectual content and navigation structure. This is exit velocity by design: the kernel is what you take with you when you leave.
+
+---
+---
+
+Relevant Notes:
+- [[structure enables navigation without reading everything]] — synthesis showing how primitives 2, 3, 4, 5 compose into a discovery layer stack; the kernel guarantees these four mechanisms are always co-present, and their composition is what turns retrieval from linear scan into targeted traversal
+- [[four abstraction layers separate platform-agnostic from platform-dependent knowledge system features]] — the kernel maps to the foundation and convention layers; everything here works without hooks, skills, or orchestration
+- [[cognitive offloading is the architectural foundation for vault design]] — the cognitive science grounding: each primitive exists because agents need external structures to think beyond context window limits
+- [[eight configuration dimensions parameterize the space of possible knowledge systems]] — dimensions parameterize variation ABOVE the kernel; these ten primitives are what never varies
+- [[derivation generates knowledge systems from composable research claims not template customization]] — derivation navigates dimensions while inheriting the kernel unchanged; the kernel is the derivation constant
+- [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]] — the processing skeleton sits atop the kernel; capture-process-connect-verify needs these primitives to operate
+- [[local-first file formats are inherently agent-native]] — explains why the kernel requires only filesystem access: plain text with embedded metadata needs no infrastructure
+- [[MOCs are attention management devices not just organizational tools]] — grounds primitive 3 in cognitive science: MOCs reduce context-switching cost by presenting topic state immediately
+- [[session handoff creates continuity without persistent memory]] — grounds primitive 10: externalized state in files gives each fresh session a briefing from the previous one
+- [[configuration dimensions interact so choices in one create pressure on others]] — dimension interactions operate above the kernel; the kernel is the invariant substrate that all coherent configurations share
+- [[methodology traditions are named points in a shared configuration space not competing paradigms]] — every methodology tradition includes these ten primitives; they are the shared substrate beneath all named configurations
+- [[descriptions are retrieval filters not summaries]] — grounds primitive 5: the description field enables progressive disclosure, letting agents decide what to read before loading
+- [[spreading activation models how agents should traverse]] — grounds primitive 2: wiki links implement spreading activation for agents, priming related concepts through explicit edges
+- [[schema enforcement via validation agents enables soft consistency]] — grounds primitive 7: validation against templates catches drift that instruction-following alone cannot prevent
+- [[premature complexity is the most common derivation failure mode]] — the kernel defines the floor of the complexity budget: minimum viable configuration cannot go below these ten primitives, and the budget constrains initial derivation between this floor and the locally-justified-but-globally-unsustainable maximum
+- [[composable knowledge architecture builds systems from independent toggleable modules not monolithic templates]] — the composable architecture builds its module dependency graph on top of the kernel: foundation modules correspond to these primitives, and every higher-layer module assumes the kernel is present
+- [[the vault constitutes identity for agents]] — why primitives 9 and 10 are existential not just operational: if the vault constitutes identity, then the self space (primitive 9) and session rhythm (primitive 10) are identity-maintenance infrastructure, not convenience features; without them the agent loses not just continuity but selfhood
+- [[flat files break at retrieval scale]] — the failure the kernel prevents: without these ten primitives, any agent knowledge system degrades to flat files at scale, hitting the retrieval wall where content becomes unfindable and agent cognition narrows to what can be located by accident
+
+Topics:
+- [[design-dimensions]]

package/methodology/testing effect could enable agent knowledge verification.md

@@ -0,0 +1,38 @@
+---
+description: Agents can apply the testing effect to verify vault quality by predicting note content from title+description, then checking against actual content
+kind: research
+topics: ["[[agent-cognition]]"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# testing effect could enable agent knowledge verification
+
+The testing effect (Roediger & Karpicke, 2006) demonstrates that self-testing strengthens memory more than re-reading. This is why Cornell Note-Taking emphasizes the cue column: covering notes and quizzing yourself on content creates stronger retention than passively reviewing.
+
+Hypothesis: agents can apply this same pattern to verify vault quality. Instead of strengthening memory, the testing effect reveals whether descriptions enable retrieval. An agent reads only the title and description, predicts what the note should contain, then checks against actual content. Notes that fail prediction need better descriptions or restructuring.
+
+This is quality assurance through simulated use rather than static linting. Because [[skills encode methodology so manual execution bypasses quality gates]], retrieval testing can encode this workflow as a quality gate — the testing effect methodology becomes enforceable rather than optional. The experiment tests whether the pattern produces measurable quality improvements. Since [[retrieval verification loop tests description quality at scale]], this principle extends from individual verification to systematic vault-wide assessment — running prediction-then-verify cycles across all notes with scoring and tracking transforms description quality from subjective judgment to measurable property. An alternative implementation emerges from [[mnemonic medium embeds verification into navigation]], where verification happens during traversal rather than as a separate phase — link context phrases become the prompts that test whether relationships hold.
+
+The sibling experiment [[metacognitive confidence can diverge from retrieval capability]] tests a prior question: whether verification is even necessary, or whether structural quality signals (descriptions exist, links are dense) reliably predict retrieval success without testing. If structural metrics correlate with retrieval, retrieval testing is redundant with good structure. If they diverge, retrieval testing becomes essential.
+
+The testing effect directly validates whether [[progressive disclosure means reading right not reading less]]. Progressive disclosure assumes that descriptions provide enough information to decide what deserves full reading. If an agent can't predict note content from title and description, the disclosure layer has failed — the filtering information doesn't match what's being filtered. Retrieval testing is the verification mechanism for this assumption.
+---
+
+Relevant Notes:
+- [[the generation effect requires active transformation not just storage]] — related cognitive effect; generation creates hooks, testing reveals whether hooks work
+- [[summary coherence tests composability before filing]] — sibling pattern: this note tests description quality via prediction, that note tests structural coherence via summary generation; both use attempted generation as diagnostic
+- [[descriptions are retrieval filters not summaries]] — the theory this experiment tests: if descriptions are filters, testing should reveal filter quality
+- [[good descriptions layer heuristic then mechanism then implication]] — provides testable structure: retrieval test failures should map to missing layers (no mechanism, no implication)
+- [[does agent processing recover what fast capture loses]] — sibling experiment on whether agent-driven quality processes work
+- [[claims must be specific enough to be wrong]] — the specificity anti-pattern applies to descriptions: paraphrase descriptions fail recite because they lack the specificity needed to enable prediction
+- [[skills encode methodology so manual execution bypasses quality gates]] — retrieval testing is a skill encoding the testing effect as a quality gate; without the skill, this verification would be ad-hoc and inconsistent
+- [[progressive disclosure means reading right not reading less]] — recite validates whether progressive disclosure works: if descriptions don't predict content, the disclosure layer has failed
+- [[spaced repetition scheduling could optimize vault maintenance]] — sibling Cornell-derived experiment: this note tests what verification reveals (description quality), that note tests when verification happens (adaptive scheduling); both optimize maintenance through cognitive science principles
+- [[maintenance targeting should prioritize mechanism and theory notes]] — provides targeting guidance: reweave this experiment toward description quality theory notes, not MOC neighbors
+- [[verbatim risk applies to agents too]] — interdependent experiment: if testing effect validates, retrieval testing becomes the detection mechanism for verbatim-style outputs that look structured but contain no genuine synthesis
+- [[metacognitive confidence can diverge from retrieval capability]] — sibling experiment: this tests WHETHER recite works as verification, that tests WHETHER verification is necessary (because structural metrics may produce false confidence without testing)
+- [[retrieval verification loop tests description quality at scale]] — operationalizes this principle at scale: systematic scoring across all vault notes with 5-point measurement, pattern detection, and continuous improvement tracking
+- [[dual-coding with visual elements could enhance agent traversal]] — sibling Cornell-derived experiment: this tests text-based verification via prediction, that tests visual enhancement via dual encoding; both propose alternative channels for agent cognition
+
+Topics:
+- [[agent-cognition]]

package/methodology/the AgentSkills standard embodies progressive disclosure at the skill level.md

@@ -0,0 +1,40 @@
+---
+description: The same metadata-then-depth loading pattern that governs note retrieval in the vault also governs skill loading in the AgentSkills standard, revealing a structural isomorphism driven by shared
+kind: research
+topics: ["[[discovery-retrieval]]", "[[agent-cognition]]"]
+methodology: ["Original"]
+source: [[agent-platform-capabilities-research-source]]
+---
+
+# the AgentSkills standard embodies progressive disclosure at the skill level
+
+The AgentSkills standard structures skill loading in three layers: metadata (roughly 100 tokens) loads at startup for all skills so the agent knows what is available, full instructions (recommended under 5000 tokens) load when the skill is activated, and supporting resources load only when needed. This is the same progressive disclosure pattern the vault uses for knowledge content -- file tree gives awareness, descriptions give filtering, full notes give depth -- operating at the infrastructure level instead of the content level.
+
+The structural parallel is not a coincidence. Both systems face the same fundamental constraint: context windows are finite, and what fills them determines reasoning quality. Since [[progressive disclosure means reading right not reading less]], the goal is a context window dense with relevant material, not one stuffed with everything available. At the note level, since [[structure enables navigation without reading everything]], four structural mechanisms — wiki links, MOCs, claim titles, and YAML descriptions — compose into the discovery layer stack that makes this filtering operational. At the skill level, this means metadata filters before full instructions load. The pattern recurs because the constraint recurs — and at the content level, the composition of four distinct filtering mechanisms demonstrates how progressive disclosure goes beyond a single technique to become an architectural pattern.
+
+What makes this more than an analogy is that both layers interact within the same context window. An agent's context budget absorbs skill descriptions and note descriptions simultaneously. Since [[skill context budgets constrain knowledge system complexity on agent platforms]], Claude Code allocates roughly 2% of context (with a 16,000-character fallback) for all skill descriptions, which means a knowledge system with many skills competes with note content for the same limited space. The progressive disclosure pattern is not merely similar across levels -- it is the same resource management strategy applied twice to the same scarce resource. And since [[metadata reduces entropy enabling precision over recall]], skill metadata is information-theoretically identical to note descriptions: both are pre-computed low-entropy representations that shrink the search space before full content loads. The difference is that skill metadata operates under a platform-enforced hard budget while note descriptions face only the softer constraint of attention degradation.
+
+Since [[skills encode methodology so manual execution bypasses quality gates]], skills carry accumulated learning in their instructions and quality gates. The progressive disclosure loading pattern ensures this accumulated learning enters context only when relevant, not constantly. A vault with twenty skills would overwhelm context if every skill's full instructions loaded at startup. The metadata layer lets the agent hold awareness of all twenty skills while only loading the full methodology for the one it needs right now.
+
+The pattern also has a pragmatic standardization value. Since [[platform fragmentation means identical conceptual operations require different implementations across agent environments]], the AgentSkills standard reduces fragmentation at the skill metadata level by defining a common SKILL.md format that works across twenty-plus platforms. The metadata layer is standardizable precisely because it is the progressive disclosure layer -- it captures what any agent needs to know (what the skill does, when to use it) while leaving platform-specific implementation details in the full instructions that load on demand. The standard solves fragmentation where the cost of fragmentation is lowest: at the awareness layer, where agents need to know what skills exist, not how they work internally.
+
+The complementary infrastructure story connects to how [[hooks enable context window efficiency by delegating deterministic checks to external processes]]. Hooks save context by running validation outside the context window entirely. Skill progressive disclosure saves context by deferring full instructions until needed. Together, these mechanisms form the complete context management strategy at the infrastructure level: hooks handle what can run externally, progressive disclosure handles what must enter context but can enter on demand rather than at startup.
+
+The deeper implication is architectural: any system that operates under context window constraints will converge on progressive disclosure patterns at every level of its stack. But convergence requires the platform to support the pattern. Since [[platform capability tiers determine which knowledge system features can be implemented]], the AgentSkills standard's progressive disclosure only functions at tier one and tier two, where skill infrastructure exists. At tier three, there are no skills to disclose progressively — the methodology lives entirely in instruction-level context files, and the metadata-then-depth loading pattern collapses to a single layer. The standard standardizes an inherently tier-dependent feature, which means its portability value is bounded by the tier distribution of actual agent platforms. Since [[intermediate packets enable assembly over creation]], skill metadata functions as a packet specification -- it tells the orchestrator what the skill does and when to invoke it, enabling workflow assembly from modular skills rather than monolithic execution. The metadata-then-instructions pattern is literally a packet structure: compressed awareness enabling informed assembly decisions. The question is not whether to use progressive disclosure but at which levels it has been implemented and at which levels it is still missing.
+---
+
+Relevant Notes:
+- [[progressive disclosure means reading right not reading less]] -- foundation: the vault philosophy that this claim extends to infrastructure
+- [[structure enables navigation without reading everything]] -- content-level counterpart: composes wiki links, MOCs, claim titles, and descriptions into the discovery layer stack that demonstrates progressive disclosure as an architectural pattern, not just a single technique
+- [[skills encode methodology so manual execution bypasses quality gates]] -- establishes that skills carry accumulated learning, making their loading pattern consequential
+- [[descriptions are retrieval filters not summaries]] -- the note-level instance of the same pattern: descriptions enable filtering before full content loading
+- [[skill context budgets constrain knowledge system complexity on agent platforms]] -- develops the hard budget constraint (2% / 16k chars) that makes this progressive disclosure pattern not optional but mandatory
+- [[metadata reduces entropy enabling precision over recall]] -- provides the information-theoretic formalization: skill metadata is entropy-reducing pre-computation, the same mechanism that justifies note descriptions
+- [[platform fragmentation means identical conceptual operations require different implementations across agent environments]] -- the AgentSkills standard partially solves fragmentation by standardizing the metadata layer while leaving platform-specific capabilities outside scope
+- [[hooks enable context window efficiency by delegating deterministic checks to external processes]] -- complementary context efficiency mechanism: hooks save context by running outside the window, progressive disclosure saves context by loading on demand; together they form the complete infrastructure-level context management story
+- [[intermediate packets enable assembly over creation]] -- skill metadata functions as a packet specification: it tells the orchestrator what the skill does and when to invoke it, enabling workflow assembly from modular skills
+- [[platform capability tiers determine which knowledge system features can be implemented]] -- the progressive disclosure pattern at the skill level only operates at tier one and two; tier-three platforms lack skill infrastructure entirely, collapsing the metadata-then-depth pattern to a single instruction layer
+
+Topics:
+- [[discovery-retrieval]]
+- [[agent-cognition]]