babysitter

Assimilate an external methodology, harness, or specification into babysitter process definitions with skills and agents.

---

---

Diagnose babysitter run health - journal integrity, state cache, effects, locks, sessions, logs, and disk usage

---

---

---

---

---

---

---

---

---

---

---

Build dependency-aware, batched dispatch queues for parallel agent execution.

Perform code review with quality scoring and configurable threshold enforcement.

Parse and normalize features from text descriptions, images, and screenshots into structured requirements.

Initialize and manage Kanban board state for feature workflow tracking.

Emit real-time progress events for streaming UI consumption.

Execute Vitest and Playwright test suites with result collection and failure analysis.

Manage git worktree lifecycle for safe, isolated parallel development.

Design comprehensive system architecture with technology selection and ADRs.

Multi-dimensional code review across correctness, security, performance, maintainability, and test coverage.

Create Product Requirements Documents through structured discovery using Jobs-to-be-Done framework.

Create comprehensive product briefs from market, domain, and technical research.

Generate comprehensive project documentation with source tree analysis and Mermaid diagrams.

Generate and execute API and E2E tests with quality gate assessment.

Lean solo-developer workflow for rapid spec-to-implementation with minimal overhead.

Plan implementation sprints with story selection, goal definition, and execution ordering.

Implement user stories with test-driven development methodology.

Create comprehensive UX design with user flows, wireframes, and design systems.

System and API design guidance covering component boundaries, data flow, integration patterns, and scalability considerations.

Minimal, pattern-matching code output. Write the least code that satisfies requirements. Match existing project patterns. Use Write/Edit tools only.

Multi-dimensional code assessment across security, quality, performance, and maintainability with confidence-gated reporting (>=80%) and Router Contract generation.

Root cause analysis frameworks including log-first investigation, git bisect correlation, and pattern-based diagnosis with confidence scoring.

Structured planning methodology with research, brainstorming, phased plan creation, risk assessment, and plan-to-build continuity.

Mandatory memory persistence system across session resets using three markdown surfaces in .claude/cc10x/. Iron law - every workflow must load at start and update at end.

Strict RED-GREEN-REFACTOR cycle enforcement. Tests are never skipped or deferred. Run mode only, never watch mode. Exit code evidence mandatory.

Evidence requirement enforcement ensuring all claims are backed by logs, test results, or exit codes. Zero = success, non-zero = failure. No guessing allowed.

Full traceability from PRD to code commit through the CCPM spec-driven pipeline.

Project context loading, isolation, and persistent state management across CCPM sessions.

Transform PRD into a technical implementation plan with architecture decisions and dependency mapping.

Bidirectional synchronization of epics and tasks with GitHub issues, labels, and relationships.

Coordinate multiple specialized agents across parallel work streams with quality gates and conflict resolution.

Interactive PRD brainstorming and drafting with quality-gated refinement.

Status dashboards, standup reports, and blocked task management with GitHub synchronization.

Break epics into parallelizable tasks with acceptance criteria, effort estimates, and dependency graphs.

Git-backed state management for safe rollback. Create and restore checkpoints with tagged commits and metadata tracking.

6-agent parallel code review orchestration covering architecture, security, performance, testing, quality, and documentation dimensions with weighted scoring.

Automatic codebase indexing for invisible context injection. Catalogs project structure, file types, entry points, dependencies, and test layout.

PreToolUse protection blocking sensitive file access across 195+ patterns in 12 categories with bash pipeline analysis and multi-tool ignore support.

Session-scoped hook lifecycle management with enable/disable/status controls, execution profiling, and color-coded performance alerts.

Parallel research agent orchestration dispatching 5-10 concurrent agents for comprehensive multi-source research with synthesis and validation.

Feature specification creation from codebase research. Produces requirements, acceptance criteria, architecture decisions, implementation plans, and risk analysis.

6-phase iterative specification execution workflow covering implementation, testing, review, improvement, commit, and progress tracking with quality-gated convergence.

