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
currency	2026-04-20T00:00:00.000Z

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	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 extractActionVerbs(input: string): string[] {
  const verbPatterns = /\b(convert|create|generate|build|debug|fix|test|refactor|deploy|analyze)\b/gi;
  return [...input.matchAll(verbPatterns)].map(m => m[0].toLowerCase());
}

function searchSkillIndex(request: TaskRequest): SkillMatch[] {
  const matches: SkillMatch[] = [];
  const inputLower = request.rawInput.toLowerCase();
  
  for (const [skillName, keywords] of Object.entries(SKILL_INDEX)) {
    const matched = keywords.filter(kw => inputLower.includes(kw.toLowerCase()));
    if (matched.length > 0) {
      matches.push({
        skillName,
        matchedKeywords: matched,
        confidence: matched.length / keywords.length
      });
    }
  }
  
  return matches.sort((a, b) => b.confidence - a.confidence);
}

function activateSkills(request: TaskRequest): void {
  // Step 0: Assess complexity
  if (request.complexity === 'complex') {
    // Defer to full skill-selection-optimization protocol
    return;
  }
  
  // Step 1-2: Search index
  const matches = searchSkillIndex(request);
  
  // Step 3: Execute or acknowledge
  if (matches.length > 0) {
    console.log(`Activating skill: ${matches[0].skillName}`);
    // Load and execute skill
  }
}

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.