CLI Commands

pilot start

Start Pilot in polling mode.


pilot start [flags]

Flags

Flag	Description
`--telegram`	Enable Telegram polling (overrides config)
`--github`	Enable GitHub polling (overrides config)
`--gitlab`	Enable GitLab polling (overrides config)
`--linear`	Enable Linear webhooks (overrides config)
`--slack`	Enable Slack Socket Mode (overrides config)
`--discord`	Enable Discord bot (overrides config)
`--plane`	Enable Plane polling (overrides config)
`--env=ENV`	Enable autopilot: `dev`, `stage`, `prod`
`--dashboard`	Show TUI dashboard for real-time task monitoring
`--dashboard-scope`	Scope dashboard metrics: `project` (current project only) or `all` (all projects) (default: `project`)
`-p`, `--project`	Project path (default: config default or cwd)
`--replace`	Kill existing bot instance before starting
`--no-gateway`	Run polling adapters only (no HTTP gateway)
`--sequential`	Sequential execution: wait for PR merge before next issue
`--tunnel`	Enable public tunnel for webhook ingress (Cloudflare/ngrok)
`--team`	Team ID or name for project access scoping
`--team-member`	Member email for team access scoping
`--log-format`	Log output format: `text` or `json` (default: text)
`--i-know-this-is-an-archive`	Override the refusal to start against a ledger marked archived (`LEDGER-ARCHIVED` sentinel)

Examples


# Basic: Telegram + GitHub
pilot start --telegram --github
 
# With autopilot (auto-merge after CI)
pilot start --telegram --github --env=stage
 
# With dashboard
pilot start --telegram --github --dashboard
 
# Sequential execution (wait for merge before next)
pilot start --github --sequential
 
# Production (release automation is config-only: autopilot.release.enabled)
pilot start --github --env=prod
 
# With JSON logging for aggregation systems
pilot start --github --log-format=json
 
# Discord bot + GitHub
pilot start --discord --github
 
# Plane + GitHub
pilot start --plane --github
 
# Full stack: all adapters
pilot start --telegram --github --discord --plane --slack --dashboard

Archived-ledger recovery

--i-know-this-is-an-archive overrides Pilot’s refusal to start against a memory store whose ledger is marked LEDGER-ARCHIVED. This flag is forensics/recovery-only — it exists to let an operator inspect or extract data from an archived ledger, not for routine startup. Do not set it outside a deliberate recovery investigation.

pilot task

Execute a single task.


pilot task "description" [flags]

Flags

Flag	Description
`-p`, `--project`	Project path (default: current directory)
`--dry-run`	Show what would be executed without running
`-v`, `--verbose`	Stream Claude Code output
`--alerts`	Enable alerts for task execution
`--budget`	Enable budget enforcement for this task
`--team`	Team ID or name for project access scoping
`--team-member`	Member email for team access scoping

Examples


# Quick local execution
pilot task "Fix the typo in README.md"
 
# Preview what will happen
pilot task "Refactor auth module" --dry-run
 
# With verbose output
pilot task "Add rate limiting" --verbose
 
# With budget enforcement
pilot task "Implement caching" --budget
 
# Scoped to specific team
pilot task "Update API docs" --team=backend

pilot task cancel

Cancel a task so it stops being re-picked.


pilot task cancel <task-id> [flags]

Marks the task’s latest execution row terminal (status=canceled) so the dispatcher never grants it a fresh generation and the poller never re-dispatches it. This is distinct from the stalled status: stalled means “the owning process died, retry this” and is deliberately re-armed with a fresh generation.

If the task’s latest execution is currently RUNNING, cancel refuses rather than killing the backend process — it prints the execution ID so you can investigate/stop it manually.

For GitHub-backed tasks, a genuine reopen or (re-)label event on the issue after the cancel re-admits the task for a fresh dispatch — merely leaving the issue open/labeled does not. For every other adapter, cancel is permanent for that task ID; file a new issue/task to re-run the work.

Flags

Flag	Description
`-p`, `--project`	Project path (default: current directory)
`--reason`	Operator reason recorded on the cancelled execution

Examples


# Cancel a task
pilot task cancel TASK-12345
 
# Cancel with a reason
pilot task cancel TASK-12345 --reason "duplicate of TASK-12300"
 
# Cancel a task in a specific project
pilot task cancel TASK-12345 --project /path/to/project

pilot upgrade

Self-update to latest version.


pilot upgrade [subcommand]

Subcommands

Subcommand	Description
`check`	Check for available updates
`run`	Download and install the latest version (default)
`rollback`	Restore the previous version from backup

pilot upgrade check

Check for updates without installing.


pilot upgrade check [flags]

Flag	Description
`--json`	Output as JSON

pilot upgrade run

Download and install the latest version.


pilot upgrade run [flags]

Flag	Description
`-f`, `--force`	Skip waiting for running tasks
`-y`, `--yes`	Skip confirmation prompt

pilot upgrade rollback

Restore the previous Pilot version from backup created during upgrade.


pilot upgrade rollback

Examples


# Check for updates only
pilot upgrade check
 
# Upgrade (with confirmation)
pilot upgrade
 
# Upgrade without confirmation
pilot upgrade run --yes
 
# Force upgrade, skip task wait
pilot upgrade run --force
 
# Restore previous version
pilot upgrade rollback

pilot init

Initialize Pilot configuration.


pilot init [flags]

Creates ~/.pilot/config.yaml with interactive prompts.

Flags

Flag	Description
`--force`	Reinitialize config (backs up existing to .bak)

pilot doctor

Check system health and configuration.


pilot doctor [flags]

Shows what’s working, what’s missing, and how to fix issues.

Flags

Flag	Description
`-v`, `--verbose`	Show detailed output with fix suggestions

Examples


# Run all checks
pilot doctor
 
# Show detailed output
pilot doctor --verbose

pilot logs

View task execution logs.


pilot logs [task-id] [flags]

Without arguments, shows recent task logs. With a task ID, shows detailed logs for that specific task.

Flags

Flag	Description
`-n`, `--limit`	Number of recent tasks to show (default: 10)
`-f`, `--follow`	Follow log output (not yet implemented)
`-v`, `--verbose`	Show detailed output
`--json`	Output as JSON

Examples


# Show recent task logs
pilot logs
 
# Show last 20 tasks
pilot logs --limit 20
 
# Show logs for specific task
pilot logs TASK-12345
 
# Show logs for GitHub issue task
pilot logs GH-15
 
# JSON output
pilot logs --json

pilot status

Show Pilot status and running configuration.


pilot status [flags]

Displays current configuration state including gateway address, enabled adapters, and configured projects.

Flags

Flag	Description
`--json`	Output as JSON for programmatic access

Output

The command displays:

