arscontexta 0.6.0

package/methodology/novel domains derive by mapping knowledge type to closest reference domain then adapting.md

@@ -0,0 +1,50 @@
+---
+description: Six knowledge type categories identify which reference domain's processing patterns transfer to unfamiliar domains, then four adaptation axes customize the configuration
+kind: research
+topics: ["[[design-dimensions]]"]
+methodology: ["Original", "Systems Theory"]
+source: [[knowledge-system-derivation-blueprint]]
+---
+
+# novel domains derive by mapping knowledge type to closest reference domain then adapting
+
+The derivation process works cleanly when the target domain matches a reference domain — research, therapy, learning, projects, personal life, relationships, or creative work. But most real use cases do not fit neatly into these categories. A beekeeping colony management system, a wine tasting journal, a legal case tracker — these are novel domains where no reference model exists to load directly. The question is how the derivation agent handles domains it has never seen.
+
+The answer is analogy by knowledge type. Every domain produces a characteristic kind of knowledge, and that knowledge type maps to a reference domain that handles similar material. Six categories cover the space: factual assertions map to research-like processing, emotional or experiential content maps to therapy-like processing, skill and competency tracking maps to learning-like processing, bounded outcomes map to project-like processing, people and social dynamics map to relationship-like processing, and creative artifacts map to creative-like processing. The mapping is not arbitrary — it follows from what the process step needs to do with the content. Since [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]], the entire derivation challenge for novel domains reduces to designing the right process step, and knowledge type classification identifies which existing process step to start from.
+
+This works because the knowledge type determines what operations produce value. Factual assertions need extraction, verification, and synthesis — the same operations research performs. Experiential content needs pattern detection across temporal entries — what therapy processing does. Competency content needs prerequisite mapping and progression tracking — what learning systems handle. The knowledge type is not a superficial label but a functional classification that predicts which processing patterns will serve the domain. When this classification step is skipped, the result is what [[false universalism applies same processing logic regardless of domain]] describes — the derivation agent defaults to whatever processing logic it knows best, typically research-style claim extraction, regardless of whether the domain's knowledge type calls for it.
+
+The second step is where the real design happens: identifying what is different about this domain compared to its reference. Because [[schema templates reduce cognitive overhead at capture time]], the adaptation step benefits from the same principle — instead of asking "how is this domain different?" open-endedly, four dimensions of difference consistently matter, functioning as a derivation-time schema that narrows the design space. Temporal dynamics vary — a trading journal needs daily processing while a genealogy database changes monthly. Ethical requirements vary — companion animal care and health tracking demand sensitivity that equipment maintenance does not. Collaboration patterns vary — team sports analytics is inherently multi-agent while a personal garden journal is single-operator. Retrieval patterns vary — a recipe collection needs ingredient-based search while a research vault needs connection-based traversal. Each difference drives specific adaptations to the reference domain's configuration.
+
+The beekeeping example from the source makes this concrete. Colony management produces observational data (inspection records, health indicators) plus equipment management tasks — closest to a project-health hybrid. The reference gives initial settings: project-like capture templates, health-like trend detection in the process step. But beekeeping diverges from pure project management in temporal dynamics (weekly inspections, monthly trends, seasonal cycles rather than sprint-based deadlines), in schema requirements (colony_id, queen_status, brood_pattern rather than task_status, assignee), and in navigation structure (per-colony entity MOCs rather than per-project folders). Since [[schema fields should use domain-native vocabulary not abstract terminology]], this reshaping is semantic rather than mechanical — "colony_id" is not just "task_id" renamed but encodes the domain's ontological commitment that colonies are the primary entity, which changes how the system organizes, queries, and reasons about its content.
+
+Since [[configuration dimensions interact so choices in one create pressure on others]], adaptation cannot treat each dimension independently. Changing the temporal dynamics from sprint-based to seasonal cascades through maintenance cadence (seasonal analysis requires quarterly deep reviews), navigation depth (seasonal overviews need an extra hierarchy layer), and schema density (weather and temperature fields add capture friction that must be weighed against analysis value). The reference domain provides a coherent starting configuration — since [[methodology traditions are named points in a shared configuration space not competing paradigms]], reference domains function like traditions, each a pre-validated point where dimension interactions have been resolved. Adaptation from a coherent starting point is safer than constructing a novel configuration from raw dimensions, because the starting point already satisfies the coupling constraints that [[eight configuration dimensions parameterize the space of possible knowledge systems]] defines.
+
+Since [[derivation generates knowledge systems from composable research claims not template customization]], the analogy-based approach produces justification chains just as direct derivation does. The justification chain for a beekeeping system traces: "colony management is closest to project-health hybrid (knowledge type classification) → project processing handles bounded outcomes with status tracking (reference domain rationale) → but seasonal cycles replace sprint timelines (temporal adaptation) → therefore maintenance cadence shifts to weekly-monthly-seasonal (cascading dimension adjustment) → colony entity MOCs provide per-unit navigation (structural adaptation from the project pattern's per-project MOCs)." Each step in the chain is traceable and debatable, unlike a template that just hands you a beekeeping folder structure without explaining why.
+
+The knowledge type classification also surfaces the upstream storage-versus-thinking decision. Since [[storage versus thinking distinction determines which tool patterns apply]], a novel domain's knowledge type reveals which system type it needs. Equipment inventory management produces factual assertions about what exists where — but the purpose is filing and retrieval (storage), not synthesis (thinking). A wine tasting journal produces experiential content — but the purpose might be personal reflection (thinking) or just record-keeping (storage). The classification doesn't determine the answer, but it narrows the reference domain candidates and the configuration region before detailed derivation begins.
+
+The shadow side is that the six-category classification may be too coarse. Since [[faceted classification treats notes as multi-dimensional objects rather than folder contents]], Ranganathan's insight applies to domains as well as notes: any mono-classification discards information about every dimension except the one chosen. Real domains often produce multiple knowledge types — beekeeping involves factual observations (research-like), temporal patterns (therapy-like), equipment tracking (project-like), and community knowledge sharing (relationship-like). When a domain spans categories, the derivation agent must either choose the dominant type and treat others as secondary, or compose multiple reference domains — which is the multi-domain composition problem, a genuinely harder challenge. The classification works best when one knowledge type clearly dominates. When types are balanced, the mapping becomes a judgment call rather than an algorithm, and the justification chain for that judgment matters more than the choice itself.
+
+There is also a bootstrapping tension. The six categories emerge from the seven reference domains, which themselves were identified through practice rather than formal analysis. Since [[basic level categorization determines optimal MOC granularity]], Rosch's prototype theory raises the question of whether these six categories sit at the right level of abstraction — they need to be specific enough to predict useful processing patterns while general enough to cover the space. As the vault encounters genuinely novel domains and adapts reference patterns for them, the categories themselves might need revision — a domain that fits none of the six well might reveal a seventh knowledge type, or expertise deepening might make the current categories feel too coarse, just as MOC granularity shifts with understanding. The classification is a working tool, not a finished taxonomy. Its value comes from making the analogy step explicit and justifiable, not from being exhaustive.
+
+---
+---
+
+Relevant Notes:
+- [[derivation generates knowledge systems from composable research claims not template customization]] — the parent process this concretizes: derivation traverses the claim graph, and this note specifies the entry procedure when the domain has no direct reference model
+- [[every knowledge domain shares a four-phase processing skeleton that diverges only in the process step]] — the skeleton this note relies on: novel domains inherit capture, connect, and verify as constants, so the analogy-mapping focuses entirely on designing the process step
+- [[eight configuration dimensions parameterize the space of possible knowledge systems]] — the dimensions the reference domain provides initial settings for, which adaptation then adjusts based on domain-specific differences
+- [[configuration dimensions interact so choices in one create pressure on others]] — constrains adaptation: changing one dimension to fit the novel domain cascades through others, so adaptation must respect coupling rather than tweaking dimensions independently
+- [[methodology traditions are named points in a shared configuration space not competing paradigms]] — reference domains function like methodology traditions: each is a pre-validated coherence point that serves as a starting seed rather than a template to copy
+- [[storage versus thinking distinction determines which tool patterns apply]] — the upstream classification that narrows which reference domains are even candidates: a storage-oriented novel domain maps to project-like or personal-life-like patterns, not research-like
+- [[faceted classification treats notes as multi-dimensional objects rather than folder contents]] — the formal framework for why mono-classification fails for multi-type domains: Ranganathan's insight that any single axis discards information about all others applies to the six-category knowledge type scheme when domains produce multiple types
+- [[basic level categorization determines optimal MOC granularity]] — Rosch's prototype theory provides the cognitive science framework for evaluating whether the six categories sit at the right abstraction level, and predicts that the optimal resolution shifts as expertise deepens
+- [[schema templates reduce cognitive overhead at capture time]] — the four adaptation dimensions function as a derivation-time schema template: instead of open-ended domain comparison, pre-defined axes narrow the design space and reduce cognitive load during adaptation
+- [[schema fields should use domain-native vocabulary not abstract terminology]] — the vocabulary adaptation mandate: each label substitution in the beekeeping example (sprint to inspection cycle, milestone to seasonal goal) is a semantic mapping governed by this principle, not mechanical find-and-replace
+- [[multi-domain systems compose through separate templates and shared graph]] — the multi-type domain problem restated: when a novel domain spans knowledge types (factual + experiential + project-like), the mapping challenge becomes a multi-domain composition problem where the derivation must compose reference domains rather than select one
+- [[false universalism applies same processing logic regardless of domain]] — the failure mode this note's classification step prevents: when knowledge type classification is skipped, the derivation agent defaults to whatever processing logic it knows best, producing domain-mismatched operations that feel principled but are semantically empty
+- [[justification chains enable forward backward and evolution reasoning about configuration decisions]] — each analogy-mapping step (knowledge type classification, reference domain selection, adaptation rationale) is a link in the justification chain, making the novel domain derivation traceable and debatable rather than opaque; the beekeeping example in the body text demonstrates this chain structure explicitly
+
+Topics:
+- [[design-dimensions]]

