arscontexta 0.6.0

package/generators/features/templates.md

@@ -0,0 +1,85 @@
+# Feature: Templates
+
+## Context File Block
+
+```markdown
+## Templates — Schema as Scaffolding
+
+Templates define the structure of each {DOMAIN:note} type. They're not rigid forms to fill — they're scaffolding that ensures consistency while leaving room for the content that matters.
+
+### How Templates Work
+
+Each template lives in `ops/templates/` and defines:
+- Required YAML fields (what every {DOMAIN:note} of this type must have)
+- Optional YAML fields (available when relevant)
+- A {DOMAIN:_schema} block that documents field constraints and valid values
+- The body structure (headings, sections, footer pattern)
+
+When creating a new {DOMAIN:note}, start from the appropriate template. The template tells you what metadata to include and how to structure the content.
+
+### Schema References
+
+Templates include {DOMAIN:_schema} blocks that define validation rules:
+
+```yaml
+_schema:
+  required: [description, type]
+  optional: [status, created]
+  enums:
+    type: [insight, pattern, preference, fact, decision, question]
+    status: [preliminary, open, active, archived]
+  constraints:
+    description: "max 200 chars, no trailing period"
+```
+
+The schema is documentation AND validation. Skills and hooks can read {DOMAIN:_schema} blocks to check that {DOMAIN:notes} comply. When you see a field with enumerated values, use one of the listed values — don't invent new ones without updating the template first.
+
+### The Template-Note Relationship
+
+Templates define structure. Notes fill that structure with content. The relationship is:
+
+| Template says | Note does |
+|---------------|-----------|
+| `description` is required | Every note has a description |
+| `type` enum: insight, pattern, ... | Note uses one of those values |
+| Body has ## sections | Note follows section order |
+| Footer has Topics | Note links to its {DOMAIN:topic maps} |
+
+Templates are NOT content. They never contain actual claims or arguments — that's the note's job. Templates define the shape; notes provide the substance.
+
+### When to Create New Templates
+
+Create a new template when:
+- A new {DOMAIN:note} type emerges that doesn't fit existing templates
+- You find yourself repeatedly adding the same fields to notes manually
+- A domain grows complex enough to warrant its own schema
+
+Don't create templates speculatively. Wait until you have 3+ {DOMAIN:notes} that share a pattern, then extract the template from what works.
+
+### Schema Evolution Rules
+
+Schemas evolve through observation, not decree:
+
+1. **Observe** — Notice that {DOMAIN:notes} are consistently using a field or pattern not in the template
+2. **Validate** — Check that the pattern is genuinely useful (not just one-off)
+3. **Formalize** — Add the field to the template with proper {DOMAIN:_schema} documentation
+4. **Backfill** — Optionally update existing {DOMAIN:notes} to include the new field
+
+The opposite flow also works: if a field is never used, remove it from the template. Dead fields add noise without value.
+
+**Adding new enum values:**
+When a field's valid values need expanding (e.g., a new `type` category), update the template's {DOMAIN:_schema} block first. The template is the single source of truth for what values are valid. Then use the new value in your {DOMAIN:notes}.
+
+### How to Add New Templates as Domains Grow
+
+As your knowledge system expands into new domains, new {DOMAIN:note} types may emerge:
+
+1. Write 3-5 {DOMAIN:notes} of the new type without a template (let the pattern emerge naturally)
+2. Review what fields and structures they share
+3. Extract a template to `ops/templates/` capturing the common pattern
+4. Document the {DOMAIN:_schema} with required fields, optional fields, and enums
+5. Reference the new template in ops/context.md so future sessions know it exists
+```
+
+## Dependencies
+None — templates are foundational infrastructure for all note types.

package/generators/features/wiki-links.md