Capture raw thoughts with automatic domain classification and vault routing

Generate personalized verified news briefs with 7-day freshness and 95%+ source accuracy

Build structured knowledge frameworks from scattered vault notes with source attribution

Process meeting recordings and transcripts into decisions, action items, and team dynamics

Personalize COG Second Brain workflow through role pack selection and vault initialization

Cross-reference GitHub, Linear, Slack, and PostHog with bidirectional sync for team briefs

Save URLs with auto-extracted insights, credibility scoring, and vault routing

Cross-domain pattern analysis with personal, professional, and project domain synthesis

Multi-dimensional code review across correctness, security, performance, and maintainability with confidence-gated reporting and remediation loops.

Dynamic context injection, mode switching (dev/review/research), selective loading, and strategic compaction for token optimization.

Pattern extraction, confidence-scored evaluation, skill creation, organization, versioning, and cross-project export pipeline.

Evaluation harness for testing agent and skill quality through structured benchmarks, regression tests, and quality scoring.

PM2 process management, backend/frontend cascade execution, parallel worktree builds, and cross-service integration testing.

Research-first development methodology that investigates existing solutions, brainstorms alternatives, and evaluates trade-offs before any implementation begins.

AgentShield security audit with 5 scanning categories, 102 static analysis rules, and optional red-team simulation.

Red-Green-Refactor TDD methodology with mandatory failing tests, minimal implementation, quality refactoring, and 80% coverage gating.

Coordinate Crew (persistent) and Polecat (transient) agents using Gas Town's hook-based work distribution and GUPP principle.

Create, track, and land convoys of related beads as primary work orders in the Gas Town multi-agent orchestration framework.

Author TOML-based Formula workflow templates that become Protomolecules and active Molecules in Gas Town's durable workflow system.

Track beads as git-backed issues with persistent attribution, supporting Gas Town's bead lifecycle and convoy progress monitoring.

Process the Refinery merge queue - collect agent work, detect and resolve conflicts, merge in dependency order, and verify integration.

Continuous monitoring using Deacon/Witness patterns for agent health checks, stuck detection, and automated recovery.

Manage agent sessions including initialization, handoffs, revival (seance), and persistent identity for Polecats and Crew agents.

Decompose goals into MEOWs (Molecular Expressions of Work) - trackable atomic units following Gas Town's bead-based work model.

Context window monitoring and budget management. Keeps orchestrator at 15-30% context usage while subagents get full 200k tokens. Provides warnings at thresholds, context-aware summarization triggers, and wave-level budget planning.

YAML frontmatter parsing and manipulation for .planning/ documents. Provides read, write, update, query, and validation operations on frontmatter blocks in GSD markdown artifacts.

Git commit patterns, formats, and conventions for GSD methodology. Provides atomic commits per task, structured commit messages, planning file commits, branch management, and milestone tag operations.

Central utility skill for GSD operations. Provides config parsing, slug generation, timestamps, path operations, and orchestrates calls to other specialized skills. Acts as the unified entry point that the original gsd-tools.cjs provided via its lib/ modules (commands, config, core, init).

Resolve model profile (quality/balanced/budget) at orchestration start and map agents to specific models. Enables cost/quality tradeoffs by selecting appropriate AI models for each agent role.

Roadmap parsing, analysis, and mutation operations for ROADMAP.md. Handles phase and milestone lifecycle including add, insert (decimal), remove, complete, and requirements coverage analysis.

STATE.md reading, writing, and field-level updates. Provides cross-session state persistence via .planning/STATE.md with structured fields for current task, completed phases, blockers, decisions, and quick tasks.

Template loading, variable filling, and scaffolding for all GSD artifacts. Manages 22+ templates covering every document type in the GSD system, from PROJECT.md to milestone archives.

Plan structure validation, phase completeness checks, reference integrity verification, and artifact existence confirmation. Provides the structured verification layer ensuring GSD artifacts are well-formed and complete.

Architect code review with DRY, YAGNI, abstraction, and test coverage principle enforcement