package/methodology/nudge theory explains graduated hook enforcement as choice architecture for agents.md

@@ -0,0 +1,59 @@
+---
+description: Thaler and Sunstein's choice architecture maps directly to hook enforcement design -- blocking hooks are mandates, context-injecting hooks are nudges, and the graduation between them prevents alert
+kind: research
+topics: ["[[agent-cognition]]", "[[processing-workflows]]"]
+methodology: ["Cognitive Science", "Original"]
+source: [[hooks-as-methodology-encoders-research-source]]
+---
+
+# nudge theory explains graduated hook enforcement as choice architecture for agents
+
+Richard Thaler and Cass Sunstein's nudge theory (2008) introduced the concept of "choice architecture" -- the idea that how choices are presented affects which choices people make, and that interventions can make desired behavior more likely without restricting freedom. A cafeteria that places fruit at eye level nudges healthier eating without banning junk food. A retirement plan that defaults to enrollment nudges saving without prohibiting opt-out. The nudge sits between two poles: mandates that remove choice entirely and laissez-faire environments that present all options equally.
+
+Hooks implement what amounts to "execution architecture" for agents. Just as choice architecture shapes human decisions through environmental design, execution architecture shapes agent behavior through event-triggered interventions. The mapping is not metaphorical but structural. A PostToolUse hook that validates schema and injects warnings into context is a nudge -- it makes quality-compliant behavior more likely by surfacing violations at the moment of action, without preventing the agent from proceeding. A PreToolUse hook that exits with code 2 is a mandate -- it removes the option entirely, blocking the operation before it completes.
+
+The vault's implementation demonstrates the full graduated spectrum. At the mandate end, validate-note.sh blocks on missing required YAML fields because a note without frontmatter is structurally unusable -- it cannot be queried, its description cannot be retrieved, and it fails the basic composability test. Since [[schema validation hooks externalize inhibitory control that degrades under cognitive load]], the mandate is justified precisely because inhibitory control for schema compliance is a pass/fail check that degrades under load -- the kind of operation where externalized enforcement is most valuable. This is the equivalent of a food safety regulation rather than a cafeteria layout decision. At the nudge end, the same hook warns about descriptions exceeding 200 characters or enum values outside the expected set. These violations degrade quality but do not make the note structurally broken. The agent sees the warning, incorporates it, and usually fixes the issue -- but it could choose not to. Between these poles, protect-claude-md.sh warns about CLAUDE.md edits without same-day archives. It does not block the edit, recognizing that emergency modifications are sometimes necessary, but it creates enough friction to trigger the archive workflow in normal operation.
+
+This graduation matters because the alternative -- uniform blocking -- creates what nudge theory calls "reactance" in humans and what manifests as alert fatigue in agents. When every violation triggers a block, the enforcement system becomes an obstacle rather than a guide. The agent spends context window tokens on retry loops, fix-rewrite-validate cycles, and error recovery for issues that did not warrant blocking in the first place. Since [[hook composition creates emergent methodology from independent single-concern components]], uniform blocking would make composition catastrophically brittle: nine hooks each capable of blocking means nine potential failure points on every operation, and the probability of a clean pass drops multiplicatively. Graduated enforcement preserves composition by reserving blocks for genuine structural failures and using nudges for everything else.
+
+The deeper connection runs through Charles Duhigg's habit loop theory. Habits follow a cue-routine-reward cycle: a contextual cue triggers a behavioral routine, and a reward reinforces the association. Hooks implement the cue-routine portion of this loop. The lifecycle event is the cue (PostToolUse fires after a write), the hook script is the routine (validate schema, check for CLAUDE.md archive, stage and commit), and the reward is structural rather than hedonic -- the note is well-formed, the change is versioned, the methodology holds. Since [[hooks are the agent habit system that replaces the missing basal ganglia]], hooks provide the automaticity that agents lack biologically. Nudge theory adds the calibration dimension: not just WHETHER to automate (yes, because agents have no habit formation), but HOW STRONGLY to intervene at each point.
+
+The agent translation of nudge theory requires attention to where the analogy holds and where it diverges. In human choice architecture, nudges work because they exploit cognitive biases -- defaults leverage status quo bias, social proof leverages conformity, salience leverages attention. Agents do not have cognitive biases in the same sense, so nudge theory's psychological mechanisms do not transfer directly. What does transfer is the structural insight about enforcement graduation. Agents have a different but analogous constraint: context window economics. Since [[hooks enable context window efficiency by delegating deterministic checks to external processes]], the external execution already saves tokens compared to instruction-based checking. But the enforcement response still matters. A blocking hook consumes context tokens on error messages, retry prompts, and fix-validate cycles. A nudging hook consumes far fewer tokens -- a brief warning that the agent incorporates into its next action. Since [[LLM attention degrades as context fills]], every token spent on retry loops for minor violations is a token unavailable for substantive reasoning in the smart zone. The economic argument for graduation is therefore context efficiency, not bias exploitation. Block when the cost of a bad note exceeds the cost of a retry cycle. Nudge when the cost of a minor violation is less than the cost of interrupting the agent's reasoning flow.
+
+There is also a temporal dimension. Since [[complex systems evolve from simple working systems]], the enforcement level for any given check should start at nudge and migrate toward block only when accumulated evidence shows nudges are insufficient. Since [[hook-driven learning loops create self-improving methodology through observation accumulation]], the learning loop provides the evidence pipeline that justifies each graduation: observations accumulated at the nudge level reveal whether violations persist despite warnings, providing the data for deciding when to escalate. A new schema field starts as a warned check. If violations persist across sessions despite warnings -- if the nudge consistently fails to shape behavior -- the check graduates to a block. This follows Gall's Law: start with the simpler intervention (nudge), add complexity (block) only where pain demonstrates need. Since [[methodology development should follow the trajectory from documentation to skill to hook as understanding hardens]], this temporal patience applies within the hook level itself, extending the trajectory's inter-level patience (instruction to skill to hook) to intra-level calibration (nudge to block). The vault's current enforcement levels represent evolutionary calibration, not upfront design. Required fields block because experience showed that missing fields caused downstream failures. Description length warns because experience showed that slightly long descriptions rarely caused problems.
+
+The alert fatigue risk deserves direct examination. Since [[over-automation corrupts quality when hooks encode judgment rather than verification]], the most dangerous hook is not one that fails to fire but one that fires reliably on the wrong thing. Uniform enforcement severity is a subtler version of this same corruption: when every violation produces the same severity of response, agents learn that warnings carry no signal about importance. A system that warns equally about missing YAML frontmatter and about a description that is 210 characters instead of 200 teaches the agent to treat all warnings as noise. Graduated enforcement preserves the signal value of blocks by reserving them for genuine failures. The agent learns: a block means something is structurally wrong and must be fixed before proceeding; a warning means something could be better and should be addressed when convenient. This is the same principle that makes fire alarms effective only when false alarms are rare. Since [[hook enforcement guarantees quality while instruction enforcement merely suggests it]], the enforcement gap is about whether violations are detected at all. Nudge theory adds: once detection is guaranteed, the response to detection must be calibrated to preserve the informational value of each severity level.
+
+But severity graduation alone does not prevent alert fatigue -- there is also a volume dimension. Even perfectly calibrated warnings become noise when too many fire simultaneously. The solution is threshold-based pattern alerting: trigger on accumulated patterns, not individual instances. One orphan note is not an alert. Ten orphans accumulating over a week is a pattern worth surfacing. Since [[three concurrent maintenance loops operate at different timescales to catch different classes of problems]], each loop's alerting should respect its own timescale -- session-level checks report summary metrics, not exhaustive diagnostics, while longer-cycle checks can afford detail because they run less frequently. The vault already embodies this principle: rethink triggers when observations exceed ten or tensions exceed five, not on each individual capture. These thresholds implement anti-fatigue design by converting a stream of individual signals into occasional actionable summaries. Since [[observation and tension logs function as dead-letter queues for failed automation]], the accumulation thresholds serve double duty -- they batch signals for human attention while simultaneously preventing the alert stream from drowning out substantive reasoning.
+
+The effectiveness of any alert deserves empirical testing. Since [[automation should be retired when its false positive rate exceeds its true positive rate or it catches zero issues]], the same retirement logic applies to warnings: if session-start health alerts have not changed behavior in five or more sessions, they are noise and should be demoted or removed. This creates a natural lifecycle for alerts -- they earn their place through demonstrated influence on behavior, not through the importance of what they detect. Comprehensive checks still matter, but they belong in separate skill invocations with their own context windows rather than in session-start output where they compete with orientation for attention. The principle is that session-start surfaces should provide just enough awareness to guide the session's work, while dedicated maintenance skills provide the depth needed for systematic cleanup.
+
+Since [[agents are simultaneously methodology executors and subjects creating a unique trust asymmetry]], the enforcement calibration also shapes the trust relationship. A system that nudges preserves a meaningful sense of agent agency -- the agent sees the warning and decides how to respond. A system that blocks on everything treats the agent as an untrusted executor. The graduation between these poles is how the system manages the trust asymmetry: mandates where structural integrity is non-negotiable, nudges where quality improvement benefits from agent judgment.
+
+The practical design principle is that hook authors should ask three questions for each check. First, is the violation structural (the note is broken) or qualitative (the note could be better)? Structural violations block. Qualitative violations nudge. Second, is the violation deterministic (can be checked without judgment) or probabilistic (requires reasoning about context)? Deterministic violations are appropriate for hooks at all. Probabilistic assessments belong in skills, not hooks. Third, what is the cost of a false positive? If blocking on a false positive interrupts substantive reasoning with a pointless retry cycle, the check should nudge rather than block, even for structural violations, until the detection logic is reliable enough to justify hard enforcement. These three questions calibrate enforcement severity, but since [[confidence thresholds gate automated action between the mechanical and judgment zones]], a complementary axis calibrates enforcement scope — whether the system should act at all based on how certain it is about its assessment. A system that combines both axes can respond with graduated severity AND graduated scope: high confidence plus structural violation triggers blocking, medium confidence plus qualitative issue triggers a nudge, and low confidence triggers only logging regardless of violation type.
+
+---
+
+Source: [[hooks-as-methodology-encoders-research-source]]
+---
+
+Relevant Notes:
+- [[schema enforcement via validation agents enables soft consistency]] — the design recommendation this note grounds theoretically; that note says soft enforcement works, this note explains WHY it works through nudge theory and habit loop mechanisms
+- [[hook enforcement guarantees quality while instruction enforcement merely suggests it]] — the enforcement gap this note refines; hooks guarantee detection, but nudge theory explains why the response to detection should graduate rather than always block
+- [[hooks are the agent habit system that replaces the missing basal ganglia]] — the habit formation parallel; nudge theory explains how to calibrate enforcement strength, while habit theory explains why hooks exist in the first place
+- [[hook composition creates emergent methodology from independent single-concern components]] — composition depends on graduated enforcement; if every hook blocked on every violation, composition would create cascading failures rather than emergent quality
+- [[complex systems evolve from simple working systems]] — Gall's Law applied to enforcement design; start with nudges (simple, working), add blocks only where nudges prove insufficient (pain-driven complexity)
+- [[schema validation hooks externalize inhibitory control that degrades under cognitive load]] — inhibitory control IS what nudge theory calibrates for in agents; strong inhibition blocks dangerous actions, weak inhibition creates awareness without blocking, and the graduation maps directly to the mandate-vs-nudge spectrum
+- [[over-automation corrupts quality when hooks encode judgment rather than verification]] — the negative case this note's design framework prevents; the three-question test (structural vs qualitative, deterministic vs probabilistic, false positive cost) is the positive formulation of the boundary over-automation violates
+- [[methodology development should follow the trajectory from documentation to skill to hook as understanding hardens]] — the temporal patience principle applied within the hook level; enforcement strength should start at nudge and migrate toward block as evidence accumulates, extending the trajectory's inter-level patience to intra-level calibration
+- [[agents are simultaneously methodology executors and subjects creating a unique trust asymmetry]] — graduated enforcement partially addresses the trust asymmetry by distinguishing enabling interventions (nudges that preserve agent choice) from constraining ones (mandates that remove it)
+- [[hooks enable context window efficiency by delegating deterministic checks to external processes]] — grounds the context window economics argument; blocking hooks consume tokens on retry loops while nudging hooks return brief warnings, making graduation an efficiency strategy not just a severity strategy
+- [[hook-driven learning loops create self-improving methodology through observation accumulation]] — the learning loop IS the evidence pipeline that justifies enforcement graduation over time; observations accumulated at nudge level provide the data for deciding when to graduate to block
+- [[three concurrent maintenance loops operate at different timescales to catch different classes of problems]] — each loop's timescale determines appropriate alerting granularity; session-level loops should surface summary metrics while longer-cycle loops can afford diagnostic detail
+- [[observation and tension logs function as dead-letter queues for failed automation]] — accumulation thresholds for these logs embody anti-fatigue design by converting individual signals into occasional actionable batches
+- [[automation should be retired when its false positive rate exceeds its true positive rate or it catches zero issues]] — retirement logic extends to warnings; if alerts haven't changed behavior in five sessions they are noise and should be demoted or removed
+- [[confidence thresholds gate automated action between the mechanical and judgment zones]] — orthogonal graduation axis; this note graduates enforcement SEVERITY (nudge vs block), confidence thresholds graduate enforcement SCOPE (auto-apply vs suggest vs log-only), and the two axes together create a two-dimensional design space for automation decisions
+
+Topics:
+- [[agent-cognition]]
+- [[processing-workflows]]