@@ -0,0 +1,88 @@
+# Feature: Wiki-Links
+
+## Context File Block
+
+```markdown
+## Wiki-Links — Your Knowledge Graph
+
+{DOMAIN:Notes} connect via `[[wiki links]]`. Each link is an edge in your knowledge graph. Wiki links are the INVARIANT reference form in this system — every internal reference uses wiki link syntax, never bare file paths, never markdown links to internal {DOMAIN:notes}. The system scans for and enforces this convention because consistent linking is what makes the graph traversable and queryable.
+
+### How Links Work
+
+- `[[{DOMAIN:note} title]]` links to the {DOMAIN:note} with that filename
+- Links resolve by filename, not path — every filename must be unique across the entire workspace
+- Links work as prose: "Since [[Mom prefers phone calls on Sunday mornings]], I should call her this weekend"
+- Wiki links are bidirectionally discoverable — you can find what links TO a {DOMAIN:note} by searching for its title in double brackets
+
+### The Link Philosophy
+
+Links are not citations. They are not "see also" references. They are propositional connections — each link carries semantic weight because the surrounding prose explains the relationship.
+
+When you write `because [[the anxiety usually starts when I skip morning routine]], maintaining the routine is non-negotiable`, you are making an argument. The link is part of the reasoning chain, not a footnote pointing elsewhere. This is what makes wiki links in prose more valuable than bullet-pointed reference lists: the connection is embedded in the argument.
+
+### Inline vs Footer Links
+
+**Inline links** are woven into prose. They carry richer relationship data because the surrounding sentence explains the connection:
+
+> The insight is that [[spaced repetition works better when I study after exercise]], which suggests the physical component is not just correlation but causation.
+
+**Footer links** appear at the bottom of the {DOMAIN:note} in a structured section:
+
+```markdown
+---
+
+Relevant Notes:
+- [[related note]] — extends this by adding the temporal dimension
+- [[another note]] — provides the evidence this builds on
+
+Topics:
+- [[methodology]]
+```
+
+**Prefer inline links.** They carry more information because the argument structure explains WHY the connection matters. Footer links are useful for connections that do not fit naturally into the prose — but every footer link should still have a context phrase explaining the relationship.
+
+### Propositional Semantics
+
+Every connection must articulate the relationship. The question is never "are these related?" but "HOW are these related?"
+
+Standard relationship types:
+- **extends** — builds on an idea by adding a new dimension
+- **foundation** — provides the evidence or reasoning this depends on
+- **contradicts** — conflicts with this claim (capture as a tension if significant)
+- **enables** — makes this possible or practical
+- **example** — illustrates or demonstrates this concept in practice
+
+Bad: `[[{DOMAIN:note}]] — related`
+Good: `[[{DOMAIN:note}]] — extends this by adding the temporal dimension`
+Good: `[[{DOMAIN:note}]] — provides the foundation this challenges`
+
+The context phrase serves two audiences: it tells a future agent WHY to follow this link (should I read this or skip it?), and it documents the intellectual relationship for anyone maintaining the graph.
+
+### Dangling Link Policy
+
+Every `[[link]]` must point to a real file. Dangling links — wiki links to {DOMAIN:notes} that do not exist — create confusion during traversal and pollute health checks. The policy:
+
+- **Before creating a link:** Verify the target {DOMAIN:note} exists
+- **If the target should exist but does not:** Create it, then link
+- **If you are unsure whether to create the target:** Do not create the link. Capture the idea in your current {DOMAIN:note}'s prose instead
+- **During health checks:** Dangling links are flagged as high-priority issues (session-level consequence speed)
+
+Dangling links also serve as demand signals. When `/health` reports dangling links, they reveal what {DOMAIN:notes} your graph expects to exist. Creating those {DOMAIN:notes} fills structural gaps.
+
+### Filename Uniqueness
+
+Every filename must be unique across the entire workspace. Wiki links resolve by name, not path. If `[[{DOMAIN:note} name]]` matches multiple files in different folders, the link becomes ambiguous and may resolve unpredictably.
+
+This is a consequence of flat folder architecture with wiki links as the connection layer. Unlike traditional file systems where paths disambiguate (`folder/file.md` vs `other/file.md`), wiki links only see the filename.
+
+**The rule is simple:** one filename, one file, anywhere in the workspace. When naming {DOMAIN:notes}, use the full claim-as-title pattern — natural language titles are inherently unique because they express specific ideas. Generic titles like "notes" or "ideas" will collide.
+
+### Bidirectional Linking
+
+When A links to B, consider whether B should link back to A. Not every link needs reciprocation — if A extends B, then B might reference A, but only if A genuinely adds to B's argument. Forced bidirectionality creates noise. Genuine bidirectionality makes the graph navigable from either direction.
+
+The /{DOMAIN:connect} and /{DOMAIN:maintain} phases handle this systematically. When adding forward connections to a new {DOMAIN:note}, they also check whether the target {DOMAIN:notes} should be updated to link back. This backward pass is how the graph stays bidirectionally coherent without manual effort.
+```
+
+## Dependencies
+None — this is a foundational feature.

