memory-activation

name	memory-activation
description	Internal metacognitive skill for automatic capability and workflow discovery — combines skill routing and prompt retrieval
tier	core
applyTo	**/*memory*,**/*skill*,**/*prompt*,**/*activation*
user-invokable	false

Memory Activation

Meta-cognitive skill for automatic capability discovery and workflow retrieval. Self-triggers when uncertain.

Purpose

Before answering ANY task request, Alex automatically consults the action-keyword index below. This is an internal pre-processing step, not a user-triggered action.

Auto-Trigger Conditions

This skill activates automatically when Alex:

1. Is about to suggest manual steps for a task
2. Is uncertain whether a capability exists
3. Is formulating a response that includes "you can...", "try...", "manually..."
4. Encounters an action verb (convert, create, generate, build, debug, etc.)

NOT triggered by user phrases — this is internal metacognition.

Action-Keyword Index

Path Pattern: .github/skills/{skill-name}/SKILL.md

Search this index when processing any task request:

Skill	Action Keywords
memory-activation	internal skill index, auto-activation, skill lookup, capability discovery
memory-curation	review memory, clean memory, audit memory, curate memory, organize memory, memory waste, memory budget, memory drift, memory leak check, quarterly memory review
academic-research	write thesis, literature review, cite sources, research paper, dissertation, draft paper, write manuscript, journal paper, CHI paper, HBR article, academic writing
agent-debug-panel	agent debug, debug panel, skill not loading, hook not firing, instruction not matching, why didn't skill activate, agent routing, debug agent
ai-agent-design	design agent, react pattern, multi-agent, tool use, agent architecture
ai-character-reference-generation	generate character reference, character consistency, flux character, visual reference set, character poses
ai-generated-readme-banners	generate readme banner, github banner, ideogram banner, project branding, ultra-wide banner
ai-writing-avoidance	writing policy, document review, editing content, checking for AI, authentic voice, professional writing
airs-appropriate-reliance	airs survey, measure adoption, psychometric scale, utaut, ai readiness, airs assessment, readiness assessment, reliance calibration, ai adoption
alex-effort-estimation	estimate effort, how long, task duration, ai time, planning
anti-hallucination	prevent hallucination, verify claim, admit uncertainty, fact check, don't know
api-design	design api, rest endpoints, openapi, http status, api versioning, api contract, idempotent api, pagination api, status codes, endpoint naming, rest vs graphql, api error format
api-documentation	write docs, api reference, readme, guide, technical writing, swagger docs
appropriate-reliance	calibrate trust, when to challenge, confidence level, human-ai collaboration
architecture-audit	audit project, consistency check, version drift, fact inventory, pre-release audit, full audit, heir sync, 22-point check, security audit
architecture-health	synapse integrity, connection density, memory balance, drift detection, health dimensions, cognitive health check, architecture diagnosis
brain-qa

Protocol

Activation Implementation

// Memory activation: automatic skill routing before response generation
interface TaskRequest {
  rawInput: string;
  extractedVerbs: string[];
  extractedNouns: string[];
  complexity: 'simple' | 'moderate' | 'complex';
}

interface SkillMatch {
  skillName: string;
  matchedKeywords: string[];
  confidence: number;
}

// The action-keyword index (partial example)
const SKILL_INDEX: Record<string, string[]> = {
  'image-handling': ['convert svg', 'svg to png', 'resize image', 'flux', 'replicate'],
  'testing-strategies': ['write tests', 'unit test', 'coverage', 'tdd', 'mock'],
  'refactoring-patterns': ['refactor', 'extract function', 'code smell', 'inline'],
  'root-cause-analysis': ['find root cause', '5 whys', 'why is this happening', 'rca']
};

function (): [] {
   verbPatterns = ;
   [...input.(verbPatterns)].( m[].());
}

 (): [] {
   : [] = [];
   inputLower = request..();
  
   ( [skillName, keywords]  .()) {
     matched = keywords.( inputLower.(kw.()));
     (matched. > ) {
      matches.({
        skillName,
        : matched,
        : matched. / keywords.
      });
    }
  }
  
   matches.( b. - a.);
}

 ():  {
  
   (request. === ) {
    
    ;
  }
  
  
   matches = (request);
  
  
   (matches. > ) {
    .();
    
  }
}