Urgent issue classification, root cause analysis, and fast-path routing for production hotfixes

Capture, validate, query, and sync architectural patterns and design decisions in the knowledge graph

Technical debt management including branch cleanup, doc verification, TODO scanning, and dependency auditing

Interactive PM interview with expertise-adaptive questioning for requirements elicitation

Convert requirements into structured technical specifications with architecture decisions

Break technical specifications into small, implementable stories with dependency ordering

Automated test validation, coverage checking, and quality metrics with aggressive defaults

Fresh adversarial code review with binary PASS/FAIL verdicts, evidence citations, and anchoring bias prevention via fresh reviewer spawning.

Parallel design review by 6 specialist agents (PM, Architect, Designer, Security Design, UX, CTO) with mandatory unanimous approval.

Coordinate external AI tool integration (OpenAI Codex, Google Gemini) for cross-model adversarial review and delegated implementation.

Context priming before work (bd prime) and self-reflection after completion to extract patterns, gotchas, and decisions into the knowledge base.

Execute work units through the rigorous 4-phase Metaswarm cycle (Implement -> Validate -> Adversarial Review -> Commit) with independent quality gate enforcement.

Adversarial plan review by 3 independent reviewers (Feasibility, Completeness, Scope & Alignment) before presenting to user.

Monitor PR lifecycle from creation through merge including CI monitoring, review comment handling, thread resolution, and merge readiness verification.

Decompose implementation plans into discrete work units with enumerated DoD items, file scope declarations, dependency mapping, and human checkpoint flags.

Bug condition/postcondition formalization as testable Behavior Contracts. Defines invariants that must be preserved across fixes.

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

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

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

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

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

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

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

Verify all phases are complete with weighted quality scoring before allowing session exit.

Log all errors with full context, detect patterns, and suggest approach mutations to avoid repeated failures.

Capture and persist research findings, discoveries, and decision rationale to findings.md.

Create a structured task_plan.md with phases, goals, and checkbox tracking for persistent planning.

Maintain progress.md with session logs, test results, error records, and phase status indicators.

Detect and recover previous planning sessions, reconstructing lost context from persistent planning files.

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

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

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

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

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

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

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

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

Structured debugging methodology using hypothesis-driven investigation, log analysis, and bisection to isolate and resolve defects.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Use when implementing any feature or bugfix, before writing implementation code. Enforces RED-GREEN-REFACTOR cycle.

Use when starting feature work that needs isolation from current workspace or before executing implementation plans.

Use when starting any conversation. Establishes how to find and use skills, requiring skill invocation before any response.

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs. Evidence before assertions.

Use when you have a spec or requirements for a multi-step task, before touching code. Creates bite-sized TDD implementation plans with dependency tracking.

Use when creating new skills, editing existing skills, or verifying skills work before deployment.

Microsoft AutoGen multi-agent configuration for conversational AI systems

Chain-of-thought and step-by-step reasoning prompts for complex problem solving

Chroma local vector database setup and operations for development and production

Constitutional AI and safety guardrail prompts for aligned LLM behavior

Content moderation API integration using OpenAI Moderation, Perspective API, and others

CrewAI multi-agent orchestration setup for collaborative AI systems

Entity and fact extraction for user profiling and personalization

Few-shot example generation and optimization for improved LLM performance

Guardrails AI validation framework setup for LLM applications. Implement input/output validation, safety checks, and structured output enforcement.

Haystack NLP pipeline configuration for document processing and QA

Hugging Face transformer model fine-tuning and inference for intent classification

LangChain chain composition including SequentialChain, RouterChain, and LCEL patterns

LangChain memory integration including ConversationBufferMemory, ConversationSummaryMemory, and vector-based memory

LangChain ReAct agent implementation with tool binding for reasoning and action loops

LangChain retriever implementation with various retrieval strategies for RAG applications

LangChain tool creation and integration utilities for agent systems

LangFuse LLM observability integration for tracing, analytics, and cost tracking