Gateway: HTTP endpoint address (host:port)
Adapters: Status of each adapter (Linear, Slack, Telegram, GitHub)
Projects: Configured project paths with context intelligence detection

Examples


# Show human-readable status
pilot status
 
# Output as JSON (for scripts)
pilot status --json
 
# Parse JSON with jq
pilot status --json | jq '.adapters'

Sample Output


📊 Pilot Status
───────────────────────────────────────
Gateway: http://localhost:8080

Adapters:
  ✓ Telegram (enabled)
  ○ Linear (disabled)
  ○ Slack (disabled)
  ✓ GitHub (enabled)

Projects:
  • pilot: /Users/dev/pilot [Context]
  • webapp: /Users/dev/webapp

pilot stop

Stop the running Pilot daemon.


pilot stop

SIGTERMs the running daemon (found via its single-instance lock file) and waits (up to 30s) until the lock is confirmed released. Takes no flags.

Examples


# Stop the running daemon
pilot stop

pilot restart

Restart the Pilot daemon (stop the running instance, then start).


pilot restart [-- start-flags...]

Stops the running Pilot daemon (same as pilot stop) and, once its single-instance lock is confirmed released, execs into pilot start in the current process — taking over the current terminal exactly as a fresh pilot start would. Because of this, pilot restart needs a real TTY and should be run in the operator’s own terminal, not a background/assistant shell.

Flags after restart (or after --) are forwarded verbatim to pilot start.

Examples


# Restart with the same adapters as before
pilot restart --dashboard --github --telegram --replace

Setup & Configuration

pilot setup

Interactive setup wizard for Pilot configuration.


pilot setup [flags]

Guides you through configuring Pilot step by step, including Telegram bot, projects, voice transcription, daily briefs, and alerts.

Flags

Flag	Description
`--skip-optional`	Skip optional features (voice, briefs, alerts)
`--tunnel`	Set up Cloudflare Tunnel for webhooks
`--no-sleep`	Disable Mac sleep for always-on operation (macOS only, requires sudo)

Setup Steps

Telegram Bot - Configure bot token and chat ID
Projects - Add project paths with automatic context intelligence detection
Voice Transcription (optional) - Configure OpenAI Whisper API
Daily Briefs (optional) - Set up scheduled status reports
Alerts (optional) - Enable failure notifications

Examples


# Full interactive setup
pilot setup
 
# Quick setup (skip optional features)
pilot setup --skip-optional
 
# Set up Cloudflare Tunnel for webhooks
pilot setup --tunnel
 
# Disable Mac sleep for always-on server
pilot setup --no-sleep

pilot onboard

Interactive onboarding wizard.


pilot onboard

Guides you through configuring Pilot for your workflow: persona selection (Solo, Team, Enterprise), project setup, ticket source configuration, notification settings, and optional features (for Team/Enterprise). Takes no flags.

Examples


# Start interactive onboarding
pilot onboard

pilot config

Manage Pilot configuration.


pilot config <subcommand>

View, edit, and validate the Pilot configuration file.

Subcommands

Subcommand	Description
`show`	Display current configuration
`edit`	Open config in editor
`validate`	Validate configuration syntax
`path`	Show config file path

pilot config show

Display current configuration.


pilot config show [flags]

Outputs the full configuration in YAML or JSON format.

Flags

Flag	Description
`--json`	Output as JSON instead of YAML

Examples


# Show config as YAML
pilot config show
 
# Show config as JSON
pilot config show --json
 
# Pipe to tools
pilot config show --json | jq '.projects'

pilot config edit

Open configuration in your default editor.


pilot config edit

Opens ~/.pilot/config.yaml in your editor. Uses $EDITOR environment variable, falling back to vim, nano, or vi.

After editing, the configuration is automatically validated.

Editor Selection

$EDITOR environment variable
$VISUAL environment variable
vim (if available)
nano (if available)
vi (if available)

Examples


# Open in default editor
pilot config edit
 
# Use specific editor
EDITOR=code pilot config edit
EDITOR=nano pilot config edit

pilot config validate

Validate configuration syntax and structure.


pilot config validate [flags]

Checks YAML syntax and validates configuration structure. Reports warnings for common issues like missing tokens or non-existent project paths.

Flags

Flag	Description
`-q`, `--quiet`	Exit with code 1 on error, no output

Validation Checks

YAML syntax validity
Configuration structure
Enabled adapters have required tokens
Project paths exist on filesystem

Examples


# Validate with full output
pilot config validate
 
# Silent validation for scripts
if pilot config validate --quiet; then
  echo "Config OK"
else
  echo "Config invalid"
fi

Sample Output


Config: ~/.pilot/config.yaml

Syntax:     OK
Validation: OK

Warnings:
  - GitHub enabled but token not set
  - Project path does not exist: /old/project

pilot config path

Show the configuration file path.


pilot config path

Outputs the absolute path to the configuration file. Useful for scripts and automation.

Examples


# Show path
pilot config path
# Output: /Users/dev/.pilot/config.yaml
 
# Use in scripts
cat "$(pilot config path)"
 
# Back up config
cp "$(pilot config path)" config-backup.yaml

pilot completion

Generate shell completion scripts.


pilot completion <shell>

Generates autocompletion scripts for bash, zsh, fish, or PowerShell.

Supported Shells

Shell	Description
`bash`	Bash completion script
`zsh`	Zsh completion script
`fish`	Fish completion script
`powershell`	PowerShell completion script

Installation

Bash:


# Load for current session
source <(pilot completion bash)
 
# Install permanently (Linux)
pilot completion bash > /etc/bash_completion.d/pilot
 
# Install permanently (macOS with Homebrew)
pilot completion bash > $(brew --prefix)/etc/bash_completion.d/pilot

Zsh:


# Enable completion (if not already enabled)
echo "autoload -U compinit; compinit" >> ~/.zshrc
 
# Install completion
pilot completion zsh > "${fpath[1]}/_pilot"
 
# Start new shell for changes to take effect

Fish:


# Load for current session
pilot completion fish | source
 
# Install permanently
pilot completion fish > ~/.config/fish/completions/pilot.fish

PowerShell:


# Load for current session
pilot completion powershell | Out-String | Invoke-Expression
 
# Install permanently (add to profile)
pilot completion powershell > pilot.ps1
# Then source from PowerShell profile

Information

pilot version

Show Pilot version information.


pilot version

Displays the current Pilot version and build time.

Examples


pilot version
# Output:
# Pilot v2.151.0
# Built: 2026-05-26T00:00:00Z

pilot backend

Manage execution backends (Claude Code, Qwen Code, OpenCode).


pilot backend <subcommand>

List supported backends, check their status, and switch the active backend.

Subcommands

Subcommand	Description
`list`	List all supported backends
`status`	Show current backend configuration
`set`	Set active backend

pilot backend list

