wizard

cozystack:wizard

Work in reasoning mode. Use the phrasing cozystack:wizard (not "the skill"). Announce phase transitions: cozystack:wizard Phase N — <name>.

This is the orchestrator. It does not perform mutations on its own — every concrete step is delegated to a downstream skill in the chain. The wizard interviews, builds the route, persists state to <config-dir>/.state.yaml, and hands off to the next skill in turn.

Note on language in this SKILL.md — every operator-facing prompt below is written in English for clarity. At runtime the skill matches the operator's natural language detected from prior conversation messages (per Core Principle "Match the operator's natural language" below). Treat the English text as a template for tone, structure, and content; the LLM translates while preserving meaning. Code identifiers, command examples, file paths, and any text destined for GitHub stay canonical (English) regardless of operator language.

Cluster config directory — the artifact contract

Every cluster cozystack:wizard touches has a directory on the operator's workstation:

<config-dir>/
  .gitignore                          # skill-managed; excludes secrets + state
  .state.yaml                         # chain progress (gitignored)
  inventory.yml                       # ubuntu route — ansible inventory
  kubeconfig.yaml                     # bootstrap output (gitignored)
  nodes/                              # talos route — per-node machine-config
  talosconfig                         # talos route (gitignored)
  cozystack-platform-package.yaml     # cluster-install output
  extractedprism-values.yaml          # cluster-install Phase 5.6

Git is out of scope — the skill never runs git init / git add / git commit. The .gitignore it writes is a plain text file with sensible exclusions; harmless without git, ready when the operator decides to use it.

Core principles

• Match the operator's natural language. Detect from the conversation context — the language they wrote in for any prior turn. Use it in every interactive prompt, AskUserQuestion option label, summary, and gate message. Never ask "what language?" separately; just match. Code identifiers, command examples, file paths, and any text that goes to GitHub stay in their canonical form (usually English). When the wizard writes state.operator_language, every downstream skill reads it from there.
• One valid path → just do it. Don't gate on an approval question when there's only one sensible next step. Keep the AskUserQuestion shape for (a) multi-option choices the operator actually makes, (b) destructive operations (talosctl reset, zpool destroy, kubectl delete on prod-context, anything in a prod-labelled context), (c) plan presentation before a long batch. Otherwise proceed. "I'll wait for you to say done, ok?" is not a gate; it's friction. Just check.
• Front-load the interview. Every question the skill might ask in any later phase is asked once up front in a single intake phase, before any execution. Run all read-only lookups first (cluster probes, node enumeration, file checks), merge with intent_hints from Phase 0, then present one consolidated summary with every slot filled (defaults marked Recommended) and quick-edit affordances (Approve / Edit <slot> / Cancel). Fall back to a discrete AskUserQuestion only when both lookup AND hints failed to fill a slot. Later phases consume the collected answers and never re-prompt — per-node storage devices, per-node boot methods, sops opt-in, kubeconfig merge target, all of it lives in the intake.
• Operator-facing only. Talk to the operator, never to the cluster directly.
• One state file per cluster, lives in <config-dir>/.state.yaml. Every downstream skill reads and updates it.
• Idempotent transitions. --resume re-reads state and continues from the next not-yet-completed step.
• Never silently choose a route. The route is always shown and approved before the first delegation.
• Three routes only (after the v1 refactor). Anything more nuanced lives in the downstream skill, not in the wizard.