meta-continuous-learning

version	2.1.0
name	meta-continuous-learning
description	Analyze session patterns and extract reusable skills, rules, or conventions. Turns recurring corrections, debugging techniques, and workarounds into permanent knowledge. Use when the user says "learn from this session", "extract patterns", "what did we learn", or at session wrap-up when significant patterns were discovered.
disable-model-invocation	true
user-invocable	true
argument-hint	[--review | --extract | --adaptations | --status]

Continuous Learning — Session Pattern Extraction

Analyze the current session (or recent sessions) for patterns worth extracting as reusable knowledge. This turns one-time fixes into permanent improvements.

Philosophy

The agentic-workflow system has a memory hierarchy:

Session conversation (volatile — lost on context clear)
    ↓ wrap-up captures
Daily memory file (raw notes — kept 30 days)
    ↓ periodic distillation
MEMORY.md (curated wisdom — permanent)
    ↓ THIS SKILL extracts
New skills / rules / SOUL.md updates (actionable — permanent)

Most memory captures what happened. This skill captures what to do differently.

When to Activate

• After a session where you had to correct Claude multiple times on the same issue
• When a debugging technique took effort to discover and will likely recur
• When you established a project convention that isn't obvious from the code
• When a workaround was needed for a tool, library, or framework quirk
• During /meta-wrap-up when the learnings section has significant entries
• When the user says "remember this pattern", "learn from this", "extract this"

What to Extract

Pattern Types

Type	Example	Destination
Correction	"Don't use rm, use trash"	context/SOUL.md or .claude/rules/
Convention	"Tests go in __tests__/ next to source"	Project CLAUDE.md or rule file
Technique	"Debug Aspire by checking resource logs first"	New skill or MEMORY.md
Workaround	"EF Core needs explicit include for nested entities"	MEMORY.md or rule file
Workflow	"Always run dotnet format before committing C#"	New hook or skill
Skill Adaptation	"The TDD skill needs an Aspire integration phase"	context/adaptations.md

Confidence Assessment

Before extracting, assess confidence:

Level	Criteria	Action
High	Pattern observed 3+ times, user confirmed	Extract immediately
Medium	Pattern observed 1-2 times, seems generalizable	Extract as draft, flag for review
Low	Single occurrence, might be situational	Note in MEMORY.md, don't extract yet

Extraction Process

Step 0: Detect Environment

Determine if you're running inside an agentsandbox:

1. Check if $AGENTSANDBOX_SESSION env var is set, or /workspace/CLAUDE.md exists, or current branch starts with asb/
2. If in a sandbox, determine session name from $AGENTSANDBOX_SESSION (preferred), or strip asb- from $HOSTNAME, or strip asb/{source}- from branch name
3. Set your file paths accordingly:
   • Reading history: Use .context-main/memory/ (read-only mount of main's context) for full history, plus context/memory/ for this session's files
   • Daily memory file: context/memory/{YYYY-MM-DD}_{session-name}.md (sandbox) or context/memory/{YYYY-MM-DD}.md (main)
   • MEMORY.md / SOUL.md: Write to context/MEMORY.md and context/SOUL.md in the worktree (not .context-main/)

Step 1: Identify Candidates

Review the session for extractable patterns:

1. Read today's daily memory file (use the correct path from Step 0)
2. Check the session's Decisions and Learnings sections
3. Look at git diff for what was changed
4. Identify any corrections the user made ("no, don't do X, do Y instead")
5. Identify any debugging paths that were non-obvious

Step 2: Categorize and Draft

For each candidate pattern:

1. Determine the best destination (see Pattern Types table above)
2. Draft the extraction:
   • For SOUL.md updates: Add to the Development Values or as a new section
   • For rules: Create a .claude/rules/{topic}.md file
   • For skills: Create a new skill in .claude/skills/{category}-{name}/SKILL.md
   • For MEMORY.md: Add to the Lessons Learned section
   • For hooks: Create or update a hook script

Step 3: Present for Review

Present all candidates to the user in a table:

### Extracted Patterns

| # | Pattern | Confidence | Destination | Action |
|---|---------|-----------|-------------|--------|
| 1 | Always check resource logs before restarting Aspire services | High | MEMORY.md | Add to Lessons Learned |
| 2 | Use `trash` instead of `rm` for recoverable deletes | High | SOUL.md | Already there ✓ |
| 3 | Run dotnet format after C# edits | Medium | New hook | Draft hook script |

Apply all? Or select specific ones?

Step 4: Apply

Only apply after user approval. For each approved pattern:

1. Write the extraction to its destination
2. Note in today's daily memory (use the correct path from Step 0): "Extracted pattern: {description} → {destination}"
3. If a new skill was created, run /meta-skill-catalog rebuild to update the catalog

Sandbox note: All writes go to the worktree's context/ — never to .context-main/ (that's read-only). After session exit, the host syncs sandbox memory files back to main automatically.

Skill Adaptation Detection

When a pattern involves modifying an installed skill's behavior, log it as an adaptation rather than (or in addition to) a regular extraction.

When to Detect

• User corrects a skill's workflow ("don't do X in the TDD skill, do Y instead")
• A skill is edited directly (SKILL.md modified during the session)
• A workaround is needed because a skill doesn't cover a specific case

Classification

Classification	Meaning	Example
universal	Any project using this skill's stack would benefit	"TDD skill should handle integration tests with TestContainers"
stack-specific	Applicable to same stack but may need tweaks	"Verification should check Aspire health endpoints"
project-specific	Only relevant to this project	"TDD needs custom EventStoreTestFixture from this repo"

Logging to adaptations.md

Write adaptations to context/adaptations.md. Create the file if it doesn't exist.

Format:

# Skill Adaptations

## {skill-name} (installed: {version})

### {YYYY-MM-DD} — {short description}
- **Classification:** {universal | stack-specific | project-specific}
- **What:** {What was changed or needs changing}
- **Why:** {Why the adaptation was needed}
- **Diff summary:** {Brief description of what changed in the SKILL.md}
- **Status:** {pending-contribution | local-only}

Set status to pending-contribution for universal/stack-specific adaptations, local-only for project-specific ones.

Integration with Wrap-Up

During /meta-wrap-up, if any skill was modified during the session:

[SKILL ADAPTATION] Detected modifications to dev-tdd-backend.
Classify this adaptation? (universal / stack-specific / project-specific / skip)

Flags

Flag	Behavior
--review	Review recent sessions for unextracted patterns (read-only)
--extract	Run full extraction on current session
--status	Show what's been extracted recently (check daily memory files)
--adaptations	Review and classify skill modifications from this session

Anti-Pattern Guards

• Don't extract obvious things: "Use git for version control" is not a useful extraction
• Don't extract one-offs: A bug fix specific to one ticket isn't a pattern
• Don't over-extract: 2-3 patterns per session is a good rate; 10+ means you're being too granular
• Don't skip review: Always present candidates before applying
• Don't create skills for simple rules: A one-liner belongs in .claude/rules/, not a full skill

Integration with Wrap-Up

During /meta-wrap-up, if the Learnings section has entries with high confidence:

[CONTINUOUS LEARNING] Found 2 patterns worth extracting:
1. "EF Core: always use .Include() for navigation properties in queries" (High)
2. "Aspire: check /health endpoint before assuming service is ready" (Medium)

Run /meta-continuous-learning --extract to formalize these, or skip.

This is a suggestion, not automatic. The user decides.