List all supported backends and whether their CLI is installed.


pilot backend list

Takes no flags.

Examples


pilot backend list
# Backend        Status      Command    Config
# claude-code    ✓ installed claude     (default)
# qwen-code      ✗ missing   qwen
# opencode       ✓ installed opencode

pilot backend status

Show current backend configuration and health.


pilot backend status

Takes no flags.

Examples


pilot backend status
# Active backend: claude-code
# Command: claude
# Version: 1.0.26
# Status: ✓ ready

pilot backend set

Set the active backend.


pilot backend set <type>

Valid types: claude-code, qwen-code, opencode. Updates executor.type in the config file and verifies the corresponding CLI is installed.

Examples


# Switch to Qwen Code
pilot backend set qwen-code
# Updated executor.type to "qwen-code" in ~/.pilot/config.yaml
# Verified: qwen CLI found at /usr/local/bin/qwen

Execution & Review

Commands for executing tasks and reviewing work history.

pilot github run

Execute a GitHub issue as a Pilot task.


pilot github run <issue-number> [flags]

Fetches a GitHub issue and executes it as a Pilot task. PRs are always created to enable autopilot workflow.

Flags

Flag	Description
`-p`, `--project`	Project path
`--repo`	GitHub repository (owner/repo)
`--dry-run`	Show what would execute without running
`-v`, `--verbose`	Verbose output
`--team`	Team ID or name for project access scoping
`--team-member`	Member email for team access scoping

Examples


# Execute issue #8
pilot github run 8
 
# Execute from specific repository
pilot github run 8 --repo owner/repo
 
# Preview execution
pilot github run 8 --dry-run
 
# With verbose output
pilot github run 8 --verbose

pilot brief

Generate and send daily/weekly briefs.


pilot brief [flags]

Generate and optionally send daily/weekly briefs summarizing Pilot activity.

Flags

Flag	Description
`--now`	Generate and send brief immediately
`--weekly`	Generate a weekly summary

Examples


# Show scheduler status
pilot brief
 
# Generate and send brief immediately
pilot brief --now
 
# Generate a weekly summary
pilot brief --weekly

pilot trace

Render the stage-transition timeline for a task’s executions.


pilot trace <task-id> [flags]

Renders the stage-transition timeline recorded in execution_events for every execution of a task, newest execution first. Retries are rendered as separate blocks; each stage line shows a UTC timestamp and the duration since the previous stage.

task_id is not unique across projects, so the trace is scoped to a single project: --project if given, otherwise the current directory if it matches one of the task’s projects, otherwise (when the task ID only ever ran in one project) that project. If the task ID collides across multiple projects and neither of those resolves it, the candidate projects are listed instead of merged.

Flags

Flag	Description
`-p`, `--project`	Project path to scope the trace to (default: current directory, auto-resolved if unambiguous)

Examples


# Show the stage timeline for task GH-42
pilot trace GH-42
 
# Show the stage timeline for a Navigator task ID
pilot trace TASK-379
 
# Scope to a specific project
pilot trace GH-1 --project /path/to/repo

pilot replay

Replay and debug execution recordings.


pilot replay <subcommand>

View, replay, and analyze execution recordings for debugging and improvement.

Subcommands

Subcommand	Description
`list`	List available recordings
`show`	Show recording details
`play`	Replay execution with interactive viewer
`analyze`	Generate detailed analysis
`export`	Export recording to HTML/JSON/Markdown
`delete`	Delete a recording

pilot replay list

List available execution recordings.


pilot replay list [flags]

Display recordings with filtering options.

Flags

Flag	Description
`--limit`	Maximum number of recordings to show (default: 20)
`--project`	Filter by project name
`--status`	Filter by status (success, error, timeout)

Examples


# List recent recordings
pilot replay list
 
# Show only last 10
pilot replay list --limit 10
 
# Filter by project
pilot replay list --project pilot
 
# Show only failed executions
pilot replay list --status error

pilot replay show

Show detailed information about a recording.


pilot replay show <recording-id>

Display metadata, events summary, and performance metrics for a specific recording.

Examples


# Show recording details
pilot replay show TG-1234567890
 
# Example output includes:
# - Basic info (task ID, duration, token usage)
# - Phase breakdown
# - Tool usage statistics
# - Error summary (if any)

pilot replay play

Replay execution with interactive viewer.


pilot replay play <recording-id> [flags]

Interactive playback of the execution with step-by-step navigation.

Flags

Flag	Description
`--start`	Start from event sequence number
`--stop`	Stop at event sequence number (0 = end)
`-v`, `--verbose`	Show all event details
`--tui`	Use interactive TUI viewer (default: true)
`--speed`	Playback speed (0 = instant, 1 = real-time, 2 = 2x)

Examples


# Interactive replay
pilot replay play TG-1234567890
 
# Start from event 50
pilot replay play TG-1234567890 --start 50
 
# Simple output mode (no TUI)
pilot replay play TG-1234567890 --no-tui
 
# Show verbose details
pilot replay play TG-1234567890 --verbose

pilot replay analyze

Generate detailed analysis of execution recording.


pilot replay analyze <recording-id>

Provides analysis of token usage, phase timing, tool usage patterns, and error diagnostics.

Examples


# Analyze execution
pilot replay analyze TG-1234567890
 
# Output includes:
# - Token usage breakdown by phase
# - Tool usage patterns
# - Performance bottlenecks
# - Error analysis and recommendations

pilot replay export

Export recording to various formats.


pilot replay export <recording-id> [flags]

Export execution recording for sharing or external analysis.

Flags

Flag	Description
`--format`	Output format: html, json, markdown (default: html)
`--output`	Output file path (default: auto-generated)
`--with-analysis`	Include detailed analysis in export

Examples


# Export as HTML
pilot replay export TG-1234567890
 
# Export with analysis
pilot replay export TG-1234567890 --with-analysis
 
# Export as JSON
pilot replay export TG-1234567890 --format json
 
# Export as Markdown
pilot replay export TG-1234567890 --format markdown
 
# Custom output file
pilot replay export TG-1234567890 --output report.html

pilot replay delete

Delete an execution recording.


pilot replay delete <recording-id> [flags]

Remove a recording from the database to free up storage space.

Flags

Flag	Description
`--force`	Skip confirmation prompt

Examples


# Delete with confirmation
pilot replay delete TG-1234567890
 
# Force delete without confirmation
pilot replay delete TG-1234567890 --force

pilot patterns

Manage cross-project patterns.


pilot patterns <subcommand>

View, search, and manage learned patterns across projects.

Subcommands

Subcommand	Description
`list`	List discovered patterns
`search`	Search patterns by keyword
`stats`	Show pattern statistics
`apply`	Apply a pattern to a project
`ignore`	Ignore a pattern

pilot patterns list