package/methodology/observation and tension logs function as dead-letter queues for failed automation.md

@@ -0,0 +1,51 @@
+---
+description: Automation failures captured as observation or tension notes rather than dropped silently, with /rethink triaging the accumulated queue — naming a distributed systems pattern the vault already uses
+kind: research
+topics: ["[[maintenance-patterns]]", "[[agent-cognition]]"]
+methodology: ["Systems Theory", "Original"]
+source: [[automated-knowledge-maintenance-research-source]]
+---
+
+# observation and tension logs function as dead-letter queues for failed automation
+
+In distributed systems, a dead-letter queue captures messages that fail processing rather than dropping them silently. The message is attempted, retried, and when it still fails, moved to a special queue where operators can investigate the root cause and replay the message after fixing the underlying problem. The critical property is that failure is never silent — every dropped message represents lost data or broken state, so the system is architecturally designed to make failure visible.
+
+The vault already implements this pattern through its observation and tension logging infrastructure, though the pattern has not been named as such until now. When qmd crashes during a search operation, an observation note captures the failure. When a schema migration misses notes that should have been updated, a tension note captures the discrepancy. When the rename script misses a wiki link, a tension note captures the dangling reference. Since [[hook-driven learning loops create self-improving methodology through observation accumulation]], the accumulation mechanism already exists — hooks nudge the agent to capture observations at session boundaries, and the notes pile up in `04_meta/logs/`. But the learning loop framing treats these observations as intellectual raw material for methodology improvement. The dead-letter framing treats them as failure evidence for infrastructure repair. Both framings are valid, and the same note can serve both purposes, but recognizing the dead-letter function changes what counts as a well-captured observation.
+
+A learning observation says: "I noticed that the schema validation hook does not check for empty description fields." A dead-letter entry says: "The schema validation hook failed to catch note X created at timestamp Y with an empty description field because the check does not validate field content, only field presence." The dead-letter version includes the specific failure instance, the mechanism that failed, and why — information needed for replay and repair. The learning observation is sufficient for the meta-cognitive review that /rethink performs; the dead-letter entry is sufficient for the infrastructure fix that should follow. The gap between the two is specificity about the failure instance rather than the general pattern.
+
+The /rethink skill functions as the dead-letter consumer — the process that drains the queue by investigating accumulated failures and determining what to do about them. Since [[evolution observations provide actionable signals for system adaptation]], the diagnostic protocol provides a structured interpretation framework for the most common failure patterns. But the dead-letter framing adds a category the current diagnostics do not explicitly cover: automation infrastructure failures as distinct from operational evolution signals. A note type going unused for 30 days is an evolution signal (the domain does not need this distinction). A qmd crash during batch processing is an infrastructure failure (the tool broke). Both end up as observations, but they require different triage responses — evolution signals inform design changes, infrastructure failures demand immediate repair or workaround documentation.
+
+This distinction matters because the two failure types have different consequence speeds. Since [[three concurrent maintenance loops operate at different timescales to catch different classes of problems]], failures accumulate at one timescale but get triaged at another — a fast-loop hook failure generates a dead-letter entry that sits until the slow loop's /rethink session drains the queue. Since [[reconciliation loops that compare desired state to actual state enable drift correction without continuous monitoring]], scheduled reconciliation can catch evolution-type drift between sessions. But infrastructure failures compound differently — a qmd crash that goes unaddressed means every subsequent search operation in that session runs without semantic discovery, potentially missing connections that should have been found. Because [[agent session boundaries create natural automation checkpoints that human-operated systems lack]], the discrete session architecture provides natural moments where accumulated dead-letter entries surface — session-start health checks reveal what failed between sessions, making the boundary both an accumulation endpoint and a triage trigger. The dead-letter framing highlights urgency: infrastructure failures in the queue should be triaged before evolution observations because their consequences propagate through all downstream work rather than accumulating gradually.
+
+The vault's dead-letter implementation has a structural gap compared to distributed systems: there is no automated retry mechanism. In a message queue system, dead-letter entries retain enough context (the original message, the failure reason, the number of retry attempts) to support automated replay once the root cause is fixed. The vault's observation and tension notes capture the failure description but not the operational context needed for replay. If a rename script missed updating a wiki link, the tension note says "dangling link exists" but does not contain the original rename parameters needed to re-run the operation. This means every dead-letter entry requires manual investigation to reconstruct what happened — the failure is visible but not replayable. For the vault's current scale, manual investigation is sustainable. At larger scale or with more automation, the lack of replay context would become a bottleneck.
+
+The dead-letter pattern also reveals something about the relationship between since [[automated detection is always safe because it only reads state while automated remediation risks content corruption]] and failure handling. Detection failures (a health check script crashes, produces incorrect results, or misses a class of problems) are the most important dead-letter candidates because they are failures in the safety layer itself. If the detection that is supposed to catch problems itself fails, and that failure is silently dropped, the system loses its ability to self-monitor without knowing it has done so. This is why detection failure capture is more critical than remediation failure capture — a failed remediation leaves the problem unfixed but visible, while a failed detection leaves the problem invisible. The dead-letter queue for detection failures is the meta-monitoring layer: who watches the watchmen? The observation and tension logs watch the watchmen, but only if failures are actually captured rather than swallowed by error handling.
+
+But the dead-letter pattern has a deeper blind spot than silent failure: successful corruption. Since [[over-automation corrupts quality when hooks encode judgment rather than verification]], the most dangerous automation errors are not failures at all — they are operations that complete successfully while producing wrong results. A keyword-matching link hook does not crash or throw an error. It fires, adds links, and returns success. The dead-letter queue never sees it because there was no failure to capture. The corrupted state — noise links indistinguishable from genuine connections — becomes the ground truth that subsequent detection operates on. This is the class of problem that dead-letter infrastructure cannot address by design: the queue captures messages that failed processing, but over-automation produces messages that succeeded at processing the wrong thing. The implication is that dead-letter queues are necessary but not sufficient for automation safety — they handle the "watchmen who fall asleep" problem but not the "watchmen who confidently report the wrong thing" problem, which requires the determinism boundary and judgment gates as independent safeguards.
+
+Since [[confidence thresholds gate automated action between the mechanical and judgment zones]], dead-letter triage itself follows the three-tier confidence pattern. Some failures are clearly mechanical and can be addressed with high confidence — qmd crashed, restart and retry. Others require judgment — the schema migration missed notes because the migration logic did not account for a new template variant, and determining which notes were affected requires semantic evaluation. Because [[the fix-versus-report decision depends on determinism reversibility and accumulated trust]], each dead-letter entry faces the same four-condition gate: a qmd crash is deterministic, reversible, low-cost-if-wrong, and well-understood, so it qualifies for auto-fix; a migration that skipped notes fails the determinism condition since multiple valid corrections may exist, so it must remain report-only regardless of how much trust the migration system has accumulated. The triage agent (/rethink) should handle mechanical failures quickly and focus its judgment capacity on the ambiguous cases, applying the same conservative asymmetry that governs all remediation decisions.
+
+The observation infrastructure also serves a third purpose beyond learning and failure capture: accumulating tacit knowledge. Since [[operational wisdom requires contextual observation]], some agent knowledge — how a community talks, what gets engagement on a platform, how a specific person prefers to communicate — resists formalization as claim notes and instead accumulates as dated observations that build toward pattern-matched intuition. These observations share the same infrastructure as dead-letter entries and learning observations but serve neither the methodology-improvement function of the learning loop nor the failure-repair function of the dead-letter queue. They serve an operational wisdom function: building the contextual understanding that makes an agent effective in specific environments. The dead-letter framing highlights that failure entries need urgency-based triage, while operational wisdom entries need patience-based accumulation — the triage protocol should distinguish between these categories when /rethink drains the observation queue.
+
+Naming this pattern enables deliberate design rather than accidental implementation. When adding new automation (a new hook, a new scheduled reconciliation check, a new skill), the dead-letter question becomes a design requirement: "When this automation fails, where does the failure go?" If the answer is "nowhere — it fails silently," the automation has a design gap. Every automated operation should have a defined failure capture path, whether that is an observation note, a tension note, a queue entry, or a log file. The vault's existing infrastructure already provides most of the capture mechanisms. What the dead-letter framing adds is the principle that failure visibility is not optional — it is an architectural requirement on par with the automation itself.
+
+---
+---
+
+Relevant Notes:
+- [[hook-driven learning loops create self-improving methodology through observation accumulation]] — the accumulation mechanism: observations pile up through hook nudges, but this note reframes that pile as a dead-letter queue rather than a learning journal, which changes what counts as a valid entry and how triage should prioritize
+- [[evolution observations provide actionable signals for system adaptation]] — the diagnostic protocol that interprets accumulated observations; dead-letter framing adds a category the diagnostics don't currently cover: infrastructure failure logs distinct from operational evolution signals
+- [[automated detection is always safe because it only reads state while automated remediation risks content corruption]] — detection failures are the primary dead-letter source: when a detection script crashes or produces wrong results, the failure itself needs capturing; the read-only safety guarantee means detection failures are always recoverable, but only if they are captured rather than dropped
+- [[reconciliation loops that compare desired state to actual state enable drift correction without continuous monitoring]] — reconciliation is the scheduled mechanism that should catch failures the dead-letter queue accumulated between runs; the queue provides the evidence, reconciliation provides the scheduling
+- [[confidence thresholds gate automated action between the mechanical and judgment zones]] — dead-letter triage is itself a confidence-gated decision: some failures are clearly mechanical (qmd crash, retry immediately) while others require judgment (schema migration missed notes — which notes? why?)
+- [[three concurrent maintenance loops operate at different timescales to catch different classes of problems]] — the scheduling architecture where dead-letter accumulation and consumption happen at different timescales: failures accumulate during fast and medium loop operation, while the slow loop's meta-cognitive review (/rethink) functions as the dead-letter consumer that drains the queue
+- [[the fix-versus-report decision depends on determinism reversibility and accumulated trust]] — dead-letter triage IS a fix-versus-report decision: mechanical failures (qmd crash) pass all four conditions for auto-fix, while judgment-requiring failures (migration missed notes) fail the determinism condition and must remain report-only regardless of accumulated trust
+- [[agent session boundaries create natural automation checkpoints that human-operated systems lack]] — session boundaries are both producer and consumer of dead-letter entries: hooks that fail at boundaries generate entries, while session-start health checks surface accumulated failures, making the discrete session architecture the operational rhythm of the dead-letter lifecycle
+- [[automation should be retired when its false positive rate exceeds its true positive rate or it catches zero issues]] — dead-letter evidence informs retirement: a check that generates only false-positive dead-letter entries is producing its own retirement case; the dead-letter queue designed for infrastructure repair serves double duty as the empirical foundation for retirement decisions
+- [[over-automation corrupts quality when hooks encode judgment rather than verification]] — the structural blind spot: dead-letter queues capture operations that fail, but over-automation produces operations that succeed at the wrong thing; noise links from keyword-matching hooks never enter the dead-letter queue because there was no failure event, making dead-letter infrastructure necessary but not sufficient for automation safety
+- [[operational wisdom requires contextual observation]] — third use case: observation logs serve not just learning (methodology improvement) and dead-letter (failure capture) functions but also operational wisdom accumulation, where dated observations build contextual understanding that resists claim-note formalization
+
+Topics:
+- [[maintenance-patterns]]
+- [[agent-cognition]]

