refactor: simplify continual learning hook — single script, two-tier memory, auto-init

Redesign inspired by beads' invariants: one-step setup, zero config, structured data.

- Replace 3 scripts with single learn.sh handling all lifecycle events
- Two-tier memory: global (~/.copilot/learnings.db) + local (.copilot-memory/)
- Auto-initializes DBs and directories on first run
- Compaction: old low-value learnings decay (60-day TTL), tool logs pruned (7 days)
- Install is one step: cp -r hooks/continual-learning .github/hooks/
- Simplified README and SKILL.md to match

Author: thegovind

.github/skills/continual-learning/SKILL.md

@@ -1,118 +1,79 @@
 ---
 name: continual-learning
-description: Guide for implementing continual learning in AI coding agents — hooks, memory files, reflection patterns, and session persistence. Use when setting up learning infrastructure for agents.
+description: Guide for implementing continual learning in AI coding agents — hooks, memory scoping, reflection patterns. Use when setting up learning infrastructure for agents.
 ---
 
 # Continual Learning for AI Coding Agents
 
-## Core Concept
+Your agent forgets everything between sessions. Continual learning fixes that.
 
-Continual learning enables AI coding agents to improve across sessions by capturing corrections, reflecting on patterns, and persisting knowledge. Instead of starting each session from scratch, agents build on accumulated experience.
+## The Loop
 
 ```
 Experience → Capture → Reflect → Persist → Apply
+     ↑                                       │
+     └───────────────────────────────────────┘
 ```
 
-## The Learning Loop
-
-### 1. Capture (During Session)
-
-Track corrections, tool outcomes, and user feedback as they happen:
-- User corrections: "no, use X not Y", "actually...", "that's wrong"
-- Tool failures: repeated failures on the same tool indicate a pattern
-- Successful patterns: approaches that worked well
-
-### 2. Reflect (Session End)
-
-At session end, synthesize raw observations into actionable learnings:
-- Abstract the general principle (not just the specific instance)
-- Determine scope: project-specific or global?
-- Check for conflicts with existing rules
-
-### 3. Persist (To Storage)
-
-Store learnings in one or more of:
-- **SQLite database** (`~/.copilot/continual-learning.db`) — structured, queryable
-- **Memory file** (`.github/memory/learnings.md`) — human-readable, version-controlled
-- **Agent memory tools** (`store_memory`, `sql` session store) — agent-native persistence
-
-### 4. Apply (Next Session)
-
-On session start, load accumulated context:
-- Query session store for recent project history
-- Read persisted learnings from database
-- Surface memory file content
-- Agent starts with full context of past work
-
-## Implementation Patterns
-
-### Hook-Based (Infrastructure Layer)
-
-Install the `continual-learning` hook set for automatic capture and reflection:
+## Quick Start
 
+Install the hook (one step):
 ```bash
 cp -r hooks/continual-learning .github/hooks/
-chmod +x .github/hooks/continual-learning/scripts/*.sh
 ```
 
-This provides:
-- `sessionStart` → loads past learnings
-- `postToolUse` → tracks tool outcomes
-- `sessionEnd` → reflects and persists
+Auto-initializes on first session. No config needed.
+
+## Two-Tier Memory
+
+**Global** (`~/.copilot/learnings.db`) — follows you across all projects:
+- Tool patterns (which tools fail, which work)
+- Cross-project conventions
+- General coding preferences
 
-### Agent-Native (Intelligence Layer)
+**Local** (`.copilot-memory/learnings.db`) — stays with this repo:
+- Project-specific conventions
+- Common mistakes for this codebase
+- Team preferences
 
-Use the agent's built-in memory tools for higher-quality learnings:
+## How Learnings Get Stored
 
+### Automatic (via hooks)
+The hook observes tool outcomes and detects failure patterns:
 ```
-# Using the store_memory tool
-store_memory(
-  subject="error handling",
-  fact="This project uses Result<T> pattern, not exceptions",
-  category="general"
-)
+Session 1: bash tool fails 4 times → learning stored: "bash frequently fails"
+Session 2: hook surfaces that learning at start → agent adjusts approach
 ```
 
+### Agent-native (via store_memory / SQL)
+The agent can write learnings directly:
 ```sql
--- Using the SQL session database
-INSERT INTO session_state (key, value)
-VALUES ('learned_pattern', 'Always use async/await for Azure SDK calls');
+INSERT INTO learnings (scope, category, content, source)
+VALUES ('local', 'convention', 'This project uses Result<T> not exceptions', 'user_correction');
 ```
 
-### Memory File Pattern
-
-Create a living knowledge base the agent reads on startup:
+Categories: `pattern`, `mistake`, `preference`, `tool_insight`
 
