arscontexta 0.6.0

package/methodology/three capture schools converge through agent-mediated synthesis.md

@@ -0,0 +1,55 @@
+---
+description: Accumulationist speed, Interpretationist quality, and Temporal context preservation stop being tradeoffs when agent processing handles the generation that human capture skips — the "fundamental
+kind: research
+topics: ["[[processing-workflows]]", "[[agent-cognition]]"]
+methodology: ["Capture Design", "Zettelkasten", "Evergreen"]
+source: [[tft-research-part3]]
+---
+
+# three capture schools converge through agent-mediated synthesis
+
+PKM research identifies three capture philosophies as a "fundamental divergence" — schools of thought that make incompatible assumptions about what capture should optimize for.
+
+The Accumulationist school (Progressive Summarization, Readwise) prioritizes speed and fidelity. Capture everything, highlight generously, process later. The risk is the Collector's Fallacy: accumulating without understanding, building a library that feels productive but produces no synthesis. The Interpretationist school (Zettelkasten, Smart Notes) prioritizes transformation at capture time. Rewrite in your own words, generate connections immediately, never store a quote without your reaction. The risk is friction: interpretation is slow, and the friction prevents capturing thoughts that arrive faster than you can process them. The Temporal school (Daily Notes, Roam) prioritizes context preservation through chronological ordering. Everything lands on today's page, linked but not filed, organized by when rather than what. The risk is retrieval complexity: without spatial filing, finding things depends entirely on link quality and search.
+
+These schools diverge because they make different assumptions about who does the processing and when. Accumulationists defer processing entirely. Interpretationists process at capture time. Temporalists replace processing with linking. Each optimizes one dimension while sacrificing others — speed, quality, or context.
+
+Agent operation dissolves this divergence by splitting capture and processing across different actors. The human captures with Accumulationist speed: zero-friction dumps, voice memos, rapid highlights. No interpretation required at capture time — and since [[Zeigarnik effect validates capture-first philosophy because open loops drain attention]], this speed is not merely convenient but cognitively necessary, because every uncaptured thought drains working memory until externalized. The agent then processes with Interpretationist quality: extracting claims, writing descriptions, generating connections, producing the synthesis that Zettelkasten demands. Since [[the generation effect requires active transformation not just storage]], the agent's processing is genuine generation — producing descriptions, articulated connections, and synthesis claims that didn't exist in the source — not mere reorganization. The convergence only works because the agent does real interpretive work, not because it automates filing.
+
+The Temporal school's contribution survives in a different form. Daily Notes preserve capture context through chronological ordering. In the agent-mediated model, context preservation happens through temporal processing urgency instead: since [[temporal separation of capture and processing preserves context freshness]], processing must follow capture within hours before Ebbinghaus decay erodes the context that makes interpretation possible. The temporal dimension shifts from an organizational principle (file by date) to a processing constraint (process before context fades). The Temporal school's insight — that when matters — is preserved even though its mechanism (Daily Notes) is replaced.
+
+But this convergence has a shadow side. Since [[does agent processing recover what fast capture loses]], the system gets Interpretationist quality while the human gets Accumulationist encoding — which is to say, minimal encoding. The generation effect benefits whoever generates, and if agents do all the generating, the human's understanding may be shallow even as the vault's representation is deep. Since [[cognitive outsourcing risk in agent-operated systems]], this is not just encoding loss but potential skill atrophy — the human may lose not only specific memories but the meta-cognitive ability to structure ideas and recognize connections. The convergence is real at the system level but potentially hollow at the human level. This is why [[capture the reaction to content not just the content itself]] matters: prompting for reactions at capture time preserves a sliver of Interpretationist encoding within Accumulationist speed. "What's your reaction?" costs seconds but generates a human-side cognitive hook that pure agent processing cannot reconstruct.
+
+The convergence is not just theoretical — since [[vibe notetaking is the emerging industry consensus for AI-native self-organization]], the "dump and AI organizes" pattern is converging across tools from Notion AI to Mem to Supermemory. But most implementations stop at embedding-based linking rather than genuine agent-curated synthesis. The industry validates the capture convergence while mostly failing the processing convergence: tools implement Accumulationist speed without Interpretationist quality, producing searchable archives rather than traversable knowledge graphs. The differentiation lives in whether the agent generates reasoned connections or merely clusters by surface similarity.
+
+The convergence also depends on what the agent actually does with accumulated content. Since [[concept-orientation beats source-orientation for cross-domain connections]], the agent must extract concepts from sources rather than merely filing them. Accumulationist capture without concept extraction just produces well-organized hoarding — the first stage in what [[PKM failure follows a predictable cycle]] documents as a 7-stage cascade from collection to abandonment. The agent's interpretive pass must transform accumulated material into concept nodes that can participate in cross-domain synthesis — otherwise the convergence delivers Accumulationist speed without Interpretationist value, which is exactly the Collector's Fallacy dressed in automation.
+
+There is a practical mechanism that bridges Accumulationist speed with some Interpretationist structure even before agent processing begins: since [[schema templates reduce cognitive overhead at capture time]], pre-defined fields can prompt minimal generative acts during capture without imposing the full friction of manual rewriting. Fill "key claim" and "my reaction" rather than restructuring the entire passage. This is not full Interpretationist processing, but it seeds the agent's later work with human-generated anchors that improve extraction quality.
+
+The deeper claim is that the "fundamental divergence" was an artifact of assuming a single actor. Because [[methodology traditions are named points in a shared configuration space not competing paradigms]], the capture schools are also configuration choices along the processing-intensity dimension — Accumulationist at the light end, Interpretationist at the heavy end, Temporal using time as a substitute for both. Framing them as configurations rather than competing philosophies makes mixing them natural rather than contradictory. When one person must capture AND process, speed and quality genuinely trade off. When capture and processing are distributed — human for speed, agent for quality — the tradeoff dissolves into a division of labor. The schools converge not because one wins but because agent mediation lets you take the best of each: Accumulationist speed, Interpretationist depth, Temporal urgency. Since [[cognitive offloading is the architectural foundation for vault design]], frictionless capture is optimal for offloading economics, and agent processing addresses the generation gap that pure offloading creates. The convergence is the architecture working as designed. And because [[AI shifts knowledge systems from externalizing memory to externalizing attention]], the convergence represents something more than workflow optimization — it is an instance of the broader shift where agents externalize not just what you know but what you attend to, deciding which claims deserve extraction and which connections are genuine.
+
+Since [[incremental formalization happens through repeated touching of old notes]], the convergence isn't a one-shot event either. The agent's initial processing is the first interpretive pass, but subsequent traversals — during reflect, reweave, and organic encounters — continue crystallizing what fast capture deposited as raw material. The Interpretationist ideal of fully processed notes is achieved not at capture time but through accumulated agent touches over time.
+
+---
+---
+
+Relevant Notes:
+- [[temporal separation of capture and processing preserves context freshness]] — operationalizes the timing dimension: agent mediation only works if processing follows capture before Ebbinghaus decay erodes the context that makes interpretation possible
+- [[the generation effect requires active transformation not just storage]] — the mechanism that makes Interpretationist quality real: agent processing must produce genuine generation (descriptions, connections, synthesis), not just reorganization, for the convergence to deliver on its promise
+- [[does agent processing recover what fast capture loses]] — the critical tension: convergence delivers system-level quality but may sacrifice human encoding benefits, splitting who benefits from the generation effect
+- [[capture the reaction to content not just the content itself]] — the middle path that preserves human generation within fast capture: prompting for reactions at capture time maintains encoding benefits without Interpretationist friction
+- [[concept-orientation beats source-orientation for cross-domain connections]] — the extraction step that makes convergence productive: agent processing must extract concepts from accumulated sources, not just file them, or Accumulationist speed produces Accumulationist hoarding
+- [[cognitive offloading is the architectural foundation for vault design]] — the theoretical foundation: frictionless capture is optimal for offloading economics, and agent processing addresses the generation gap that pure offloading creates
+- [[incremental formalization happens through repeated touching of old notes]] — the temporal dimension of convergence: initial agent processing is the first formalization pass, subsequent traversals continue crystallizing what fast capture initially deposited as raw material
+- [[schema templates reduce cognitive overhead at capture time]] — a practical convergence mechanism: templates give Accumulationist capture some Interpretationist structure without requiring full manual rewriting
+- [[cognitive outsourcing risk in agent-operated systems]] — the deepest shadow side: convergence may produce not just encoding loss but skill atrophy, where humans lose the meta-cognitive ability to structure ideas after delegating all processing to agents
+- [[Zeigarnik effect validates capture-first philosophy because open loops drain attention]] — cognitive science grounding for Accumulationist speed: zero-friction capture is not just practical but necessary because uncaptured thoughts drain working memory via open loops
+- [[PKM failure follows a predictable cycle]] — the documented cascade that convergence must prevent: without genuine agent processing, Accumulationist speed triggers Stage 1 (Collector's Fallacy) leading to eventual abandonment
+- [[AI shifts knowledge systems from externalizing memory to externalizing attention]] — the broader paradigm shift: the convergence is an instance of agents externalizing not just storage but attention allocation, deciding what deserves extraction and connection
+- [[vibe notetaking is the emerging industry consensus for AI-native self-organization]] — industry validation: the dump-and-AI-organizes consensus across tools is the convergence happening at product scale, but most implementations stop at embedding-based filing rather than agent-curated synthesis
+- [[storage versus thinking distinction determines which tool patterns apply]] — maps the divergence: Accumulationist/Interpretationist maps onto storage/thinking; agent mediation dissolves the divergence by enabling thinking-system quality with storage-system capture speed
+- [[methodology traditions are named points in a shared configuration space not competing paradigms]] — the configuration view applied to capture philosophy: capture schools are positions on the processing-intensity dimension rather than competing paradigms, and agent mediation dissolves their apparent incompatibility by distributing configuration across actors
+
+Topics:
+- [[processing-workflows]]
+- [[agent-cognition]]

package/methodology/three concurrent maintenance loops operate at different timescales to catch different classes of problems.md

@@ -0,0 +1,56 @@
+---
+description: Fast loops (per-event hooks) catch instant violations, medium loops (per-session checks) catch accumulated drift, and slow loops (weekly-monthly audits) catch structural evolution — each timescale
+kind: research
+topics: ["[[maintenance-patterns]]"]
+methodology: ["Systems Theory", "Original"]
+source: [[automated-knowledge-maintenance-blueprint]]
+---
+
+# three concurrent maintenance loops operate at different timescales to catch different classes of problems
+
+A single maintenance schedule cannot serve a knowledge system because the problems it faces develop at fundamentally different rates. A schema violation exists the instant a malformed note is saved. An orphan note accumulates over the course of a session as new notes arrive without MOC updates. Stale descriptions develop over weeks as understanding evolves and the surrounding graph changes. These are not the same problem at different severities — they are different classes of problem with different propagation characteristics, and addressing them requires different operational architectures running concurrently.
+
+The three-loop architecture groups maintenance by timescale, giving each loop a distinct character:
+
+**The fast loop** operates per-event, typically in sub-second response. Schema validation on every write, auto-commit after every file change, index invalidation when content changes. These operations are fully mechanical — they require zero judgment and produce deterministic results. Since [[hook enforcement guarantees quality while instruction enforcement merely suggests it]], the fast loop runs as infrastructure rather than instruction, firing regardless of agent attention state. The fast loop catches problems that cannot wait because downstream operations immediately consume the output. A malformed note that passes schema validation will be linked from MOCs, cited in other notes, and indexed for semantic search — each consuming the broken state before any scheduled check could catch it.
+
+**The medium loop** operates per-session or per-day. Health dashboards at session start, qmd freshness checks before semantic search, orphan detection between processing batches. These operations combine mechanical detection with judgment-requiring remediation. Since [[session boundary hooks implement cognitive bookends for orientation and reflection]], the medium loop's detection side is already implemented — the session-start health check compares actual vault state against desired state and surfaces the delta. The medium loop catches problems that accumulate within or across a small number of sessions but do not propagate catastrophically. Since [[agent session boundaries create natural automation checkpoints that human-operated systems lack]], the discrete session architecture provides enforcement points that continuous human operation lacks — each boundary is an event where maintenance can fire automatically, which is why the medium loop is structurally feasible for agents in a way it is not for humans. An orphan note is equally orphaned whether you detect it after one minute or one hour, so per-event checking would waste the attention budget without catching problems faster.
+
+**The slow loop** operates per-week or per-month. Full vault health audits, meta-cognitive review of accumulated observations and tensions, trend analysis across maintenance logs, structural review of MOC sizes and graph topology. These are high-judgment operations that require loading significant context and reasoning about patterns rather than checking individual items. The slow loop catches problems that develop as understanding evolves — since [[spaced repetition scheduling could optimize vault maintenance]], individual note review at maturity-adapted intervals operates within this timescale, where newly created notes get shorter review intervals and mature notes get longer ones. Since [[evolution observations provide actionable signals for system adaptation]], the slow loop's detection side has a concrete diagnostic protocol: six observation patterns (unused types, N/A-stuffed fields, emergent fields, navigation failure, unlinked output, oversized MOCs) each mapping to specific structural causes and prescribed responses. The slow loop also catches problems that no individual check can detect: gradual methodology drift, assumption invalidation, structural imbalances in the graph.
+
+The key insight is that each loop has a different relationship between detection and remediation. In the fast loop, detection and remediation are identical — a schema check that finds a violation blocks the write, and the agent immediately fixes it. In the medium loop, detection is mechanical but remediation requires judgment — orphan detection is a simple graph query, but deciding whether to connect or archive an orphan requires understanding the note's role. In the slow loop, even detection requires judgment — determining whether a description has gone stale requires comparing the note's claims against current understanding, which is a semantic operation. Since [[confidence thresholds gate automated action between the mechanical and judgment zones]], each loop operates at a different point on the confidence spectrum: the fast loop auto-applies, the medium loop suggests, and the slow loop logs for review. This gradient maps directly onto the question of when to fix versus merely flag — since [[the fix-versus-report decision depends on determinism reversibility and accumulated trust]], the fast loop passes all four conditions trivially (deterministic, reversible, low-cost, trusted), the medium loop passes detection but not remediation conditions, and the slow loop fails even the determinism condition for detection itself. The four-condition framework operationalizes what it means for each loop to have a "different relationship between detection and remediation."
+
+The loops are not nested versions of the same check but genuinely different operations. The fast loop cannot catch what the slow loop catches because stale descriptions do not violate any schema — they are valid at write time and become misleading only as context changes. The slow loop cannot replace the fast loop because a weekly audit that catches a schema violation means a week of downstream operations consumed broken state. Since [[reconciliation loops that compare desired state to actual state enable drift correction without continuous monitoring]], all three loops implement the same reconciliation pattern — declare desired state, measure divergence, correct — but they differ in what "desired state" means, how divergence is measured, and how correction happens.
+
+This architecture also explains why since [[maintenance scheduling frequency should match consequence speed not detection capability]], the constraint on each loop's frequency is the propagation rate of the problems it targets rather than the cost of running the check. The fast loop runs per-event because schema violations propagate instantly. The medium loop runs per-session because orphan accumulation propagates at session scale. The slow loop runs per-month because description staleness propagates at the timescale of understanding evolution. Since [[automated detection is always safe because it only reads state while automated remediation risks content corruption]], running detection more frequently than necessary wastes tokens but cannot corrupt content. And since [[idempotent maintenance operations are safe to automate because running them twice produces the same result as running them once]], overlapping detection across loops is harmless — the fast loop and medium loop may both check for dangling links, but the redundant check produces identical results rather than compounding into errors.
+
+The three-loop architecture relates to but differs from its sibling scheduling concepts. The consequence speed spectrum provides the theoretical principle — match frequency to propagation rate. Spaced repetition provides the note-level implementation within the slow loop — adapt review intervals to maturity. The three-loop architecture provides the organizational container — how many concurrent loops a system needs, what each loop's character should be, and how they compose without interference. Since [[gardening cycle implements tend prune fertilize operations]], the slow loop's remediation side maps to the three gardening operations: tend catches content that needs updating, prune catches notes that have overgrown, and fertilize catches connection gaps. But the detection that triggers these gardening operations happens at the medium loop's timescale (orphan detection, link density checks), while the judgment-heavy remediation happens in the slow loop's dedicated sessions. The detection and remediation for a single class of problem can span multiple loops.
+
+The architecture also has a lifecycle dimension: checks within each loop can become obsolete. Since [[automation should be retired when its false positive rate exceeds its true positive rate or it catches zero issues]], each loop's checks need periodic evaluation — a fast-loop schema check that catches nothing for three months may indicate that upstream skills have structurally eliminated the problem, and keeping the check active wastes the attention budget the three-loop architecture was designed to protect. Retirement is the terminal tier of the scheduling spectrum: frequency zero.
+
+When any loop's detection or remediation fails silently, since [[observation and tension logs function as dead-letter queues for failed automation]], the failure evidence accumulates in atomic observation and tension notes rather than disappearing. This matters especially for detection failures — if a medium-loop health check crashes, the system loses its self-monitoring capability without knowing it has done so, and the dead-letter queue is what makes that failure visible for the slow loop's meta-cognitive review.
+
+Since [[maintenance operations are more universal than creative pipelines because structural health is domain-invariant]], the three-loop architecture transfers across knowledge system deployments because each loop checks structural properties (schema compliance, link integrity, graph topology) rather than domain semantics. The practical consequence for agent-operated systems is that maintenance is not a single activity scheduled at a single frequency but a concurrent architecture where multiple timescales operate simultaneously. Agent sessions are cheap — they cost tokens, not human time — but context is expensive, because it costs attention quality. Scheduling maintenance into its own dedicated sessions at the appropriate timescale preserves the quality budget of productive sessions while ensuring each class of problem gets caught at the rate its propagation demands.
+
+---
+---
+
+Relevant Notes:
+- [[maintenance scheduling frequency should match consequence speed not detection capability]] — provides the theoretical foundation: consequence speed determines detection frequency, and the three loops are the architectural embodiment of grouping problems by propagation rate into discrete operational tiers
+- [[spaced repetition scheduling could optimize vault maintenance]] — operates WITHIN the slow loop: spaced repetition schedules individual note review based on maturity, but the three-loop architecture is the container that determines which timescale note-level scheduling belongs to
+- [[hook enforcement guarantees quality while instruction enforcement merely suggests it]] — implements the fast loop: hooks fire on every event regardless of attention state, which is why the fast loop can guarantee schema compliance while the medium and slow loops cannot guarantee anything without explicit invocation
+- [[session boundary hooks implement cognitive bookends for orientation and reflection]] — implements the medium loop: session-start health dashboards surface problems that accumulated since the last session, placing the detection at exactly the right timescale for session-scale consequences
+- [[reconciliation loops that compare desired state to actual state enable drift correction without continuous monitoring]] — the architectural pattern underlying all three loops: each loop is a reconciliation cycle that declares desired state and periodically measures divergence, differing only in frequency and scope
+- [[automated detection is always safe because it only reads state while automated remediation risks content corruption]] — enables aggressive scheduling across all three loops: since detection only reads state, each loop can run its checks at whatever frequency consequence speed demands without risk of corruption
+- [[gardening cycle implements tend prune fertilize operations]] — the slow loop's remediation actions: tend, prune, and fertilize are what happens when slow-loop detection finds structural drift, but the detection and remediation happen at different timescales within the slow loop itself
+- [[idempotent maintenance operations are safe to automate because running them twice produces the same result as running them once]] — the safety property that makes overlapping loops harmless: when fast-loop and medium-loop checks cover the same territory, idempotency ensures redundant detection produces identical results rather than compounding errors
+- [[confidence thresholds gate automated action between the mechanical and judgment zones]] — each loop has a different confidence profile: fast loops operate in the mechanical zone (schema checks are deterministic), medium loops straddle the boundary (orphan detection is mechanical but remediation requires judgment), slow loops operate primarily in the judgment zone (structural review needs semantic understanding)
+- [[the fix-versus-report decision depends on determinism reversibility and accumulated trust]] — operationalizes the detection-remediation gradient: the four conditions (determinism, reversibility, low cost, accumulated trust) explain why the fast loop auto-fixes while the slow loop only logs; the framework maps the three loops onto the fix-versus-report spectrum
+- [[agent session boundaries create natural automation checkpoints that human-operated systems lack]] — explains why the medium loop is structurally feasible: discrete session boundaries provide enforcement points where health checks fire automatically, making per-session maintenance guaranteed rather than aspirational
+- [[evolution observations provide actionable signals for system adaptation]] — provides the slow loop's concrete diagnostic protocol: six observation patterns mapping symptoms to structural causes give the slow loop structured detection rather than open-ended pattern recognition
+- [[automation should be retired when its false positive rate exceeds its true positive rate or it catches zero issues]] — the lifecycle endpoint for checks in any loop: retirement criteria determine when a check should stop running, completing the loop lifecycle from creation through scheduling to retirement
+- [[observation and tension logs function as dead-letter queues for failed automation]] — the failure capture mechanism across all three loops: when detection or remediation fails silently, the dead-letter queue makes failures visible for slow-loop meta-cognitive review rather than allowing silent degradation
+- [[maintenance operations are more universal than creative pipelines because structural health is domain-invariant]] — grounds transferability: the three-loop architecture transfers across deployments because each loop checks structural properties rather than domain semantics
+
+Topics:
+- [[maintenance-patterns]]

package/methodology/throughput matters more than accumulation.md

@@ -0,0 +1,58 @@
+---
+description: Success in knowledge systems is measured by processing velocity from capture to synthesis, not by the size of the archive
+kind: research
+topics: ["[[processing-workflows]]"]
+---
+
+# throughput matters more than accumulation
+
+The fundamental mistake in knowledge management is measuring success by what you have instead of what flows through. PKM research names this the "Collector's Fallacy" — believing that saving information equals learning. A vault with 10,000 unprocessed notes is not ten times more valuable than one with 1,000 — it's potentially worse, because accumulation without synthesis creates a graveyard of good intentions. Since [[behavioral anti-patterns matter more than tool selection]], the Collector's Fallacy is behavioral, not tool-dependent — users migrate from app to app seeking features that will solve their throughput problems, but the behavior travels with them. Since [[structure without processing provides no value]], even sophisticated structure — flat folders, wiki links, MOCs — produces no benefit when the processing steps are skipped. The Lazy Cornell anti-pattern proves this experimentally: students who draw the structural lines but skip the cognitive work show no improvement over linear notes.
+
+The insight comes from distinguishing stock from flow. Stock is static: the number of notes, the size of the archive, the breadth of coverage. Flow is dynamic: the rate at which raw captures become synthesized understanding, the velocity from inbox to integrated knowledge. Since [[ThreadMode to DocumentMode transformation is the core value creation step]], this velocity has a specific name from wiki collaboration theory — throughput measures how fast chronological thread captures become timeless synthesized documents, and the transformation itself is where value is created. But velocity has a companion metric: since [[insight accretion differs from productivity in knowledge systems]], high throughput of mechanical operations produces no value. Throughput measures speed; accretion measures depth. A session with high throughput but zero accretion has efficiently produced nothing meaningful.
+
+When capture is easy (and with AI assistance, it's nearly frictionless), the constraint shifts entirely to processing. Anyone can clip articles, save highlights, dump voice notes. The differentiator is whether those captures ever transform into something usable. This is structurally predictable: since [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]], the bottleneck always concentrates at the process phase because capture, connection, and verification are structural operations while processing requires domain-specific semantic judgment. The skeleton predicts that ANY knowledge system will find its throughput constraint at the same point. And since [[LLM attention degrades as context fills]], throughput applies at session level too — chaining phases in one session means later phases run on degraded attention, so fresh context per task becomes part of the throughput discipline. But high velocity can be deceptive: since [[verbatim risk applies to agents too]], an agent can rapidly produce well-structured outputs that reorganize content without genuine insight. This creates the illusion of throughput while the processing is merely rearrangement. True throughput requires the velocity to be of genuine synthesis, not just formatted compression.
+
+A 1:1 ratio of capture to synthesis means everything that enters gets processed. A growing gap between capture and synthesis means the system is failing regardless of how impressive the archive looks. Since [[PKM failure follows a predictable cycle]], this velocity gap is Stage 1 (Collector's Fallacy) — the first stage in a cascade that leads through under-processing, productivity porn, over-engineering, analysis paralysis, and orphan accumulation to eventual abandonment. Tracking the capture-to-synthesis ratio provides early warning before the cascade completes.
+
+This suggests concrete practices:
+
+**WIP limits on inbox.** When the inbox exceeds ~20 items, stop capturing and start processing. Accumulation is a signal to process, not to celebrate collection size. And since [[temporal separation of capture and processing preserves context freshness]], age matters too — since [[temporal processing priority creates age-based inbox urgency]], a 12-hour-old item demands attention before a 1-hour-old item because context freshness decays exponentially, with notes under 24 hours at standard priority, 24-72 hours elevated, and beyond 72 hours critical. [[continuous small-batch processing eliminates review dread]] tests the psychological mechanism: whether preventing backlog accumulation also prevents the dread that causes system abandonment.
+
+**Track the ratio.** If captures outpace synthesis by 10:1, the system isn't scaling — it's drowning. The metric that matters is throughput, not volume. Since [[spreading activation models how agents should traverse]], frequently traversed nodes reveal what actually gets used, and since [[dangling links reveal which notes want to exist]], link frequency reveals what deserves processing. These demand signals provide objective throughput metrics. And since [[queries evolve during search so agents should checkpoint]], traversal includes reassessment points — which themselves consume processing bandwidth, making throughput efficiency even more critical.
+
+**Just-in-time over just-in-case.** Since [[processing effort should follow retrieval demand]], heavy upfront processing wastes effort on content that may never be revisited. Process on demand, not on capture.
+
+The counterargument is that some knowledge compounds over time and having a large archive enables serendipitous discovery. This is true but misleading. The archive's value comes from its processedness, not its size. A small, densely connected vault enables more serendipity than a large, unprocessed dump because connections create the discovery paths — since [[small-world topology requires hubs and dense local links]], it's the topology that enables serendipity, not raw volume. But density isn't the only path to serendipity: [[incremental reading enables cross-source connection finding]] proposes that interleaved processing creates serendipity through forced context collision, not just through connection density. The open question is whether the vault's reflect phase — which finds relationships between claim notes regardless of source — already captures cross-source connections, or whether sequential extraction causes some connections to never surface as claims in the first place. And since [[wiki links implement GraphRAG without the infrastructure]], each curated link is a deliberate API invocation, not a statistical correlation. Unprocessed dumps have no edges, only nodes. You cannot traverse an unconnected graph.
+
+Flow thinking reframes what "productivity" means in knowledge work. It's not about how much you read, bookmark, or capture. It's about the transformation rate — how quickly raw inputs become integrated understanding that can be used, shared, or built upon. And since [[backward maintenance asks what would be different if written today]], throughput requires maintenance: without periodic reconsideration, even processed content becomes stale, effectively reverting to unprocessed accumulation. The question is selection: if maintenance attention follows the same power-law as link density, peripheral notes accumulate neglect. [[random note resurfacing prevents write-only memory]] tests whether random selection counteracts this bias, while [[spaced repetition scheduling could optimize vault maintenance]] tests whether interval-based scheduling — front-loading attention on recently created notes — allocates maintenance bandwidth more efficiently than uniform or random selection. The [[productivity porn risk in meta-system building]] experiment tests this principle at the system level: does building sophisticated infrastructure increase output velocity, or does it become accumulation disguised as throughput improvement? The discriminator is whether complexity growth correlates with output growth — if the system gets more sophisticated but publishes nothing more, building has become the new accumulation.
+
+Since [[intermediate packets enable assembly over creation]], high-throughput systems naturally produce composable building blocks. Each session creates a packet that future work can assemble from. The packet production rate becomes an operational throughput metric: how many reusable outputs did this session produce? This connects flow thinking to concrete practice — sessions should end with archived packets, not just completed tasks.
+---
+
+Relevant Notes:
+- [[insight accretion differs from productivity in knowledge systems]] — the complementary quality metric: throughput measures speed, accretion measures depth; high throughput of mechanical operations produces no value
+- [[processing effort should follow retrieval demand]] — the JIT processing principle that makes throughput sustainable
+- [[descriptions are retrieval filters not summaries]] — enables fast filtering, improving processing velocity
+- [[metadata reduces entropy enabling precision over recall]] — information-theoretic foundation for filtering: precision-first retrieval means fewer irrelevant notes pollute processing
+- [[good descriptions layer heuristic then mechanism then implication]] — the structural formula that makes descriptions effective filters; better-structured descriptions improve filtering speed
+- [[small-world topology requires hubs and dense local links]] — grounds the density over volume claim: topology creates discovery, not accumulation
+- [[spreading activation models how agents should traverse]] — traversal frequency provides objective throughput metrics: what gets activated is what matters
+- [[dangling links reveal which notes want to exist]] — demand signals reveal where processing investment pays off, operationalizing throughput
+- [[wiki links implement GraphRAG without the infrastructure]] — unprocessed content has nodes but no edges; throughput creates the curated links that enable traversal
+- [[queries evolve during search so agents should checkpoint]] — checkpointing adds processing overhead, making throughput efficiency even more critical for complex searches
+- [[intermediate packets enable assembly over creation]] — packets are what high-throughput systems produce: session outputs structured for reuse, enabling assembly over creation
+- [[each new note compounds value by creating traversal paths]] — WHY throughput matters: each synthesis creates new paths that increase the value of all existing notes
+- [[LLM attention degrades as context fills]] — grounds why throughput applies at session level: chained phases run on degraded attention
+- [[fresh context per task preserves quality better than chaining phases]] — the design decision that operationalizes session-level throughput: fresh context per task
+- [[random note resurfacing prevents write-only memory]] — experiments with random selection to prevent the accumulation-without-revisiting failure mode this note warns against
+- [[spaced repetition scheduling could optimize vault maintenance]] — experiments with interval-based scheduling as alternative maintenance allocation; tests whether front-loading attention preserves throughput better than uniform review
+- [[incremental reading enables cross-source connection finding]] — tests the serendipity claim: density creates discovery through topology, but interleaved processing may create additional serendipity through forced context collision that sequential extraction misses
+- [[structure without processing provides no value]] — the Lazy Cornell proof: structural affordances without processing operations produce no measurable benefit, explaining WHY throughput (processing) matters more than accumulation (structure)
+- [[PKM failure follows a predictable cycle]] — tests whether the Collector's Fallacy (the failure mode this note warns against) predicts a 7-stage cascade; if validated, throughput metrics become early-warning indicators for system failure
+- [[verbatim risk applies to agents too]] — adds quality dimension to velocity: high throughput of verbatim-style outputs is not genuine processing, so the experiment tests whether agents produce processing illusions alongside real synthesis
+- [[ThreadMode to DocumentMode transformation is the core value creation step]] — names what throughput actually produces: the transformation from chronological thread captures into timeless synthesized documents; throughput measures the velocity of this transformation
+- [[storage versus thinking distinction determines which tool patterns apply]] — scope qualifier: throughput is specifically a thinking-system metric; storage systems legitimately optimize for accumulation because their purpose IS the archive, making the Collector's Fallacy a thinking-system criticism that does not apply to storage contexts
+- [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]] — structural prediction: the bottleneck always concentrates at the process phase because capture, connection, and verification are structural operations while processing requires domain-specific semantic judgment
+
+Topics:
+- [[processing-workflows]]

package/methodology/title as claim enables traversal as reasoning.md

@@ -0,0 +1,50 @@
+---
+description: when note titles are complete claims rather than topics, traversing wiki links reads like prose and following paths becomes reasoning — the file tree becomes a scan of arguments
+kind: research
+topics: ["[[note-design]]", "[[graph-structure]]"]
+source: [[2026-01-25-build-claude-a-tool-for-thought]]
+---
+
+# title as claim enables traversal as reasoning
+
+don't name notes like topics ("thoughts on memory"). name them like claims ("structure enables navigation without reading everything").
+
+when you link to a claim-titled note, the link becomes part of your argument:
+
+> "because [[structure enables navigation without reading everything]], we invest in wiki links even though they have maintenance overhead"
+
+the title IS the reasoning. traversal IS thinking. since [[note titles should function as APIs enabling sentence transclusion]], the title functions as a typed signature — you know what you're getting before you load the full note. a topic label like "memory notes" is an undocumented function; a claim like "structure enables navigation" tells you the return value.
+
+this works because [[inline links carry richer relationship data than metadata fields]]. the prose surrounding a link encodes WHY the linked note matters here — "because `[[X]]`" is a causal claim, "since `[[Y]]`" is a foundation claim, "but `[[Z]]`" is a tension. claim-as-title makes these constructions possible, because topic labels don't compose grammatically. you can write "since [[claims must be specific enough to be wrong]]" but not "since `[[specificity notes]]`." and because [[propositional link semantics transform wiki links from associative to reasoned]], these informal relationship signals (since, because, but) could be standardized into a constrained vocabulary (causes, enables, contradicts, extends) — making the reasoning chains not just readable prose but machine-parseable argument structure.
+
+**practical benefits:**
+- scanning file tree = scanning arguments
+- following links = following reasoning chains
+- the vault becomes readable without opening files
+
+since [[progressive disclosure means reading right not reading less]], this matters for context window management. the first disclosure layer is titles. if titles are claims, agents can curate what to load based on what each note argues. if titles are topics, agents must load notes to discover what they argue — the disclosure layer fails.
+
+**contrast with topic titles:**
+- "memory notes" tells you nothing
+- "structure enables navigation" tells you the claim
+- one is a folder, the other is a thought
+
+over time, since [[implicit knowledge emerges from traversal]], the traversal paths themselves build argumentative intuition. an agent that repeatedly follows the chain from "title as claim" through "specificity" to "composability" internalizes the reasoning pattern, not just the individual facts. since [[IBIS framework maps claim-based architecture to structured argumentation]], this has a formal name: the vault is a discourse graph where claim-titled notes are Positions, wiki links are Arguments connecting them, and traversal follows argumentation chains. the informal insight that "following links reads as reasoning" turns out to map precisely onto Rittel's Issue-Position-Argument structure — claim-as-title is what makes the notes function as genuine Positions rather than vague topic gestures.
+
+but there is a shadow side. since [[vault conventions may impose hidden rigidity on thinking]], the claim-as-title pattern demands that insights resolve into sentence form. when reformulation feels forced, the question is whether the insight isn't ready or the format can't accommodate it. not every idea decomposes into a single declarative sentence — some are relational, procedural, or emergent. the pattern works best for ideas that ARE claims; it may distort ideas that aren't.
+---
+
+Relevant Notes:
+- [[note titles should function as APIs enabling sentence transclusion]] — formalizes this insight: titles as function signatures, bodies as implementation, links as function calls
+- [[claims must be specific enough to be wrong]] — the specificity requirement that makes claim-as-title work; vague titles degenerate into topic labels that carry no information when linked
+- [[inline links carry richer relationship data than metadata fields]] — explains why traversal-as-reasoning works: prose context around links encodes relationship type, making each link a typed reasoning step
+- [[structure enables navigation without reading everything]] — the navigability claim this pattern serves; claim titles are what make navigation-without-reading possible
+- [[implicit knowledge emerges from traversal]] — repeated path traversal builds intuition, and claim-titled paths make the intuition argumentative rather than merely associative
+- [[progressive disclosure means reading right not reading less]] — claim titles enable the first disclosure layer: know what a note argues before deciding to load it
+- [[vault conventions may impose hidden rigidity on thinking]] — the shadow side: forcing insights into claim-as-title form may distort genuinely non-linear or relational ideas
+- [[propositional link semantics transform wiki links from associative to reasoned]] — extends: the informal encoding this note describes (since/because/but as relationship signals) could be standardized into machine-parseable relationship types, making traversal-as-reasoning not just readable but queryable
+- [[IBIS framework maps claim-based architecture to structured argumentation]] — formalizes: claim-titled notes are Positions in Rittel's discourse framework, and traversing wiki links between them constitutes following argumentation chains — giving this note's informal insight a formal theoretical grounding
+
+Topics:
+- [[note-design]]
+- [[graph-structure]]

package/methodology/topological organization beats temporal for knowledge work.md

@@ -0,0 +1,52 @@
+---
+description: The garden vs stream distinction from digital gardening theory grounds why vaults use topic MOCs and wiki links rather than date-based folders
+kind: research
+topics: ["[[graph-structure]]"]
+methodology: ["Evergreen"]
+source: TFT research corpus (00_inbox/heinrich/)
+---
+
+# topological organization beats temporal for knowledge work
+
+Knowledge belongs in networks, not timelines. This is the theoretical foundation for why the system uses a flat structure with wiki links and topic MOCs rather than date-based folders or chronological filing.
+
+Maggie Appleton's "Topography over Timelines" principle articulates a 25-year-old distinction in knowledge work theory. Mike Caulfield (2015) and Mark Bernstein (1998) before him contrasted two fundamentally different orientations:
+
+**The Stream** — Time-ordered, ephemeral, recency-dominant. Blogs, Twitter feeds, daily journals. Content is understood by *when* it appeared. New items push old items down. What matters is what's recent. The organizing principle is the calendar.
+
+**The Garden** — Topological, timeless, integrative. Wikis, zettelkastens, knowledge graphs. Content is understood by *what it connects to*. Old ideas interweave with new ideas. What matters is how things relate. The organizing principle is the concept.
+
+The stream works for communication. When you're publishing or sharing, recency signals relevance. Readers want to know what's new. But the stream fails for thinking. Ideas don't have timestamps that matter. A good idea from last year is just as useful as one from today — more useful if it's been tested and connected. Organizing by date buries good thinking under chronological sediment.
+
+The garden works for understanding. By organizing topologically — clustering related concepts regardless of when they emerged — you can traverse by meaning rather than by recency. The question shifts from "what did I think about last Tuesday" to "what do I know about X." This is how understanding actually works: not as a timeline but as a web. But topological organization alone doesn't guarantee navigability — since [[navigational vertigo emerges in pure association systems without local hierarchy]], a purely associative garden still needs MOCs to provide local landmarks, or semantic neighbors remain unreachable.
+
+For agent-operated vaults, this distinction matters operationally. When an agent traverses the system looking for relevant context, date-based organization forces it to scan chronologically — loading "January notes" then "February notes" — with no semantic guidance. Topological organization lets it load "notes about knowledge management" directly. The structure matches how agents (and humans) actually seek understanding.
+
+But topological organization alone doesn't guarantee efficient navigation. Since [[small-world topology requires hubs and dense local links]], the power-law distribution where MOCs have many links (~90) and atomic notes have few (3-6) creates the short paths that make topological organization practical. Without this distribution — if every note had uniform connectivity — path lengths would grow with vault size, making large gardens untraversable. The garden metaphor implies cultivated structure: hubs as central clearings, atomic notes as local clusters, wiki links as paths between them.
+
+The system embodies this choice. The thinking folder is flat. Notes live as `[claim as sentence].md`, not `2026-01-30/notes.md`. Topic MOCs (like `knowledge-work.md`) provide entry points into concept clusters. Wiki links create the edges that let you traverse by meaning. There are no date folders because dates don't matter for understanding — only relationships matter. And since [[type field enables structured queries without folder hierarchies]], category-based organization (finding all methodology notes, all tensions, all synthesis) happens through metadata queries rather than folder structure — the flat architecture loses nothing while gaining the flexibility that single-folder-membership restrictions would deny.
+
+The garden-vs-stream distinction operates at the media format level too, not just the organizational level. Since [[temporal media must convert to spatial text for agent traversal]], audio and video are streams not just metaphorically but literally — time-locked sequences where reaching a specific point requires either knowing the timestamp or scanning linearly. They must convert to spatial text (markdown transcripts) before they can participate in topological organization at all. The garden metaphor applies to format choice as much as to filing structure: text is the garden, temporal media is the stream.
+
+The garden-vs-stream distinction also has a page-level twin. Since [[ThreadMode to DocumentMode transformation is the core value creation step]], individual wiki pages undergo the same transformation: ThreadMode content (chronological thread contributions organized by when) becomes DocumentMode content (timeless synthesis organized by what it means). Garden/stream is the system architecture; ThreadMode/DocumentMode is the page-level transformation that populates the garden with genuinely topological content rather than temporally organized threads dressed in wiki formatting.
+
+This is a closed design decision. The theoretical foundation is established. The implementation is committed. We use gardens for thinking.
+---
+
+Relevant Notes:
+- [[wiki links implement GraphRAG without the infrastructure]] — wiki links are the mechanism that enables topological organization
+- [[wiki links are the digital evolution of analog indexing]] — the topological pattern has 70+ year validation: Cornell cue columns indexed by concept, not chronology
+- [[concept-orientation beats source-orientation for cross-domain connections]] — extends this principle to extraction: within the garden, organize by concept not by source, enabling cross-domain edges
+- [[spreading activation models how agents should traverse]] — traversal works by semantic connections, which topological organization provides
+- [[each new note compounds value by creating traversal paths]] — compounding requires connection-based structure, not temporal sequence
+- [[retrieval utility should drive design over capture completeness]] — the foundational design principle: topological organization is retrieval-first architecture applied to structure
+- [[type field enables structured queries without folder hierarchies]] — shows how flat architecture doesnt sacrifice category-based queries: type metadata provides query dimensions without folder constraints
+- [[navigational vertigo emerges in pure association systems without local hierarchy]] — the failure mode: topological organization solves the stream problem but creates its own navigability problem when MOCs are absent
+- [[small-world topology requires hubs and dense local links]] — structural requirements: topological organization needs power-law distribution (MOC hubs with many links, atomic notes with few) to enable short paths between any concepts
+- [[faceted classification treats notes as multi-dimensional objects rather than folder contents]] — formal justification: Ranganathan's framework explains why temporal filing impoverishes retrieval by collapsing multiple independent classification dimensions into a single axis (date)
+- [[temporal media must convert to spatial text for agent traversal]] — extends the garden-vs-stream distinction to media FORMAT: audio and video are streams not just metaphorically but literally, and must convert to spatial text before they can participate in topological organization
+- [[ThreadMode to DocumentMode transformation is the core value creation step]] — the page-level twin: garden/stream is the system-level architecture, ThreadMode/DocumentMode is the page-level transformation; both articulate the same insight at different scales
+- [[storage versus thinking distinction determines which tool patterns apply]] — the garden-vs-stream distinction is the structural expression of the storage/thinking split: storage systems tolerate temporal filing while thinking systems require topological organization because 'how does this relate?' demands concept-based traversal
+
+Topics:
+- [[graph-structure]]