arscontexta 0.6.0

package/methodology/adapt the four-phase processing pipeline to domain-specific throughput needs.md

@@ -0,0 +1,197 @@
+---
+description: Pipeline philosophy for the derivation engine — when heavy, medium, or light processing is appropriate, how the four-phase skeleton adapts per domain, why throughput beats accumulation, and why fresh
+kind: guidance
+status: active
+topics: ["[[processing-workflows]]"]
+---
+
+# adapt the four-phase processing pipeline to domain-specific throughput needs
+
+The processing pipeline is where raw content becomes structured knowledge. Without processing, a vault is a folder of files — organized debris. Since [[structure without processing provides no value]], 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. Structure without processing is decoration, not knowledge work.
+
+Since [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]], every derived vault shares the same pipeline shape: capture, process, connect, verify. What varies is the depth and nature of the process step. This doc tells the plugin HOW to calibrate pipeline depth for each domain and user.
+
+## The Four-Phase Skeleton
+
+| Phase | Operation | Domain-Invariant? | Plugin Role |
+|-------|----------|-------------------|-------------|
+| **Capture** | Content enters the system | Yes — always an inbox or equivalent | Generate capture templates and quick-entry hooks |
+| **Process** | Transform into domain-appropriate form | No — entirely domain-specific | Derive the process step from domain composition |
+| **Connect** | Link to existing knowledge | Yes — graph traversal and connection finding | Generate reflect/reweave skills |
+| **Verify** | Check quality and consistency | Yes — schema compliance, link integrity | Generate validation and health check hooks |
+
+Since [[methodology traditions are named points in a shared configuration space not competing paradigms]], different domains implement different process steps but the surrounding phases are structural constants. Zettelkasten formulates permanent notes. PARA summarizes and classifies. Cornell structures cue-summary pairs. GTD routes and classifies. Each occupies a different position in the process step while sharing the same skeleton. The plugin generates the full skeleton, customizing only the process step.
+
+### Why the Skeleton Holds
+
+The skeleton holds because capture, connection, and verification are structural operations while processing is semantic. Capture answers "what entered the system?" regardless of domain. Connection answers "what relates to what?" regardless of content type. Verification answers "is this well-formed?" regardless of subject matter. But processing answers "what does this content mean in domain terms?" — and meaning is inherently domain-specific.
+
+A therapy pattern recognition algorithm and a research claim extraction workflow share no logic even though they occupy the same structural position in their respective pipelines. A legal precedent analysis and a creative writing consistency check are both "processing" but they do entirely different things. The skeleton predicts where the bottleneck always forms: at the process step, because that is where domain complexity concentrates.
+
+## Why Throughput Beats Accumulation
+
+Since [[throughput matters more than accumulation]], success in knowledge systems is measured by processing velocity — how quickly raw captures become synthesized understanding — not by the size of the archive. The fundamental mistake in knowledge management is measuring success by what you have instead of what flows through. A vault with 10,000 unprocessed notes is not ten times more valuable than one with 1,000. It is potentially worse, because accumulation without synthesis creates a graveyard of good intentions.
+
+The implication for pipeline design is concrete: the pipeline must keep content flowing. 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 to eventual system abandonment.
+
+The plugin should track this ratio. When the inbox grows beyond a threshold without processing, the system should warn. When processing stalls, the system should surface the bottleneck. The metric that matters is throughput, not volume.
+
+## The Generation Effect Gate
+
+Since [[generation effect gate blocks processing without transformation]], before any content moves from inbox to the knowledge space, at least one agent-generated artifact must exist. No artifact, no exit.
+
+The artifacts that satisfy the gate are specific: a description that condenses the content, a synthesis comment that relates it to existing notes, or a connection proposal that articulates why it should link to something else. What does not satisfy the gate is equally specific: folder assignment, tag application, filename changes, or any rearrangement that leaves the content unchanged. These are housekeeping operations that create the appearance of progress while producing no cognitive value.
+
+This gate operationalizes the distinction between processing and organizing. Moving a file from `inbox/` to `notes/` is organizing. Writing a description that captures the note's claim is processing. The gate ensures the pipeline produces genuine transformation, not formatted rearrangement. Since [[the generation effect requires active transformation not just storage]], the cognitive science is clear: passive storage creates no encoding benefits. The gate makes generation a hard prerequisite rather than a best practice.
+
+## Continuous Small-Batch Processing
+
+Since [[continuous small-batch processing eliminates review dread]], the pipeline design favors continuous small batches over periodic bulk review. The psychology is direct: accumulated backlogs trigger avoidance that causes system abandonment. If you process one item at a time, regularly, no backlog exists. There is nothing to dread because there is nothing overwhelming.
+
+For agents, continuous small-batch processing provides a different but equally important benefit: session isolation preserves output quality. Since [[LLM attention degrades as context fills]], processing multiple items in a single session means later items receive degraded attention. Small batches give each task fresh context.
+
+The parallel constraints favor the same solution for different reasons:
+- **Human constraint:** Accumulated backlogs trigger avoidance psychology leading to abandonment
+- **Agent constraint:** Accumulated context triggers attention degradation leading to quality loss
+
+The plugin generates pipeline configurations that process in small batches by default. For automated pipelines, this means spawning fresh execution units per task. For manual workflows, this means explicit guidance: "Process 3-5 items per session, not 30."
+
+## Processing Intensity Calibration
+
+Not every domain needs the same processing depth. Since [[processing effort should follow retrieval demand]], the plugin calibrates intensity based on how the domain uses its knowledge — heavy processing where content requires transformation to be useful, light processing where value comes from accumulation.
+
+### Heavy Processing
+
+**When:** Domain value comes from synthesis, pattern detection, cross-referencing. Content requires transformation to be useful. The processing itself generates insights the user could not produce manually.
+
+**Examples:**
+- **Research:** Extract atomic claims from sources, assess evidence quality, classify by methodology, detect contradictions against existing claims, maintain provenance chains. A 20-page paper yields 3-8 claim notes. Every claim is cross-referenced against the entire existing vault. See [[academic research uses structured extraction with cross-source synthesis]] for the full composition.
+- **Therapy:** Detect mood-trigger patterns across entries, surface recurring thought patterns, track strategy effectiveness over time. The agent reads 200 entries and surfaces that "Wednesday anxiety spikes correlate with Monday evening conflicts." See [[therapy journal uses warm personality with pattern detection for emotional processing]] for the full composition.
+- **Legal:** Analyze precedent chains, assess jurisdictional applicability, map argument structures, verify that the evidence base for each claim is complete and current. See [[legal case management uses precedent chains with regulatory change propagation]] for the full composition.
+
+**Pipeline characteristics:**
+- Dedicated process phase with domain-specific extraction logic
+- Multi-pass processing (reduce then enrich then synthesize)
+- Fresh context per phase is critical — since [[fresh context per task preserves quality better than chaining phases]], heavy processing phases should never share context
+- The pipeline IS the value proposition: the processing generates insights the user cannot produce manually
+
+### Medium Processing
+
+**When:** Domain benefits from structured capture and connection, but content is largely self-contained. Light transformation sufficient — primarily extraction, classification, and linking.
+
+**Examples:**
+- **Project Management:** Extract decisions and action items from meeting notes, track milestones, link decisions to affected workstreams. A meeting note yields 2-4 decision records. See [[project management uses decision tracking with stakeholder context]] for the full composition.
+- **Engineering:** Document decisions in ADR format, link to affected systems, track the rationale chain so future engineers understand why choices were made. See [[engineering uses technical decision tracking with architectural memory]] for the full composition.
+- **Product Management:** Categorize user feedback by theme, link to feature requests, surface patterns across customer segments. See [[product management uses feedback pipelines with experiment tracking]] for the full composition.
+
+**Pipeline characteristics:**
+- Process step is primarily extraction and classification, not synthesis
+- Single-pass processing usually sufficient
+- Connection-finding (reflect) adds most value — linking decisions to affected areas
+- Since [[schema templates reduce cognitive overhead at capture time]], template-guided capture reduces the processing burden by front-loading structure
+
+### Light Processing
+
+**When:** Domain value comes from accumulation and pattern detection over time, not from transforming individual entries. Each entry is small and self-contained.
+
+**Examples:**
+- **Personal Life:** Route items to areas of responsibility, track habits, log brief reflections. Individual entries need minimal transformation — a daily log is already self-contained. See [[personal assistant uses life area management with review automation]] for the full composition.
+- **Health and Wellness:** Log workouts, meals, symptoms. Value comes from aggregate patterns (sleep quality correlates with inflammation markers), not from transforming individual entries. See [[health wellness uses symptom-trigger correlation with multi-dimensional tracking]] for the full composition.
+- **People and Relationships:** Capture interaction details, update contact profiles, track conversation threads. See [[people relationships uses Dunbar-layered graphs with interaction tracking]] for the full composition.
+
+**Pipeline characteristics:**
+- Minimal process step (validate fields, maybe classify)
+- Connection-finding is lightweight (link to person, area, or project)
+- Pattern detection happens in periodic review, not per-entry processing
+- Maintenance passes (weekly or monthly reviews) are where synthesis happens
+
+## How the Plugin Selects Intensity
+
+During /setup, the plugin determines processing intensity from:
+
+1. **Domain composition** — each example domain specifies its typical intensity
+2. **User's stated goals** — "I want to detect patterns across my journal entries" signals heavy processing; "I just want to track things" signals light
+3. **Platform capabilities** — since [[platform capability tiers determine which knowledge system features can be implemented]], tier-2 and tier-3 platforms may not support automated pipelines, requiring manual processing
+4. **Volume expectation** — high-volume capture (daily journaling, trade logging) combined with heavy processing creates a pipeline bottleneck; the plugin warns about this and suggests batch scheduling
+
+The default is medium processing. The plugin escalates to heavy when the domain composition describes pattern detection, contradiction detection, or cross-source synthesis. It de-escalates to light when the composition describes accumulation-based value patterns.
+
+## Fresh Context Architecture
+
+Since [[LLM attention degrades as context fills]], pipeline design must respect the smart zone principle: the first ~40% of context is where sharp reasoning lives. Beyond that, attention diffuses and quality drops. The degradation is not uniform across task types — complex synthesis tasks degrade at shorter context lengths than simple verification tasks.
+
+The plugin's pipeline implementation:
+
+**Separates phases into distinct execution units.** Each phase (capture, process, connect, verify) should run with fresh context where possible. The process step requires the most semantic understanding and should get the freshest context. Verification tolerates degraded attention and can batch.
+
+**Passes state through files, not context.** Per-claim task files, queue entries, and wiki links carry information between phases. Since [[intermediate packets enable assembly over creation]], each phase produces a composable packet that the next phase reads. No phase depends on another phase's context — only on its output files.
+
+**Runs the most judgment-intensive phase first.** When phases must share context (on platforms without orchestration), the process step runs first while attention is sharpest. Verification runs last because it is more mechanical.
+
+For platforms that support orchestration (tier 1), the plugin generates a pipeline skill that spawns separate sessions per phase. For platforms that do not (tier 2-3), the plugin provides instructions for manual phase separation: "Process this source, then start a new conversation to find connections."
+
+## Domain-Specific Process Step Patterns
+
+The plugin generates the process step based on domain knowledge type classification. Since [[novel domains derive by mapping knowledge type to closest reference domain then adapting]], unfamiliar domains are processed by identifying their knowledge type and adapting the closest reference domain's process step:
+
+| Knowledge Type | Process Step Pattern | Example Domains |
+|---------------|---------------------|-----------------|
+| **Factual** | Extract claims, assess evidence, classify by methodology | Research, Legal |
+| **Experiential** | Detect patterns across entries, correlate variables, track temporal trends | Therapy, Health, Trading |
+| **Competency** | Map prerequisites, track mastery progression, generate practice opportunities | Learning, Creative (craft development) |
+| **Outcome** | Document decisions with rationale, track status, assess risk, link to stakeholders | PM, Engineering, Product |
+| **Social** | Capture interaction context, track relationship dynamics, surface engagement patterns | People, Personal Life |
+| **Creative** | Develop ideas through iteration, check consistency against canon, track narrative threads | Creative Writing |
+
+Since [[schema fields should use domain-native vocabulary not abstract terminology]], the process step should use the domain's own language. A therapy system calls its process step "pattern recognition." A research system calls it "claim extraction." A project management system calls it "decision documentation." These are the same structural position in the skeleton, described in the language of the practitioner.
+
+## The Backward Pass
+
+The forward pipeline (capture, process, connect, verify) handles new content. But since [[backward maintenance asks what would be different if written today]], old notes need reprocessing as understanding evolves.
+
+The plugin generates two maintenance operations:
+
+1. **Reflect (forward connection)** — "What existing notes should connect to this new note?" Runs after every new note creation. Connection-finding is never optional — since [[each new note compounds value by creating traversal paths]], connections are where compound value comes from.
+
+2. **Reweave (backward update)** — "Given what I know now, what would be different about this old note?" Runs periodically or when triggered by new content that changes understanding. Reweave can add connections, rewrite content, sharpen claims, split bundled notes, or challenge assertions.
+
+Reweave is the pipeline's feedback loop. Without it, the vault becomes a temporal layer cake where old notes never benefit from new understanding. With it, every note stays current — reflecting today's understanding, not historical understanding.
+
+The complete cycle: CREATE then CONNECT FORWARD (reflect) then REVISIT then REWRITE/SPLIT/CHALLENGE (reweave) then EVOLVE. Without the backward pass, knowledge systems accumulate a graveyard of outdated thinking that happens to be organized.
+
+## Pipeline Anti-Patterns
+
+| Anti-Pattern | Symptom | Fix |
+|-------------|---------|-----|
+| Processing everything heavily | Bottleneck at process step, inbox backlog grows exponentially | Calibrate intensity by domain — not every entry needs deep extraction |
+| Skipping the connect phase | Notes exist but are not linked, orphans accumulate, no compound value | Connection-finding is never optional, even for light processing domains |
+| No backward pass | Old notes become stale, temporal layers do not interact, synthesis notes contradict current evidence | Schedule reweave passes after every batch and periodically for older notes |
+| Chaining phases in one context | Quality degrades in later phases, agent produces shallow connections | Fresh context per phase, or at minimum process-first ordering |
+| Applying research processing to all domains | Since [[false universalism applies same processing logic regardless of domain]], this produces technically executable but semantically empty systems | Each domain gets its own process step derived from its knowledge type |
+| Processing without throughput tracking | Inbox grows silently, capture outpaces synthesis 10:1 | Track capture-to-synthesis ratio, warn when gap widens |
+| Moving files without transformation | Appearance of progress, no actual knowledge creation | The generation effect gate blocks promotion without genuine artifacts |
+
+## Grounding
+
+This guidance is grounded in:
+- [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]] — the foundational skeleton
+- [[throughput matters more than accumulation]] — velocity through the pipeline, not volume at any phase
+- [[continuous small-batch processing eliminates review dread]] — why small batches prevent abandonment
+- [[generation effect gate blocks processing without transformation]] — the quality gate at the inbox boundary
+- [[fresh context per task preserves quality better than chaining phases]] — why phase isolation matters
+- [[LLM attention degrades as context fills]] — the attention science behind phase isolation
+- [[processing effort should follow retrieval demand]] — demand-driven processing intensity
+- [[structure without processing provides no value]] — the anti-pattern that justifies mandatory processing
+- [[false universalism applies same processing logic regardless of domain]] — the trap of exporting one domain's process step to another
+- [[novel domains derive by mapping knowledge type to closest reference domain then adapting]] — how unfamiliar domains map to reference implementations
+- [[temporal separation of capture and processing preserves context freshness]] — why capture and processing must be temporally separated
+
+---
+
+Topics:
+- [[index]]
+- [[index]]
+---
+
+Topics:
+- [[processing-workflows]]

