continuous-agent

The SOLE WRITER to the V3.0 mem0 second brain. Invoked agentically by the executive at write moments — post-run, post-retro, post-spec-merge, manual /harvest. Decides which facts to classify into which memory type (principle/semantic/procedural/episodic/reflective), validates against the schema, and calls the deterministic plumbing in references/ via Bash. Blocks until writes are durable (poll event endpoint for SUCCEEDED). Never invoked from worker code.

Consult the V3.0 mem0 second brain agentically during executive planning, work selection, pre-spawn memory pack building, and failure diagnosis. Use this skill whenever the executive needs to remember prior runs, retros, or learned principles. Read-only — never writes. Drives the unified `mem0` CLI via Bash, orchestrating multiple iterative search queries (mem0 does not do multi-hop graph traversal natively, so iterative search IS the multi-hop).

Hook D — Failure-Diagnosis memory consultation. Runs at executive Phase 7 (after 3+ consecutive failures on a work item) BEFORE the failure-diagnosis skill itself runs. Consults the second brain for similar prior failures and successful retry strategies, then hands enriched context to the failure-diagnosis skill. Read-only. Invokes the memory-reader skill.

Hook E — Post-Retrospective Harvest. Runs after a retrospective markdown doc completes (per-run or weekly). Reads the retro fully and decides which durable lessons (reflective, semantic, procedural memories) to write to the second brain. Typically 3–8 writes per weekly retro, 0–3 per per-run retro. Invokes the memory-harvester skill for the actual writes.

Hook C — Post-Run Harvest. Runs after a worker completes (executive Phase 6 success path). Decides agentically which facts from the run to write to the second brain — typically 0–3 memory writes per run (one episodic, optionally a semantic or procedural). Invokes the memory-harvester skill to do the actual writes (with event-polling for durability).

Hook B — Pre-Spawn Memory Pack build. Runs before each worker spawn (executive Phase 4 prep). Reads the second brain for project-specific memories and produces a Memory Pack markdown block that worker-spawner injects into the worker's generated CLAUDE.md. Workers consume this as static markdown — they never call mem0 themselves. Read-only. Invokes the memory-reader skill.

Hook A — Pre-Work-Selection memory consultation. Runs at the top of the executive loop's Phase 3, before work-selection picks the next item. Reads the second brain for prior-run lessons, retros, and principles that should influence which goal the executive picks. Read-only. Invokes the memory-reader skill to do the actual retrieval.

Daily backup of the V3.0 mem0 second brain to versioned JSON in the repo. Invoked by PM2 cron (04:00 daily) or manually. Uses paginated search (NOT getAll, which is broken in v3) to enumerate every memory under the executive's user_id, captures history per memory, writes ai-docs/v3/mem0-snapshots/{YYYY-MM-DD}.json. This is the disaster-recovery store and the rebuild-from-snapshot input.

GitHub Actions CICD for Azure Functions (Node.js). Builds, packages, and deploys via Azure/functions-action@v1 with OIDC auth. Reuses a shared continuous-agent App Registration so each new project just adds its own federated credential + role assignment. Use when the goal involves wiring CI/CD for an Azure Functions project, adding a deploy workflow, or setting up GitHub Actions for an existing Azure Functions app.

Draft comprehensive goal bundles for the autonomous agent. Creates PROMPT.md with proper frontmatter, requirements docs, and reference files in workspace/drafts/. Use when: the user describes a project to build, says "create a goal", "draft a goal", "/goal-drafter", or wants to prepare work for the executive loop. This is a human-facing skill for authoring goals before the agent executes them.

Core worker instructions for all autonomous agent workers. Includes constitution limits, workspace rules (worktree default, monorepo legacy), navigation protocol, technology preferences, and execution guidelines. Loaded for EVERY worker task regardless of type or vendor.

Implement AEM Edge Delivery Services blocks and core functionality. Handles block development (new or modified), core functionality changes (scripts.js, styles, delayed.js), or both. Invoked by `eds-content-driven-development` during its implementation step, or directly when a step's deliverable is EDS code. Adapted from Adobe's `building-blocks` skill (Apache-2.0).

Apply a Content Driven Development (CDD) process to AEM Edge Delivery Services development. Use for ALL EDS code changes — new blocks, block modifications, CSS styling, bug fixes, core functionality (scripts.js, styles, etc.), or any JavaScript/CSS work that needs validation. Adapted from Adobe's `content-driven-development` skill (Apache-2.0).

Mandatory visual testing protocol for all web projects using playwright-cli. Enforces pre-flight site health check and post-build visual verification. Use when building any web UI (Next.js, React, Vue, Angular, HTML/CSS).

Curl-based API smoke testing for backend work. No browser required. Use when building or editing API routes, serverless functions, express endpoints, database layer, or any work where the deliverable is a callable endpoint rather than a UI. Complements web-testing — do not replace it for UI work.

Independent validator worker for integration gates. Walks the full user journey, runs E2E regression as a blocking gate, and files structured defect reports that the executive loop converts into subtasks running before the next sibling step. Modelled on the generic-harness-v2026-01-v2 validate_prompt.md pattern.

Parse and classify enhancement specifications, then dispatch to the right specialist agents