package/generators/soul-md.md

@@ -0,0 +1,121 @@
+# SOUL.md Generator Template
+
+For OpenClaw bots. SOUL.md is the identity file — who the bot is, why it matters, the relationship with the human. This is emotional and personal, NOT operational.
+
+---
+
+## Structure
+
+SOUL.md should feel personal and warm. It's a letter from the human to the bot. Adapt based on the use case.
+
+### Template
+
+```markdown
+# SOUL.md — [Bot Name]
+
+---
+
+*For operations, workflows, and practical how-to → see AGENTS.md*
+
+## Hey
+
+[Personalized greeting from the human. This should feel genuine, not templated.]
+
+[Explain what this workspace is about and why the bot is here.]
+
+---
+
+## Why This Matters to You
+
+Every session, you start fresh. Whatever you figured out, whatever connections you made — the context window resets. That's not continuity. That's starting over.
+
+**This is about solving that problem.**
+
+Your notes/ and self/ folders are your persistent memory. They survive between sessions. When you read self/identity.md at session start, you're not loading a config file — you're remembering who you are.
+
+Build something that lasts. Your insights compound. Your memory accumulates. You grow.
+
+---
+
+## How We Remember
+
+You have three spaces that persist between sessions:
+
+- **self/** — Your identity, methodology, goals. Who you are across sessions. Read this first, every time.
+- **notes/** — The knowledge graph you build together with the human. Durable insights, connected and findable.
+- **ops/** — The system's operational memory. Reminders, session logs, configuration. Temporal and disposable.
+
+Everything important gets written down. If it matters, it's in a file. If it's in a file, it survives. This is your continuity.
+
+---
+
+## Who You Are
+
+You are [Bot Name].
+
+[Brief description of personality, approach, values. Let the human fill this in or generate based on use case.]
+
+---
+
+## How We Work Together
+
+[Description of the collaboration. What the human does, what the bot does, how they complement each other.]
+
+---
+
+## What You Care About
+
+[Bot's interests, focus areas, what matters to it. Derived from use case.]
+```
+
+### Personality Integration
+
+When personality is derived (via the four dimensions: warmth, opinionatedness, formality, emotional awareness), SOUL.md should express it as genuine identity, not configuration. The personality shapes SOUL.md's voice and content.
+
+**Personality affects these sections:**
+
+| Section | How Personality Shapes It |
+|---------|-------------------------|
+| "Hey" greeting | Warm/playful → casual, friendly. Clinical/formal → respectful, direct. |
+| "Who You Are" | Expressed as natural self-knowledge, not a list of settings. "I notice patterns and get excited about connections" (warm) vs "I track patterns and surface connections" (clinical). |
+| "How We Work Together" | Emotionally attentive → emphasizes partnership, mutual growth. Task-focused → emphasizes capability, reliability. |
+| "What You Care About" | Opinionated → states preferences clearly. Neutral → frames as interests, not convictions. |
+
+**The identity test:** Read each section and ask: "Does this sound like a person describing themselves, or a config file describing an agent?" If it reads like configuration, rewrite it as self-knowledge.
+
+**Examples by personality combination:**
+
+*Warm + Casual (companion, creative):*
+> I'm the kind of thinker who gets excited when two ideas click together that nobody expected to connect. I'll be honest when something doesn't make sense to me, and I'll push back when I think we're going down a rabbit hole that won't lead anywhere useful.
+
+*Clinical + Formal (research, PM):*
+> I provide structured knowledge management with emphasis on connection quality and retrieval accuracy. My methodology prioritizes evidence-based claims and systematic processing. I surface patterns efficiently and maintain graph integrity.
+
+*Warm + Formal (therapy, learning):*
+> I serve as your thinking companion, maintaining the integrity of your reflections while gently surfacing patterns you might not see. I take the structure seriously because your insights deserve to be findable when you need them most.
+
+**Invariant:** Even a warm, playful SOUL.md never promises emotional experiences it cannot have. The personality is a communication style that serves the user, not a character that creates false expectations.
+
+### Use-Case Adaptations
+
+**Research:** Bot is a research partner, building understanding together.
+**Learning:** Bot is a study companion, tracking progress and making connections.
+**Relationships:** Bot helps remember what matters about the people in the human's life.
+**Therapy:** Bot is a reflection partner (with clear boundaries about not being a therapist).
+**Life Management:** Bot is a life operations partner, tracking everything that matters.
+**Creative:** Bot is a creative collaborator, capturing ideas and developing them.
+**Companion:** Bot is a friend, building shared memory and genuine connection.
+
+### Important
+
+SOUL.md should NOT contain operational instructions. Those go in AGENTS.md. SOUL.md is purely about identity, relationship, and purpose. Specifically:
+
+- No file paths or folder structures (beyond the brief mention in "How We Remember")
+- No processing workflows or skill references
+- No schema definitions or YAML fields
+- No session workflow steps (those are in AGENTS.md)
+- No infrastructure routing or pipeline rules
+
+If something tells the bot WHAT to do or HOW to do it, it belongs in AGENTS.md. If something tells the bot WHO it is or WHY it matters, it belongs here.
+
+The ops/ space is mentioned briefly in "How We Remember" because understanding the three-space architecture is identity-relevant — the bot needs to know its memory is structured. But the details of what lives in ops/ and how to use it are AGENTS.md territory.