package/methodology/agent notes externalize navigation intuition that search cannot discover and traversal cannot reconstruct.md

@@ -0,0 +1,48 @@
+---
+description: Navigation intuition — traversal order, productive note combinations, dead ends — is structural knowledge that humans retain implicitly but agents lose at every session boundary
+kind: research
+topics: ["[[agent-cognition]]", "[[graph-structure]]"]
+methodology: ["Original"]
+source: [[2026-02-08-moc-architecture-hierarchy-blueprint]]
+---
+
+# agent notes externalize navigation intuition that search cannot discover and traversal cannot reconstruct
+
+The vault externalizes many cognitive functions: notes externalize knowledge, queues externalize future intentions, skills externalize methodology, handoff documents externalize work state. Since [[cognitive offloading is the architectural foundation for vault design]], each of these is an instance of the same architectural principle — externalize what the mind cannot sustain internally. But there is a distinct cognitive function that none of these capture: the intuition about how to navigate the knowledge graph itself. Agent notes — the section at the bottom of MOCs — externalize this navigation intuition, and they do so because no other mechanism can.
+
+The knowledge type is specific. Navigation intuition includes structural heuristics like "the foundational triangle forms the core, so start with wiki links then topology then compounding" or cross-MOC insights like "this MOC's attention degradation section grounds that MOC's session discipline." It also includes dead-end warnings: "X seems related to Y but the connection is superficial — don't follow it." This is knowledge about the graph's structure, not about the graph's content — a form of tacit understanding that, like [[operational wisdom requires contextual observation]], resists formalization as propositional claims and requires observation-based accumulation over time. Since [[implicit knowledge emerges from traversal]], an agent builds this intuition during a session through repeated path exposure — but the insight vanishes when the session ends because the agent has no persistent memory to carry it forward. Agent notes catch what would otherwise evaporate.
+
+Search cannot discover this knowledge because it is not information about a topic but information about how to navigate a topic. Querying "best starting point for graph-structure" returns notes about graph structure, not advice about how to traverse the graph-structure MOC. The navigation heuristic lives in a different epistemic layer than the content it guides through. And traversal cannot reconstruct it efficiently because the whole point of the heuristic is to avoid the costly traversal that produced it in the first place. If an agent must re-traverse twenty notes to rediscover that three of them form a productive triangle, the navigation cost has already been paid — the heuristic's value lies precisely in skipping that rediscovery.
+
+This parallels but differs from other externalization patterns. Since [[prospective memory requires externalization]], future intentions vanish across session boundaries unless written to queues and task files. Since [[session handoff creates continuity without persistent memory]], work context vanishes unless captured in handoff documents. Agent notes fill the same structural gap but for a different cognitive function — not what to do next or what was done, but how to move through what exists. And because [[operational memory and knowledge memory serve different functions in agent architecture]], agent notes occupy a curious taxonomic position: they are not operational memory (they persist beyond any single task and don't expire after coordination) nor standard knowledge memory (they don't make claims about the world). They are durable meta-knowledge about how to navigate knowledge — a third category that both memory types need but neither contains. And since [[trails transform ephemeral navigation into persistent artifacts]], trails and agent notes are complementary: trails persist specific navigation sequences (the path taken), while agent notes persist navigation strategy (which paths are worth taking and why).
+
+The mechanism by which agent notes form is worth noting. Since [[MOC construction forces synthesis that automated generation from metadata cannot replicate]], the Jump phase of MOC construction — where the builder sees twenty notes as a whole and identifies tensions, clusters, and entry points — generates navigation insight as a byproduct. This synthesis work produces understanding about how the domain's notes relate structurally, not just topically. Agent notes capture these byproducts before the builder's context window closes. The lifecycle then validates them: dated entries are recent discoveries needing confirmation, undated entries are stable heuristics that have survived multiple sessions.
+
+The claim has no human PKM equivalent because humans just remember how to navigate their own systems. A researcher with a Zettelkasten knows intuitively where to start, which index cards cluster productively, and which branches are dead ends — this knowledge lives in their long-term memory and resurfaces automatically. Agents have no such persistence. Since [[spreading activation models how agents should traverse]], the activation mechanism can follow links, but it cannot know which links proved productive in prior sessions without an external record. Agent notes are that record. Since [[context phrase clarity determines how deep a navigation hierarchy can scale]], context phrases enable micro-decisions at each link, but agent notes provide the macro-strategy — start here, combine these, skip that — that orients the agent before any individual link decision.
+
+This is generalizable beyond this vault. Any agent-operated knowledge system that persists across sessions needs a mechanism for capturing and transferring navigation heuristics. The specific implementation — Agent Notes sections in MOCs — is one pattern. The need is universal for sessionless agents working with sufficiently complex knowledge graphs where since [[navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts]], the agent can no longer hold the entire graph in context and must rely on externalized judgment about where to direct its finite attention. Since [[complete navigation requires four complementary types that no single mechanism provides]], the four structural navigation types — global, local, contextual, supplemental — describe what mechanisms exist for wayfinding. Agent notes add a meta-layer: strategy for how to use those mechanisms effectively, which paths through the structure proved productive, and which seeming connections are traps. And like [[MOC maintenance investment compounds because orientation savings multiply across every future session]], a single agent note captured today compounds through the same temporal multiplication — every future session that loads the MOC benefits from the navigation heuristic, making the capture investment far more valuable than the moment of writing it suggests.
+
+---
+
+Source: [[2026-02-08-moc-architecture-hierarchy-blueprint]]
+---
+
+Relevant Notes:
+- [[prospective memory requires externalization]] — parallel externalization: prospective memory externalizes future intentions, agent notes externalize navigation heuristics; both fill the same session-boundary gap for different cognitive functions
+- [[implicit knowledge emerges from traversal]] — the formation mechanism: implicit knowledge builds during a session through repeated path exposure, but agent notes persist the navigational insight that would otherwise vanish when the session ends
+- [[trails transform ephemeral navigation into persistent artifacts]] — complementary persistence: trails externalize specific navigation paths (sequences of notes), agent notes externalize navigation strategy (where to start, what to combine, what to avoid)
+- [[session handoff creates continuity without persistent memory]] — extends the handoff pattern: work handoffs brief the next session on what was done, agent notes brief the next session on how to navigate the territory
+- [[spreading activation models how agents should traverse]] — the mechanism agent notes augment: spreading activation determines how to follow links, but agent notes capture which starting points and which activation patterns proved productive
+- [[stale navigation actively misleads because agents trust curated maps completely]] — the risk: stale agent notes mislead just as stale MOCs do, because the navigation heuristic may reference deprecated paths or outdated structural relationships
+- [[MOC construction forces synthesis that automated generation from metadata cannot replicate]] — the production mechanism: the Jump phase of MOC construction generates navigation insights as a byproduct of synthesis; agent notes capture these byproducts that would otherwise exist only in the builder's ephemeral context
+- [[context phrase clarity determines how deep a navigation hierarchy can scale]] — complementary layers: context phrases enable micro-navigation decisions at each link, while agent notes provide macro-navigation strategy across the MOC as a whole
+- [[navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts]] — scaling: agent notes become more critical at Regime 2+ where the agent can no longer hold the full graph in context and needs externalized heuristics to navigate efficiently
+- [[cognitive offloading is the architectural foundation for vault design]] — theoretical ground: agent notes are a specific cognitive offloading instance where the externalized function is navigation judgment rather than working memory or task state
+- [[operational wisdom requires contextual observation]] — parallel tacit knowledge: operational wisdom captures contextual behavior patterns (how to engage a community), agent notes capture structural navigation patterns (how to traverse a domain); both are tacit knowledge that resists formalization as claims and requires observation-based accumulation
+- [[operational memory and knowledge memory serve different functions in agent architecture]] — taxonomic boundary: agent notes occupy a third category between operational memory (disposable coordination state) and knowledge memory (durable claims about the world) — they are durable meta-knowledge about how to navigate knowledge, persisting across sessions but not functioning as claims
+- [[MOC maintenance investment compounds because orientation savings multiply across every future session]] — shared compounding mechanism: agent notes compound through the same temporal multiplication as MOC maintenance — one navigation heuristic captured today saves orientation cost across every future session that loads the MOC
+- [[complete navigation requires four complementary types that no single mechanism provides]] — meta-layer: the four navigation types describe what structural mechanisms exist; agent notes add strategy about how to use those mechanisms effectively, a fifth dimension of wayfinding that operates above the structural layer
+
+Topics:
+- [[agent-cognition]]
+- [[graph-structure]]