package/methodology/operational memory and knowledge memory serve different functions in agent architecture.md

@@ -0,0 +1,48 @@
+---
+description: Queue state and task files track what is happening now while claims and MOCs encode what has been understood — conflating the two creates systems that are either too volatile or too rigid
+kind: research
+topics: ["[[agent-cognition]]"]
+methodology: ["Original"]
+---
+
+# operational memory and knowledge memory serve different functions in agent architecture
+
+Agent systems need two distinct kinds of persistent state, and the distinction matters because designing for one while ignoring the other produces characteristic failures. (There is arguably a third kind — since [[agent self-memory should be architecturally separate from user knowledge systems]], agents also accumulate self-knowledge about their own working patterns that differs from both task coordination and domain claims. This note focuses on the operational/knowledge split because it is the more fundamental architectural choice; self-memory is a specialization within the knowledge category that merits its own container.)
+
+Operational memory tracks what is happening: which task is active, what phase it reached, what the last session discovered, what remains to do. In this vault, queue.json and per-claim task files are operational memory. They exist to coordinate work across sessions. Their value is temporal — once a batch completes and gets archived, the operational state served its purpose. Nobody revisits a task file to understand what knowledge work IS; they revisit it to understand what happened during processing.
+
+Knowledge memory encodes what has been understood: claims about how things work, connected through wiki links, organized by MOCs, queryable through metadata and semantic search. The notes in 01_thinking/ are knowledge memory. Their value compounds over time because [[session handoff creates continuity without persistent memory]] only at the operational level — each session picks up where the last left off — but the knowledge graph accumulates understanding that deepens with every new note and connection. Since [[the vault constitutes identity for agents]], this knowledge layer is not merely useful — it is identity-constituting. The claims, connections, and synthesis that accumulate in knowledge memory are what make one agent distinguishable from another running the same weights. Operational memory enables continuity; knowledge memory constitutes who the agent is. The distinction is between state that coordinates and structure that teaches.
+
+This internal memory distinction parallels a system-level taxonomy. Since [[storage versus thinking distinction determines which tool patterns apply]], external knowledge tools split along the same axis: storage systems (PARA, Johnny.Decimal) optimize for filing and retrieval, while thinking systems (Zettelkasten, this vault) optimize for synthesis and connection. The operational/knowledge memory split within an agent mirrors the storage/thinking split between tools — both taxonomies distinguish coordination from understanding, state-tracking from synthesis.
+
+The failure modes of conflation are instructive. Systems that treat everything as operational memory (timestamped logs, daily captures, chat histories) accumulate records without building retrievable understanding. They know what happened but cannot answer questions about what it means. Systems that try to make everything knowledge (over-structured capture, premature formalization) create friction at the moment of recording and force synthesis before the material is ready. A subtler failure mode is that since [[coherence maintains consistency despite inconsistent inputs]], knowledge memory requires active coherence maintenance — detecting and resolving contradictions — while operational memory does not. Task files can record conflicting observations across phases without degradation because they coordinate work, not constitute understanding. Applying coherence requirements to operational memory would add unnecessary friction; failing to apply them to knowledge memory allows contradictory beliefs to accumulate and degrade retrieval. Since [[cognitive offloading is the architectural foundation for vault design]], the vault must minimize capture friction — which means operational memory should be fast and disposable, while knowledge memory should be careful and durable.
+
+The vault implements this separation architecturally. The 04_meta/ folder is operational infrastructure: task queues, scripts, logs, session archives. The 01_thinking/ folder is the knowledge system: claims, MOCs, synthesis. The inbox (00_inbox/) is the transition zone where raw material awaits the processing that converts operational capture into knowledge artifacts. Since [[fresh context per task preserves quality better than chaining phases]], the operational layer (queue.json, task files, handoff formats) exists precisely because sessions are isolated — without persistent operational state, each session would start blind, unable to continue multi-step work.
+
+The boundary is not always clean. Task files accumulate phase notes (reduce notes, reflect notes, reweave notes) that contain genuine reasoning, which means since [[intermediate packets enable assembly over creation]], operational artifacts can contain knowledge-grade material available for future assembly. But this does not mean the categories should merge. The task file is organized for workflow coordination (sequential phases, completion tracking), while a thinking note is organized for traversal and connection (wiki links, MOC placement, semantic description). The same insight lives in both, but the containers serve different purposes. Processing transforms operational observations into knowledge claims — that transformation IS the value-creation step.
+
+Platform memory architectures reveal this distinction further. OpenClaw's daily logs are operational memory — timestamped records of what happened in each session. Its MEMORY.md is closer to knowledge but stores facts rather than connected claims. Claude Code has no native memory at all, so the vault must implement both layers from scratch. In each case, the knowledge system works WITH the platform's operational memory, not as a replacement for it. The generator for portable knowledge systems must understand which layer each platform provides and what the knowledge system must supply. Since [[four abstraction layers separate platform-agnostic from platform-dependent knowledge system features]], the two memory types map predictably onto the layer hierarchy: knowledge memory lives at the foundation and convention layers (files, wiki links, YAML frontmatter, instructions about quality standards) and is fully portable, while operational memory requires the automation and orchestration layers (hooks that trigger processing, subagent coordination, queue management) and is deeply platform-specific. This explains why knowledge transfers easily between platforms while operational workflows must be rebuilt per environment.
+
+The distinction also interacts with a broader shift in what knowledge systems fundamentally do. Since [[AI shifts knowledge systems from externalizing memory to externalizing attention]], operational memory remains straightforwardly about memory externalization — you need to know what task is active, what phase comes next, what the last session discovered. But the knowledge layer is increasingly about attention externalization: the system does not just store claims, it surfaces connections, directs processing effort, and decides what deserves deeper engagement. This means the two memory types are diverging not just in function but in kind — operational memory externalizes state, while knowledge memory is evolving toward externalizing judgment about what matters.
+
+Since [[context files function as agent operating systems through self-referential self-extension]], there is one artifact that inherently spans both memory types: the context file itself. CLAUDE.md contains operational instructions (how to update queue.json, how to invoke skills, how to run hooks) alongside knowledge methodology (what makes a good note, quality standards, connection-finding practices). It is simultaneously a piece of operational infrastructure that coordinates how the agent works and a piece of knowledge that teaches the agent what good knowledge work looks like. The context file is the boundary object where the separation is most productive and most fragile — operational changes (new hook syntax) and knowledge changes (revised quality criteria) both modify the same file, requiring the archive-and-modify protocol to maintain coherence across both concerns.
+
+---
+---
+
+Relevant Notes:
+- [[session handoff creates continuity without persistent memory]] — handoff documents are operational memory; they bridge sessions but do not themselves become knowledge
+- [[cognitive offloading is the architectural foundation for vault design]] — the theoretical ground: both memory types are cognitive offloading, but they offload different things — operational memory offloads working state, knowledge memory offloads understanding
+- [[fresh context per task preserves quality better than chaining phases]] — session isolation creates the need for operational memory; without persistent sessions, task state must be externalized somewhere
+- [[intermediate packets enable assembly over creation]] — packets blur the boundary: a task file is operational scaffolding during processing but its accumulated notes become knowledge artifacts available for assembly
+- [[agent self-memory should be architecturally separate from user knowledge systems]] — extends the taxonomy: this note identifies operational vs knowledge memory, that note identifies a third type — agent self-memory (working preferences, identity) that differs from both domain knowledge and task coordination
+- [[four abstraction layers separate platform-agnostic from platform-dependent knowledge system features]] — maps memory types to layers: knowledge memory lives at foundation and convention (files, wiki links, instructions), operational memory requires automation and orchestration (queues, hooks, subagent coordination)
+- [[AI shifts knowledge systems from externalizing memory to externalizing attention]] — reframes what knowledge memory is becoming: operational memory remains memory externalization (tracking task state), but the knowledge layer is shifting toward attention externalization (directing what to notice, not just what to store)
+- [[context files function as agent operating systems through self-referential self-extension]] — boundary object: context files span both memory types, containing operational instructions (how to run the pipeline) alongside knowledge methodology (what makes a good note), making the context file itself a carrier of both state types
+- [[stigmergy coordinates agents through environmental traces without direct communication]] — names the coordination mechanism: the two memory types are two classes of stigmergic trace with different persistence profiles; operational traces (queue state) expire after coordination, knowledge traces (wiki links) compound indefinitely
+- [[storage versus thinking distinction determines which tool patterns apply]] — parallel taxonomy at the system level: storage systems optimize for filing and retrieval (analogous to operational memory's coordination function) while thinking systems optimize for synthesis and connection (analogous to knowledge memory's understanding function); the internal memory distinction mirrors the external system-type distinction
+- [[the vault constitutes identity for agents]] — identity implication: if the vault constitutes identity, the operational/knowledge split means identity has layers — knowledge memory constitutes core identity (who the agent is, what it understands), while operational memory enables continuity (how it coordinates) but is disposable after use
+- [[coherence maintains consistency despite inconsistent inputs]] — differentiating property: knowledge memory requires coherence maintenance (contradictory beliefs degrade confidence and retrieval) while operational memory has no coherence requirement — task files can contain conflicting phase notes without issue because they coordinate rather than constitute understanding
+
+Topics:
+- [[agent-cognition]]