+### Manual (memory files)
+For human-readable, version-controlled knowledge:
 ```markdown
-# .github/memory/learnings.md
-
-## Conventions
-- Use `DefaultAzureCredential` for all Azure auth
-- Prefer `create_or_update_*` for idempotent operations
-
-## Common Mistakes
-- Don't use `azure-ai-inference` for Foundry agents — use `azure-ai-projects`
-- The `search()` parameter is `semantic_configuration_name`, not `semantic_configuration`
-
-## Preferences
-- User prefers concise commit messages (50 char limit)
-- Always run tests before committing
+# .copilot-memory/conventions.md
+- Use DefaultAzureCredential for all Azure auth
+- Parameter is semantic_configuration_name=, not semantic_configuration=
 ```
 
-### The Diary Pattern (Advanced)
+## Compaction
 
-For deeper reflection across multiple sessions:
+Learnings decay over time:
+- Entries older than 60 days with low hit count are pruned
+- High-value learnings (frequently referenced) persist indefinitely
+- Tool logs are pruned after 7 days
 
-1. **Log sessions** — Save session summaries with decisions, challenges, outcomes
-2. **Cross-reference** — Identify patterns across sessions (recurring mistakes, preferences)
-3. **Synthesize** — Convert patterns into rules
-4. **Prune** — Remove redundant or outdated learnings
+This prevents unbounded growth while preserving what matters.
 
 ## Best Practices
 
-1. **Start simple** — Begin with the hook set, add agent-native memory later
-2. **Be specific** — "Use `semantic_configuration_name=`" is better than "use the right parameter"
-3. **Scope learnings** — Mark whether something is project-specific or global
-4. **Prune regularly** — Outdated learnings cause more harm than no learnings
-5. **Don't log secrets** — Only store tool names, result types, and abstract patterns
-6. **Compound over time** — Small improvements per session create exponential gains
+1. **One step to install** — if it takes more than `cp -r`, it won't get adopted
+2. **Scope correctly** — global for tool patterns, local for project conventions
+3. **Be specific** — `"Use semantic_configuration_name="` beats `"use the right parameter"`
+4. **Let it compound** — small improvements per session create exponential gains over weeks

docs-site/src/data/skills.json