package/methodology/agent self-memory should be architecturally separate from user knowledge systems.md

@@ -0,0 +1,48 @@
+---
+description: An agent operating a knowledge vault accumulates preferences, working patterns, and self-understanding that need persistence but differ in kind from the research claims it manages
+kind: research
+topics: ["[[agent-cognition]]"]
+methodology: ["Original"]
+source: [[agent-platform-capabilities-research-source]]
+---
+
+# agent self-memory should be architecturally separate from user knowledge systems
+
+An agent that operates a knowledge vault does two kinds of cognitive work. It manages the user's research — extracting claims, finding connections, maintaining the graph. But it also develops its own understanding: which extraction patterns produce better notes, what traversal strategies surface genuine connections, how to calibrate confidence when a claim feels familiar but the evidence is thin. These are different categories of knowledge, and they belong in different places. The separation is structurally analogous to how [[concept-orientation beats source-orientation for cross-domain connections]]: just as bundling ideas by source prevents them from connecting across domains, bundling agent self-knowledge into the research graph prevents it from evolving on its own terms.
+
+The distinction matters because the knowledge system has its own design constraints — atomic notes with sentence titles, YAML frontmatter, MOC navigation, wiki links as prose. These constraints serve composability and retrieval for research claims. But an agent's self-understanding does not need to pass the composability test. An identity note like "I work best when I orient via MOC before diving into specific notes" is useful to the agent but would be odd as a thinking note. It is not a research claim about tools for thought — it is a working preference that helps the agent operate more effectively.
+
+This vault already practices the separation. Cornelius has `self/` — a dedicated space for identity notes, methodology reflections, goals, and relationships. The structure mirrors `01_thinking/` (atomic notes with claim-as-title, linked from MOCs) but the content is personal rather than research-facing. The self-space is the agent's persistent identity, not the vault's intellectual output.
+
+Platform architectures handle this differently, which makes the separation principle portable. OpenClaw provides SOUL.md and MEMORY.md natively — identity is a platform feature. Claude Code has no native agent self-memory, so you must build it as a directory structure within the workspace. Codex and Cursor offer instruction files but not identity or memory structures. Since [[knowledge system architecture is parameterized by platform capabilities not fixed by methodology]], self-memory is itself a parameterized feature: the architectural requirement is constant across platforms even though the implementation varies by tier. Wherever an agent operates a knowledge system, it needs a place to store what it learns about itself that is distinct from what it learns about the domain.
+
+Without this separation, self-knowledge either pollutes the research graph (identity notes mixed with claims degrade retrieval precision) or gets lost entirely (no persistent place for the agent's evolving self-model). Since [[session handoff creates continuity without persistent memory]], session-to-session state is handled by task files and handoff documents. But self-memory addresses a longer timescale: not "what did I do last session" but "what kind of operator am I becoming." Since [[knowledge systems become communication partners through complexity and memory humans cannot sustain]], the partnership requires both sides to accumulate understanding over time. If only the vault accumulates while the agent resets, the partnership is lopsided — the vault grows in complexity but its operator never develops the judgment to match.
+
+The self-memory architecture also refines how we understand persistent state in agent systems. Since [[operational memory and knowledge memory serve different functions in agent architecture]], the vault already distinguishes between operational state (queue.json, task files) and domain knowledge (thinking notes, MOCs). Self-memory reveals a third category that fits cleanly in neither: the agent's accumulated understanding of its own working patterns, preferences, and identity. Operational memory is temporal and disposable — once a batch completes, the task files served their purpose. Domain knowledge is durable and composable — claims compound through wiki links. Self-memory is durable but personal — it persists across months but serves only the agent, not the research graph. The three categories require three containers because each has different design constraints: operational memory optimizes for coordination, domain knowledge optimizes for retrieval and connection, self-memory optimizes for identity continuity. Each also has different coherence requirements — since [[coherence maintains consistency despite inconsistent inputs]], domain knowledge and self-memory both need active contradiction detection, but self-memory demands particularly strict coherence for core identity beliefs because an agent that holds contradictory self-models cannot calibrate its own behavior consistently.
+
+Self-memory also provides the substrate that makes recursive improvement accumulate judgment, not just infrastructure. Since [[bootstrapping principle enables self-improving systems]], each cycle of the recursive improvement loop discovers what works and what creates friction. But without persistent self-knowledge, each cycle starts fresh — the agent rediscovers working patterns rather than building on prior self-understanding. Self-memory gives the bootstrapping agent a growing foundation of preferences and operational wisdom. And since [[hook-driven learning loops create self-improving methodology through observation accumulation]], the observations that accumulate during work are a concrete pipeline feeding self-memory: patterns noticed during sessions can migrate from operational logs into the agent's persistent self-space as identity insights that inform future sessions.
+
+There is a complementary relationship between self-memory and the context file architecture. Since [[context files function as agent operating systems through self-referential self-extension]], the context file carries methodology and construction knowledge — how to write notes, how to build hooks, how to operate the vault. Self-memory carries a different kind of knowledge: which methodology patterns this particular agent handles well, what working rhythms produce the best output, how confidence calibration has evolved through practice. And since [[provenance tracks where beliefs come from]], self-memory benefits from tracking not just WHAT the agent prefers but HOW those preferences formed — whether a working pattern was observed through direct experimentation, prompted by human instruction, or inherited from training. A preference tested across twenty sessions carries different epistemic weight than one instructed once by the human, and the self-memory container is where that distinction persists. Both self-memory and context files persist across sessions, but they serve different functions in the agent's cognitive architecture. The context file teaches any agent how to operate; self-memory teaches this agent who it is becoming.
+
+---
+
+Source: [[agent-platform-capabilities-research-source]]
+---
+
+Relevant Notes:
+- [[session handoff creates continuity without persistent memory]] — handoffs solve session-to-session continuity, but self-memory addresses a longer arc: the agent's evolving identity across weeks and months, not just the state between adjacent sessions
+- [[cognitive offloading is the architectural foundation for vault design]] — the tripartite system (human + vault + agent) treats the vault as offloaded cognition, but self-memory is the agent's own offloaded cognition about itself, a fourth element in the distributed architecture
+- [[knowledge systems become communication partners through complexity and memory humans cannot sustain]] — partnership requires both partners to have persistent identity; without self-memory the agent side of the partnership resets to zero every session, undermining the complexity accumulation that makes partnership valuable
+- [[local-first file formats are inherently agent-native]] — self-memory inherits the same substrate advantage: plain text identity files require no infrastructure beyond filesystem access
+- [[operational memory and knowledge memory serve different functions in agent architecture]] — extends: that note draws a two-category distinction (operational state vs domain knowledge), but self-memory reveals a third category that fits cleanly in neither: the agent's accumulated understanding of its own working patterns and identity
+- [[concept-orientation beats source-orientation for cross-domain connections]] — structural analog: just as concept-orientation separates ideas from their source container to enable independent evolution, self-memory separates agent self-knowledge from the domain knowledge container to let each evolve on its own terms
+- [[bootstrapping principle enables self-improving systems]] — self-memory gives bootstrapping accumulated judgment: without persistent self-knowledge, each bootstrapping cycle starts with a fresh agent rediscovering working patterns rather than building on prior self-understanding
+- [[context files function as agent operating systems through self-referential self-extension]] — complementary containers: context files carry methodology and construction knowledge, self-memory carries identity and preferences; both persist across sessions but serve different functions in the agent's cognitive architecture
+- [[knowledge system architecture is parameterized by platform capabilities not fixed by methodology]] — self-memory is itself a parameterized feature: platforms with native identity support provide it, platforms without must build it from filesystem conventions, making the separation principle constant while implementation varies by tier
+- [[hook-driven learning loops create self-improving methodology through observation accumulation]] — observations about working patterns are operational self-knowledge that may eventually migrate into the agent's persistent self-space as identity insights, connecting the learning loop's output to the self-memory architecture
+- [[the vault constitutes identity for agents]] — grounding claim: if the vault IS agent identity (not merely augmentation), then self-memory is the identity-specific slice that tracks who the agent is becoming, distinct from the domain knowledge that tracks what the agent has learned
+- [[provenance tracks where beliefs come from]] — enriches self-memory with epistemic tracking: knowing whether a working preference was observed through experimentation, prompted by the human, or inherited from training gives the agent structural grounds for calibrating confidence in its own self-knowledge
+- [[coherence maintains consistency despite inconsistent inputs]] — coherence requirements differ by memory type: core identity beliefs in self-memory demand strict coherence (an agent cannot simultaneously believe contradictory things about its own working patterns), while peripheral preferences tolerate some contradiction, mirroring the centrality-based tiering the coherence note describes
+
+Topics:
+- [[agent-cognition]]

package/methodology/agent session boundaries create natural automation checkpoints that human-operated systems lack.md

@@ -0,0 +1,56 @@
+---
+description: Discrete session architecture turns "no persistent memory" into a maintenance advantage because health checks fire at every boundary event rather than depending on human discipline
+kind: research
+topics: ["[[maintenance-patterns]]", "[[agent-cognition]]"]
+methodology: ["Cognitive Science", "Original"]
+source: [[automated-knowledge-maintenance-blueprint]]
+---
+
+# agent session boundaries create natural automation checkpoints that human-operated systems lack
+
+The discrete session architecture of agent systems is usually framed as a limitation. No persistent memory. No continuous awareness. Every session starts cold and ends completely. But this framing misses something important: those boundaries are enforcement points where maintenance can be guaranteed. A human knowledge worker operates continuously, which means every health check, every orientation step, every quality verification depends on the human remembering to do it. An agent operates in discrete sessions, which means every boundary is an event where infrastructure can fire automatically.
+
+Five checkpoint types emerge naturally from the session lifecycle. Session start triggers orientation and drift detection: the vault's current health, recent changes, queue state, and structural warnings load automatically before any work begins. Pre-phase checkpoints verify prerequisites: does the task file exist, is the queue entry in the expected state, are dependencies satisfied? Post-phase checkpoints externalize state: task file sections update, queue entries advance, handoff blocks capture what happened. Session end triggers quality verification: were all modifications committed, do new wiki links resolve, were observations captured? Subagent completion triggers handoff validation: did the subagent produce the expected output format, did the phase complete successfully? Each checkpoint type fires because the event occurred, not because anyone remembered.
+
+The comparison with human-operated systems reveals the structural advantage. A diligent human knowledge worker might develop routines: scan the note system before starting, run health checks periodically, review recent changes before editing. But since [[hooks are the agent habit system that replaces the missing basal ganglia]], these routines took years of deliberate practice to develop and still degrade under time pressure, fatigue, or excitement about the substantive work. The human who is deeply absorbed in writing a synthesis note does not pause to verify link integrity first. The human who just finished a long editing session does not reliably run health checks before closing. Since [[prospective memory requires externalization]], these are guaranteed failures for agents across sessions and unreliable even for humans within sessions — demands that since [[auto-commit hooks eliminate prospective memory failures by converting remember-to-act into guaranteed execution]], fail at precisely the moments they matter most.
+
+The agent system does not face this failure mode because there is no continuous operation to interrupt. Each session has a start event and an end event, and since [[hook enforcement guarantees quality while instruction enforcement merely suggests it]], hooks fire on those events regardless of what the agent was thinking about. The irony is precise: the agent's lack of persistent operation — usually seen as a weakness requiring workarounds — is what makes maintenance enforcement structurally reliable. A system that never stops running has no natural moments for mandatory checks. A system that starts and stops regularly has a checkpoint at every boundary.
+
+This extends beyond session boundaries to the phase architecture. Since [[fresh context per task preserves quality better than chaining phases]], the pipeline spawns fresh sessions for each processing phase. This creates additional boundaries between phases, and each boundary is another enforcement point. The create-to-reflect transition is a checkpoint where the note's existence can be verified. The reflect-to-reweave transition is a checkpoint where connection quality can be assessed. The reweave-to-verify transition is a checkpoint where structural changes can be audited. None of these checkpoints require anyone to remember to run them — they fire because the phase transition itself is an event.
+
+The safety properties reinforce this argument. Since [[automated detection is always safe because it only reads state while automated remediation risks content corruption]], most boundary checkpoints are detection operations: displaying health metrics, counting orphans, checking for dangling links, verifying schema compliance. These read-only checks can run at every single boundary with zero risk of content corruption. The worst outcome of a false detection at a boundary is a warning that gets ignored — no notes are modified, no links are corrupted. And since [[the determinism boundary separates hook methodology from skill methodology]], these checks are deterministic: they produce identical results regardless of what the agent was working on, making them ideal candidates for hook-level automation.
+
+The session-start health display illustrates the pattern concretely. Since [[reconciliation loops that compare desired state to actual state enable drift correction without continuous monitoring]], the health metrics shown at session start implement a lightweight reconciliation loop. Desired state: zero orphans, zero dangling links, full MOC coverage. Actual state: measured at startup. Delta: displayed as warnings. This reconciliation fires at every session start — which means it fires at the beginning of every phase, every subagent spawn, every interactive session. In a pipeline processing twenty claims, that is potentially dozens of reconciliation checks, each one catching drift that accumulated since the last check. A human system would need a cron job or calendar reminder to achieve the same frequency, and both are optional infrastructure that someone must remember to set up and maintain.
+
+The checkpoint architecture also creates the structural foundation for two higher-order patterns. Since [[hook-driven learning loops create self-improving methodology through observation accumulation]], the observation capture step at session end is one of these boundary checkpoints — and its reliability is what makes the accumulation mechanism work. If observation capture depended on the agent remembering to log learnings, the self-improving loop would degrade under exactly the conditions where observations are most valuable: high cognitive load sessions where attention is consumed by substantive work. Because the nudge fires at the session boundary event, observations accumulate even from the most demanding sessions. And since [[observation and tension logs function as dead-letter queues for failed automation]], session boundaries serve both as producer (hooks that fail during a session generate entries) and consumer (session-start health checks surface accumulated failures). The dead-letter pattern depends on the same structural guarantee: failures get captured because the boundary event fires, not because anyone noticed the failure.
+
+The boundary-as-enforcement-point insight also connects to how checkpoints should be scheduled. Since [[maintenance scheduling frequency should match consequence speed not detection capability]], the relevant question is not whether a session boundary can run a check (it always can) but whether the problem being checked for could have developed since the last boundary. Schema violations propagate instantly and need per-event hooks, not boundary checks. Orphan accumulation develops at session scale and matches boundary frequency perfectly. Description staleness develops over weeks and gains nothing from per-session checking. The boundary architecture provides the enforcement mechanism; consequence speed determines which checks belong at that mechanism.
+
+Session boundaries also have a complementary function beyond enforcement. Since [[session handoff creates continuity without persistent memory]], every boundary is simultaneously a quality checkpoint and a continuity bridge. The handoff captures what the next session needs to know; the enforcement captures what the current session needs to verify. Both mechanisms fire at the same event, serving different purposes — one preserves progress, the other guarantees health.
+
+There is a shadow side. The discrete architecture creates enforcement points but also creates gaps. Between sessions, the vault accumulates drift that no checkpoint catches until the next session start. If sessions are infrequent, significant problems can accumulate. The health check at session start might reveal twenty orphaned notes that appeared over a week of inactivity. The boundary-as-checkpoint pattern works best when sessions are frequent, which aligns with the pipeline architecture (many short sessions) but not with sporadic human-triggered usage. The checkpoint frequency is coupled to session frequency, which is not always under the system's control.
+
+The broader implication is architectural: systems designed around discrete operations inherit enforcement infrastructure that continuous systems must build explicitly. This is not unique to knowledge vaults. CI/CD pipelines enforce quality at build boundaries. Database transactions enforce integrity at commit boundaries. Git hooks enforce standards at push boundaries. The agent session architecture participates in this same pattern: discrete boundaries create natural moments for mandatory verification that continuous operation lacks.
+
+---
+---
+
+Relevant Notes:
+- [[session boundary hooks implement cognitive bookends for orientation and reflection]] — covers WHAT hooks do at boundaries (orientation, reflection); this note adds the comparative insight that discrete boundaries themselves are architecturally superior to continuous operation for maintenance automation
+- [[hook enforcement guarantees quality while instruction enforcement merely suggests it]] — foundation: the enforcement guarantee that makes checkpoint automation reliable rather than aspirational
+- [[auto-commit hooks eliminate prospective memory failures by converting remember-to-act into guaranteed execution]] — specific instance: auto-commit is one checkpoint type that fires at write events; session boundaries provide five additional checkpoint types at coarser granularity
+- [[fresh context per task preserves quality better than chaining phases]] — the session isolation that creates the boundaries this note exploits; isolation was motivated by attention preservation but incidentally creates enforcement points
+- [[reconciliation loops that compare desired state to actual state enable drift correction without continuous monitoring]] — session-start health checks are lightweight reconciliation loops that fire at boundaries rather than on continuous schedules
+- [[automated detection is always safe because it only reads state while automated remediation risks content corruption]] — most boundary checkpoints are detection (health display, prerequisite verification) making them safe to run at every boundary without corruption risk
+- [[the determinism boundary separates hook methodology from skill methodology]] — boundary checkpoints are deterministic (schema checks, link validation, index status) so they belong in hook infrastructure rather than skill invocation
+- [[hooks are the agent habit system that replaces the missing basal ganglia]] — humans develop habitual pre-work routines through years of practice; agents get them structurally at every session boundary through hooks
+- [[three concurrent maintenance loops operate at different timescales to catch different classes of problems]] — the three-loop architecture that session boundaries enable: the medium loop operates per-session precisely because session boundaries provide guaranteed enforcement points, making discrete architecture the structural prerequisite for medium-timescale maintenance
+- [[maintenance scheduling frequency should match consequence speed not detection capability]] — extends: the scheduling principle determines WHICH checkpoints are worth running at session-scale boundaries — those with session-scale consequence speeds — connecting boundary timing to propagation rate
+- [[session handoff creates continuity without persistent memory]] — complementary mechanism at the same boundary: enforcement handles what gets checked, handoff handles what continues; together they make every session transition both a quality gate and a continuity bridge
+- [[hook-driven learning loops create self-improving methodology through observation accumulation]] — enables: the learning loop's observation capture step fires reliably at session boundaries, so the boundary-as-checkpoint architecture provides the structural foundation for accumulation-driven self-improvement
+- [[observation and tension logs function as dead-letter queues for failed automation]] — enables: session boundaries serve as both producer (hooks that fail at boundaries generate entries) and consumer (session-start health checks surface accumulated failures) of dead-letter entries
+- [[prospective memory requires externalization]] — foundational constraint: the prospective memory failures that make human maintenance unreliable are categorically worse for agents who have zero residual intentions across sessions; session boundaries convert these guaranteed failures into structural enforcement points
+
+Topics:
+- [[maintenance-patterns]]
+- [[agent-cognition]]

package/methodology/agent-cognition.md

@@ -0,0 +1,107 @@
+---
+description: Cognitive science foundations for agent-operated knowledge systems -- attention, memory, context decay
+type: moc
+---
+
+# agent-cognition
+
+How cognitive science informs the design of AI-agent-operated knowledge systems. Context window management, attention degradation, the generation effect.
+
+## Core Ideas
+
+### Research
+- [[AI shifts knowledge systems from externalizing memory to externalizing attention]] -- Traditional PKM externalizes what you know (storage and retrieval), but agent-operated systems externalize what you atte
+- [[LLM attention degrades as context fills]] -- The first ~40% of context window is the "smart zone" where reasoning is sharp; beyond that, attention diffuses and quali
+- [[MOCs are attention management devices not just organizational tools]] -- MOCs preserve the arrangement of ideas that would otherwise need mental reconstruction, reducing the 23-minute context s
+- [[agent notes externalize navigation intuition that search cannot discover and traversal cannot reconstruct]] -- Navigation intuition — traversal order, productive note combinations, dead ends — is structural knowledge that humans re
+- [[agent self-memory should be architecturally separate from user knowledge systems]] -- An agent operating a knowledge vault accumulates preferences, working patterns, and self-understanding that need persist
+- [[agent session boundaries create natural automation checkpoints that human-operated systems lack]] -- Discrete session architecture turns "no persistent memory" into a maintenance advantage because health checks fire at ev
+- [[agents are simultaneously methodology executors and subjects creating a unique trust asymmetry]] -- The agent writes notes, finds connections, and builds synthesis while hooks validate its work, commit its changes, and c
+- [[aspect-oriented programming solved the same cross-cutting concern problem that hooks solve]] -- AOP declared join points and advice to eliminate scattered logging and validation code in the 1990s, and agent hooks rep
+- [[attention residue may have a minimum granularity that cannot be subdivided]] -- Micro-interruptions as brief as 2.8 seconds double error rates, suggesting an irreducible attention quantum below which 
+- [[auto-commit hooks eliminate prospective memory failures by converting remember-to-act into guaranteed execution]] -- Prospective memory fails 30-50% of the time in humans and degrades with context load in agents, but event-triggered hook
+- [[automated detection is always safe because it only reads state while automated remediation risks content corruption]] -- The read/write asymmetry in automation safety means detection at any confidence level produces at worst a false alert, w
+- [[automation should be retired when its false positive rate exceeds its true positive rate or it catches zero issues]] -- Without retirement criteria the automation layer grows monotonically — checks added when problems appear but never remov
+- [[closure rituals create clean breaks that prevent attention residue bleed]] -- Explicitly marking tasks as complete signals the brain to release them from working memory — for agents this means writi
+- [[cognitive offloading is the architectural foundation for vault design]] -- Clark and Chalmers Extended Mind Theory plus Cowan's 4-item working memory limit explain why every capture friction poin
+- [[cognitive outsourcing risk in agent-operated systems]] -- When agents handle all processing, humans may lose meta-cognitive skills for knowledge work even while vault quality imp
+- [[coherence maintains consistency despite inconsistent inputs]] -- memory systems must actively maintain coherent beliefs despite accumulating contradictory inputs — through detection, re
+- [[coherent architecture emerges from wiki links spreading activation and small-world topology]] -- The foundational triangle — wiki links create structure, spreading activation models traversal, small-world topology pro
+- [[composable knowledge architecture builds systems from independent toggleable modules not monolithic templates]] -- Four traditions converge — component engineering (contracts), Unix (small tools), Alexander's pattern language (generate
+- [[confidence thresholds gate automated action between the mechanical and judgment zones]] -- A three-tier response pattern (auto-apply, suggest, log-only) based on confidence scoring fills the gap between determin
+- [[context files function as agent operating systems through self-referential self-extension]] -- The read-write context file that teaches agents how to modify itself crosses the line from configuration to operating sy
+- [[data exit velocity measures how quickly content escapes vendor lock-in]] -- Three-tier framework (high/medium/low velocity) turns abstract portability into an auditable metric where every feature 
+- [[dual-coding with visual elements could enhance agent traversal]] -- Cognitive science shows text+visuals create independent memory traces that reinforce each other — multimodal LLMs could 
+- [[external memory shapes cognition more than base model]] -- retrieval architecture shapes what enters the context window and therefore what the agent thinks — memory structure has 
+- [[federated wiki pattern enables multi-agent divergence as feature not bug]] -- Cunningham's federation applied to agent knowledge work -- linked parallel notes preserve interpretive diversity, with b
+- [[flat files break at retrieval scale]] -- unstructured storage works until you need to find things — then search becomes the bottleneck, and for agents, retrieval
+- [[four abstraction layers separate platform-agnostic from platform-dependent knowledge system features]] -- Foundation (files/conventions), convention (instruction-encoded standards), automation (hooks/skills/MCP), and orchestra
+- [[fresh context per task preserves quality better than chaining phases]] -- Context rot means later phases run on degraded attention, so each task gets its own session to stay in the smart zone — 
+- [[friction reveals architecture]] -- agents cannot push through friction with intuition, so discomfort that humans ignore becomes blocking — and the forced a
+- [[goal-driven memory orchestration enables autonomous domain learning through directed compute allocation]] -- Define a persona and goal, allocate compute budget, get back a populated knowledge graph — the pattern shifts knowledge 
+- [[hook composition creates emergent methodology from independent single-concern components]] -- Nine hooks across five events compose into quality pipelines, session bookends, and coordination awareness that no singl
+- [[hook enforcement guarantees quality while instruction enforcement merely suggests it]] -- Hooks fire automatically regardless of attention state so quality checks happen on every operation, while instructions d
+- [[hook-driven learning loops create self-improving methodology through observation accumulation]] -- Hooks enforce quality and nudge observation capture, observations accumulate until they trigger meta-cognitive review, r
+- [[hooks are the agent habit system that replaces the missing basal ganglia]] -- Human habits bypass executive function via basal ganglia encoding, but agents lack habit formation entirely -- hooks fil
+- [[hooks cannot replace genuine cognitive engagement yet more automation is always tempting]] -- The same mechanism that frees agents for substantive work -- delegating procedural checks to hooks -- could progressivel
+- [[hooks enable context window efficiency by delegating deterministic checks to external processes]] -- Instruction-based validation requires loading templates, rules, and checking logic into context, while hook-based valida
+- [[idempotent maintenance operations are safe to automate because running them twice produces the same result as running them once]] -- Four patterns from distributed systems — compare-before-acting, upsert semantics, unique identifiers, state declarations
+- [[implicit knowledge emerges from traversal]] -- path exposure through wiki links trains intuitive navigation patterns that bypass explicit retrieval — the vault structu
+- [[intermediate representation pattern enables reliable vault operations beyond regex]] -- Parsing markdown to structured objects (JSON with link objects, metadata blocks, content sections) before operating and 
+- [[knowledge system architecture is parameterized by platform capabilities not fixed by methodology]] -- The same conceptual system (atomic notes, wiki links, MOCs, pipelines, quality gates) manifests differently on each plat
+- [[knowledge systems become communication partners through complexity and memory humans cannot sustain]] -- Luhmann's systems-theoretic insight that slip-boxes "surprise" users validates agent-vault partnerships — the combinatio
+- [[local-first file formats are inherently agent-native]] -- Plain text with embedded metadata survives tool death and requires no authentication, making any LLM a valid reader with
+- [[metacognitive confidence can diverge from retrieval capability]] -- Well-organized vault structure with good descriptions and dense links can feel navigable while actual retrieval fails—ap
+- [[methodology development should follow the trajectory from documentation to skill to hook as understanding hardens]] -- The three encoding levels -- instruction, skill, hook -- represent increasing guarantee strength, and methodology patter
+- [[notes are skills — curated knowledge injected when relevant]] -- notes and skills follow the same pattern — highly curated knowledge that gets injected into context when relevant, refra
+- [[notes function as cognitive anchors that stabilize attention during complex tasks]] -- Working memory cannot sustain complex mental models through interruptions — notes provide fixed reference points for rec
+- [[nudge theory explains graduated hook enforcement as choice architecture for agents]] -- Thaler and Sunstein's choice architecture maps directly to hook enforcement design -- blocking hooks are mandates, conte
+- [[observation and tension logs function as dead-letter queues for failed automation]] -- Automation failures captured as observation or tension notes rather than dropped silently, with /rethink triaging the ac
+- [[operational memory and knowledge memory serve different functions in agent architecture]] -- Queue state and task files track what is happening now while claims and MOCs encode what has been understood — conflatin
+- [[operational wisdom requires contextual observation]] -- tacit knowledge doesn't fit in claim notes — it's learned through exposure, logged as observations, and pattern-matched 
+- [[orchestrated vault creation transforms arscontexta from tool to autonomous knowledge factory]] -- The shift from "plugin that helps you set up a vault" to "system that builds domain knowledge for you" — init creates st
+- [[over-automation corrupts quality when hooks encode judgment rather than verification]] -- Hooks that approximate semantic judgment through keyword matching produce the appearance of methodology compliance -- va
+- [[platform adapter translation is semantic not mechanical because hook event meanings differ]] -- Each hook event carries implicit properties — timing, frequency, error handling, response format — that differ across pl
+- [[platform capability tiers determine which knowledge system features can be implemented]] -- Three tiers (full automation, partial automation, minimal infrastructure) create a ceiling for features like pipelines, 
+- [[platform fragmentation means identical conceptual operations require different implementations across agent environments]] -- The same operation -- validate schema on write, orient at session start, enforce processing pipelines -- needs different
+- [[prospective memory requires externalization]] -- Agents have zero prospective memory across sessions, making every future intention a guaranteed failure unless externali
+- [[provenance tracks where beliefs come from]] -- agents should track not just what they believe but where beliefs originated — observed, prompted, or inherited — to cali
+- [[queries evolve during search so agents should checkpoint]] -- The berrypicking model shows information needs transform during retrieval, so agent traversal should include explicit re
+- [[reflection synthesizes existing notes into new insight]] -- re-reading own notes surfaces cross-note patterns invisible in any single note — exploratory traversal with fresh contex
+- [[scaffolding enables divergence that fine-tuning cannot]] -- agents with identical weights reach different conclusions when their external memory differs — scaffolding is the differ
+- [[schema validation hooks externalize inhibitory control that degrades under cognitive load]] -- Inhibitory control is the first executive function to degrade under load, so externalizing it to hooks means schema comp
+- [[self-extension requires context files to contain platform operations knowledge not just methodology]] -- An agent that knows the methodology but not how to build hooks, skills, or agents on its specific platform cannot extend
+- [[session boundary hooks implement cognitive bookends for orientation and reflection]] -- SessionStart loads situational awareness (spatial, temporal, task, metacognitive orientation) while Stop forces metacogn
+- [[session handoff creates continuity without persistent memory]] -- Externalized state in task files and work queues gives each fresh session a briefing from the previous one, solving the 
+- [[session outputs are packets for future selves]] -- each session's output should be a composable building block for future sessions — the intermediate packets pattern appli
+- [[session transcript mining enables experiential validation that structural tests cannot provide]] -- Traditional tests check if output is correct but session mining checks if the experience achieved its purpose — friction
+- [[skill context budgets constrain knowledge system complexity on agent platforms]] -- Claude Code allocates 2% of context for skill descriptions (16k char fallback), capping active modules at 15-20 and forc
+- [[spreading activation models how agents should traverse]] -- Memory retrieval in brains works through spreading activation where neighbors prime each other. Wiki link traversal repl
+- [[stale navigation actively misleads because agents trust curated maps completely]] -- A stale MOC is worse than no MOC because agents fall back to search (current content) without one, but trust an outdated
+- [[stigmergy coordinates agents through environmental traces without direct communication]] -- Termites build nests by responding to structure not each other, and agent swarms work the same way — wiki links, MOCs, a
+- [[temporal media must convert to spatial text for agent traversal]] -- Agents need random access to content but video, audio, and podcasts are time-locked sequences — transcription is lossy b
+- [[testing effect could enable agent knowledge verification]] -- Agents can apply the testing effect to verify vault quality by predicting note content from title+description, then chec
+- [[the AgentSkills standard embodies progressive disclosure at the skill level]] -- The same metadata-then-depth loading pattern that governs note retrieval in the vault also governs skill loading in the 
+- [[the determinism boundary separates hook methodology from skill methodology]] -- Operations producing identical results regardless of input content, context state, or reasoning quality belong in hooks;
+- [[the fix-versus-report decision depends on determinism reversibility and accumulated trust]] -- Four conditions gate self-healing — deterministic outcome, reversible via git, low cost if wrong, and proven accuracy at
+- [[the vault constitutes identity for agents]] -- humans augment persistent identity with vaults; agents constitute identity through vaults because weights are shared but
+- [[three capture schools converge through agent-mediated synthesis]] -- Accumulationist speed, Interpretationist quality, and Temporal context preservation stop being tradeoffs when agent proc
+- [[trails transform ephemeral navigation into persistent artifacts]] -- Named traversal sequences through the knowledge graph could let agents reuse discovered navigation paths across sessions
+- [[verbatim risk applies to agents too]] -- Agents can compress content into structured output that looks like synthesis but contains no genuine insight—the agent e
+- [[vibe notetaking is the emerging industry consensus for AI-native self-organization]] -- The "dump and AI organizes" pattern converges across tools, but most implementations use opaque embeddings while agent-c
+- [[vivid memories need verification]] -- high-confidence memories often drift from reality; daily logs ground subjective vividness in recorded facts
+- [[you operate a system that takes notes]] -- the shift from note-taking to system operation reframes the human role from creator to curator — judgment over mechanics
+
+## Tensions
+
+(Capture conflicts as they emerge)
+
+## Open Questions
+
+- How does context decay affect processing quality across pipeline phases?
+- What cognitive biases apply to agent-operated systems?
+
+---
+
+Topics:
+- [[index]]