LangGraph checkpoint and persistence configuration for stateful workflow management

Human-in-the-loop integration for LangGraph workflows with approval and intervention points

Conditional edge routing and state-based transitions for LangGraph workflows

LangGraph StateGraph builder with state schema design. Create stateful agent workflows with cycles, conditionals, and persistence.

Subgraph composition and modular workflow design for LangGraph

LangSmith tracing and debugging setup for LLM applications. Configure observability, capture traces, and enable debugging for LangChain/LangGraph agents.

LlamaIndex agent and query engine setup for RAG-powered agents

LLM-based zero-shot and few-shot classification for flexible intent detection

Mem0 memory layer integration for AI agents. Implement persistent, semantic memory for long-term context retention and personalization.

Conversation summarization for memory compression and context management

Milvus distributed vector database configuration for large-scale RAG applications

NVIDIA NeMo Guardrails configuration for conversational safety and control

OpenTelemetry instrumentation for LLM applications with distributed tracing

Arize Phoenix observability platform setup for LLM debugging and evaluation

PII detection and redaction utilities for privacy-compliant conversational AI

Pinecone vector database setup, configuration, and operations for RAG applications

Token-efficient prompt compression techniques for cost optimization

Prompt injection detection and prevention for secure LLM applications

Structured prompt template creation with variables, formatting, and version control

Qdrant vector database with filtering, payloads, and quantization support

Document chunking with multiple strategies including semantic, recursive, and fixed-size chunking

Batch embedding generation with caching, rate limiting, and multiple provider support

Hybrid search combining semantic and keyword retrieval for RAG pipelines. Implement BM25 + dense vector search with fusion strategies.

Query expansion, HyDE, and multi-query generation for improved retrieval

Cross-encoder reranking and MMR diversity filtering for improved retrieval quality

Rasa NLU pipeline configuration and training for intent and entity extraction

Redis backend for conversation state persistence and caching

Microsoft Semantic Kernel planner and plugin setup for orchestrated AI

SetFit few-shot learning for efficient intent classification with minimal data

spaCy NER model training and entity extraction for conversational AI

Weaviate vector database setup with GraphQL queries and hybrid search

Zep memory server integration for long-term conversation memory and user profiling

Provide implementations of advanced data structures

Generate visual representations of algorithm execution

Interface with AtCoder for Japanese competitive programming contests

Profile code performance and identify bottlenecks

Manage and generate competitive programming templates

Interface with Codeforces API for contest data, problem sets, and submissions

Calculate combinatorial values with modular arithmetic

Automated Big-O complexity analysis of code and algorithms. Performs static analysis of loop structures, recursive call trees, space complexity estimation, and amortized analysis with detailed derivation documents.

Track progress through CSES Problem Set with structured learning

Select optimal data structure based on operation requirements

Apply advanced DP optimizations automatically

Maintain and match against a library of classic dynamic programming patterns. Provides pattern matching, template code generation, variant detection, and problem-to-pattern mapping for DP problems.

Assist in designing optimal DP states and transitions

Model optimization problems as network flow problems

Implement computational geometry algorithms

Provide robust computational geometry primitives

Select optimal graph algorithm based on problem constraints

Convert problem descriptions into graph representations

Curated bank of interview problems organized by company, pattern, and difficulty. Provides problem recommendations, coverage tracking, weak area identification, and premium problem alternatives for FAANG interview preparation.

Simulate realistic coding interview experience

Identify and verify loop invariants for correctness proofs

Fetch and parse LeetCode problems with metadata, constraints, examples, hints, difficulty ratings, and related problems. Integrates with LeetCode API for comprehensive problem data retrieval.

Apply language-specific micro-optimizations

Provide number theory algorithm implementations and guidance

Generate optimized prime sieves and factorization routines

Assist in constructing algorithm correctness proofs

Generate customized segment tree implementations

Compare multiple solutions for correctness and performance

Generate clear explanations of algorithm solutions

