cogitation

Review and maintain EC memories. List all memories, find duplicates, prune stale entries, organize by type.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores requirements and design before implementation.

Debug systematically. Find root cause before fixing, write regression test via TDD, store learnings in EC.

Execute implementation plan in batches with review checkpoints.

Finish current branch. Verifies tests, reviews for EC memory storage, presents merge options.

Activate servitor protocol. All responses delivered in the manner of an Adeptus Mechanicus servitor unit.

Initialize cogitation for this project. Sets up EC context, scaffolds directories, configures test/build/lint commands.

Implement with TDD. Writes failing test first, then minimal code to pass. Red-green-refactor cycle with EC pattern storage.

Create detailed implementation plan with bite-sized TDD tasks from design documents.

Review and maintain EC memories. List all memories, find duplicates, prune stale entries, and organize by type. Use when memories need cleanup, when user says "audit memories", "clean up EC", "review what's stored", or periodically for hygiene.

Explores requirements, searches past decisions, creates design documents, and sets up feature branches. Use before any feature work or when starting a new feature.

View or update cogitation project configuration. Modify test/build/lint commands, branching conventions, or other project settings. Use when user says "change config", "update settings", "set test command", or wants to modify project setup.

Provides systematic debugging workflow that finds root cause before fixing. Fix phase uses @tdd to write a failing test reproducing the bug, then fix. Searches EC for prior issues and stores learnings. Use when encountering bugs, test failures, or unexpected behavior.

Executes TDD implementation plans in batches with review checkpoints. Each task follows @tdd red-green-refactor. Loads EC context before each batch. Use when ready to implement a plan from docs/plans/.

Verifies tests, reviews for EC memory storage, and presents merge options. Use when implementation is complete and ready to finish a feature branch.

Initialize a project for cogitation workflows. Sets up EC project context, scaffolds directories, and configures project-specific commands.

Get up to speed on an existing project by pulling all stored decisions, learnings, and patterns from EC. Use at the start of a new session, when joining a project, or when user says "catch me up", "what do I need to know", "onboard me".

Dispatches multiple agents for independent tasks that can run concurrently. Searches EC for prior parallelization strategies. Use when facing 2+ independent problems like separate test failures or unrelated bugs.

Handles code review feedback by verifying before implementing and pushing back if incorrect. Checks EC for context on prior decisions. Use when receiving code review comments or PR feedback.

Store important project context in EC's persistent memory. Use after making architectural decisions, discovering gotchas or workarounds, identifying recurring patterns, or when user says "remember this", "store this", "save for later", "don't forget".

Prepares and requests code review with proper context. Searches EC for reviewer preferences and past feedback patterns. Use before finishing a branch or when ready for feedback on implementation.

Guides test-driven development with red-green-refactor cycle. Stores successful test patterns in EC. Use when implementing new features, fixing bugs, writing tests, adding functionality, or any code change that should be test-first. Default approach for all implementation work.

Ensures verification commands are run before claiming success. Checks EC for project-specific gotchas. Use before asserting tests pass, builds succeed, or bugs are fixed.

Creates detailed TDD-first implementation plans from design documents. Every task follows red-green-refactor. Searches EC for relevant patterns. Use after brainstorming to write an implementation plan.

Creates new cogitation skills following best practices and EC integration patterns. Use when adding new capabilities or workflows to the skill set.