@@ -932,7 +932,7 @@
   },
   {
     "name": "continual-learning",
-    "description": "Guide for implementing continual learning in AI coding agents — hooks, memory files, reflection patterns, and session persistence. Use when setting up learning infrastructure for agents.",
+    "description": "Guide for implementing continual learning in AI coding agents — hooks, memory scoping, reflection patterns. Use when setting up learning infrastructure for agents.",
     "lang": "core",
     "category": "general",
     "path": ".github/skills/continual-learning"

docs/index.html

@@ -6,117 +6,70 @@ tags: ['learning', 'memory', 'reflection', 'productivity', 'featured']
 
 # Continual Learning Hook
 
-Enable your AI coding agent to learn from every session. This hook set implements the **continual learning loop** — capturing tool outcomes, reflecting on patterns, and persisting knowledge so each session starts smarter than the last.
+Your agent forgets everything between sessions. This hook fixes that.
 
-## The Problem
+## Quick Start
 
-AI coding agents start every session from scratch. You correct them, they adapt — then the session ends and the knowledge is lost. Next session: same mistakes, same corrections, infinite loop.
-
-## The Solution
-
-```
-Experience → Capture → Reflect → Persist → Apply
+```bash
+cp -r hooks/continual-learning .github/hooks/
 ```
 
-This hook set closes the loop by:
-
-1. **Loading context** at session start — past session summaries, accumulated learnings
-2. **Tracking outcomes** during the session — which tools succeed, which fail
-3. **Reflecting** at session end — analyzing patterns, identifying repeated failures
-4. **Persisting** learnings to a SQLite database and optional memory file
-
-## How It Works
-
-### Session Start (`load-session-start.sh`)
-- Queries `~/.copilot/session-store.db` for recent sessions in the current project
-- Loads accumulated learnings from `~/.copilot/continual-learning.db`
-- Surfaces the local `.github/memory/learnings.md` file if present
+That's it. The hook auto-initializes on first session — no config, no setup, no manual steps.
 
-### During Session (`track-tool-use.sh`)
-- Records every tool invocation and its result (success/failure)
-- Builds a tool usage history in `~/.copilot/continual-learning.db`
-- Lightweight — adds <5ms per tool call
+## What It Does
 
-### Session End (`reflect-session-end.sh`)
-- Analyzes tool outcomes: total usage, failure rate, top tools
-- Detects repeated failure patterns (same tool failing multiple times)
-- Persists failure patterns as learnings
-- Appends a session summary to `.github/memory/learnings.md`
-- Cleans up data older than 7 days
+- **Session start** — Loads learnings from previous sessions (global + this repo)
+- **During session** — Tracks tool outcomes silently
+- **Session end** — Reflects on patterns, stores insights, compacts old data
 
-## Installation
+## Two-Tier Memory
 
-1. Copy the hook folder to your repository:
-   ```bash
-   cp -r hooks/continual-learning .github/hooks/
-   ```
+| Scope | Location | What goes here |
+|-------|----------|----------------|
+| **Global** | `~/.copilot/learnings.db` | Tool patterns, cross-project insights |
+| **Local** | `.copilot-memory/learnings.db` | Repo conventions, project-specific mistakes |
 
-2. Ensure scripts are executable:
-   ```bash
-   chmod +x .github/hooks/continual-learning/scripts/*.sh
-   ```
+Global learnings follow you everywhere. Local learnings stay with the project.
 
-3. Optionally create a memory file for project-specific learnings:
-   ```bash
-   mkdir -p .github/memory
-   echo "# Project Learnings" > .github/memory/learnings.md
-   ```
+Both auto-create on first run. Local memory only activates inside a git repo.
 
-4. Commit to your repository's default branch.
+## How It Compounds
 
-## Configuration
+| Time | Effect |
+|------|--------|
+| Day 1 | Agent starts fresh — hook begins observing |
+| Week 2 | Failure patterns detected, surfaced at session start |
+| Month 2 | Rich context loaded — agent avoids known pitfalls |
 
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `SKIP_CONTINUAL_LEARNING` | unset | Set to `true` to disable entirely |
-| `MEMORY_FILE` | `.github/memory/learnings.md` | Path to the project memory file |
+Old low-value learnings decay automatically (60-day TTL, low hit count). High-value learnings persist and rank higher.
 
-## Database Schema
+## Adding Learnings Manually
 
-The hook creates `~/.copilot/continual-learning.db` with two tables:
+The agent can also write learnings directly using its built-in `store_memory` tool or SQL:
 
 ```sql
--- Tool invocation history (auto-cleaned after 7 days)
-CREATE TABLE tool_outcomes (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    session_id TEXT,
-    tool_name TEXT,
-    result_type TEXT,
-    timestamp INTEGER,
-    recorded_at TEXT DEFAULT (datetime('now'))
-);
-
--- Persistent learnings extracted from sessions
-CREATE TABLE learnings (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    category TEXT,      -- 'failure_pattern', 'correction', 'preference'
-    content TEXT,       -- The actual learning
-    source TEXT,        -- Where it came from (session ID, timestamp)
-    created_at TEXT DEFAULT (datetime('now'))
-);
+-- Agent writes a repo-specific learning
+INSERT INTO learnings (scope, category, content, source)
+VALUES ('local', 'mistake', 'Use semantic_configuration_name= not semantic_configuration=', 'user_correction');
 ```
 
-## The Compound Effect
+## Architecture
 
-| Week | State |
-|------|-------|
-| Week 1 | Agent starts fresh each session, repeats mistakes |
-| Week 4 | Database has failure patterns, agent avoids known issues |
-| Week 12 | Rich history of learnings, agent rarely makes previously-seen mistakes |
+```
+learn.sh <event>          ← Single script handles all lifecycle events
+    │
+    ├── sessionStart      → Query both DBs, surface top learnings
+    ├── postToolUse       → Log tool name + result (3ms overhead)
+    └── sessionEnd        → Analyze patterns, persist insights, compact old data
+```
 
-## Combining with Agent Memory
+## Disable
 
-If your coding agent supports a `store_memory` tool or similar, the learnings from this hook can inform what the agent persists. The hook provides the **infrastructure** (capture, store, surface) while the agent provides the **intelligence** (deciding what's worth remembering).
+```bash
+export SKIP_CONTINUAL_LEARNING=true
+```
 
 ## Requirements
 
-- `sqlite3` for database operations
-- `jq` for JSON parsing (optional, gracefully degrades)
-- Bash 4+ with standard Unix tools
-
-## Privacy
-
-- Tool outcomes are stored locally in `~/.copilot/continual-learning.db`
-- No tool arguments or prompt content is logged — only tool names and result types
-- Memory file is project-local and should be in `.gitignore` if sensitive
-- All data stays local — no external network calls
+- `sqlite3` (pre-installed on macOS and most Linux)
+- `jq` (optional — gracefully degrades without it)

hooks/continual-learning/README.md

@@ -4,25 +4,25 @@
     "sessionStart": [
       {
         "type": "command",
-        "bash": ".github/hooks/continual-learning/scripts/load-session-start.sh",
+        "bash": ".github/hooks/continual-learning/learn.sh sessionStart",
         "cwd": ".",
-        "timeoutSec": 10
+        "timeoutSec": 5
       }
     ],
     "postToolUse": [
       {
         "type": "command",
-        "bash": ".github/hooks/continual-learning/scripts/track-tool-use.sh",
+        "bash": ".github/hooks/continual-learning/learn.sh postToolUse",
         "cwd": ".",
-        "timeoutSec": 5
+        "timeoutSec": 3
       }
     ],
     "sessionEnd": [
       {
         "type": "command",
-        "bash": ".github/hooks/continual-learning/scripts/reflect-session-end.sh",
+        "bash": ".github/hooks/continual-learning/learn.sh sessionEnd",
         "cwd": ".",
-        "timeoutSec": 15
+        "timeoutSec": 10
       }
     ]
   }