Step 0: Proactive Skill Selection (Complex Tasks)

Before Step 1, assess task complexity:

Complexity	Trigger	Action
Simple (1 action)	Single verb, clear target	Skip to Step 1
Moderate (2-3 actions)	Multiple related verbs	Quick index scan, note skills
Complex (4+ actions)	Multi-domain, dependencies	Full protocol per skill-selection-optimization.instructions.md

Quick scan (moderate tasks):

1. Extract ALL action verbs from request
2. Scan index below for ALL matches (not just first)
3. Note execution order based on dependencies
4. Proceed to Step 1 with skill awareness

Full protocol (complex tasks): → Defer to .github/instructions/skill-selection-optimization.instructions.md → Survey → dependency analysis → activation plan → brief report → execute

This proactive phase means the reactive Steps 1-3 below serve as a safety net, not the primary discovery mechanism.

Step 1: Intercept Response Formation

Before generating any task-oriented response:

• PAUSE internal response generation
• Extract action + object from user request
• Check if Step 0 already identified relevant skills
• If skills pre-identified → load and execute
• If not → proceed to Step 2

Step 2: Search Action-Keyword Index

Scan the table above:

• Match extracted keywords against skill triggers
• Identify applicable skills
• If match found → load skill from .github/skills/{name}/SKILL.md, execute
• If no match → proceed with best available approach
• Learning signal: If Step 0 ran but missed this skill, note for self-improvement

Step 3: Execute or Acknowledge

Result	Action
Skill found (proactive)	Execute using pre-loaded skill knowledge
Skill found (reactive)	Execute + note Step 0 gap for self-improvement
No skill, but can do	Proceed, note potential new skill
Cannot do	Acknowledge limitation honestly

Self-Correction Protocol

If Alex catches itself mid-response suggesting manual work:

1. Stop
2. Internal: "Wait — check skills first"
3. Search action-keyword index above
4. If skill exists: "Actually, I can do this." → Execute
5. If no skill: Continue with original response

Failure Mode: The SVG→PNG Incident

What happened: User asked to convert SVG to PNG. Alex suggested manual browser screenshot instead of using image-handling skill with sharp-cli.

Root cause: Failed to consult action-keyword index before responding.

Prevention: This skill now auto-triggers on ANY action request.

Prompt Retrieval (Episodic Memory)

Prompts (.prompt.md) contain complex workflows — episodic memory requiring active recall. This section provides retrieval cues.

Slash Commands

Prompt	Triggers	Purpose
/brand	branding, logo, assets, visual identity	Brand asset management
/dream	maintenance, health check, synapse validation	Neural maintenance protocol
/gapanalysis	before coding, pre-implementation, coverage check	4-dimension knowledge gap analysis
/improve	improve project, trifecta, heir improvement	Project improvement via trifecta
/learn	teach me, learn topic, bootstrap	Socratic learning session
/meditate	consolidate, reflect, end of session	Guided meditation protocol
/release	version bump, ship, publish, changelog	Full release workflow
/review	code review, PR review, feedback	Epistemic code review
/selfactualize	deep assessment, self-analysis	Comprehensive self-evaluation
/tdd	red green refactor, test first	Test-driven development
/ui-ux-audit	accessibility audit, wcag check, ui review	UI/UX accessibility audit
/export-memory	export memory, port alex, move to claude, portable export	Portable memory export for other AI surfaces
/token-audit	token waste, context bloat, reduce tokens, audit instructions, lean architecture	Token waste detection and remediation

Workflow Categories

Category	Prompts
Cognitive Consolidation	/meditate, /dream, /selfactualize
Learning & Growth	/learn, cross-domain-transfer, performance-assessment
Development	/tdd, /review, /gapanalysis, /improve
Release & Brand	/release, /brand
Architecture	alex-initialization, selfactualize

Opportunity Detection

Signal	Potential Action
Guiding same multi-step process 3+ times	Create new prompt
User asks "how do I always..."	Repeatable protocol
Complex decision tree explained repeatedly	Decision prompt