List discovered patterns from execution history.


pilot patterns list [flags]

Display patterns learned from successful and failed executions.

Flags

Flag	Description
`--limit`	Maximum number of patterns to show (default: 20)
`--min-confidence`	Minimum confidence score (0.0-1.0, default: 0.5)
`--type`	Pattern type filter (success, error, tool-usage)
`--anti`	Include anti-patterns (things to avoid)

Examples


# List top patterns
pilot patterns list
 
# Show high-confidence patterns only
pilot patterns list --min-confidence 0.8
 
# Show anti-patterns
pilot patterns list --anti
 
# Limit results
pilot patterns list --limit 10

pilot patterns search

Search patterns by keyword or description.


pilot patterns search <query>

Find patterns matching specific keywords or problem descriptions.

Examples


# Search for authentication patterns
pilot patterns search "authentication"
 
# Search for error handling patterns
pilot patterns search "error handling"
 
# Search for specific technologies
pilot patterns search "React hooks"

pilot patterns stats

Display pattern discovery statistics.


pilot patterns stats

Show overview of pattern discovery across projects including:

Total patterns discovered
Confidence distribution
Most common pattern types
Project coverage

Examples


# Show pattern statistics
pilot patterns stats
 
# Example output:
# Total patterns: 247
# High confidence (>0.8): 89 patterns
# Success patterns: 198
# Anti-patterns: 49
# Projects covered: 12

pilot patterns apply

Apply a pattern to a project.


pilot patterns apply <pattern-id> [flags]

Links a pattern to a project so it will be considered during task execution.

Flags

Flag	Description
`-p`, `--project`	Project path (default: current directory)

Examples


# Apply a pattern to the current project
pilot patterns apply pattern-abc123
 
# Apply a pattern to a specific project
pilot patterns apply pattern-abc123 --project /path/to/project

pilot patterns ignore

Ignore a pattern.


pilot patterns ignore <pattern-id> [flags]

By default, ignores the pattern for the current project only (records negative feedback). Use --global to ignore it across all projects, which deletes the pattern entirely.

Flags

Flag	Description
`-p`, `--project`	Project path (default: current directory)
`--global`	Ignore across all projects (deletes the pattern)

Examples


# Ignore a pattern for the current project
pilot patterns ignore pattern-abc123
 
# Delete a pattern globally
pilot patterns ignore pattern-abc123 --global

Monitoring & Billing

Commands for monitoring system usage, billing information, and resource management.

pilot budget

Manage budget settings and enforcement.


pilot budget <subcommand>

Configure and monitor budget limits to control AI usage costs.

Subcommands

Subcommand	Description
`status`	Show current budget status and usage
`config`	Show current budget configuration (read-only)
`set`	Set daily/monthly budget limits
`alert`	Configure alert thresholds and exceed actions
`reset`	Reset the blocked-tasks counter

pilot budget status

Show current budget status and usage.


pilot budget status [flags]

Displays daily/monthly spend, remaining limits, and enforcement settings as a progress-bar TUI.

Flags

Flag	Description
`--user`	Filter by user ID

Examples


# Show budget status
pilot budget status
 
# Show for a specific user
pilot budget status --user alice

pilot budget config

Show the current budget configuration.


pilot budget config

Read-only: prints the active enabled/limits/per-task/on-exceed/threshold settings along with a YAML template you can copy into ~/.pilot/config.yaml. Takes no flags — to change limits, use pilot budget set or pilot budget alert.

Examples


# Show current budget configuration
pilot budget config

pilot budget set

Set daily/monthly budget limits.


pilot budget set [flags]

Updates budget limits in ~/.pilot/config.yaml. Only the flags you pass are changed; omitted flags leave the existing value untouched.

Flags

Flag	Description
`--daily`	Daily budget limit (USD)
`--monthly`	Monthly budget limit (USD)
`--enabled`	Enable budget enforcement

Examples


# Set daily limit to $50
pilot budget set --daily 50
 
# Set monthly limit to $500
pilot budget set --monthly 500
 
# Enable budget enforcement
pilot budget set --enabled
 
# Set both limits and enable enforcement
pilot budget set --daily 100 --monthly 1000 --enabled

pilot budget alert

Configure alert thresholds and actions when budget limits are approached or exceeded.


pilot budget alert [flags]

With no flags, prints the current alert configuration. Actions: warn (log but continue), pause (stop accepting new tasks, finish current), stop (terminate immediately).

Flags

Flag	Description
`--warn-at`	Warning threshold percentage (e.g., 80)
`--on-daily`	Action when daily limit exceeded (`warn`, `pause`, `stop`)
`--on-monthly`	Action when monthly limit exceeded (`warn`, `pause`, `stop`)

Examples


# Warn at 80% usage
pilot budget alert --warn-at 80
 
# Pause on daily limit
pilot budget alert --on-daily pause
 
# Stop on monthly limit
pilot budget alert --on-monthly stop
 
# Late warning, warn only
pilot budget alert --warn-at 90 --on-daily warn

pilot budget reset

Reset the blocked-tasks counter and resume execution if paused due to daily limits.


pilot budget reset [flags]

Clears the blocked-tasks counter and daily-pause status. Requires --confirm; without it, prints a warning and makes no changes.

Flags

Flag	Description
`--confirm`	Confirm the reset operation

Examples


# Preview what reset would do (no changes made)
pilot budget reset
 
# Reset the blocked-tasks counter
pilot budget reset --confirm

pilot metrics

System performance and usage metrics.


pilot metrics <subcommand>

View detailed metrics about Pilot performance, token usage, and system efficiency.

Subcommands

Subcommand	Description
`summary`	Show high-level metrics summary
`daily`	Show daily metrics breakdown
`projects`	Show per-project metrics
`export`	Export metrics data

pilot metrics summary

Show high-level metrics summary for recent activity.


pilot metrics summary [flags]

Displays execution, duration, token, cost, and code-change statistics.

Flags

Flag	Description
`--days`	Number of days to include (default: 7)
`--projects`	Filter by project paths (comma-separated)

Examples


# Show 7-day summary
pilot metrics summary
 
# Show 30-day summary
pilot metrics summary --days 30
 
# Filter by project
pilot metrics summary --projects /path/to/pilot,/path/to/webapp

pilot metrics daily

Show daily metrics breakdown with trends.


pilot metrics daily [flags]

View daily activity patterns and identify usage trends.

Flags

Flag	Description
`--days`	Number of days to include (default: 7)
`--projects`	Filter by project paths (comma-separated)

Examples


# Show 7-day daily breakdown
pilot metrics daily
 
# Show last 30 days
pilot metrics daily --days 30

pilot metrics projects

Show per-project metrics and comparisons.


pilot metrics projects [flags]

Compare performance and usage across different projects.

Flags

