memory-alignment-check

Compare implementation reports against memory entries to detect contradictions and new knowledge.

1|Updated Mar 12, 2026
One-click install
npx skills add https://github.com/bketelsen/truenas-mcp --skill memory-alignment-check
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: memory-alignment-check
Source: https://github.com/bketelsen/truenas-mcp/tree/main/.gaai/core/skills/cross/memory-alignment-check
Command: npx skills add https://github.com/bketelsen/truenas-mcp --skill memory-alignment-check

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill ensures that the AI's long-term memory (decisions, patterns, project context) remains accurate and consistent with the actual code implementation after a task (Story) is completed.

Core Features & Use Cases

  • Verifies Memory Consistency: Compares the footprint of a delivered Story against relevant memory entries.
  • Identifies Discrepancies: Flags contradictions between memory and implementation.
  • Detects New Knowledge: Identifies new patterns or decisions introduced in the implementation that are not yet in memory.
  • Use Case: After a developer completes a Story and it passes QA, this Skill is activated to check if the new code aligns with established project patterns and decisions stored in memory, or if memory needs updating.

Quick Start

Activate the memory-alignment-check skill after QA PASS on story E01S01.

Frequently Asked Questions about memory-alignment-check

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I verify code implementation consistency against stored project memory?

Checking implementation against project memory detects new patterns, decisions, or constraints introduced during development that are not yet present in memory. It identifies unaddressed memory items and contradictions, ensuring long-term project knowledge remains accurate after code delivery.

When should I run a memory consistency check after completing development tasks?

Run a memory consistency check immediately after a developer completes a Story and it passes QA. Activating the check at this stage ensures the new code aligns with established project patterns and decisions stored in memory before further development proceeds.

How do I identify new patterns and decisions from code that are missing from knowledge management memory?

To identify new patterns and decisions missing from knowledge management memory, analyze implementation reports and selective memory entries. This comparison detects newly introduced constraints or decisions, extracting them for ingestion to update the long-term project context.

Does memory alignment verification work without external dependencies?

Memory alignment verification works without external dependencies, relying solely on internal references. It functions independently to analyze implementation footprints and selective memory entries, requiring only the completed Story's report and existing memory data to execute the consistency check.

What are the limitations of comparing implementation footprints against memory entries?

A limitation of comparing implementation footprints against memory entries is that the analysis depth is intermediate, focusing on pattern, decision, and constraint detection. It relies on the accuracy of implementation reports and selective memory entries rather than scanning the entire codebase independently.