Skip to content
Kompass Kompass Docs

Commands

Kompass ships workflow-oriented commands authored as explicit templates in packages/core/commands/.

Groups

  • Workflow: /ask, /branch, /commit, /commit-and-push, /merge, /rmslop
  • Guidelines: /learn, /skill/create, /skill/optimize
  • Ticket: /ticket/ask, /ticket/create, /ticket/dev, /ticket/plan, /ticket/plan-and-sync
  • PR: /pr/create, /pr/fix, /pr/review, /review
  • Orchestration: /dev, /ship, /todo

What makes them different

  • each command is a documented workflow, not an opaque prompt
  • placeholders like <arguments>, <plan>, and <ticket-url> are normalized before execution
  • navigator workflows orchestrate locally and delegate focused leaf work with literal <delegate> blocks
  • outputs are deterministic, reviewable, and usually terminal

Workflow Commands

/ask

Answers a project or code question using only the relevant repository context.

  • usage: /ask <question>
  • arguments: question or focus guidance; auto-derives from the conversation when omitted
  • expected tools: read, grep, repository exploration tools as needed

/branch

Creates and switches to a categorized work branch from current uncommitted changes.

  • usage: /branch [context]
  • arguments: optional naming guidance that can steer the category and slug
  • expected tools: changes_load(uncommitted), git checkout -b

/commit

Creates a commit with an appropriate message summarizing uncommitted changes.

  • usage: /commit [message-guidance]
  • arguments: optional commit message guidance
  • expected tools: changes_load(uncommitted), staging/commit git commands

/commit-and-push

Creates a commit and immediately pushes it to the remote repository.

  • usage: /commit-and-push [message-guidance]
  • arguments: optional commit message guidance
  • expected tools: changes_load(uncommitted), git commit, git push with upstream fallback when needed

/merge

Merges a provided branch into the current branch, defaulting to the repo base branch, and resolves conflicts with a best-effort preference for the incoming branch.

  • usage: /merge [source-or-guidance]
  • arguments: optional merge source branch or ref plus additional merge guidance
  • expected tools: git status, git merge, file-edit tools for conflict resolution, git add, git merge --continue

/rmslop

Removes AI-generated code slop and inconsistencies from branch changes.

  • usage: /rmslop [base-or-guidance]
  • arguments: optional base branch or cleanup guidance
  • expected tools: changes_load, file-edit tools, validation commands, commit git commands

Guidelines Commands

/learn

Extracts non-obvious learnings from the current session and documents them into the right AGENTS.md scope.

  • usage: /learn [focus]
  • arguments: optional focus scope or extra guidance
  • expected tools: read, file edit tools

/skill/create

Creates a focused Agent Skill from repository context and user direction.

  • usage: /skill/create [skill-direction]
  • arguments: optional skill request, desired name, supporting sources, or constraints; auto-derives from the conversation when omitted
  • expected tools: glob, read, file-edit tools, and relevant validation commands

/skill/optimize

Improves an existing Agent Skill using real prompts, failures, evals, or other grounded feedback.

  • usage: /skill/optimize [skill-and-focus]
  • arguments: optional skill path or slug, optimization focus, supporting evidence, or constraints; auto-derives from the conversation when omitted
  • expected tools: read, glob, file-edit tools, and relevant validation commands

Ticket workflows

/ticket/ask

Loads a ticket and its discussion, answers the question, and posts the answer back to the ticket.

  • usage: /ticket/ask <ticket-reference> <question>
  • arguments: ticket reference plus question; auto-derives the question from the conversation when needed
  • expected tools: ticket_load(comments), repository context tools as needed, ticket_sync

/ticket/create

Creates a ticket summarizing the current change comparison.

  • usage: /ticket/create [base-or-context]
  • arguments: optional base branch or additional context; auto-discovers comparison mode when omitted
  • expected tools: changes_load, ticket_sync

/ticket/dev

Implements a ticket through a navigator-led orchestration of /dev, /branch, /commit-and-push, and /pr/create.

  • usage: /ticket/dev <ticket-reference>
  • arguments: ticket reference, URL, file path, or raw request
  • expected tools: ticket_load, command_expansion(dev), command_expansion(branch), command_expansion(commit-and-push), command_expansion(pr/create)

/ticket/plan

Creates a scoped implementation plan from a request or ticket without modifying ticket state.

  • usage: /ticket/plan <ticket-reference-or-request>
  • arguments: ticket reference, URL, request text, or planning guidance
  • expected tools: ticket_load(comments) when planning from a ticket, light repo reconnaissance tools

/ticket/plan-and-sync

Creates a scoped implementation plan from a request or ticket and stores that plan in the ticket flow.

  • usage: /ticket/plan-and-sync <ticket-reference-or-request>
  • arguments: ticket reference, URL, request text, or planning guidance
  • expected tools: ticket_load(comments) when planning from a ticket, light repo reconnaissance tools, ticket_sync

PR workflows

/pr/create

Creates a pull request for the current branch, including mandatory ticket resolution when the interaction tool is available.

  • usage: /pr/create [base-or-ticket-context]
  • arguments: optional base branch, ticket directive, ticket reference, skip directive, or additional context
  • expected tools: changes_load, question when ticket handling is unresolved, ticket_sync when auto-creating a ticket, git push, pr_sync

/pr/fix

Addresses PR feedback by making fixes and responding to review threads.

  • usage: /pr/fix [pr-or-auto-or-context]
  • arguments: optional PR ref, auto, or additional fix guidance
  • expected tools: pr_load, file-edit tools, validation commands, question unless auto, git push, pr_sync

/pr/review

Reviews a GitHub pull request and publishes findings as a formal review.

  • usage: /pr/review [pr]
  • arguments: optional PR number, URL, or review focus areas
  • expected tools: pr_load, ticket_load when the PR body links to one clear ticket, changes_load, pr_sync

/review

Reviews code changes and returns a grade, verdict, and severity-counted findings summary without publishing comments.

  • usage: /review [base-or-uncommitted]
  • arguments: optional base branch, uncommitted, or review focus guidance
  • expected tools: changes_load, read changed files, reviewer analysis

Orchestration workflows

/dev

Implements a feature or fix, validates the result, and prepares a PR handoff.

  • usage: /dev <description>
  • arguments: direct implementation guidance or a ticket-like source
  • expected tools: ticket_load only when a ticket-like source is provided, file-edit tools, validation commands

/ship

Ships current work by delegating branch creation, commit creation, and PR creation.

  • usage: /ship [context]
  • arguments: optional base branch, branch naming guidance, or additional shipping context
  • expected tools: command_expansion(branch), command_expansion(commit), command_expansion(pr/create)

/todo

Works through a todo file one pending item at a time with planning, approval, implementation, commit, checklist update, and repeat loops.

  • usage: /todo [@todo-file]
  • arguments: optional @file reference and execution guidance; defaults to @TODO.md
  • expected tools: read, question, command_expansion(ticket/plan), command_expansion(dev), command_expansion(commit)