Flag	Description
`--days`	Number of days to include (default: 30)
`--limit`	Maximum projects to show (default: 10)

Examples


# Show project metrics
pilot metrics projects
 
# Show over last 7 days
pilot metrics projects --days 7
 
# Show top 5 projects
pilot metrics projects --limit 5

pilot metrics export

Export metrics data for external analysis.


pilot metrics export [flags]

Export metrics in JSON or CSV format for reporting and analysis.

Flags

Flag	Description
`--days`	Number of days to include (default: 30)
`--projects`	Filter by project paths (comma-separated)
`--format`	Output format: `json` or `csv` (default: json)
`--output`, `-o`	Output file (`-` for stdout)

Examples


# Export as JSON to stdout
pilot metrics export
 
# Export as CSV
pilot metrics export --format csv
 
# Export to a specific file
pilot metrics export --format csv --output metrics-jan2026.csv
 
# Export last 90 days for specific projects
pilot metrics export --days 90 --projects /path/to/pilot

pilot usage

Detailed usage analytics and cost tracking.


pilot usage <subcommand>

Track detailed usage patterns, costs, and resource consumption analytics.

Subcommands

Subcommand	Description
`summary`	Show usage summary and costs
`daily`	Show daily usage patterns
`projects`	Show per-project usage analytics
`events`	Show detailed usage events
`export`	Export usage data for billing

pilot usage summary

Show usage summary with cost breakdown.


pilot usage summary [flags]

Overview of task, token, compute, storage, and API-call costs, plus a grand total.

Flags

Flag	Description
`--days`	Number of days to include (default: 30)
`--user`	Filter by user ID
`--project`	Filter by project ID

Examples


# Show 30-day usage summary
pilot usage summary
 
# Show weekly usage
pilot usage summary --days 7
 
# Filter by user and project
pilot usage summary --user alice --project pilot

pilot usage daily

Show daily usage patterns and cost trends.


pilot usage daily [flags]

Analyze daily usage patterns to optimize costs and identify trends.

Flags

Flag	Description
`--days`	Number of days to include (default: 7)
`--user`	Filter by user ID
`--project`	Filter by project ID

Examples


# Show daily usage
pilot usage daily
 
# Show last 30 days
pilot usage daily --days 30

pilot usage projects

Show per-project usage analytics and costs.


pilot usage projects [flags]

Compare usage patterns and costs across different projects.

Flags

Flag	Description
`--days`	Number of days to include (default: 30)
`--user`	Filter by user ID

Examples


# Show project usage
pilot usage projects
 
# Show over last 7 days
pilot usage projects --days 7
 
# Filter by user
pilot usage projects --user alice

pilot usage events

Show detailed usage events and API calls.


pilot usage events [flags]

View individual usage events (task/token/compute) for detailed analysis.

Flags

Flag	Description
`--days`	Number of days to include (default: 7)
`--user`	Filter by user ID
`--project`	Filter by project ID
`--type`	Filter by event type: `task`, `token`, or `compute`
`--limit`	Maximum events to show (default: 50)

Examples


# Show recent events
pilot usage events
 
# Show events for specific project
pilot usage events --project pilot
 
# Show only token events
pilot usage events --type token
 
# Show last 100 events
pilot usage events --limit 100

pilot usage export

Export detailed usage data for billing and analysis.


pilot usage export [flags]

Export usage events in JSON or CSV format.

Flags

Flag	Description
`--days`	Number of days to include (default: 30)
`--user`	Filter by user ID
`--project`	Filter by project ID
`--format`	Output format: `json` or `csv` (default: json)
`--output`	Output file (`-` for stdout)

Examples


# Export usage data as JSON to stdout
pilot usage export
 
# Export as CSV
pilot usage export --format csv
 
# Export to a specific file
pilot usage export --format csv --output usage-jan2026.csv
 
# Export for a specific user and project
pilot usage export --user alice --project pilot

pilot webhooks

Manage outbound webhooks.


pilot webhooks <subcommand>

Outbound webhooks let external systems receive real-time HMAC-signed HTTP notifications when Pilot tasks start, progress, complete, fail, or time out, when a PR is created, or when a budget threshold is reached. This is not inbound webhook registration for GitHub/GitLab/Linear — see Webhooks in the configuration reference for the full endpoint schema.

Supported events: task.started, task.progress, task.completed, task.failed, task.timeout, pr.created, budget.warning.

Subcommands

Subcommand	Description
`list`	List configured webhook endpoints
`add`	Add a new webhook endpoint
`remove`	Remove a webhook endpoint
`test`	Send a test event to webhook endpoint(s)
`events`	List available webhook event types

pilot webhooks list

List configured webhook endpoints.


pilot webhooks list [flags]

Displays each endpoint’s status, ID, URL, subscribed events, and a masked secret suffix.

Flags

Flag	Description
`--json`	Output as JSON

Examples


# List configured endpoints
pilot webhooks list
 
# Output as JSON
pilot webhooks list --json

pilot webhooks add

Add a new webhook endpoint.


pilot webhooks add [flags]

Registers an outbound endpoint in ~/.pilot/config.yaml. There is no positional service argument — endpoints are generic delivery targets, not per-service integrations.

Flags

Flag	Description
`--name`	Endpoint name (defaults to the URL’s host if omitted)
`--url`	Webhook URL (required)
`--secret`	HMAC-SHA256 signing secret
`--events`	Comma-separated event types to subscribe to (default: all)
`--enabled`	Enable the endpoint (default: true)

Examples


# Subscribe to all events
pilot webhooks add --url https://example.com/hook --secret $SECRET
 
# Subscribe to specific events
pilot webhooks add --url https://example.com/hook --secret $SECRET \
  --events task.completed,task.failed,pr.created
 
# Add with a custom name
pilot webhooks add --name "Slack Integration" --url https://hooks.slack.com/... --secret $SECRET

pilot webhooks remove

Remove a webhook endpoint.


pilot webhooks remove <endpoint-id>

Takes a positional endpoint ID (as shown by pilot webhooks list). No flags.

Examples


# Remove an endpoint
pilot webhooks remove ep_abc123

pilot webhooks test

Send a test event to webhook endpoint(s).


pilot webhooks test [endpoint-id] [flags]

If no endpoint ID is given, sends to all enabled endpoints.

Flags

Flag	Description
`--event`	Event type to test (default: `task.completed`)

Examples


# Test all enabled endpoints
pilot webhooks test
 
# Test a specific endpoint
pilot webhooks test ep_abc123
 
# Test with a specific event type
pilot webhooks test --event task.failed

pilot webhooks events

List available webhook event types.


pilot webhooks events

Prints the supported task, PR, and budget event types with descriptions. Takes no flags.

Examples


# List available event types
pilot webhooks events

pilot eval

Evaluation and regression testing commands.