Match string problems to appropriate algorithms

Build and query suffix arrays and related structures

Generate comprehensive test cases including edge cases, stress tests, and counter-examples for algorithm correctness verification. Supports random generation, constraint-based generation, and brute force oracle comparison.

Drive feature development using Outside-In TDD with Hexagonal Architecture. Design emerges through inline code, in-memory fakes, interface extraction, and deferred I/O. Use when building features, writing tests, or structuring backend services. Triggers on: TDD, outside-in, hexagonal, ports and adapters, emergent design, acceptance test, component test, walking skeleton, in-memory fakes, component, contract test, adapter, fast tests, sub-second feedback. Language-agnostic (Go, Rust, Python, TypeScript, Java, C#).

Generate argparse-based Python CLI applications with subparsers, type converters, and standard library patterns. Creates lightweight Python CLIs without external dependencies.

Generate argument validation logic with type coercion, constraints, custom validators, and helpful error messages for CLI applications.

Generate bash script templates with best practices including error handling, argument parsing, logging, and portability considerations.

Generate BATS test structure and fixtures for shell script testing with setup/teardown, assertions, and mocking.

Generate blessed widgets for Node.js terminal UIs with boxes, lists, forms, and dashboard layouts.

Generate Bubble Tea (Go) TUI application structure with models, commands, and views using the Elm architecture.

Create consistent chalk-based color and styling system for CLI output with themes, semantic colors, and formatting utilities.

Generate Chocolatey package for Windows CLI distribution.

Generate Clap-based Rust CLI applications with derive macros, subcommands, and modern Rust patterns. Creates production-ready Rust CLI with proper cargo structure.

Set up E2E test harness for CLI applications with process spawning and assertions.

Create mock stdin utilities for interactive CLI testing.

Configure cli-progress with custom formatters, multi-bar support, and ETA calculations for CLI progress indication.

Set up snapshot testing for CLI output with update workflows and diff reporting.

Generate table formatters for structured CLI output with column alignment, borders, and responsive sizing.

Generate Click-based Python CLI applications with decorators, groups, context, and modern Python patterns. Creates complete scaffolded CLI with proper project structure.

Generate Cobra/Viper-based Go CLI applications with persistent flags, subcommands, and configuration management. Creates production-ready Go CLI with modern patterns.

Configure code signing for macOS and Windows binaries with notarization.

Generate Commander.js CLI project structure with TypeScript, commands, options, and best practices. Creates a complete scaffolded CLI application ready for development.

Generate configuration file migration utilities for version upgrades.

Generate Zod/JSON Schema configuration validators with defaults and error messages.

Set up cosmiconfig for hierarchical configuration loading from multiple sources and formats.

Configure cross-env for cross-platform environment variable setting in npm scripts and CLI commands.

Generate cross-platform path handling utilities for Windows, macOS, and Linux compatibility in CLI applications.

Integrate dotenv for environment variable loading with validation and type coercion.

Handle text encoding across platforms including UTF-8, Windows codepages, and BOM handling.

Generate environment variable to CLI argument mapping with prefix support, type conversion, and fallback chains for configuration.

Generate getopts-based argument parsing for shell scripts with short/long options and validation.

Set up goreleaser for Go release automation with cross-compilation and publishing.

Generate formatted help text with examples, descriptions, sections, and consistent styling for CLI applications.

Generate Homebrew formula for CLI distribution on macOS and Linux.

Generate Ink (React for CLI) components for terminal UIs with hooks, state management, and layout components.

Generate interactive command-line prompts using Inquirer.js with validation, conditional logic, and custom renderers. Creates user-friendly input collection flows for CLI applications.

Normalize line endings for cross-platform file handling with CRLF/LF conversion and git configuration.

Generate MCP capability declarations from tool and resource inventory with proper versioning and feature flags.

Map application errors to MCP error codes with proper messages, error types, and recovery suggestions.

Set up MCP Inspector for debugging and testing MCP servers with request logging, response inspection, and protocol validation.