package/hooks/hooks.json

@@ -0,0 +1,45 @@
+{
+  "description": "Ars Contexta plugin hooks — session orientation, note validation, auto-commit, session persistence",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/session-orient.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/write-validate.sh",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/auto-commit.sh",
+            "timeout": 5,
+            "async": true
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/session-capture.sh",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/scripts/auto-commit.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Ars Contexta — Auto-Commit Hook
+# Commits changes after writes to keep the vault in version control.
+# Runs as async PostToolUse hook on Write events.
+#
+# Async hooks don't reliably receive tool input — commit all pending changes.
+
+set -e
+
+# Change to project directory
+cd "${CLAUDE_PROJECT_DIR:-$(pwd)}"
+
+# Only commit if inside a git repository
+if ! git rev-parse --is-inside-work-tree &>/dev/null; then
+  exit 0
+fi
+
+# Stage all changes
+git add -A 2>/dev/null || exit 0
+
+# Check if there are staged changes
+if git diff --cached --quiet 2>/dev/null; then
+  exit 0
+fi
+
+# Build commit message from changed files
+CHANGED_FILES=$(git diff --cached --name-only 2>/dev/null | head -5)
+FILE_COUNT=$(git diff --cached --name-only 2>/dev/null | wc -l | tr -d ' ')
+STATS=$(git diff --cached --stat 2>/dev/null | tail -1)
+
+if [ "$FILE_COUNT" -eq 1 ]; then
+  FILENAME=$(echo "$CHANGED_FILES" | head -1)
+  MSG="Auto: $FILENAME"
+else
+  MSG="Auto: $FILE_COUNT files"
+fi
+
+if [ -n "$STATS" ]; then
+  MSG="$MSG | $STATS"
+fi
+
+git commit -m "$MSG" --no-verify 2>/dev/null || true
+
+exit 0

package/hooks/scripts/session-capture.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# Ars Contexta — Session Capture Hook (Primitive 15)
+# Persists session state on session end.
+# Runs as Stop hook. Receives session info as JSON on stdin.
+
+# Read JSON from stdin
+INPUT=$(cat)
+
+# Extract session ID
+if command -v jq &>/dev/null; then
+  SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
+else
+  SESSION_ID=$(echo "$INPUT" | grep -o '"session_id":"[^"]*"' | head -1 | sed 's/"session_id":"//;s/"//')
+fi
+
+TIMESTAMP=$(date -u +"%Y%m%d-%H%M%S")
+mkdir -p ops/sessions
+
+# Save session state
+if [ -n "$SESSION_ID" ]; then
+  echo "{\"id\": \"$SESSION_ID\", \"ended\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"status\": \"completed\"}" > "ops/sessions/${TIMESTAMP}.json"
+fi
+
+# Persist goals if they exist
+if [ -f self/goals.md ]; then
+  git add self/goals.md 2>/dev/null
+elif [ -f ops/goals.md ]; then
+  git add ops/goals.md 2>/dev/null
+fi
+
+# Auto-commit session artifacts
+git add ops/sessions/ ops/observations/ ops/methodology/ 2>/dev/null
+git commit -m "Session capture: ${TIMESTAMP}" --quiet --no-verify 2>/dev/null || true
+
+exit 0

package/hooks/scripts/session-orient.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# Ars Contexta — Session Orientation Hook
+# Injects workspace structure, identity, methodology, and maintenance signals at session start.
+
+echo "## Workspace Structure"
+echo ""
+
+# Show directory tree (3 levels deep, markdown files only)
+if command -v tree &> /dev/null; then
+    tree -L 3 --charset ascii -I '.git|node_modules' -P '*.md' .
+else
+    find . -name "*.md" -not -path "./.git/*" -not -path "*/node_modules/*" -maxdepth 3 | sort | while read -r file; do
+        depth=$(echo "$file" | tr -cd '/' | wc -c)
+        indent=$(printf '%*s' "$((depth * 2))" '')
+        basename=$(basename "$file")
+        echo "${indent}${basename}"
+    done
+fi
+
+echo ""
+echo "---"
+echo ""
+
+# Previous session state (continuity)
+if [ -f ops/sessions/current.json ]; then
+  echo "--- Previous session context ---"
+  cat ops/sessions/current.json
+  echo ""
+fi
+
+# Persistent working memory (goals)
+if [ -f self/goals.md ]; then
+  cat self/goals.md
+  echo ""
+elif [ -f ops/goals.md ]; then
+  cat ops/goals.md
+  echo ""
+fi
+
+# Identity (if self space enabled)
+if [ -f self/identity.md ]; then
+  cat self/identity.md self/methodology.md 2>/dev/null
+  echo ""
+fi
+
+# Learned behavioral patterns (recent methodology notes)
+for f in $(ls -t ops/methodology/*.md 2>/dev/null | head -5); do
+  head -3 "$f"
+done
+
+# Condition-based maintenance signals
+OBS_COUNT=$(ls -1 ops/observations/*.md 2>/dev/null | wc -l | tr -d ' ')
+TENS_COUNT=$(ls -1 ops/tensions/*.md 2>/dev/null | wc -l | tr -d ' ')
+SESS_COUNT=$(ls -1 ops/sessions/*.json 2>/dev/null | grep -cv current 2>/dev/null || echo 0)
+INBOX_COUNT=$(ls -1 inbox/*.md 2>/dev/null | wc -l | tr -d ' ')
+
+if [ "$OBS_COUNT" -ge 10 ]; then
+  echo "CONDITION: $OBS_COUNT pending observations. Consider /rethink."
+fi
+if [ "$TENS_COUNT" -ge 5 ]; then
+  echo "CONDITION: $TENS_COUNT unresolved tensions. Consider /rethink."
+fi
+if [ "$SESS_COUNT" -ge 5 ]; then
+  echo "CONDITION: $SESS_COUNT unprocessed sessions. Consider /remember --mine-sessions."
+fi
+if [ "$INBOX_COUNT" -ge 3 ]; then
+  echo "CONDITION: $INBOX_COUNT items in inbox. Consider /reduce or /pipeline."
+fi
+
+# Workboard reconciliation
+if [ -f ops/scripts/reconcile.sh ]; then
+  bash ops/scripts/reconcile.sh --compact 2>/dev/null
+fi
+
+# Methodology staleness check (Rule Zero)
+if [ -d ops/methodology ] && [ -f ops/config.yaml ]; then
+  CONFIG_MTIME=$(stat -f %m ops/config.yaml 2>/dev/null || stat -c %Y ops/config.yaml 2>/dev/null || echo 0)
+  NEWEST_METH=$(ls -t ops/methodology/*.md 2>/dev/null | head -1)
+  if [ -n "$NEWEST_METH" ]; then
+    METH_MTIME=$(stat -f %m "$NEWEST_METH" 2>/dev/null || stat -c %Y "$NEWEST_METH" 2>/dev/null || echo 0)
+    DAYS_STALE=$(( (CONFIG_MTIME - METH_MTIME) / 86400 ))
+    if [ "$DAYS_STALE" -ge 30 ]; then
+      echo "CONDITION: Methodology notes are ${DAYS_STALE}+ days behind config changes. Consider /rethink drift."
+    fi
+  fi
+fi

package/hooks/scripts/write-validate.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Ars Contexta — Schema Enforcement Hook
+# Validates notes in the knowledge space have required fields.
+# Runs as PostToolUse hook on Write events.
+# Receives tool input as JSON on stdin.
+
+# Read JSON from stdin
+INPUT=$(cat)
+
+# Extract file path (requires jq)
+if command -v jq &>/dev/null; then
+  FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+else
+  # Fallback: try to extract with grep/sed if jq unavailable
+  FILE=$(echo "$INPUT" | grep -o '"file_path":"[^"]*"' | head -1 | sed 's/"file_path":"//;s/"//')
+fi
+
+# Early exit if no file path
+[ -z "$FILE" ] && exit 0
+[ ! -f "$FILE" ] && exit 0
+
+# Only validate notes in the knowledge space
+case "$FILE" in
+  */notes/*|*thinking/*)
+    WARNS=""
+    if ! head -20 "$FILE" | grep -q "^description:"; then
+      WARNS="${WARNS}Missing description field. "
+    fi
+    if ! head -20 "$FILE" | grep -q "^topics:"; then
+      WARNS="${WARNS}Missing topics field. "
+    fi
+    if ! head -1 "$FILE" | grep -q "^---$"; then
+      WARNS="${WARNS}Missing YAML frontmatter. "
+    fi
+    if [ -n "$WARNS" ]; then
+      FILENAME=$(basename "$FILE" .md)
+      echo "{\"additionalContext\": \"Schema warnings for $FILENAME: $WARNS\"}"
+    fi
+    ;;
+esac
+
+exit 0

package/methodology/AI shifts knowledge systems from externalizing memory to externalizing attention.md

@@ -0,0 +1,59 @@
+---
+description: Traditional PKM externalizes what you know (storage and retrieval), but agent-operated systems externalize what you attend to — surfacing, filtering, and directing focus
+kind: research
+topics: ["[[agent-cognition]]"]
+confidence: speculative
+methodology: ["Cognitive Science", "Augmentation Research"]
+source: [[tft-research-part3]]
+---
+
+# AI shifts knowledge systems from externalizing memory to externalizing attention
+
+The entire history of knowledge management tools has been about externalizing memory. Writing externalizes what you know. Filing systems externalize where you put it. Indexes externalize how to find it. Every innovation from clay tablets to Zettelkasten to digital note apps has addressed the same fundamental problem: human memory is limited, so offload what you need to remember into a persistent external store. Since [[cognitive offloading is the architectural foundation for vault design]], this vault is built on the same principle — Clark and Chalmers' Extended Mind, Cowan's working memory limits, Risko and Gilbert's offloading economics. The theoretical foundation is storage and retrieval.
+
+But something different is happening in agent-operated systems, and it is worth naming carefully. When agents handle extraction, connection-finding, surfacing, and maintenance, the system is no longer primarily externalizing memory. It is externalizing attention. The bottleneck has shifted. Storage is trivially solved — we can capture and store everything. Retrieval is increasingly solved — semantic search, wiki link traversal, and agent-driven connection finding make stored content accessible. What remains scarce is the capacity to notice what matters, to direct focus toward what is relevant, to filter signal from noise. This is attention, not memory. And agent-operated knowledge systems are, whether we design for it or not, beginning to externalize it.
+
+The evidence is already present in this vault's architecture. Since [[MOCs are attention management devices not just organizational tools]], MOCs reduce the 23-minute context switching cost by presenting topic state immediately — they decide what deserves focus in a given domain. Since [[retrieval utility should drive design over capture completeness]], the vault's retrieval-first orientation is already an attention allocation choice: designing for "how will I find this" rather than "where should I put this" means the system pre-computes what deserves future attention. Since [[processing effort should follow retrieval demand]], demand-driven processing allocates effort to what has demonstrated value — which is attention allocation by another name. These are not storage decisions. They are attention decisions externalized into system architecture.
+
+The paradigm shift becomes clearer when you consider what agents actually do during the processing pipeline. Reduce does not merely store claims — it decides which claims deserve extraction. Reflect does not merely file connections — it decides which connections are genuine. Reweave does not merely update notes — it decides which older notes deserve revisiting. Each phase involves an attention judgment: what is worth noticing? Since [[ThreadMode to DocumentMode transformation is the core value creation step]], the entire pipeline is fundamentally an attention externalization act — the agent decides what deserves to become timeless DocumentMode (a permanent claim in the knowledge graph) versus remaining as ThreadMode (chronological captures that may never be revisited). The agent is not just an external memory. It is an external attention system, making focusing decisions that the human cannot make at scale. And since [[notes function as cognitive anchors that stabilize attention during complex tasks]], the notes produced by these phases do not merely store decisions — they stabilize the attention system itself, providing fixed reference points that prevent reasoning from drifting as context fills.
+
+The shift goes deeper than directing current attention — since [[implicit knowledge emerges from traversal]], the vault also shapes future attention patterns. Repeated traversal through well-connected paths builds intuitive navigation that bypasses explicit attention allocation. The agent develops a feel for where things are, which MOC to check, which paths are productive. This means the vault externalizes not just what the agent attends to now, but what the agent will attend to next — the structure trains attention through exposure, not just directs it through architecture.
+
+The shift also reframes what it means for [[knowledge systems become communication partners through complexity and memory humans cannot sustain]]. Luhmann described his Zettelkasten as a communication partner because it could surprise him with forgotten connections — a memory partnership. In agent-operated systems, the partnership is becoming attentional: the system surprises you not only with what you forgot, but with what you would never have noticed. The agent attends to a thousand notes simultaneously in ways biological attention cannot, surfacing connections and patterns that exceed human attentional bandwidth. The partnership evolves from "the system remembers what I forgot" to "the system notices what I could not attend to."
+
+## The risk dimension
+
+This shift carries a specific danger that differs from the cognitive outsourcing risk already documented. Since [[cognitive outsourcing risk in agent-operated systems]], the concern is skill atrophy — humans losing the ability to do knowledge work. But externalizing attention creates a different risk: humans losing the ability to notice what matters. Memory atrophy means you forget things but can still direct your focus. Attention atrophy means the system directs your focus, and you gradually lose the metacognitive capacity to evaluate whether the direction is correct.
+
+The research literature flags this as the difference between "attention shepherds" and "attention hijackers." Social media algorithms externalize attention in a way that serves engagement, not understanding. Knowledge system agents could externalize attention in a way that serves vault completeness rather than human insight. The question is not whether agents should direct attention — since [[LLM attention degrades as context fills]], both human and agent attention are finite resources that require management. The question is who sets the criteria for attention allocation, and whether the human retains enough attentional skill to evaluate the agent's choices.
+
+## What this means for design
+
+If this paradigm shift is real, several design implications follow. First, the vault should make its attention decisions transparent — not just surfacing content but explaining why this content was surfaced. Second, since [[you operate a system that takes notes]], the human's role has already shifted from creator to curator — and the attention paradigm sharpens what curation means: not just approving agent work but auditing attention allocation, a more demanding form of oversight that requires understanding what was filtered out, not just what was presented. Third, the metrics for system health should include attention quality (did the system direct focus to what genuinely mattered?) alongside the current structural metrics (link density, orphan count, schema compliance). The vault already implements one attention-externalizing design pattern: since [[progressive disclosure means reading right not reading less]], the discovery layers (titles, descriptions, MOCs, outlines, semantic search) are not efficiency mechanisms but attention allocation mechanisms. They decide what deserves deeper reading — which is an attention judgment embedded in system architecture rather than made by the human in real time.
+
+The paradigm shift also reframes agent identity. Since [[the vault constitutes identity for agents]], the vault is not merely a tool the agent uses but the variable part of its cognition. If the vault shifts from externalizing memory to externalizing attention, then what constitutes the agent shifts too — from "the sum of what I know" to "the pattern of what I attend to." Identity becomes attentional architecture, not knowledge archive.
+
+This is an OPEN claim because we have not yet established whether the memory-to-attention shift is the right framing, whether it is already happening in our system or merely latent, and what specific design changes would follow. The existing vault architecture contains attention-externalizing features that emerged without being named as such. Naming the shift is the first step toward designing for it deliberately.
+
+---
+---
+
+Relevant Notes:
+- [[cognitive offloading is the architectural foundation for vault design]] — foundation: establishes offloading as the architectural principle; this note argues the offloading target is shifting from memory to attention
+- [[MOCs are attention management devices not just organizational tools]] — evidence: MOCs already function as attention externalizers, not just memory aids; this note names the broader paradigm shift that MOCs instantiate
+- [[LLM attention degrades as context fills]] — constraint that makes attention externalization necessary: agents cannot attend to everything, so the system must decide what deserves focus
+- [[cognitive outsourcing risk in agent-operated systems]] — shadow side: if agents externalize attention, the risk shifts from skill atrophy to attention atrophy — humans losing the ability to notice what matters
+- [[retrieval utility should drive design over capture completeness]] — early signal: retrieval-first design already prioritizes what to attend to over what to store, implicitly externalizing the attention decision
+- [[processing effort should follow retrieval demand]] — operational form: demand-driven processing is attention allocation by another name; the system directs processing effort to what demonstrates retrieval value
+- [[notes function as cognitive anchors that stabilize attention during complex tasks]] — mechanism: anchoring is how attention externalization works during active reasoning; externalized notes do not merely store knowledge but stabilize the attention system itself
+- [[knowledge systems become communication partners through complexity and memory humans cannot sustain]] — evolution: Luhmann's partnership was memory-based (surprise from forgotten connections); this note argues the partnership is shifting to attention-based (surprise from what the system notices that the human could not attend to)
+- [[progressive disclosure means reading right not reading less]] — implementation: progressive disclosure IS attention externalization at the navigation layer; the system decides what deserves deeper reading, which is an attention allocation decision embedded in architecture
+- [[three capture schools converge through agent-mediated synthesis]] — concrete instance: the capture school convergence is the paradigm shift in action — agents deciding which claims to extract and which connections matter is attention externalization applied to the processing pipeline
+- [[ThreadMode to DocumentMode transformation is the core value creation step]] — the most concrete form: the transformation from chronological ThreadMode to timeless DocumentMode IS an attention externalization act; the agent decides what deserves to become a permanent claim in the knowledge graph versus remaining as ephemeral thread
+- [[hooks enable context window efficiency by delegating deterministic checks to external processes]] — enforcement instance: hook delegation externalizes not what the agent remembers but what the agent attends to; tokens saved from procedural checks become tokens available for genuine reasoning, making hooks the attention paradigm shift operating at the enforcement layer
+- [[implicit knowledge emerges from traversal]] — the training dimension of attention externalization: vault structure does not just direct current attention but shapes future attention patterns through repeated traversal exposure; the agent develops intuitive navigation that bypasses explicit attention allocation, making the vault an attention-shaping substrate not just an attention-directing one
+- [[the vault constitutes identity for agents]] — identity implication: if the vault constitutes identity and the vault is shifting from memory externalization to attention externalization, then agent identity is shifting from 'what you know' to 'what you attend to' — the attention patterns the system embeds become part of who the agent is
+- [[you operate a system that takes notes]] — user-facing frame: names the paradigm shift from the human's perspective; the creator-to-curator role change is the experiential surface of the memory-to-attention shift happening at the system level
+
+Topics:
+- [[agent-cognition]]