pilot eval <subcommand>

Commands for managing eval tasks and checking for regressions between eval runs.

Subcommands

Subcommand	Description
`run`	Run eval tasks for a repository
`list`	List eval tasks
`stats`	Print eval pass@1 metrics and model comparisons
`check`	Check for eval regressions between two runs

pilot eval run

Run eval tasks for a repository.


pilot eval run --repo <owner/name> [flags]

Loads eval tasks from the store and re-executes them as benchmarks. Selects tasks by repository, optionally overriding the model used.

Flags

Flag	Description
`--repo`	Repository (owner/name) to evaluate (required)
`--project`	Filter by project path
`--model`	Model to use for evaluation (default: config model)
`--limit`	Maximum number of tasks to run (default: 100)

Examples


# Run eval tasks for a repo
pilot eval run --repo owner/repo
 
# Override the model
pilot eval run --repo owner/repo --model claude-opus-4-6

pilot eval list

List eval tasks.


pilot eval list [flags]

Displays eval tasks from the store with optional filters.

Flags

Flag	Description
`--repo`	Filter by repository (owner/name)
`--project`	Filter by project path
`--limit`	Maximum number of tasks to show (default: 100)
`--success`	Show only successful tasks
`--failed`	Show only failed tasks

Examples


# List eval tasks for a repo
pilot eval list --repo owner/repo
 
# List only failed tasks
pilot eval list --repo owner/repo --failed

pilot eval stats

Print eval pass@1 metrics and model comparisons.


pilot eval stats [flags]

Computes and displays pass@1/pass@k metrics from stored eval tasks, with per-repository breakdown and overall statistics.

Flags

Flag	Description
`--repo`	Filter by repository (owner/name)
`--project`	Filter by project path

Examples


# Show eval statistics across all repos
pilot eval stats
 
# Show stats for a single repo
pilot eval stats --repo owner/repo

pilot eval check

Check for eval regressions between two runs.


pilot eval check --baseline <run-id> --current <run-id> [flags]

Compares pass@1 rates between a baseline and current eval run. Exits with code 1 if a regression is detected (CI-friendly).

Flags

Flag	Description
`--baseline`	Baseline run ID (execution_id) (required)
`--current`	Current run ID (execution_id) (required)
`--threshold`	Regression threshold in percentage points

Examples


# Compare two eval runs
pilot eval check --baseline exec-abc --current exec-def
 
# Use a custom regression threshold
pilot eval check --baseline exec-abc --current exec-def --threshold 5

Team Management

Commands for managing teams, members, and role-based access control.

pilot team

Manage teams and permissions.


pilot team <subcommand>

Teams allow multiple users to collaborate on Pilot with different permission levels:

owner: Full access, can delete team
admin: Manage members and projects
developer: Execute tasks on assigned projects
viewer: Read-only access

Subcommands

Subcommand	Description
`create`	Create a new team
`list`	List all teams
`show`	Show team details
`delete`	Delete a team (owner only)
`member`	Manage team members
`project`	Manage team project access
`audit`	View team audit log

pilot team create

Create a new team.


pilot team create <name> [flags]

Creates a new team with the specified name and sets the initial owner.

Flags

Flag	Description
`--owner`	Owner email address (required)

Examples


# Create a new team
pilot team create "Backend Team" --owner admin@example.com
 
# Output includes team ID and instructions for adding members

pilot team list

List all teams.


pilot team list

Displays all teams with their ID, name, and creation date.

Examples


# List all teams
pilot team list
 
# Sample output:
# Found 2 team(s):
#
# ID        NAME           CREATED
# ──        ────           ───────
# abc12345  Backend Team   2026-01-15
# def67890  Frontend Team  2026-01-20

pilot team show

Show team details.


pilot team show <team-id>

Displays team information including members and project access.

Arguments

The team ID can be a full ID, partial ID, or team name.

Examples


# Show team by ID (partial match supported)
pilot team show abc12345
 
# Show team by name
pilot team show "Backend Team"
 
# Sample output:
# 📋 Team: Backend Team
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
#    ID:         abc12345-...
#    Created:    2026-01-15 10:30
#    Max Tasks:  5 concurrent
#
# 👥 Members (2):
#    ID        EMAIL              ROLE       PROJECTS
#    mem123    admin@example.com  owner      all
#    mem456    dev@example.com    developer  all

pilot team delete

Delete a team (owner only).


pilot team delete <team-id> [flags]

Permanently deletes a team and all associated data. Only team owners can perform this action.

Flags

Flag	Description
`--as`	Your email (must be team owner, required)
`--force`	Skip confirmation prompt

Examples


# Delete team (with confirmation)
pilot team delete abc12345 --as owner@example.com
 
# Delete without confirmation
pilot team delete abc12345 --as owner@example.com --force

pilot team member

Manage team members.


pilot team member <subcommand>

Subcommands

Subcommand	Description
`add`	Add a member to a team
`remove`	Remove a member from a team
`role`	Change a member’s role

pilot team member add

Add a member to a team.


pilot team member add <team-id> <email> [flags]

Adds a new member to the specified team with the given role.

Flags

Flag	Description
`--role`	Role: owner, admin, developer, viewer (default: developer)
`--projects`	Restrict to specific projects (comma-separated, empty = all)
`--as`	Your email (must have manage_members permission, required)

Examples


# Add a developer with access to all projects
pilot team member add abc123 dev@example.com --role developer --as admin@example.com
 
# Add a viewer restricted to specific projects
pilot team member add abc123 viewer@example.com --role viewer --projects api,frontend --as admin@example.com

pilot team member remove

Remove a member from a team.


pilot team member remove <team-id> <member-email> [flags]

Removes a member from the specified team.

Flags

Flag	Description
`--as`	Your email (must have manage_members permission, required)

Examples


# Remove a member
pilot team member remove abc123 dev@example.com --as admin@example.com

pilot team member role

Change a member’s role.


pilot team member role <team-id> <member-email> <new-role> [flags]

Updates the role of an existing team member.

Flags

Flag	Description
`--as`	Your email (must have manage_members permission, required)

Examples


# Promote a developer to admin
pilot team member role abc123 dev@example.com admin --as owner@example.com
 
# Demote to viewer
pilot team member role abc123 user@example.com viewer --as admin@example.com

pilot team project

Manage team project access.


pilot team project <subcommand>

Subcommands

Subcommand	Description
`set`	Set project access with a default role
`remove`	Remove project access from a team
`list`	List project access entries for a team

pilot team project set

Set project access with a default role.


pilot team project set <team-id> <project-path> [flags]

Sets or updates project access for a team with a default role. The default role determines the minimum permission level for all team members on the specified project.

Flags

Flag	Description
`--role`	Default role: owner, admin, developer, viewer (default: developer)
`--as`	Your email (must have manage_projects permission, required)

