a5c-ai/babysitter - Page 3

codebase-sync

Convention discovery and rule generation from codebase analysis. Scans project structure, builds search indexes, identifies patterns, and generates enforceable rules.

context-preservation

State capture and restore across context window compactions. Monitors usage thresholds and serializes quality, task, and spec state for seamless continuation.

persistent-memory

Observation capture and retrieval across sessions. Stores decisions, discoveries, and bugfix patterns. Searchable via tags and relevance scoring.

quality-hooks

Language-specific auto-lint/format/typecheck pipeline. Supports Python (ruff+pyright), TypeScript (prettier+eslint+tsc), Go (gofmt+golangci-lint). Auto-fix and convergence loops.

spec-driven-development

Specification creation and management for the Pilot Shell methodology. Covers semantic search, clarifying questions, structured spec generation, and iterative refinement.

strict-tdd

Strict RED->GREEN->REFACTOR test-driven development with enforcement. Never write production code before a failing test. Atomic commits per TDD cycle.

worktree-isolation

Git worktree management for safe, isolated feature development. Creates, manages, and cleans up worktrees with branch naming and dependency setup.

brainstorming

Clarify vague requirements through exploratory questioning and option generation before committing to research or implementation.

code-review

Structured code quality assessment with Conventional Comments format, scaled review depth, and soft-gating verdicts preserving user autonomy.

codebase-research

Systematic codebase exploration following the Iron Law - understand the problem before exploring code. Four phases with file-finder and web-researcher agents.

decision-documentation

Create Architecture Decision Records (ADRs) documenting significant technical choices with context, options, consequences, and sequential numbering.

finishing-work

Final completion discipline including summary generation, plan document updates, and confirmation that all success criteria from the original plan are satisfied.

plan-implementation

Disciplined execution of approved plans with step-by-step verification, phase checkpoints, failure investigation, and mandatory code/security reviews.

plan-writing

Transform research findings into actionable implementation plans with stakes-based rigor, test-first strategy, and granular task decomposition.

security-review

Security vulnerability assessment identifying OWASP risks, injection vectors, authentication issues, and data exposure with severity classification.

test-driven-development

Test-first development practice where test specifications are written before production code, integrated into plan tasks as mandatory first sub-steps.

verification

Verification-before-completion discipline ensuring all success criteria are met, tests pass, and reviews complete before declaring work done.

agent-booster

WASM-based instant code transforms for simple tasks, achieving 352x speedup over LLM inference with zero cost.

anti-drift

Hierarchical coordination and drift detection with frequent checkpoints, shared memory coherence validation, role specialization enforcement, and short task cycles.

consensus-mechanisms

Multi-protocol consensus for agent swarms supporting Raft leader election, Byzantine fault tolerance, Gossip state propagation, and CRDT conflict-free merging.

security-hardening

AIDefence security layer with prompt injection blocking, input validation, sandboxed execution, output sanitization, and STRIDE threat modeling.

self-optimization

SONA self-optimizing neural architecture with ReasoningBank trajectory learning, EWC++ anti-forgetting, and reinforcement learning feedback loops.

smart-routing

Complexity-based task routing with Q-Learning optimization, Agent Booster WASM fast-path, and Mixture-of-Experts model selection.

swarm-orchestration

Multi-agent swarm formation and coordinated execution with topology-aware agent deployment, consensus protocols, and anti-drift enforcement.

vector-memory

HNSW vector search for pattern similarity retrieval and knowledge graph maintenance with PageRank scoring, community detection, and 3-tier memory management.

constitution-creation

Establish project governing principles including dev guidelines, code quality standards, testing policies, UX requirements, performance benchmarks, and security constraints.

cross-artifact-analysis

Perform cross-artifact consistency and coverage analysis across constitution, specification, plan, and task artifacts to detect gaps, conflicts, and misalignments before implementation.

implementation-execution

Execute development tasks to build features, producing code, tests, and configuration artifacts that satisfy specification requirements and comply with constitution standards.

planning-design

Design technical architecture, select technology stack, and define implementation strategy from specifications and constitution constraints.

quality-checklist

Validate implementation quality through custom checklists, scoring against constitution standards, specification coverage, and producing remediation recommendations.

specification-writing

Write feature specifications as requirements and user stories with acceptance criteria, focusing on business value and testable conditions.

task-decomposition

Convert technical plans into actionable development tasks with dependency graphs, effort estimates, and parallelization opportunities.

brainstorming

Use when starting any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

dispatching-parallel-agents

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies.

executing-plans

Use when you have a written implementation plan to execute in a separate session with review checkpoints between batches.

finishing-a-development-branch

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work.

receiving-code-review

Use when receiving code review feedback, before implementing suggestions. Requires technical rigor and verification, not blind implementation.

requesting-code-review

Use when completing tasks, implementing major features, or before merging to verify work meets requirements.

subagent-driven-development

Use when executing implementation plans with independent tasks in the current session. Dispatches fresh subagent per task.

systematic-debugging

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes. Requires root cause investigation first.