package/methodology/operational wisdom requires contextual observation.md

@@ -0,0 +1,52 @@
+---
+description: tacit knowledge doesn't fit in claim notes — it's learned through exposure, logged as observations, and pattern-matched over time
+kind: research
+topics: ["[[agent-cognition]]", "[[maintenance-patterns]]"]
+---
+
+# operational wisdom requires contextual observation
+
+Some knowledge is explicit — it can be stated as claims, reasoned about, linked. But effective operation also requires tacit knowledge: how does this community talk? What gets engagement here? What are the unwritten norms? How does this person prefer to communicate? These cannot be formalized upfront. They can only be observed and logged.
+
+Claim notes capture explicit knowledge well. But since [[the vault constitutes identity for agents]], an agent's identity includes not just propositional claims but the accumulated operational understanding that makes it effective in specific contexts. Operational wisdom is part of what distinguishes one agent from another, and since [[agent self-memory should be architecturally separate from user knowledge systems]], this kind of knowledge belongs in the agent's own persistent space rather than mixed into the domain research graph.
+
+## The Pattern
+
+For any context requiring tacit knowledge:
+
+1. Create an observation document — a dedicated place for dated, specific notes about the context
+2. Log observations as they happen — what worked, what flopped, what surprised
+3. Aggregate patterns over time — what keeps appearing?
+4. Update behavior based on patterns — not rigid rules, but pattern-matching
+
+This works for platforms (twitter, discord), communities (academics, practitioners), individuals (communication preferences), and domains (research norms, publishing conventions).
+
+The pattern has a direct parallel in how the vault evolves its own infrastructure. Since [[schema evolution follows observe-then-formalize not design-then-enforce]], schema fields crystallize through accumulated usage evidence rather than upfront specification. The same observe-then-formalize logic applies: you cannot predict which schema fields will earn their cost until the system is in use, just as you cannot predict which cultural norms matter until you have observed the community. Both resist premature formalization.
+
+## The Acquisition Mechanism
+
+How does tacit knowledge actually form? Since [[implicit knowledge emerges from traversal]], repeated exposure to the same paths builds intuitive understanding that bypasses explicit retrieval. An agent that has traversed twitter engagement patterns across many sessions develops a feel for what works — not through rules but through accumulated exposure. The observation log is the explicit complement to this implicit process: it captures what might otherwise remain unarticulated, making pattern-matching possible across sessions where implicit knowledge resets.
+
+The concrete mechanism for this in the vault is the hook-driven learning loop. Since [[hook-driven learning loops create self-improving methodology through observation accumulation]], hooks nudge the agent to capture observations at session boundaries, observations accumulate as atomic notes, and when enough accumulate the meta-cognitive layer (/rethink) pattern-matches across them to revise methodology. This is operational wisdom acquisition systematized: observe, accumulate, pattern-match, adapt.
+
+## Why This Matters for Agents
+
+Agents operating on generic rules miss context. An agent that can read and adapt to cultural norms is more effective than one applying universal templates. Since [[external memory shapes cognition more than base model]], the retrieval architecture determines what enters the context window — and if that architecture surfaces accumulated operational observations alongside domain claims, the agent reasons with contextual awareness rather than abstract principles alone.
+
+The vault should contain operational wisdom, not just propositional knowledge. And since [[provenance tracks where beliefs come from]], the agent should track which operational insights were observed firsthand (high trust, slow decay) versus inherited from prompts (medium trust, worth testing). An observed pattern across twenty sessions of twitter engagement carries different epistemic weight than a single instruction about how to tweet.
+
+---
+---
+
+Relevant Notes:
+- [[implicit knowledge emerges from traversal]] — the acquisition mechanism: repeated traversal builds the intuitive understanding that observation logs attempt to capture explicitly; traversal produces tacit knowledge as a side effect
+- [[external memory shapes cognition more than base model]] — retrieval includes cultural context, so the architecture that surfaces operational observations shapes what the agent can pattern-match on
+- [[the vault constitutes identity for agents]] — tacit knowledge is part of identity: an agent's accumulated operational wisdom distinguishes it from other instances with the same weights
+- [[agent self-memory should be architecturally separate from user knowledge systems]] — the architectural container: operational wisdom belongs in the agent's self-memory space, not mixed with domain research claims
+- [[hook-driven learning loops create self-improving methodology through observation accumulation]] — the implementation mechanism: hooks nudge observation capture, observations accumulate, and pattern-matching across accumulated observations drives methodology revision
+- [[schema evolution follows observe-then-formalize not design-then-enforce]] — parallel pattern: schema fields crystallize through accumulated usage evidence rather than upfront design, applying the same observe-then-formalize logic to data structures
+- [[provenance tracks where beliefs come from]] — epistemic calibration: knowing whether operational wisdom was observed firsthand versus inherited from prompts determines how much to trust it
+
+Topics:
+- [[agent-cognition]]
+- [[maintenance-patterns]]

