Review Code Plan Satisfaction
Review implementation fidelity against `PLAN.md` and `AMENDMENTS.md`; emit `PS#` findings and validation-fact gaps into the task packet.
Demo Recording
Explore a real site/feature with agent-browser, record per-scene screen clips + artifacts, then generate a CapCut-ready script grounded in the captured files. Includes retake workflow.
Atelier Orchestrator
Orchestrate the full atelier workflow in one task window using pi teams runtime teams plus predefined agents, spawning right-side worker panes only when a phase is active and routing review loops until acceptance while preserving planner/implementer live context. Use when running discovery→plan→implement→review→distill as a lead agent from one orchestrator window, including initiative work that m…
Interview Me
Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
Write A Prd
Create a PRD through user interview, codebase exploration, and module design, then save it as a local artifact under a dedicated .prd folder.
Design Child Contract
Compare 2-3 materially different child-level contract/interface shapes and write the chosen direction into `CONTRACT_DECISION.md` before planning when local contract shape is ambiguous.
Edit Article
Edit and improve articles by restructuring sections, improving clarity, and tightening prose. Use when user wants to edit, revise, or improve an article draft.
Ubiquitous Language
Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions "domain model" or "DDD".
Development Task Planner
Plan development tasks into clear, low-risk, reviewable increments. Use when the user wants an implementation plan, breakdown of a coding task, sequencing for a feature or refactor, migration planning, validation strategy, or a roadmap that stays maintainable and easy to review.
Prd To Plan
Turn a PRD into a multi-phase implementation plan using tracer-bullet vertical slices, saved as a local plan artifact alongside the PRD.
Improve Codebase Architecture
Explore a codebase to find opportunities for architectural improvement, focusing on making the codebase more testable by deepening shallow modules. Use when user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more AI-navigable.
Agent Browser
Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to…
Request Refactor Plan
Create a detailed refactor plan with tiny commits via user interview, then save it as a local refactor RFC. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.
Review Agents Tree
Audit the tracked `AGENTS.md` tree against best practices, write `.agents/AGENTS_TREE_REVIEW.md`, and propose cleanup, compaction, conflict resolution, or sharding when needed. May auto-apply only trivial non-semantic hygiene fixes.
Electron
Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using agent-browser via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, control a native app, or test an Electron application. Triggers include "automate Slack app", "control VS Code", "interact with Discord app", "test this E…
Video Production
Turn a video brief into a CapCut-ready production script by asking up to 8 high-signal clarification questions (one at a time), then generating a scene-by-scene timeline with exact timings, track layout, and actionable editing steps.
Tdd
Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.
Design An Interface
Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".
Plan Task
Plan a development task into a self-sufficient execution contract stored in `.plans/<task-slug>/` for later fresh-context implementation and review.
Plan Reviewer Agent
Review a written plan for ambiguity, hidden assumptions, missing context, and handoff readiness. Use when the user provides a plan that must be clear, self-sufficient, standards-compliant, and safe to hand to another agent in a fresh context window with no extra explanation.
Hydrate Child Packet
Create an initiative child task packet in the selected child row's `Packet Root` at `.plans/<task-slug>/` with imported context, placeholder plan ownership, and packet-phase bootstrap metadata before planning begins.
Gitlab Mr
Create focused GitLab merge requests with `glab`. Use when code changes are already implemented in a Git repository and Codex needs to inspect git state, isolate only the intended files, create or reuse a feature branch, run the repo's required validation commands, commit cleanly, push to `origin`, and open a merge request in GitLab.
Sync Initiative
Fold a child loop back into the parent initiative packet, update canonical parent truth, record the sync log, and route the next durable-distill timing decision.
Distill Knowledge
Curate durable residue from a completed task packet into canonical tracked `AGENTS.md` files or choose an explicit no-op.
Code Implementer Agent
Implement development tasks in safe, reviewable increments. Use when the user wants code changes executed with clear sequencing, validation, maintainability guardrails, and alignment with later code review.
Review Code Maintainability
Review implementation for maintainability, evolvability, anti-slop, and human complexity; emit `M#` findings and durable residue candidates when needed.
Review Initiative Split
Blind-review `TASK_GRAPH.md` and optional `SPLIT_OPTIONS.md`, then write `SPLIT_REVIEW.md` with a ready/not_ready verdict before any child packets are hydrated.
Prd To Issues
Break a PRD into independently grabbable implementation issues using tracer-bullet vertical slices, saved as local issue files alongside the PRD.
Split Initiative
Turn a framed initiative into a reviewed child-task graph in `TASK_GRAPH.md`, using vertical slices, explicit dependencies, canonical child statuses, and reviewable child boundaries.
Code Reviewer Agent
Review code changes for correctness, regressions, edge cases, maintainability, and testing gaps. Use when the user asks for a review, asks whether an implementation is correct, wants a regression scan, wants a second pass after fixes, or wants findings-first feedback on a diff, patch, PR, commit, or uncommitted workspace changes.
Stabilize Initiative Language
Populate `UBIQUITOUS_LANGUAGE.md` inside an initiative packet with canonical terms, aliases to avoid, flagged ambiguities, and term relationships before decomposition hardens.
Extract Artifact Candidates
Mine the current chat/history for forgotten durable-residue candidates and backfill `.plans/<task>/ARTIFACT_CANDIDATES.md` without touching tracked `AGENTS.md`. Use when implementation/debugging ran long, candidate capture was likely missed, or a human wants a manual mid-task history harvest.
Caveman Review
>
Triage Issue
Triage a bug or issue by exploring the codebase to find root cause, then write an issue document in a local .issues folder with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions "triage", or wants to investigate and plan a fix for a problem.
Implement Task
Implement a planned task from `.plans/<task-slug>/` with strict plan adherence, explicit amendments, and no direct writes to tracked `AGENTS.md`.
Write A Skill
Create new agent skills with clear triggers, compact instructions, and optional bundled references or helper scripts. Use when user wants to create, write, design, refine, or package a reusable skill.
Frame Initiative
Create a parent initiative packet under `.initiatives/<initiative-slug>/` with the canonical file tree, seeded shared-context docs, placeholder-owned files, and initial routing fields before split work begins.
Review Plan
Review `PLAN.md` as a blind-handoff execution contract; emit `P#` findings into the task packet and block plans with ambiguity, hidden assumptions, poor artifact hygiene, or missed durable-residue calls.
Rebase
Rebase the current branch with smart conflict resolution.
Adhoc Teammate
Manually spawn a one-off teammate after listing available models and proposing the best provider, model, and thinking level for the task. Use when manually invoked to create an ad hoc worker for focused implementation, research, review, or planning.
Compress
>
Grill Me
Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree one decision at a time. Use when a task is under-specified, a design needs stress-testing, or the user asks to be grilled.
Design Split Options
Compare 2-3 materially different initiative decompositions in `SPLIT_OPTIONS.md` when task boundaries or sequencing are still ambiguous before authoring `TASK_GRAPH.md`.
Obsidian Vault
Search, create, and manage notes in the Obsidian vault with wikilinks and index notes. Use when user wants to find, create, or organize notes in Obsidian.