Complete Guide to Ponytail Slash Commands: Available Commands and Usage

Ponytail exposes six primary slash commands—/ponytail, /ponytail-review, /ponytail-audit, /ponytail-gain, /ponytail-debt, and /ponytail-help—registered programmatically in pi-extension/index.js and defined declaratively via TOML configuration files in the commands/ directory.

The DietrichGebert/ponytail repository provides a modular AI assistant framework that surfaces functionality through standardized Ponytail slash commands. These commands operate through the Pi extension API and as file-based definitions consumed by Claude and Gemini adapters, enabling users to toggle analysis intensity levels and invoke specialized code review skills directly from chat interfaces.

Available Ponytail Slash Commands

Ponytail ships with six distinct slash commands that provide both system control and skill invocation capabilities. According to the source code in pi-extension/index.js (lines 14-71), the following commands are registered via pi.registerCommand:

• /ponytail — The primary control command that switches Ponytail intensity levels (lite, full, ultra, off) or queries current status. Registered at lines 14-47.

• /ponytail-review — Invokes the ponytail-review skill for code analysis. Registered at lines 49-52.

• /ponytail-audit — Triggers the ponytail-audit skill for security and quality auditing. Registered at lines 54-57.

• /ponytail-gain — Executes the ponytail-gain skill. Registered at lines 59-62.

• /ponytail-debt — Runs the ponytail-debt skill for technical debt assessment. Registered at lines 64-67.

• /ponytail-help — Displays help documentation via the ponytail-help skill. Registered at lines 69-72.

Each skill-specific command utilizes the sendAlias helper function (defined at lines 1-12) to forward messages to their corresponding skills using the format /skill:ponytail-review.

How Commands Are Registered

The command registration logic resides in pi-extension/index.js, where the Pi extension API exposes the registerCommand method to bind handlers to command strings.

The implementation distinguishes between the primary toggle command and skill aliases:

// Primary command with argument handling (lines 14-47)
pi.registerCommand('ponytail', {
  description: 'Switch Ponytail mode or query status',
  handler: async (args, ctx) => {
    // Handles 'lite', 'full', 'ultra', 'off', 'status'
  }
});

// Skill aliases using sendAlias helper (lines 49-52)
pi.registerCommand('ponytail-review', {
  description: 'Run the ponytail-review skill',
  handler: sendAlias('/skill:ponytail-review')
});

The sendAlias helper generates a handler that emits the skill invocation message to the underlying AI system, allowing seamless integration with the Pi message bus.

File-Based Command Definitions

In addition to programmatic registration, Ponytail slash commands are defined declaratively through TOML files in the commands/ directory. These definitions provide adapter-specific metadata for Claude, Gemini, and other file-based command consumers:

• commands/ponytail.toml — Base command description and prompt templates
• commands/ponytail-review.toml — Review skill parameters
• commands/ponytail-audit.toml — Audit skill configuration
• commands/ponytail-gain.toml — Gain skill definition
• commands/ponytail-debt.toml — Debt analysis prompts
• commands/ponytail-help.toml — Help system content

This dual-layer approach ensures commands are accessible both through the JavaScript API and static configuration files parsed by adapter implementations.

Working with Ponytail Slash Commands

Switching Intensity Modes

Control Ponytail analysis depth programmatically using the Pi API:

// Enable maximum analysis depth
await pi.runCommand('ponytail', 'ultra');

// Check current configuration
await pi.runCommand('ponytail', 'status');

Valid mode parameters include lite (minimal overhead), full (standard analysis), ultra (comprehensive inspection), and off (disabled).

Invoking Skill Commands

Trigger specific analysis workflows directly:

// Execute code review skill
await pi.runCommand('ponytail-review');

// Run security audit
await pi.runCommand('ponytail-audit');

These calls route through the sendAlias mechanism, translating the command into /skill:ponytail-review messages processed by the AI backend.

Building Custom Integrations

Query Ponytail status within custom extensions:

pi.registerCommand('my-tool', {
  description: 'Show current Ponytail mode',
  handler: async (_, ctx) => {
    const result = await pi.runCommand('ponytail', 'status');
    ctx?.ui?.notify(result);
  },
});

Extending the Command Set

To add new Ponytail slash commands compatible with file-based adapters, create a TOML file in the commands/ directory:

# commands/ponytail-custom.toml

description = "Run custom Ponytail analysis"
prompt = "Execute custom workflow with arguments: {{args}}"

After creating the definition, register the corresponding handler in pi-extension/index.js using the pi.registerCommand API to enable runtime execution.

Summary

• Ponytail provides six built-in slash commands: /ponytail, /ponytail-review, /ponytail-audit, /ponytail-gain, /ponytail-debt, and /ponytail-help.
• Command handlers are registered in pi-extension/index.js (lines 14-71) using the Pi extension API.
• The primary /ponytail command controls intensity modes (lite, full, ultra, off) while other commands trigger specific skills via the sendAlias helper.
• Declarative command definitions reside in TOML files under the commands/ directory for adapter compatibility.
• New commands require both a TOML definition and JavaScript registration in the extension index.

Frequently Asked Questions

What is the difference between /ponytail and the skill-specific commands?

The /ponytail command serves as the primary control interface for managing Ponytail's operational mode and intensity level, accepting arguments like ultra or status. In contrast, skill-specific commands such as /ponytail-review or /ponytail-audit are aliases that immediately trigger their respective analysis workflows without mode switching, routing directly to skills via the sendAlias mechanism in pi-extension/index.js.

How do I check the current Ponytail mode programmatically?

Invoke the status query through the Pi API by passing the status argument to the primary command: await pi.runCommand('ponytail', 'status'). This returns the current intensity configuration (lite, full, ultra, or off) as implemented in the handler at lines 14-47 of pi-extension/index.js.

Can I add custom slash commands to Ponytail?

Yes. Create a new TOML file in the commands/ directory with your command definition, then register a corresponding handler in pi-extension/index.js using pi.registerCommand(). This dual-definition approach ensures compatibility with both the Pi extension API and file-based adapters like Claude and Gemini.

Which adapters support these slash commands?

Ponytail slash commands are supported by the Pi extension API (JavaScript runtime) and file-based adapters that parse TOML definitions, specifically including the Claude and Gemini adapters. The TOML files in commands/ provide the metadata required for these adapters to expose commands in their respective chat interfaces.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}