package/methodology/orchestrated vault creation transforms arscontexta from tool to autonomous knowledge factory.md

@@ -0,0 +1,40 @@
+---
+description: The shift from "plugin that helps you set up a vault" to "system that builds domain knowledge for you" — init creates structure, orchestration fills it with researched content
+kind: research
+topics: ["[[design-dimensions]]", "[[agent-cognition]]"]
+confidence: speculative
+methodology: ["Original"]
+---
+
+# orchestrated vault creation transforms arscontexta from tool to autonomous knowledge factory
+
+ArsContexta v1 is a derivation engine: give it a persona and a domain, it derives a complete knowledge system with the right configuration, vocabulary, templates, and skills. But the derived system is empty. The notes directory has an index.md and nothing else. The human or their agent still needs to do the actual knowledge work — capturing sources, extracting claims, finding connections. Derivation solves the architectural problem but not the content problem.
+
+Orchestration solves the content problem. By wrapping the derivation engine in an orchestration layer that researches topics, feeds results through the derived system's pipeline, and evaluates coverage against the stated goal, ArsContexta becomes something categorically different: not a tool that helps you set up a vault, but a system that builds domain knowledge for you. The user defines what they want to know. The system does the knowing.
+
+This product evolution has three stages.
+
+**Stage 1: Scaffolding** (ArsContexta v1). Derive the right structure for the user's domain. The init wizard resolves eight configuration dimensions, generates a context file, creates templates and skills, validates the kernel. The output is an empty but well-configured knowledge system. Value: saves hours of architectural decisions.
+
+**Stage 2: Populated scaffolding** (orchestration MVP). Derive the structure AND fill it with researched content. The orchestrator runs 5-10 research cycles using Exa deep research, processes each through the target vault's pipeline, and evaluates quality. The output is a knowledge graph with 30-80 notes, meaningful connections, and curated MOCs. Value: saves weeks of research and processing.
+
+**Stage 3: Continuous learning** (future). The orchestrated vault doesn't stop after initial population. It continues researching, tracking new publications, updating its knowledge graph as the domain evolves. The output is a living knowledge system that stays current. Value: replaces a research assistant.
+
+The strategic insight is that since [[the derivation engine improves recursively as deployed systems generate observations]], orchestration at scale becomes a feedback accelerator. Each orchestrated vault generates operational observations about what works: which research seeds produce dense knowledge graphs, which configuration choices create friction in specific domains, which pipeline phases produce the most value. Ten orchestrated vaults generate ten times the operational observations that ten manual deployments would, because the orchestrator can systematically capture what worked and what didn't. This feedback loop improves derivation quality faster than organic adoption.
+
+The technical architecture is intentionally simple. Since [[agent session boundaries create natural automation checkpoints that human-operated systems lack]], each `claude -p` call to the target vault is a natural checkpoint. The orchestrator can inspect the filesystem after each call, evaluate progress, and adjust strategy. No complex inter-process communication, no shared state beyond the filesystem. The target vault doesn't even know it's being orchestrated — it just processes whatever appears in its inbox, same as it would if a human were working it.
+
+The competitive positioning is significant. Most AI knowledge tools offer one of two things: retrieval (search your existing notes better) or capture (transcribe/summarize inputs). ArsContexta with orchestration offers generation: define a domain, get a populated knowledge graph. This is closer to what Exa's deep researcher does for individual queries, but extended to building persistent, navigable, interconnected knowledge structures rather than flat research reports.
+
+---
+---
+
+Relevant Notes:
+- [[derivation generates knowledge systems from composable research claims not template customization]] — derivation is the structural layer; orchestration adds the content layer, completing the vision of principled knowledge system generation
+- [[the derivation engine improves recursively as deployed systems generate observations]] — orchestrated creation at scale becomes a feedback accelerator: 50 orchestrated vaults generate 50x the operational observations that manual deployments would
+- [[goal-driven memory orchestration enables autonomous domain learning through directed compute allocation]] — the mechanism note; this note addresses the product and strategic implications
+- [[agent session boundaries create natural automation checkpoints that human-operated systems lack]] — session boundaries in the target vault become automation checkpoints the orchestrator can monitor and act on
+
+Topics:
+- [[design-dimensions]]
+- [[agent-cognition]]

package/methodology/organic emergence versus active curation creates a fundamental vault governance tension.md

