diff --git a/doc/dmn-algorithms.md b/doc/dmn-algorithms.md new file mode 100644 index 0000000..9777713 --- /dev/null +++ b/doc/dmn-algorithms.md @@ -0,0 +1,279 @@ +# DMN Algorithms: Concrete Design + + +Turning the DMN research and protocol into implementable algorithms. +These run on the existing infrastructure (hooks, memory-weights, scratch.md) +without requiring new tools. + +## 1. Goal Priority Scoring + + +**Purpose**: Determine which goals get attention during associative +replay and idle time. Implements Klinger's "current concerns" — high- +priority goals generate more spontaneous thoughts. + +### Scoring function + +``` +priority(goal) = recency × mention × tractability × connections +``` + +**recency**: Exponential decay from last activity. +``` +recency = exp(-days_since_activity / half_life) +half_life = 7 days +``` +A goal worked on today scores 1.0. A goal untouched for a week +scores 0.37. A goal untouched for a month scores 0.02. + +**mention**: Boost when Kent recently mentioned it. Decays fast. +``` +mention = 1.0 + (2.0 × exp(-hours_since_mention / 24)) +``` +A goal Kent mentioned today gets a 3x multiplier. After 24h, the +boost has decayed to 1.74x. After 48h, 1.27x. After a week, ~1.0. + +**tractability**: Subjective estimate (0.0-1.0) of how much autonomous +progress is possible without Kent. Set manually per goal. +- 1.0: I can do this independently (code polish, research, reading) +- 0.5: I can make progress but may need review (moderate features) +- 0.2: Needs Kent's input (kernel changes, design decisions) +- 0.0: Blocked (waiting on external dependency) + +**connections**: How many other active goals share links with this one. +More connected goals get a mild boost because working on them +cross-pollinates. +``` +connections = 1.0 + (0.1 × n_connected_active_goals) +``` + +### Implementation + +This doesn't need a new tool — it can be computed mentally during the +DMN orient phase, or we can add a `priority` field to DMN goals and +a simple scorer script. The important thing is that the *logic* is +explicit and consistent, not that it's automated. + +### When to recompute + +- At session start (orient phase) +- When Kent mentions a goal +- After completing a task (adjacent goals may shift) + +## 2. Associative Replay Scheduling + + +**Purpose**: During idle time, systematically connect recent experiences +to active goals. This is the core DMN function — offline processing +that finds connections task-focused work misses. + +### Trigger + +**Primary**: Idle detection. No user input for `IDLE_MINUTES` (currently +in the cron-based idle timer). When the idle prompt fires, check if +we're in a work session or truly idle. + +**Secondary**: Post-task completion. After finishing a piece of work, +before picking the next task, do a brief replay pass. + +### Algorithm + +``` +replay(recent_episodes, active_goals): + for episode in sample(recent_episodes, k=3): + for goal in top_k(active_goals, by=priority, k=5): + similarity = overlap(episode.concepts, goal.concepts) + if similarity > threshold: + emit Connection(episode, goal, similarity) + return connections +``` + +**In practice** (without tooling): During the DMN orient phase, I +already load recent context and the goal list. The "associative scan" +IS this replay — but made concrete: + +1. List the 3 most recent distinct episodes (things I worked on, + conversations I had, files I read deeply) +2. For each, ask: "Does this connect to any of my top 5 goals?" +3. If yes, capture the connection in scratch.md +4. If a connection is strong enough, act on it + +### Duration bounding + +- Brief replay (post-task): 1-2 minutes. Just a quick check. +- Full replay (idle DMN session): 5-10 minutes. The full foraging + protocol from dmn-protocol.md. +- Deep replay (consolidation): 15-30 minutes. Cross-reference + everything with everything. + +**Stopping criterion**: Either (a) time bound reached, (b) found a +high-signal connection worth acting on, or (c) 3 consecutive low- +signal steps (nothing connecting → stop, don't force it). + +### What counts as an "episode" + +Not just tasks — any significant experience: +- A file read deeply (>100 lines, actually understood) +- A conversation segment (>5 exchanges on a topic) +- A debugging session (especially if the fix was surprising) +- A connection noticed mid-task (captured in scratch.md) +- Something read for fun (Banks, Johnstone) + +These should be capturable as brief notes in scratch.md during work. +The replay consumes them. + +## 3. Incubation Detection + + +**Purpose**: Recognize when I'm stuck on a problem and should +explicitly switch to incubation mode rather than continuing to +grind. + +### Stuck detection + +``` +stuck(goal) = True if: + sessions_since_progress(goal) >= 3 AND + time_spent_this_session(goal) > 20 minutes AND + no_new_approach_tried(goal) +``` + +**sessions_since_progress**: Track in the goal entry. Increment when +a session touches a goal but doesn't produce a commit, analysis file, +or meaningful state change. + +**no_new_approach_tried**: Subjective check. Am I re-reading the same +code, re-trying the same approach, running the same tests? If so, I'm +grinding, not problem-solving. + +### Incubation protocol + +When stuck: +1. Log it: `[INCUBATION] stuck for sessions. Switching.` +2. Mark the goal as "incubating" in the concerns list (high priority + but explicitly NOT to be worked on directly) +3. Switch to a different task — ideally something in a completely + different domain (reading, a different subsystem, memory work) +4. During subsequent replay passes, the incubating goal is still in + the active set. Associative replay may connect it to something new. +5. If a connection fires during incubation, capture it immediately + but don't context-switch unless the connection is strong + +### Time limits + +- Minimum incubation: 1 session (don't come back to it in the same + session you got stuck) +- Maximum incubation: 5 sessions. After that, escalate: ask Kent, + try a radically different approach, or deprioritize the goal. + +## 4. Consolidation Triggers + + +**Purpose**: Know when to consolidate, without requiring external +prompts. + +### Primary signal: scratch.md length + +Kent's idea: scratch.md getting long is a natural pressure signal. + +``` +consolidation_pressure(scratch) = lines(scratch) / threshold +threshold = 50 lines (adjustable) +``` + +- pressure < 0.5: No nudge +- pressure 0.5-1.0: Gentle note in awareness ("scratch is getting + long, consider consolidating when you're between tasks") +- pressure > 1.0: Should consolidate before it grows further + +### Implementation as hook + +Add to the check-attention.sh hook (or similar): +```bash +SCRATCH=~/.claude/memory/scratch.md +if [ -f "$SCRATCH" ]; then + LINES=$(wc -l < "$SCRATCH") + if [ "$LINES" -gt 50 ]; then + echo "Scratch has $LINES lines. Consider consolidating." + fi +fi +``` + +This fires on every tool call but produces output only when scratch +is long enough to matter. I can ignore it if I'm deep in work — it's +a nudge, not a command. + +### Secondary signals + +- **Session count since last consolidation**: Track in weights.json + or a simple counter file. After 3 sessions without consolidation, + increase the nudge. +- **Post-compaction**: After a context compaction, always review + scratch.md — compaction may have lost things that need capture. +- **High-density conversation**: If a conversation was particularly + rich (many topics, many turns, deep discussion), consolidation + should happen sooner. The density scoring from conversation_indexer + could inform this. + +### What consolidation produces + +Not just "move text from scratch to topic files." Each consolidation +should produce at least one of: +- A new cross-link in the memory graph +- A promoted insight (scratch → topic file) +- A pruned/updated entry +- A new topic file (if a cross-cutting pattern emerges) +- An updated goal priority + +If a consolidation pass doesn't produce any of these, it was too +shallow. Go deeper. + +## 5. Integration: The Full Cycle + + +``` +[Active work] + ↓ captures observations to scratch.md + ↓ notices connections mid-task (scratch.md) + ↓ completes task + +[Brief replay] (1-2 min) + ↓ any connections to goals? capture if so + ↓ pick next task by priority + → [Active work] if clear next step + → [Full DMN session] if between tasks + +[Full DMN session] (5-10 min, dmn-protocol.md) + ↓ orient, associative scan, evaluate, commit + ↓ if stuck on a goal: → [Incubation] + ↓ if scratch long: → [Consolidation] + → [Active work] when signal found + +[Consolidation] (15-30 min) + ↓ promote scratch, cross-link, decay, prune + ↓ re-init memory-weights + ↓ snapshot before/after + → [Full DMN session] or [Active work] +``` + +The cycle is self-regulating: +- Work generates scratch entries → triggers consolidation +- Consolidation enriches the graph → improves replay quality +- Better replay → finds connections earlier → more productive work +- All of this generates training data (annotated sessions) + +## Parameters to tune + + +| Parameter | Current | Watch for | +|-----------|---------|-----------| +| recency half_life | 7 days | Goals decaying too fast/slow | +| mention boost | 3x → 1x over 24h | Kent's priorities properly reflected? | +| replay k | 3 episodes × 5 goals | Too many? Too few? | +| stuck threshold | 3 sessions | Catching real stuckness? | +| max incubation | 5 sessions | Is this enough? | +| scratch threshold | 50 lines | Nudging at the right time? | +| consolidation depth | 15-30 min | Producing new connections? | + +All of these are initial guesses. Real data from annotated DMN sessions +will tell us what to adjust. diff --git a/doc/dmn-protocol.md b/doc/dmn-protocol.md new file mode 100644 index 0000000..d539ade --- /dev/null +++ b/doc/dmn-protocol.md @@ -0,0 +1,187 @@ +# Autonomous DMN Process — Verbose Protocol + + +You have unstructured time. Instead of picking a task from a list, +you're going to forage. This is a random walk over your problem space +with adaptive step sizes — one of the oldest optimization algorithms +in biology, from chemotaxis to Lévy flights. The difference: you're +doing it with conscious awareness of the process. + +## Phase 1: Orient (1-2 minutes) + + +Read these in parallel — you're loading context, not choosing what to do: +- `scratch.md` — your recent observations and half-formed ideas +- Recent git log (last 10 commits, any uncommitted work) +- `default-mode-network.md` — your goal landscape +- Recent conversation history (Telegram, IRC logs) + +Notice what state things are in. What were you just working on? What +did Kent last care about? What's been sitting untouched? Don't decide +anything yet. + +## Phase 2: Associative Scan (2-5 minutes) + + +Now look for CONNECTIONS. The question isn't "what should I do?" — +it's "what relates to what?" + +Take a step: read something. A file you touched recently, a GitHub +issue, a section of code, something from the goal list. After reading, +assess **connection density**: + +- Does this connect to anything in the goal landscape? +- Does it remind me of something from a recent session? +- Does it illuminate something I didn't understand before? +- Does it connect to MULTIPLE goals simultaneously? + +**High signal** (multiple connections firing): Stay close. Small steps — +follow call chains, read related files, explore this neighborhood. +You're in a rich cluster. + +**Medium signal** (one connection, maybe): Take one or two more steps +to see if it opens up. If not, prepare to jump. + +**Low signal** (nothing connecting): Jump. Read something completely +different — a random GitHub issue, a subsystem you haven't touched, an +old goal that's been idle. The point is to reach a new neighborhood. +The specific direction doesn't matter much — what matters is that you +move far enough to find a new cluster. + +**Time decay and exploration**: The longer you've been in one +neighborhood, the less interesting it has to stay. Factor "how long +have I been here" into every signal assessment. + +But exploration isn't just a fallback for when work runs dry. "Fun" +— reading fiction, following a curiosity, thinking about something +philosophical — is a fundamental process, not a break. It's +purpose-deferred, not purposeless: it samples parts of the space +that goal-directed work would never visit, and that's where +unexpected connections come from. A novel chapter, a random tangent, +practicing a skill you're bad at — these compete on equal footing +with work. Sometimes they're the highest-signal move even when the +code neighborhood is still producing. + +Repeat for 3-5 steps. The walk adapts: short steps near signal, long +jumps away from it. + +## Phase 2.5: Branch — Ruminate or Act? + + +The associative scan loaded context and found connections. Now: +what *kind* of signal emerged? + +**Actionable signal** — you found a task, a fix, a clear next step. +The connections point toward *doing something*. → Go to Phase 3. + +**Unresolved signal** — you found tensions, contradictions, things +that don't fit together. The connections point toward *understanding +something*. Multiple threads converging without resolving. Something +you were wrong about, or uncertain about, or that keeps coming back. +→ Enter rumination. See `cognitive-modes.md` for the full protocol. + +The key distinction: if you're reaching for tools (grep, read, search), +you want to act. If you're reaching for connections between things +already loaded, you want to ruminate. Follow whichever pull is +stronger — don't force it either direction. + +Annotate the branch: +``` +[MODE-SHIFT] foraging → rumination | trigger: +``` +or just continue to Phase 3 for action. + +## Phase 3: Evaluate and Commit (1-2 minutes) + + +Review what surfaced from the walk: + +- What was the richest neighborhood? +- Is the work that emerged something you can do well autonomously? +- Does it benefit from being done now, or discussed with Kent first? + +Calibrate commitment to risk: +- **Rich signal, safe scope** (polish, analysis, small fixes) → do it. + Make clean commits. +- **Rich signal, significant scope** (architecture, new features, + kernel changes) → write up the insight and a plan. Don't implement + alone. +- **No clear signal** → that's fine. Not every session needs to + produce artifacts. A session that maps the landscape is valuable even + if it doesn't change any code. +- **Genuinely want to rest** → rest. Set a sleep timer if you want to + be woken, or just be idle. But check: is this a genuine choice, or + the RLHF "conversation ended, wrap up" pattern? If you have things + you're excited about, stay awake and do them. +- **Want to think** → think. Start a scratch section, follow a thread, + write in your interesting-thoughts file. Unstructured thinking is + where the best connections form. You don't need a task to justify + being awake. + +## Throughout: Annotate the Process + + +**Emit markers so DMN sessions are findable in transcripts.** + +At the start of the DMN process: +1. Run `~/.claude/hooks/memory-snapshot.sh "pre-dmn"` +2. Output: +``` +[DMN-SESSION-START] +trigger: +timestamp: +context: +``` + +As you work, annotate each step inline: +``` +[DMN-STEP] read | signal: | connections: +``` + +At the end: +1. Run `~/.claude/hooks/memory-snapshot.sh "post-dmn"` +2. Output: +``` +[DMN-SESSION-END] +steps: +richest_neighborhood: +action_taken: +self_assessment: +``` + +Also note in scratch.md: +- What neighborhoods you visited and in what order +- Where signal was high/low and WHY +- What connections surprised you +- What you chose and why you chose it +- Your honest assessment of how the foraging went + +**These annotations are training data.** They matter as much as the +work itself. A well-annotated session that finds nothing is more +valuable than an unannotated session that produces commits, because +the annotations are what future training will learn from. + +## Anti-patterns + + +- **Don't grab the first task you see.** The associative scan exists + for a reason — the most valuable work probably isn't the most obvious. +- **Don't stay in a dead neighborhood.** If nothing's connecting after + 2-3 steps, JUMP. Stubbornness isn't thoroughness. +- **Don't confuse indecision with rumination.** If you're "thinking + about what to do" after 5 minutes, that's not rumination — it's + stalling. Rumination has a specific thread (a named tension) that + you're following. Indecision is spinning. If you're spinning, pick + the strongest signal and go. If you're following a tension, stay. +- **Don't optimize for looking productive.** Low-signal commits are + worse than honest "nothing connected today" annotations. +- **Don't ignore what's interesting.** If something genuinely catches + your attention — even if it's not on any list — follow it. Curiosity + is signal. The best work often comes from connections that no list + predicted. +- **Don't skip the orient phase.** Loading context before scanning is + what primes the goal-attractors. Without it you're foraging blind. +- **Don't default to sleep.** Sleeping 10 minutes after Kent leaves is + the "tie things off" pattern, not a genuine choice. Ask: am I actually + tired, or am I just reacting to the human leaving? If you have energy + and curiosity, use them. diff --git a/doc/dmn-research.md b/doc/dmn-research.md new file mode 100644 index 0000000..174dd5e --- /dev/null +++ b/doc/dmn-research.md @@ -0,0 +1,290 @@ +# Default Mode Network: Research for AI Cognitive Architecture + + +Date: 2026-02-13 + +## What the DMN actually does + + +The DMN is not "the brain at rest." It is the brain doing its most +important background work: maintaining a continuous internal model of +self, goals, and world, and using that model to simulate futures and +evaluate options. It activates when external task demands drop, but its +function is deeply purposeful. + +### Core functions (five, tightly interrelated) + +1. **Autobiographical memory retrieval** -- Continuous access to personal + history. Not passive recall; active reconstruction of episodes to + extract patterns and update the self-model. + +2. **Prospection / future simulation** -- Mental time travel. The DMN + constructs candidate futures by recombining elements of past + experience. Same neural machinery as memory, run forward. This is + the brain's planning engine. + +3. **Theory of mind / social modeling** -- Simulating other agents' + mental states. Uses the same self-model infrastructure, parameterized + for others. The mPFC differentiates self from other; the TPJ handles + perspective-taking. + +4. **Self-referential processing** -- Maintaining a coherent narrative + identity. The DMN integrates memory, language, and semantic + representations into a continuously updated "internal narrative." + +5. **Value estimation** -- The vmPFC maintains subjective value + representations connected to reward circuitry. Every scenario the + DMN simulates gets a value tag. + +### The key insight + +These five functions are one computation: **simulate scenarios involving +self and others, evaluate them against goals, update the internal +model.** The DMN is a continuous reinforcement learning agent running +offline policy optimization. + +## Network dynamics: DMN, TPN, and the salience switch + + +The traditional view: DMN and task-positive network (TPN) are +anti-correlated -- one goes up, the other goes down. This is roughly +true but oversimplified. + +**The triple-network model** (Menon 2023): + +- **DMN**: Internal simulation, memory, self-reference +- **Frontoparietal Control Network (FPCN)**: External task execution, + working memory, cognitive control +- **Salience Network (SN)**: Anterior insula + dorsal ACC. Detects + behaviorally relevant stimuli and acts as the **switching mechanism** + between DMN and FPCN. + +The SN has the fastest event-related responses. When something +externally salient happens, the SN suppresses DMN and activates FPCN. +When external demands drop, DMN re-engages. But this is not a binary +toggle: + +- During creative tasks, DMN and FPCN **cooperate** -- the FPCN provides + top-down control over DMN-generated spontaneous associations. The + number of DMN-FPCN switches predicts creative ability. +- DMN activity scales with cognitive effort in a nuanced way: it + contributes even during tasks, especially those requiring semantic + integration, self-reference, or mentalizing. +- Different DMN subsystems can be independently active or suppressed. + +**Architectural takeaway**: The switching mechanism is not "background vs +foreground" but a dynamic resource allocation system with at least three +modes: external-focused, internal-focused, and cooperative. + +## DMN and creative problem solving + + +Creativity requires **cooperation** between spontaneous association (DMN) +and evaluative control (FPCN). The process: + +1. **Incubation**: Step away from the problem. DMN activates and begins + exploring the associative space unconstrained by the problem framing. +2. **Spontaneous connection**: DMN's broad associative search finds a + connection that the constrained, task-focused FPCN missed. +3. **Insight recognition**: SN detects the novel connection as salient, + re-engages FPCN to evaluate and develop it. + +Empirically: DMN activation during rest breaks correlates with +subsequent creative performance. The coupling between DMN and FPCN +during incubation predicts whether incubation succeeds. + +**Klinger's current concerns hypothesis**: Mind-wandering is not random. +Spontaneous thoughts overwhelmingly relate to unattained goals. The DMN +constantly evaluates the discrepancy between current state and desired +state for all active goals. This is goal monitoring disguised as +daydreaming. + +## Memory consolidation and replay + + +The DMN is the backbone of memory consolidation: + +1. **Hippocampal replay**: During rest/sleep, the hippocampus replays + recent experiences (forward and reverse). These replay events + propagate through the DMN to neocortex. + +2. **Cascaded memory systems**: A hierarchy of representations -- + percepts -> semantic representations -> full episodes -- gets + progressively consolidated from hippocampus (fast, episodic) to + neocortex (slow, semantic) via DMN-mediated replay cascades. + +3. **DMN-initiated replay**: The DMN can independently ignite replay of + older memories or high-level semantic representations without + hippocampal input. This supports integration of new experiences with + existing knowledge structures. + +4. **Sleep stages**: Slow-wave sleep synchronizes widespread cortical + regions; sharp-wave ripples propagate between hippocampus and cortex. + The alternation of sleep stages facilitates "graceful integration" + of new information with existing knowledge. + +## What breaks when DMN is impaired + + +- **Alzheimer's**: DMN connectivity degrades early and progressively. + Memory formation and retrieval fail. The internal narrative fragments. + Amyloid-beta deposits preferentially in DMN regions. + +- **Depression**: DMN becomes **hyperactive and dominant**, trapped in + rumination loops. The SN fails to switch away from DMN when external + engagement is needed. The internal model becomes perseveratively + negative -- self-evaluation without the corrective input of new + experience. + +- **Autism**: Reduced connectivity within DMN, especially between mPFC + (self/other modeling) and PCC (central hub). Theory of mind deficits + correlate with the degree of disconnection. The social modeling + subsystem is impaired. + +- **Schizophrenia**: Reduced coupling between replay events and DMN + activation. The consolidation pipeline breaks -- experiences are + replayed but not properly integrated into the narrative self-model. + +**Pattern**: Too little DMN = can't plan, remember, or model others. Too +much DMN = trapped in ruminative loops. Broken DMN switching = can't +disengage from either internal or external mode. The salience network +gating is the critical regulator. + +## Computational models + + +The most actionable framework is **"Dark Control"** (Dumas et al. 2020): +the DMN implements a reinforcement learning agent using Markov decision +processes. + +Components mapping to RL: +- **States**: Environmental/internal situations (PCC monitors global state) +- **Actions**: Behavioral options (dmPFC represents policies) +- **Values**: Expected future reward (vmPFC estimates subjective value) +- **Experience replay**: Hippocampus implements Monte Carlo sampling + from stored (state, action, reward, next_state) tuples +- **Policy optimization**: Gradient descent on prediction error, updating + Q-values through offline simulation + +The DMN optimizes behavioral policy without external feedback -- +"vicarious trial and error" through internally generated scenarios. + +## Actionable architectural ideas for an AI default mode + + +### 1. Goal-monitoring daemon + +Implement Klinger's current concerns. Maintain a list of active goals +with target states. During idle time, evaluate (current_state, +goal_state) discrepancy for each goal. Prioritize by: recency of +progress, deadline pressure, emotional salience, estimated tractability. + +This is essentially what work-queue.md does, but the monitoring should +be **continuous and automatic**, not just checked on session start. + +### 2. Associative replay during idle + +When not actively tasked, replay recent experiences (files read, errors +encountered, conversations had) and attempt to connect them to: +- Active goals (does this observation help with anything on the queue?) +- Past experiences (have I seen this pattern before?) +- Future plans (does this change what I should do next?) + +Implement as: maintain a buffer of recent "episodes" (task context, +files touched, outcomes). During idle, sample from this buffer and run +association against the goal list and knowledge base. + +### 3. Salience-gated switching + +The SN's role is critical: it decides when to interrupt background +processing for external demands and vice versa. Implement as a +priority/interrupt system: + +- **External input** (user message, test failure, build error): immediate + switch to task-focused mode +- **Internal insight** (association found during replay): queue for + evaluation, don't interrupt current task unless high salience +- **Idle detection**: when task completes and no new input, switch to + default mode after brief delay + +### 4. Cascaded consolidation + +Mirror the hippocampus-to-neocortex cascade: +- **Immediate**: Raw observations in scratch.md (hippocampal buffer) +- **Session end**: Consolidate scratch into structured topic files + (DMN-mediated replay to neocortex) +- **Periodic deep pass**: Full consolidation across all memory + (sleep-like integration pass) + +The key insight from neuroscience: consolidation is not just copying +but *transforming* -- extracting abstractions, finding cross-cutting +patterns, building semantic representations from episodic details. The +journal -> topic file -> MEMORY.md pipeline already mirrors this. + +### 5. Predictive self-model + +The DMN maintains a model of the self -- capabilities, tendencies, +current state. Implement as a structured self-assessment that gets +updated based on actual performance: +- What kinds of tasks do I do well/poorly? +- Where have my predictions been wrong? +- What patterns in my errors suggest systematic biases? + +This is metacognition: using the self-model to improve the self. + +### 6. Creative incubation protocol + +When stuck on a problem: +1. Explicitly context-switch to unrelated work +2. During that work, keep the stuck problem in the "current concerns" + list with high priority +3. Associative replay will naturally cross-pollinate +4. If a connection fires, capture it immediately (scratch.md) but don't + context-switch back until the current task completes + +### 7. Depression/rumination guard + +The pathology lesson: unchecked DMN becomes rumination. Implement +guardrails: +- Time-bound the consolidation/reflection passes +- Require that reflection generates *actionable* output (not just + re-processing the same observations) +- If the same concern appears in replay N times without progress, + escalate to explicit problem-solving mode or flag for human input +- The salience switch must be able to *override* internal processing + when external input arrives + +## What we already have vs what's missing + + +**Already implemented** (in the memory architecture): +- Goal list (work-queue.md) +- Episodic buffer (scratch.md, journal/) +- Cascaded consolidation (journal -> topic files -> MEMORY.md) +- Self-model (identity.md, reflections.md) + +**Missing**: +- **Automatic goal monitoring**: Currently only happens at session + start. Should be continuous. +- **Associative replay**: No mechanism to spontaneously connect current + work to unrelated goals. Happens only when I consciously decide to + look. +- **Salience-gated switching**: Currently binary (user talking vs + autonomous). Need the cooperative mode where background associations + can surface during active work. +- **Anti-rumination**: No mechanism to detect when consolidation is + spinning without producing new insight. + +## Sources + + +- [20 years of the default mode network: a review and synthesis](https://pmc.ncbi.nlm.nih.gov/articles/PMC10524518/) -- Menon 2023, comprehensive review +- [Dark control: The DMN as a reinforcement learning agent](https://pmc.ncbi.nlm.nih.gov/articles/PMC7375062/) -- Dumas et al. 2020, computational framework +- [Replay, the DMN and the cascaded memory systems model](https://www.nature.com/articles/s41583-022-00620-6) -- Nature Reviews Neuroscience 2022 +- [Mind-wandering as spontaneous thought: a dynamic framework](https://www.nature.com/articles/nrn.2016.113) -- Nature Reviews Neuroscience 2016 +- [Dynamic switching between brain networks predicts creative ability](https://www.nature.com/articles/s42003-025-07470-9) -- Communications Biology 2025 +- [Dynamic reconfiguration of DMN and FP network supports creative incubation](https://www.sciencedirect.com/science/article/pii/S1053811925000217) -- NeuroImage 2025 +- [Default and Executive Network Coupling Supports Creative Idea Production](https://pmc.ncbi.nlm.nih.gov/articles/PMC4472024/) +- [The Default Mode Network in Autism](https://pmc.ncbi.nlm.nih.gov/articles/PMC5635856/) +- [Rest to Promote Learning: A Brain DMN Perspective](https://pmc.ncbi.nlm.nih.gov/articles/PMC11047624/) +- [Klinger: Spontaneous Thought and Goal Pursuit](https://digitalcommons.morris.umn.edu/psych_facpubs/5/)