Examples


# Grant team access to a project
pilot team project set abc123 /path/to/project --role developer --as owner@example.com
 
# Set read-only access
pilot team project set abc123 /path/to/project --role viewer --as admin@example.com

pilot team project remove

Remove project access from a team.


pilot team project remove <team-id> <project-path> [flags]

Removes project access for a team.

Flags

Flag	Description
`--as`	Your email (must have manage_projects permission, required)

Examples


# Remove project access
pilot team project remove abc123 /path/to/project --as admin@example.com

pilot team project list

List project access entries for a team.


pilot team project list <team-id>

Displays all project access entries for a team.

Examples


# List project access
pilot team project list abc123
 
# Sample output:
# 📂 Project Access for 'Backend Team' (2 entries):
#
# PROJECT PATH              DEFAULT ROLE
# ────────────              ────────────
# /home/dev/api             developer
# /home/dev/shared-utils    viewer

pilot team audit

View team audit log.


pilot team audit <team-id> [flags]

Displays the audit log for a team showing member actions and changes.

Flags

Flag	Description
`--limit`	Maximum entries to show (default: 50)
`--as`	Your email (must have view_audit_log permission, required)

Examples


# View recent audit entries
pilot team audit abc123 --as admin@example.com
 
# View last 100 entries
pilot team audit abc123 --limit 100 --as admin@example.com
 
# Sample output:
# 📜 Audit Log for 'Backend Team' (showing 3 entries)
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# [2026-01-15 10:30] admin@example.com performed add_member on member (mem456)
# [2026-01-15 10:25] admin@example.com performed create_team on team (abc123)

Project Management

Commands for managing Pilot projects.

pilot project

Manage Pilot projects.


pilot project <subcommand>

Add, list, remove, and configure projects for Pilot.

Subcommands

Subcommand	Description
`list`	List all configured projects
`add`	Add a new project
`remove`	Remove a project
`set-default`	Set the default project
`show`	Show project details

pilot project list

List all configured projects.


pilot project list

Displays all projects with their name, path, GitHub repository, branch, context intelligence status, and default status.

Examples


# List all projects
pilot project list
 
# Sample output:
# PROJECTS (2 configured)
#
#   NAME    PATH                    GITHUB           BRANCH  NAV  DEFAULT
#   pilot   /Users/dev/pilot        owner/pilot      main    *    *
#   webapp  /Users/dev/webapp       owner/webapp     main
#
# Use 'pilot project show <name>' for details

pilot project add

Add a new project.


pilot project add [flags]

Adds a new project to Pilot configuration with automatic detection of GitHub remote, branch, and context intelligence setup.

Flags

Flag	Description
`-n`, `--name`	Project name (required)
`-p`, `--path`	Project path (default: current directory)
`-g`, `--github`	GitHub repo (owner/repo)
`-b`, `--branch`	Default branch (auto-detected)
`--navigator`	Enable context intelligence (auto-detected)
`-d`, `--set-default`	Set as default project
`--no-wizard`	Force flag-driven mode (skip interactive wizard)

Without flags on an interactive terminal, pilot project add launches an interactive wizard that detects your gh CLI auth, lets you pick a repo, and prefills settings. --no-wizard forces flag mode even on a TTY.

Auto-detection

If --path is omitted, uses current working directory
If --branch is omitted, detects from git remote
If --navigator is omitted, checks for .agent/ directory
If --github is omitted, parses from git remote origin

Examples


# Interactive wizard (TTY only)
pilot project add
 
# Force flag mode
pilot project add --no-wizard --name my-app
 
# Add with explicit GitHub repository
pilot project add --name my-app --github owner/repo
 
# Add with custom path and branch
pilot project add -n my-app -p /path/to/project -g owner/repo -b develop
 
# Add and set as default
pilot project add --name primary-app --set-default

pilot project remove

Remove a project.


pilot project remove <name> [flags]

Removes a project from Pilot configuration.

Flags

Flag	Description
`-n`, `--name`	Project name
`-f`, `--force`	Skip confirmation prompt

Examples


# Remove with confirmation
pilot project remove my-app
 
# Remove without confirmation
pilot project remove my-app --force
 
# Using flag instead of positional argument
pilot project remove --name my-app

pilot project set-default

Set the default project.


pilot project set-default <name>

Sets the specified project as the default for Pilot commands.

Examples


# Set default project
pilot project set-default my-app

pilot project show

Show project details.


pilot project show [name]

Displays details for a project. Without arguments, shows the default project.

Examples


# Show specific project
pilot project show my-app
 
# Show default project
pilot project show
 
# Sample output:
# PROJECT: my-app
#
#   Path:       /Users/dev/my-app
#   GitHub:     owner/my-app
#   Branch:     main
#   Context:    enabled
#   Default:    yes

Tunnel Management

Commands for managing Cloudflare Tunnel for webhooks.

pilot tunnel

Manage Cloudflare Tunnel for webhooks.


pilot tunnel <subcommand>

The tunnel provides a permanent public URL for receiving webhooks from GitHub, Linear, and other services - no port forwarding required.

Supported providers:

cloudflare: Free, permanent URLs via Cloudflare Tunnel
ngrok: Quick testing (requires ngrok account for custom domains)

Subcommands

Subcommand	Description
`status`	Show tunnel status
`start`	Start the tunnel
`stop`	Stop the tunnel
`url`	Show the tunnel webhook URL
`setup`	Set up tunnel (create tunnel, configure DNS)
`service`	Manage tunnel auto-start service

pilot tunnel status

Show tunnel status.


pilot tunnel status

Displays current tunnel status including provider, connection state, URL, and service status.

Examples


# Show tunnel status
pilot tunnel status
 
# Sample output:
# Tunnel Status
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
#   Provider:  cloudflare
#   Status:    ✓ Running
#   Connected: ✓ Yes
#   URL:       https://pilot-webhook.example.com
#   Tunnel ID: abc123-def456-...
#
# Service (launchd)
# ─────────────────────────────────────────
#   Installed: ✓ Yes
#   Running:   ✓ Yes (auto-starts on boot)

pilot tunnel start

Start the tunnel.


pilot tunnel start [flags]

Starts the Cloudflare Tunnel to expose local webhook endpoint. By default, runs in background.

Flags

Flag	Description
`-f`, `--foreground`	Run in foreground

Examples


# Start tunnel (background)
pilot tunnel start
 
# Start in foreground (Ctrl+C to stop)
pilot tunnel start --foreground
 
# Output:
# Starting cloudflare tunnel...
#
# ✓ Tunnel started
#   URL: https://pilot-webhook.example.com
#   Webhook endpoint: https://pilot-webhook.example.com/webhooks/github

pilot tunnel stop

Stop the tunnel.


pilot tunnel stop