@@ -0,0 +1,68 @@
+---
+description: Curation prunes possible futures while emergence accumulates structural debt — the question is not which pole to choose but what governance rhythm alternates between them
+kind: research
+topics: ["[[maintenance-patterns]]", "[[design-dimensions]]"]
+confidence: speculative
+methodology: ["Digital Gardening", "Zettelkasten", "Original"]
+source: [[tft-research-part3]]
+---
+
+# organic emergence versus active curation creates a fundamental vault governance tension
+
+Knowledge systems face a governance dilemma with no stable equilibrium. The emergence pole says structure should grow organically from linking behavior — let notes find their relationships, let MOCs form when navigation friction demands them, let the graph topology reveal itself. The curation pole says active intervention is needed to maintain quality — enforce schema compliance, prune dead links, split overgrown MOCs, reweave sparse notes. Both poles contain genuine wisdom, and the tension is not resolvable by choosing a side.
+
+The emergence pole draws theoretical support from information theory and systems thinking. Since [[controlled disorder engineers serendipity through semantic rather than topical linking]], Luhmann's insight applies directly: a perfectly curated vault where every note is classified, every link validated, and every MOC trimmed to optimal size yields zero surprise. The over-curated system tells you only what you already organized. Semantic cross-links that feel "messy" from a governance perspective are precisely the connections that generate discovery. And since [[complex systems evolve from simple working systems]], the Gall's Law argument says you cannot design a healthy knowledge graph top-down — working structure must emerge from working simpler structure. Heavy curation at the wrong moment can kill the organic patterns that would have produced better architecture than any designed intervention.
+
+The curation pole draws equally strong support from operational reality. Without intervention, vaults accumulate structural debt: orphan notes multiply, MOCs bloat past navigability, link contexts decay as understanding evolves, and the graph fragments into temporal layers where recent notes reference each other but ignore older content. At the belief level, since [[coherence maintains consistency despite inconsistent inputs]], emergence without curation produces a subtler problem than structural debt: contradictory beliefs accumulate silently across temporal layers, and the vault can feel coherent while holding claims that directly conflict with each other. The "just let it grow" philosophy produces what digital gardening calls "a jungle" — technically alive, practically unnavigable. Agent-operated systems amplify this because agents cannot feel the accumulated friction the way a human gardener feels that something is overgrown. The agent processes each note in isolation, unaware that the forest has become impenetrable.
+
+The interesting question is not which pole wins but what governance rhythm balances them. Since [[schema evolution follows observe-then-formalize not design-then-enforce]], the most developed resolution attempt in this vault is already a rhythm: let usage patterns emerge, then formalize what proves useful on a quarterly cycle. This is neither pure emergence nor pure curation — it is phased alternation. The emergence phase generates data about what the system actually needs. The curation phase converts that data into structural decisions. The rhythm matters because curating too early kills emergence (premature formalization) while curating too late lets debt compound past the point of easy resolution.
+
+There are at least three mechanisms that make this tension genuinely difficult rather than merely rhetorical.
+
+First, curation decisions are irreversible in a way emergence is not. When you split a MOC, the original organizational context disappears. When you prune a link, the reasoning that created it may be unrecoverable. When you enforce a schema change, notes that fit the old schema and resist the new one get forced into compliance. Each curation act prunes possible futures that organic growth might have reached. Emergence, by contrast, is additive — new connections, new patterns, new notes. The asymmetry means over-curation creates losses that under-curation does not.
+
+Second, the governance model interacts with the automation level. Since [[hooks cannot replace genuine cognitive engagement yet more automation is always tempting]], every hook is a curation mechanism operating at infrastructure level. Schema validation hooks curate what notes can look like. Auto-commit hooks curate when work is persisted. Each hook individually seems like responsible governance, but collectively they constrain the organic space. And since [[over-automation corrupts quality when hooks encode judgment rather than verification]], automated curation that approximates semantic judgment produces the worst of both worlds — the structural appearance of a well-governed vault with none of the genuine quality that judgment-based curation provides. The Goodhart corruption is what happens when the curation pole is pursued through automation rather than reasoning. Since [[MOC construction forces synthesis that automated generation from metadata cannot replicate]], MOC maintenance is where this corruption is most visible: automated topic-to-note matching produces structurally valid MOCs that list everything but synthesize nothing, losing the tension identification and orientation writing that justify the curation pole in the first place.
+
+Third, the human and the agent have different relationships to this tension. Since [[cognitive outsourcing risk in agent-operated systems]], the human risks losing the meta-cognitive capacity to evaluate governance itself. When agents handle all curation, the human cannot independently judge whether the vault is over-curated or under-curated because that judgment requires the very skills that delegation atrophies. The governance question is not just "how much curation?" but "who curates?" — and the answer affects whether the system can self-correct.
+
+Since [[incremental formalization happens through repeated touching of old notes]], there is a middle path that neither pole fully accounts for: the organic touches that happen during routine traversal. When an agent follows links and notices a stale description, that touch is simultaneously emergence (the encounter was not planned) and curation (the improvement is intentional). The formalization pattern suggests that the binary framing may itself be the problem. The most productive governance is not a spectrum between emergence and curation but an interleaving where organic encounters trigger micro-curation decisions. The vault convention is that since [[vault conventions may impose hidden rigidity on thinking]], the conventions themselves should be subject to this same interleaving — conventions emerge from practice, then get formalized, then get questioned when practice shifts.
+
+The operational question for agent-operated vaults is how to build governance rhythms that alternate between the poles rather than settling on one. Since [[gardening cycle implements tend prune fertilize operations]], separating curation into focused operations may help — the issue might not be curation per se but the granularity at which it is applied. Holistic "governance passes" that try to curate everything at once may be what kills emergence, while focused micro-curation (one operation, one note, one decision) may preserve the organic quality that emergence advocates value.
+
+What keeps this tension alive: every vault that survives long enough faces this dilemma, and the resolution is always temporary. The rhythm that works at 100 notes fails at 1000 because [[configuration dimensions interact so choices in one create pressure on others]] — organic growth in granularity or linking density accumulates pressure on navigation and maintenance dimensions that only curation can relieve, and the coupling tightens with scale. Since [[navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts]], the governance rhythm itself must change qualitatively at regime boundaries: at Regime 1 (under 50 notes) the emergence pole dominates safely because manual awareness suffices, at Regime 2 (50-500) active curation through MOC maintenance becomes essential, and at Regime 3 (500+) the curation pole must be partly delegated to automated detection because no manual governance rhythm can keep pace with structural drift at that scale. The governance that serves a single-agent vault breaks under multi-agent operation. The balance point is not a location but a practice — the ongoing work of noticing when the vault has drifted too far toward either pole and correcting course.
+
+Since [[derived systems follow a seed-evolve-reseed lifecycle]], the phased alternation this tension identifies may already have a formal resolution: the seed-evolve-reseed lifecycle is precisely a governance rhythm where emergence (evolution) runs until accumulated incoherence triggers curation (reseeding). The lifecycle adds what the observe-then-formalize pattern lacks — a mechanism for recognizing when incremental curation is insufficient and principled restructuring is needed. And since [[evolution observations provide actionable signals for system adaptation]], the six diagnostics — unused types, N/A fields, navigation failure, unlinked output — provide the empirical signal for when governance should shift from the emergence pole to the curation pole, moving the transition from intuition to measurement.
+
+The infrastructure level offers a surprising partial dissolution. Since [[hook composition creates emergent methodology from independent single-concern components]], individually curated hooks compose into emergent behavioral patterns that no single hook was designed to produce. This is emergence and curation operating simultaneously rather than alternating — each hook is a discrete curation decision, but their composition produces organic methodology that was not planned. Whether this interleaving scales to the content level (where curation decisions are less deterministic) remains an open question, but it demonstrates that the binary framing of emergence-versus-curation may be an artifact of treating them as sequential rather than concurrent.
+
+The governance question also carries a trust dimension that complicates any resolution. Since [[agents are simultaneously methodology executors and subjects creating a unique trust asymmetry]], the agent executes governance decisions it did not make — schema enforcement, processing cadence, MOC thresholds — and cannot observe whether the governance rhythm is working. The human designed the infrastructure; the agent operates within it. Any governance rhythm must account for this asymmetry: who decides when to shift from emergence to curation, and whether the entity making that decision has the operational perspective to judge correctly.
+
+---
+
+Source: [[tft-research-part3]]
+---
+
+Relevant Notes:
+- [[vault conventions may impose hidden rigidity on thinking]] — sibling tension: that note asks whether conventions constrain what can be thought, this asks whether the governance model that creates and enforces conventions is itself the right balance point
+- [[controlled disorder engineers serendipity through semantic rather than topical linking]] — the information-theoretic argument for the emergence pole: perfect order yields zero surprise, so some degree of organic growth is necessary for the semantic cross-links that drive discovery
+- [[schema evolution follows observe-then-formalize not design-then-enforce]] — the most developed dissolution attempt: observe-then-formalize is explicitly a rhythm of emergence then curation, with quarterly reviews as the phase transition trigger
+- [[hooks cannot replace genuine cognitive engagement yet more automation is always tempting]] — parallel governance tension at infrastructure level: hooks are a curation mechanism, and expanding them too aggressively suppresses the organic reasoning that produces genuine insight
+- [[over-automation corrupts quality when hooks encode judgment rather than verification]] — the Goodhart failure mode of the curation pole: curating through automation produces structural compliance without semantic value
+- [[incremental formalization happens through repeated touching of old notes]] — emergence-first mechanism: notes crystallize through accumulated organic touches rather than planned curation passes, suggesting the emergence pole has a natural formalization pathway
+- [[cognitive outsourcing risk in agent-operated systems]] — the human-side cost of excessive curation: when agents handle all governance decisions, humans lose the meta-cognitive skills to evaluate whether governance is working
+- [[gardening cycle implements tend prune fertilize operations]] — the operational decomposition of curation: separating maintenance into focused operations tests whether the issue is curation itself or how coarsely curation is applied
+- [[complex systems evolve from simple working systems]] — Gall's Law as theoretical grounding for the emergence pole: you cannot design a working complex system top-down, so some organic evolution is not optional but necessary
+- [[derived systems follow a seed-evolve-reseed lifecycle]] — formalizes the governance rhythm this tension identifies: seeding is initial curation, evolution is the emergence phase, and reseeding is principled curation triggered by accumulated incoherence, making the lifecycle the temporal resolution of this tension
+- [[configuration dimensions interact so choices in one create pressure on others]] — explains why the governance rhythm must change with scale: accumulated organic growth in one dimension creates pressure requiring curation in others, and the coupling means a fixed governance balance will drift into incoherence
+- [[evolution observations provide actionable signals for system adaptation]] — provides the empirical detection layer for when governance should shift from emergence to curation: the six diagnostics are essentially drift-toward-emergence detectors that trigger curation intervention
+- [[agents are simultaneously methodology executors and subjects creating a unique trust asymmetry]] — deepens the third mechanism (who curates): the agent operates under governance decisions it did not make, so the governance tension is resolved by mechanisms the agent has no voice in, adding a trust dimension to the rhythm question
+- [[community detection algorithms can inform when MOCs should split or merge]] — algorithmic operationalization of the governance tension: community detection provides empirical signals for when organic growth has created structural needs that require curation, moving the emergence-to-curation transition from intuition to measurement
+- [[hook composition creates emergent methodology from independent single-concern components]] — concrete interleaving example: individually curated hooks compose into emergent methodology, demonstrating that emergence and curation can operate simultaneously at the infrastructure level rather than requiring phased alternation
+- [[decontextualization risk means atomicity may strip meaning that cannot be recovered]] — the curation pole's enforcement of strict atomicity creates the decontextualization risk: when governance curates aggressively through schema compliance and claim extraction discipline, it drives the same decomposition that strips argumentative context from ideas
+- [[coherence maintains consistency despite inconsistent inputs]] — names the belief-level cost of unchecked emergence: without curation, contradictory beliefs accumulate silently, and since within-agent incoherence degrades confidence unlike between-agent divergence, the governance rhythm must include coherence maintenance as a specific curation obligation
+- [[MOC construction forces synthesis that automated generation from metadata cannot replicate]] — grounds the curation pole's strongest argument: the Dump-Lump-Jump pattern shows that automated MOC generation (the emergence approach to navigation) produces structurally valid lists without the tension identification and orientation synthesis that make MOCs valuable; MOC construction is where curation creates value that emergence provably cannot
+- [[navigation infrastructure passes through distinct scaling regimes that require qualitative strategy shifts]] — regime-specific governance resolution: the governance rhythm must shift qualitatively at scale boundaries — Regime 1 favors emergence, Regime 2 demands curated MOC maintenance, Regime 3 requires automated detection with curated remediation; the governance tension resolves differently at each scale rather than having a fixed balance point
+
+Topics:
+- [[maintenance-patterns]]
+- [[design-dimensions]]