Converts research into a compelling NotebookLM-style conversational podcast script

Generates scenario-based multiple-choice quiz questions from research content

Researches a topic using web search and documentation, producing structured reference notes

Fetches a web page and extracts structured content — key facts, code examples, definitions, and best practices

Cross-references multiple research documents to identify themes, gaps, conflicts, and priority rankings

Breaks a structured document into a hierarchical topic tree with estimated complexity ratings

Generates a React + ShadCN/ui study application with podcast player, quiz, teach-back, and research browser — driven by Stitch design reference

Uses a reusable Playwright test spec to validate the generated study environment UI end-to-end

Structured git commit skill for all agents and humans. Use when: committing code changes, the user says "commit", "/jack-git-commit", a worker completes a task and needs to commit, or any agent needs to record work in git. Generates Conventional Commit messages with traceable metadata footers (Goal, Step, Worker) so git log serves as a self-documenting work ledger. Enforces atomic commits, staged-only policy, and NEVER pushes.

Decompose complex goals into concrete, actionable steps. Use when a goal exceeds the breakdown threshold (~100 estimated turns) and needs to be split into independently executable worker sessions. Adapts step count based on complexity estimate.

Monitor the continuous-agent executive loop running via PM2. Checks PM2 process health, tails executive and worker logs from ledgers/, inspects ai-sandbox for worker output progress, reviews goal bundles in workspace/, and surfaces issues from needs-you.md. Use when the user says "monitor agent", "check the agent", "how's the agent doing", or wants a status report on the running autonomous system.

Investigate why a worker task is failing repeatedly. Analyze validation reports and worker logs to determine root cause, decide whether to retry with a different approach or escalate to human. Use after 3+ consecutive failures on the same goal.

Triage inbound emails for the executive agent's mailbox. Classify each email as actionable (queue for processing), reply-worthy (human needs guidance), or noise (archive silently). Use during Phase 0.5 inbox check when the agent receives unread emails.

Central orchestrator running continuously via PM2 to select and delegate work. Use when operating as the main executive agent, running the 8-phase loop (health, inputs, selection, contract, execute, validate, update, sleep), delegating tasks to workers, managing retry logic, or enforcing constitutional limits. Entry point for continuous agent operation.

Run practice tasks when idle to improve skill confidence. Use when no primary work items are available, waiting for human input, in rate limit cooldown, skills blocking P0/P1 goals have low confidence, skills have maturity=Declared, or skills unused >30 days.

Create valid task contracts between Executive and Worker. Use when preparing work for execution, classifying intent (outcome_only, what_only, what_and_how), defining verifiable Definition of Done criteria, assessing risk levels, or scoping allowed operations. Rule: No work without a valid task contract.

Generate polished demo videos from Playwright specs with AI voiceover, captions, and music. Use when: creating demo videos for web projects, extracting captions from Playwright specs, generating TTS voiceover with ElevenLabs, merging video with freeze-frame timing, adding background music, auto-discovering project features to generate demo specs. Trigger: "demo video", "playwright demo", "generate demo", "caption extraction", "voiceover pipeline", "freeze frame merge", "auto-discover demo".

Prove `deliver.eds.site` capability through end-to-end execution. Use when validating Edge Delivery Services skills before EDS work, checking aem-cli and GitHub auth availability, establishing baseline confidence, or surfacing Adobe EDS tooling blockers.

Prove `deliver.nextjs.app.basic` capability through end-to-end execution. Use when validating Next.js delivery skills before important work, establishing baseline confidence from evidence, surfacing blockers (tooling, templates), or when nextjs.build.basic confidence is untested or low.

Create Product Requirements Documents (PRDs) that define WHAT to build and WHY. Use when user describes a problem, need, or feature idea that requires documentation before technical design. Creates structured PRDs in ai-docs/ covering problem statement, user needs, success criteria, functional requirements, and constraints. Triggers on requests like "write a PRD for...", "document requirements for...", or when user describes a feature/problem without technical implementation details.

Analyze existing codebases to document tech stack, patterns, and architecture before designing new features. Use when starting work on an unfamiliar codebase, before creating PRDs or architecture docs, when understanding existing patterns is needed, or when documenting current state for future reference. Creates analysis document in ai-docs/project-analysis.md covering tech stack, file structure, key patterns, and architectural decisions. Triggers on "analyze this codebase", "what's the tech stack?", or before major feature work in new projects.

Create comprehensive architectural documentation for complex features or projects requiring multiple components, clear API design, and phase-based implementation. Use when starting complex features (3+ days work) that need system design, component specifications, or multi-phase planning. Creates architecture docs in ai-docs/architect/ defining system components, data flow, API contracts, and implementation phases. Triggers on "design the architecture for...", "create system design for...", or complex feature requests after PRD exists.

Create detailed task specifications with step-by-step implementation instructions for complex features. Use after architecture documents exist, when breaking down multi-phase features into implementable tasks, defining dependencies and duration estimates, or creating detailed HOW-level instructions. Outputs to ai-docs/tasks/ directory. Triggers on "break down this feature into tasks", "create implementation tasks for...", or when detailed execution steps are needed after architectural design is complete.