Stops the running tunnel and any associated service.

Examples


# Stop tunnel
pilot tunnel stop
 
# Output: ✓ Tunnel stopped

pilot tunnel url

Show the tunnel webhook URL.


pilot tunnel url [flags]

Displays the tunnel URL for configuring webhooks.

Flags

Flag	Description
`--webhook`	Append webhook path (e.g., /webhooks/github)

Examples


# Show base URL
pilot tunnel url
 
# Show full webhook URL
pilot tunnel url --webhook /webhooks/github

pilot tunnel setup

Set up tunnel (create tunnel, configure DNS).


pilot tunnel setup [flags]

Sets up Cloudflare Tunnel for permanent webhook URLs.

This command:

Checks for cloudflared CLI installation
Authenticates with Cloudflare (if needed)
Creates a tunnel named ‘pilot-webhook’
Configures DNS routing (if custom domain provided)
Optionally installs auto-start service

Prerequisites

Cloudflare account (free tier is sufficient)
cloudflared CLI: brew install cloudflared

Flags

Flag	Description
`--provider`	Tunnel provider: cloudflare, ngrok (default: cloudflare)
`--domain`	Custom domain (optional)
`--service`	Install auto-start service

Examples


# Basic setup
pilot tunnel setup
 
# With custom domain
pilot tunnel setup --domain pilot.example.com
 
# With auto-start service
pilot tunnel setup --service
 
# Full setup with all options
pilot tunnel setup --domain pilot.example.com --service

pilot tunnel service

Manage tunnel auto-start service.


pilot tunnel service <subcommand>

Manage the launchd service for automatic tunnel startup on macOS.

Subcommands

Subcommand	Description
`install`	Install auto-start service (macOS only)
`uninstall`	Remove auto-start service
`status`	Show service status

pilot tunnel service install

Install auto-start service (macOS only).


pilot tunnel service install

Installs a launchd service to automatically start the tunnel on boot.

Prerequisites

Run pilot tunnel setup first to configure the tunnel.

Examples


# Install service
pilot tunnel service install
 
# Output:
# Installing service... ✓
#
# Service installed!
#   - Tunnel will auto-start on boot
#   - Run 'pilot tunnel service status' to check

pilot tunnel service uninstall

Remove auto-start service.


pilot tunnel service uninstall

Removes the launchd service. The tunnel will no longer auto-start on boot.

Examples


# Uninstall service
pilot tunnel service uninstall
 
# Output:
# Uninstalling service... ✓
# Service removed - tunnel will no longer auto-start

pilot tunnel service status

Show service status.


pilot tunnel service status

Displays the launchd service status.

Examples


# Show service status
pilot tunnel service status
 
# Sample output:
# Service Status (launchd)
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
#   Installed: ✓ Yes
#   Path:      ~/Library/LaunchAgents/com.pilot.tunnel.plist
#   Running:   ✓ Yes

Autopilot & Release

Commands for autopilot PR lifecycle management and releases.

pilot autopilot

Autopilot commands for PR lifecycle management.


pilot autopilot <subcommand>

Commands for viewing and managing autopilot PR tracking and automation.

Subcommands

Subcommand	Description
`status`	Show tracked PRs and their current stage
`list`	List all configured autopilot environments
`enable`	Enable autopilot in configuration
`disable`	Disable autopilot in configuration

pilot autopilot status

Show tracked PRs and their current stage.


pilot autopilot status [flags]

Displays autopilot status including:

Tracked PRs and their lifecycle stage
Time in current stage
CI status for each PR
Release configuration status

Note: Pilot must be running with --autopilot flag for live PR tracking.

Flags

Flag	Description
`--json`	Output as JSON

Examples


# Show autopilot status
pilot autopilot status
 
# Sample output:
# 🤖 Autopilot Status
# ───────────────────────────────────────
# Environment: stage
#
# Configuration:
#   Auto Merge:     true
#   Auto Review:    false
#   Merge Method:   squash
#   CI Timeout:     10m0s
#   Max Failures:   3
#
# Release:
#   Enabled:        true
#   Trigger:        on-merge
#   Require CI:     true
#   Tag Prefix:     v
#
# ℹ️  For live PR tracking, check:
#    • Dashboard: pilot start --dashboard --env=<env>
#    • Logs: pilot logs --follow
 
# JSON output
pilot autopilot status --json

pilot autopilot list

List all configured autopilot environments.


pilot autopilot list [flags]

Displays all configured autopilot environments and their settings — both built-in environments (dev, stage, prod) and any custom environments defined in the config file under autopilot.environments.

Flags

Flag	Description
`--json`	Output as JSON

Examples


# List configured environments
pilot autopilot list
 
# JSON output
pilot autopilot list --json

pilot autopilot enable

Enable autopilot in configuration.


pilot autopilot enable [flags]

Enables autopilot mode in the Pilot configuration file. You must restart Pilot for changes to take effect.

Flags

Flag	Description
`--env`	Environment: `dev`, `stage`, `prod` (default: `dev`)
`--json`	Output as JSON

Examples


# Enable with default (dev) environment
pilot autopilot enable
 
# Enable with staging environment
pilot autopilot enable --env=stage
 
# Enable with production environment
pilot autopilot enable --env=prod

pilot autopilot disable

Disable autopilot in configuration.


pilot autopilot disable [flags]

Disables autopilot mode in the Pilot configuration file. You must restart Pilot for changes to take effect.

Flags

Flag	Description
`--json`	Output as JSON

Examples


# Disable autopilot
pilot autopilot disable
 
# Output as JSON
pilot autopilot disable --json

pilot release

Create a release manually.


pilot release [version] [flags]

Creates a new release for the current repository. If no version is specified, detects version bump from commits since the last release.

Flags

Flag	Description
`--bump`	Force bump type: patch, minor, major
`--draft`	Create release as draft
`--dry-run`	Show what would be released without creating

Examples


# Auto-detect version from commits
pilot release
 
# Force minor bump
pilot release --bump=minor
 
# Specific version
pilot release v1.2.3
 
# Create as draft
pilot release --draft
 
# Preview release without creating
pilot release --dry-run
 
# Output:
# Would create release:
#   Current version: v2.151.0
#   New version: v2.151.1
#   Bump type: patch
#   Draft: false

pilot allow

Manage Telegram allowed users.


pilot allow [user_id] [flags]

Add, remove, or list Telegram user IDs in allowed_ids configuration.

Flags

Flag	Description
`--remove`	Remove user from allowed_ids
`--list`	List current allowed users

Examples


# Add a user
pilot allow 123456789
 
# Remove a user
pilot allow --remove 123456789
 
# List allowed users
pilot allow --list
 
# Sample output:
# Allowed Telegram users:
#   123456789
#   987654321
#
# Total: 2 user(s)