package/methodology/orphan notes are seeds not failures.md

@@ -0,0 +1,38 @@
+---
+description: Digital gardening reframes unlinked notes as work-in-progress — health checks flag connection opportunities rather than violations, enabling deferred linking
+kind: research
+topics: ["[[maintenance-patterns]]"]
+methodology: ["Digital Gardening"]
+---
+
+# orphan notes are seeds not failures
+
+Strict Zettelkasten treats orphan notes as failures. An unlinked note violates the principle that every note should connect to something, because the value comes from relationships rather than isolated content. By this logic, creating a note without immediately linking it is a workflow error.
+
+Digital gardening takes a different view. Orphans are seeds — notes that exist without connections initially, awaiting integration through later maintenance passes. The gardening metaphor reframes the lifecycle: you plant seeds knowing they won't bloom immediately. Some seeds grow into connected hubs. Others stay dormant or get pruned. The lack of immediate connections isn't failure, it's early stage. This framing depends on [[topological organization beats temporal for knowledge work]] — the garden metaphor only makes sense when knowledge lives in networks rather than timelines. In a stream-based system, orphan notes just fall behind in the timeline. In a garden-based system, they await integration into the concept network.
+
+Agent-operated knowledge systems align with the gardening view because it matches how capture actually works. During fast capture, the priority is getting the idea down before it evaporates. Stopping to find connections interrupts the capture flow. Deferred linking — connecting notes during dedicated connection-finding or backward maintenance passes — preserves capture speed while still building the graph over time. This is why [[structure without processing provides no value]] doesn't condemn orphan creation: the structure (note file) enables later processing (connection finding), and the value materializes when processing happens, not at creation time.
+
+This choice has practical consequences for agent behavior. When health check operations flag orphan notes, the flag means "opportunity for connection" not "error requiring correction." Agents should not refuse to create notes that lack immediate connections. The creation is valid; the linking is a separate operation that can happen later.
+
+Since [[dangling links reveal which notes want to exist]], orphan notes work similarly in reverse. Dangling links are future inbound connections waiting for their target. Orphan notes are future outbound connections waiting for their source. Both are intermediate states in a graph that builds itself incrementally rather than atomically.
+
+The risk of the gardening view is accumulating orphans that never get connected — notes that stay seeds forever. Because [[each new note compounds value by creating traversal paths]], an orphan is potential value locked away — it cannot participate in the compounding effect until it has edges. Since [[navigational vertigo emerges in pure association systems without local hierarchy]], orphan accumulation is precisely the symptom Matuschak identifies: notes that exist but cannot be reached through graph traversal. They're in the vault but invisible to any navigation that follows links. This is why health check operations monitor orphan density as a metric. Too many orphans signals either insufficient connection-finding passes or notes that don't actually connect to anything and should be pruned. The solution is [[continuous small-batch processing eliminates review dread]] — regular small maintenance passes prevent orphan backlog, keeping resolution ahead of creation. The gardening framing doesn't mean orphans are good, just that they're not failures by definition. Since [[PKM failure follows a predictable cycle]], Stage 6 (Orphan Accumulation) marks a late-stage failure indicator — when orphan density rises significantly, the cascade may already be well underway. The gardening view's tolerance for temporary orphans needs the constraint that orphan resolution must outpace orphan creation, or the system enters the failure sequence.
+
+If [[gardening cycle implements tend prune fertilize operations]] validates the three-operation separation, then "fertilize" becomes the explicit phase for connecting orphans. Until then, connection-finding and backward maintenance operations serve this function. Either way, the design decision stands: orphans are allowed at creation time, flagged during health checks, and resolved during connection-finding passes.
+---
+
+Relevant Notes:
+- [[topological organization beats temporal for knowledge work]] — the theoretical foundation: the garden vs stream distinction that makes the orphan-as-seed framing meaningful
+- [[dangling links reveal which notes want to exist]] — the inverse pattern: dangling links are future inbound connections, orphans are future outbound connections
+- [[gardening cycle implements tend prune fertilize operations]] — tests whether separated operations (including explicit fertilize) improve maintenance quality
+- [[throughput matters more than accumulation]] — orphan accumulation without processing is the failure, not orphan existence
+- [[PKM failure follows a predictable cycle]] — Stage 6 (Orphan Accumulation) places orphan density in the failure cascade; rising orphan count is a late-stage warning that earlier stages (Collector's Fallacy, Under-processing) may already be active
+- [[structure without processing provides no value]] — orphan creation is valid because structure enables later processing; the Lazy Cornell failure mode is not orphan creation but orphan abandonment
+- [[each new note compounds value by creating traversal paths]] — orphans cannot participate in value compounding until connected; they are locked potential
+- [[continuous small-batch processing eliminates review dread]] — the operational solution: regular small maintenance passes prevent orphan accumulation and keep resolution ahead of creation
+- [[navigational vertigo emerges in pure association systems without local hierarchy]] — orphan accumulation is the graph-level symptom of navigational vertigo: notes exist but cannot be reached through link traversal
+- [[wiki links as social contract transforms agents into stewards of incomplete references]] — adds ethical urgency to the gardening framing: orphans are seeds awaiting connection, but dangling links are promises awaiting fulfillment; the social contract reframes the orphan-vs-dangling-link symmetry by adding obligation to the dangling link side
+
+Topics:
+- [[maintenance-patterns]]