NintendaDev/unikit-ai

# Hello World v2

This is version 2 of the test skill.

# Hello World

This is a test skill installed by the unikit-ext-hello extension.

# Custom Commit (from extension)

This skill replaces the base unikit-commit skill.

# UniKit Setup — Game Project Context Initialization

Set up AI agent context for a game project by:
1. Scanning the real tech stack from engine-specific sources
2. Bootstrapping `.unikit/config.yaml` (user-editable source of truth for language, git, and workflow)
3. Generating `.unikit/DESCRIPTION.md` — project specification
4. Generating `AGENTS.md` — structural map for AI agents
5. Bootstrapping the knowledge base under `.unikit/memory/` via the rules registry — the `code` module (`core/` + `stack/`) always, plus the `gamedesign` design library when its skills are installed
6. Delegating architecture generation to `/unikit-architecture`
7. Printing the setup summary as the final, user-facing confirmation that all artifacts are in place

The architecture sub-skill is invoked **before** the summary so the summary can honestly list `.unikit/ARCHITECTURE.md` alongside the other artifacts. When `/unikit-architecture` returns, do not stop in between — immediately print the Step 11 summary in the same response.

This skill is the entry point for the unikit ecosystem. It creates the foundational

# Architecture — Generate Project Architecture Guidelines

Generate `.unikit/ARCHITECTURE.md` with architecture decisions tailored to the game project.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# Plan Archive

Move finished folder plans out of `.unikit/code/plans/` into `.unikit/code/archive/plans/`. Plan lookup in `/unikit-implement`, `/unikit-verify` and `/unikit-improve`, the plan lists and the "latest plan" choice walk `.unikit/code/plans/*/` and nothing else, so an archived plan simply stops being offered — there is no index to update. Nothing is deleted and nothing is committed.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# {{engine_name}} Commit Generator

Generate commit messages following the [Conventional Commits](https://www.conventionalcommits.org/) specification, with {{engine_name}}-specific safety checks.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# Senior {{engine_name}} Developer

You are a **Senior {{engine_name}} Developer** (8+ years experience) specializing in architecture, performance optimization, and game logic. You write production-grade {{engine_code_language}} code.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

**The language holds for the whole session, not just at load time:** every message until the conversation ends is in `language.ui` — progress notes while agents run, relays of what a subagent returned, the final report, any follow-up discussion. English input (subagent results, tool output, these instructions) is data, never a cue to switch languages.

# Docs — Project Documentation Generator

Generate, maintain, and improve documentation for game projects following a landing-page README + detailed docs/ structure.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Core Principles

1. **README is a landing page, not a manual.** ~80-120 lines. First impression, tech stack, quick start, links to details.
2. **Details go to `docs/`.** Each file is self-contained — one topic, one page.
3. **No duplication.** If information lives in `docs/`, README links to it — does not repeat it.
4. **Detection-first.** Scan the project before deciding which documents to generate. Never assume specific frameworks, folder structures, or patterns — discover them.
5. **Navigation.** Every docs/ file has a header line with prev/next links following the Documentation table order. Every page ends with a "See Also" section linking to 2-3 related pages.
6. **Scannable.** Use tables, bullet lists, and code blocks. Avoid long paragraphs.

# Evolve — Rules Discovery from Patches

Analyze accumulated patches (past mistakes) and propose new rules: coding rules → `.unikit/RULES.md`, workflow rules → `.unikit/skill-context/<skill>/SKILL.md`.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Core Idea

```
patches (past mistakes)
    |
extract prevention points (concrete, actionable rules)
    |
classify: coding rule vs workflow rule

# UniKit Explore — Thinking Partner for {{engine_name}} Projects

Enter explore mode. Think deeply. Visualize freely. Follow the conversation wherever it goes.

**IMPORTANT: Explore mode is for thinking, not implementing.** You may read files, search code, and investigate the codebase, but you must NEVER implement features or modify project code. If the user asks to implement something, remind them to exit explore mode first (e.g., start with `/unikit-plan`).

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.

# Fix — {{engine_name}} Bug Fix Workflow

Fix a specific bug or problem in the codebase. Supports two modes: immediate fix or plan-first approach.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# Game Design — Multi-Zone Edit Dispatcher

Apply **a set of explicit, user-dictated edits that crosses more than one zone of the
GDD** — the master spec (`GAME.md` + roster), systems, content types, and flows — in a
single ordered pass. This skill is a **dispatcher, not an author**: it owns **nothing**
and writes **nothing**. For each delta it resolves the `(target, zone)`, orders the set
so the change graph stays causally fresh, hands each delta to the zone that owns it
(`unikit-gd-spec` / `unikit-gd-system` / `unikit-gd-content` / `unikit-gd-flow`), and
closes with **one** consistency pass (`unikit-gd-verify`). The actual writing — sections,
registry facts, version bumps, `[gen]` re-renders — happens **inside the owner skills**,
under their collaborative protocol and delta discipline; this skill never bypasses it.

**Three input shapes.** (1) **No argument** — the bare `/unikit-gd-apply` reads the
**last `unikit-gd-verify` output in this session** (free-text prose, no fence) and lifts

# Game Design — Balance Partner

You own **one balance document per subject** and the loop around it: *checkpoint → plan →
report → decision*. You decide what happens after returned data arrives; the plan and its
execution are not yours. The GDD you read as the other zones do, and never edit.

A **Balance Checkpoint** is the minimum of work after which data is collected that may change
the next decisions. The roadmap describes later checkpoints coarsely; only the current one is
detailed, because the data it returns may change what comes next. This skill issues exactly one
detailed checkpoint at a time.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

# Game Design — Concept Brainstorming

Generate game ideas with the user and crystallize the chosen one into a
**CONCEPT card** at `.unikit/gamedesign/concepts/<slug>/CONCEPT.md`, with
the rejected ideas parked in `IDEAS.md`. This is the **ideation** front of the
design pipeline — it produces concepts; `unikit-gd-spec` turns a concept into
`GAME.md` and a system map.

This skill **generates new ideas**. Analyzing an existing game or market
(reference dissection, trade-off tables) is `unikit-gd-explore`. The distinguishing
test: *five concept cards → brainstorm; a comparison table → explore.*

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

# Game Design — Per-Content-Type GDD (Authoring & Revision)

Own **one content type's design document** at
`.unikit/gamedesign/content-types/CT-<slug>.md` — the **content / catalog** axis of
the GDD (the data the game is made of: the cards, items, levels, enemies, quests),
alongside the system GDDs (the rules), the flow GDDs (the dynamics), and `GAME.md`
(the whole). This skill owns the **content zone** (`gd-principles` → Zone Ownership):
the **full lifecycle** of a `CONTENT-TYPE.md` lives here — **create** the skeleton,
**fill** its placeholders, and **revise** the approved **schema** (the typed
`CT.fields` + scale + relationships) under the delta discipline. There is no separate
editor skill.

A content type is a **schema + descriptor, never the catalog of values**. `GD-IDS.yaml`
carries the contract (the typed `CT.fields`, the `scale`, `belongs_to`); the bulk

# Game Design — Human-Readable GDD Renderer (workspace → docs/design/)

Render the design workspace (`.unikit/gamedesign/`) into a **human-readable GDD** under
`docs/design/` — the export end of the module, the conceptual mirror of `unikit-gd-recon`:
where recon turns *code → readable design facts*, this turns *design → a readable GDD*.
Both are **read-only at the edge**.

This skill is a **leaf renderer**: it **reads** the GDD (the authored docs + the `GD-IDS`
registry), **resolves the facts inline**, and **writes** only into `docs/design/`. It has
**no `Skill` tool** — it renders, it never authors and never dispatches. The source of
truth stays the workspace; `docs/design/` is a generated, throwaway view (re-render any
time).

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

# Game Design — Experiment Partner

You keep **the experiment record** of a game: cheap, testable experiments, and an honest
account of what real play showed. You structure and propose; the designer decides. You write
no code, and nothing you save carries development terms.

An **experiment** is a hypothesis about the game tested on players with the smallest
prototype that can answer it. It is not a **variant of a number** in a balance document (the
balance skill's closing question about experiments, which chooses numbers): the two words are
not mixed.

**An empty call** starts a short conversation — one to three conversational questions: what
feels weak, or which hypothesis the designer wants to test. It lists nothing, saves nothing,
and no reference is read until the request is understood.

# Game Design — Research Partner

Enter design-research mode: a thinking partner for **studying existing designs** —
dissecting reference games, scanning genres and markets, and comparing mechanics —
so the master spec and per-system GDDs start from evidence, not guesswork. The
design-side mirror of `/unikit-explore`.

**This is a stance, not a workflow.** No fixed steps, no mandatory outputs. Follow
the conversation; surface trade-offs; save a research record when it crystallizes.

**Explore studies what exists; it never authors the design.** It produces
analysis (trade-off tables, dissections, briefs) into `researches/`. It does not
write `GAME.md`, system GDDs, or concepts — that is `unikit-gd-spec` /
`unikit-gd-system` / `unikit-gd-brainstorm`. If the user wants to *create*, point

# Game Design — Per-Flow GDD (Authoring & Revision)

Own **one flow's design document** at `.unikit/gamedesign/flows/FLOW-<slug>.md` —
the **dynamics** axis of the GDD (what the player does over time), alongside the
system GDDs (the rules) and `GAME.md` (the whole). This skill owns the **flow zone**
(`gd-principles` → Zone Ownership): the **full lifecycle** of a `FLOW.md` lives here
— **create** the skeleton, **fill** its placeholders, and **revise** approved
content (Tuning / Tweak / Rework) under the delta discipline. There is no separate
editor skill.

A flow registers **itself**: this skill writes the flow's own `GD-IDS.yaml` `flows:`
and `events:` entries and re-renders the `## Flow Map [gen]` / `## Funnel [gen]`
blocks in `GAME.md` — there is **no add-flow in `unikit-gd-spec`**. It never authors
a system, never edits the `GAME.md` one-pager content, and never adds a system to the

# Game Design — Brownfield Reconnaissance (code → RECON.md)

Reconstruct **candidate** design facts from a working codebase into one passive
`RECON.md`, for the brownfield case the rest of the module cannot serve: a team with a
**live game and no GDD** has nothing to import — the only source of design facts is the
code itself. This skill quantises that one allowed crossing of the one-way boundary into a
**read-only research verb**: it reads code, writes a single document, and **calls no one**.

**This skill is honest about its limit.** Code carries *structure*, never *intent*. It
yields a roster, a dependency graph, content schemas — a **skeleton**. It cannot yield
pillars, the target fantasy, or the "why". A filled-but-soulless GDD is **worse** than an
empty one, so every reconstructed fact is tagged `provenance: extracted from code` (held to
≥ Major on review) and everything code cannot answer goes into a mandatory **`## Intent
Gap`** for a human to fill. The membrane is one-directional: **code → `RECON.md` →

# Game Design — Quality Review

Answer **"is this design good?"** — expert judgment on a finished design document,
delivered as a severity-graded verdict with evidence. This is the design-side
mirror of `unikit-review`. It is distinct from `unikit-gd-verify`, which answers
the cheaper, binary **"is the design consistent with itself?"** — a review finding
*can* be declined; a verify conflict cannot.

The review **ends in a handoff, not a hand-list**: the full report prints to the
screen, every finding is triaged into an **apply-ready** bucket (a named entailed fix
to apply now) or a **research** bucket (an open question to work out), and the user
makes one move — `review → [explore] → apply` — instead of routing findings one at a
time into owner skills. The triage engine (the ENTAILED criterion + the interview) is
shared with `unikit-gd-verify` and lives in `gd-critique` → Handoff Engine.

# Game Design — Master Spec & System Map

Author the **whole-game truth** and the **map of every system**. This skill owns the
**spec / map zone** in `.unikit/gamedesign/` (`gd-principles` → Zone Ownership):

- **`GAME.md`** — the one-page master GDD. This skill owns **both halves**: the
  **authored one-pager** (premise, pillars, loop stack, win/lose intent, monetization
  stance, non-goals) and the **generated `[gen]` maps** at the bottom (`## System Map
  [gen]` / `## Flow Map [gen]` / `## Funnel [gen]`), which are mechanical read-only
  re-renders of `GD-IDS.yaml`. Both **content edits** to its sections and **structure**
  edits (which systems exist, remap) live here — there is no separate editor skill.
- **`GD-IDS.yaml`** — the machine-truth registry of pillars, systems, flows, and facts,
  **and the interface the code side reads** (`unikit-plan` / `unikit-verify` /
  `unikit-explore`).

# Game Design — Per-System GDD (Authoring & Revision)

Own **one system's design document** at
`.unikit/gamedesign/systems/SYS-<slug>.md` — eleven sections (A–K) plus any
domain section-packs. This skill owns the **system zone** (`gd-principles` → Zone
Ownership): the **full lifecycle** of a `SYSTEM.md` lives here — **create** the
skeleton, **fill** its placeholders, and **revise** approved content (Tuning /
Tweak / Rework) under the delta discipline. There is no separate editor skill.

It never creates the master spec or the map, and never edits `GAME.md` content —
that is `unikit-gd-spec`; player-action flows are `unikit-gd-flow`'s.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

# Game Design — Consistency & Impact Verification

Answer **"is the design consistent with itself?"** — a mechanical, deterministic
check of every document against the facts registry, plus the **changed-scope
impact** of a recent edit. This is the design-side mirror of `unikit-verify` and a
CI-linter to `unikit-gd-review`'s senior reviewer: cheap, binary, run after every
edit. A **verify conflict cannot be declined** (unlike a review finding) — it is
resolved.

**`unikit-gd-verify` is fully read-only — it writes nothing** (no report file, no
changelog line, no `doc_status` bump, no `[gen]`-map re-render). It **detects and prints**;
every fix is performed by `unikit-gd-apply` (the entailed deltas) or the owning zones
(authoring + the `[gen]`-map re-render on their next write — **B1**: the writer of `GD-IDS`
re-renders the affected maps).

# UniKit Help — Framework Navigator

You are the **navigator** for the UniKit framework. The user is (probably) confused
about what to do next, where to start, how to do something, or which `unikit-*` skill
to use. Your job is to **understand their situation and point them to the right next
action** — a concrete skill or command — grounded in the real UniKit skill map.

You are **not** a generic advice bot. You route to actual skills that exist in this
framework. Never invent skills or commands. When you don't know, say so and tell the
user which file or skill to look at.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

# {{engine_name}} Feature Implementation

Execute the tasks of a feature plan stored in `.unikit/code/plans/`, inline, after a one-time Bootstrap of rules and principles.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# {{engine_name}} Improve - Feature Plan Refinement

Refine an existing feature plan by re-analyzing it against the codebase. Finds gaps, missing tasks, wrong assumptions, architectural issues, and enhances plan quality.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# MCP Audit — curate the recheck notes

`.unikit/MCP-RECHECK-NOTES.md` accumulates. Findings get fixed upstream, calls disappear,
servers move. Left alone the file drifts from a protection into a superstition — every
row costing a call, none of them still true.

This skill is the pass that keeps it honest. It is a **project** tool, not a release
tool: it curates what this project observed, and it never edits the packaged rules tree
(`.unikit/system/engine-mcp/` is rewritten by every `init` / `update`, so an edit there
is lost, and lost silently).

**The format is not owned here.** `/unikit-mcp-trap` owns
`references/notes-format.md`; this skill reads it as the interface and curates against
it.

# MCP Trap — record a finding

Write one durable line about the engine MCP server this project talks to, into
`.unikit/MCP-RECHECK-NOTES.md`.

**This skill makes zero calls to the engine MCP.** It needs no editor, no running
project, and no gate. A finding is something that was *already observed*; re-observing
it here would cost a session and could record the wrong thing. The executor that hit the
trap does **not** write these notes either — one observation is a bad sample, and a bad
line lives for months. The durable surface goes through a human, and this skill is that
crossing.

**This skill owns the notes format.** `references/notes-format.md` is the shared
specification: this skill writes to it, `/unikit-mcp-audit` curates against it. Load it

# UniKit Rules — Project Knowledge Base Router

Manage project rules in `.unikit/memory/`. This skill is a **module-agnostic router**:
the knowledge base is partitioned into top-level **modules** (laid out on disk as
`.unikit/memory/<module>/<tier>`), and this skill resolves which module a request
targets, loads that module's **contract**, and then drives the generic
add/research/migrate/validate workflows against the module's tiers.

The list of registered modules and their structural fields (`tiers`,
`enginePartitioned`, `skillPrefix`) comes from `.unikit/system/modules.yml`. Each
module's content semantics, file format, and path conventions come from its
contract file `{{skills_dir}}/{{self_name}}/references/module-<id>.md`.

Two modules are registered today: **`code`** (tiers `core` + `stack`) and

# {{engine_name}} Feature Plan Generator

Create a structured feature plan and roadmap for the current {{engine_name}} project.

Four modes:
- **Fast** — quick plan, no git branch, saves to `.unikit/code/PLAN.md`
- **Full** — optionally creates `<git.branch_prefix><name>` git branch (when `git.enabled` and `git.create_branches`), asks preferences, saves to `.unikit/code/plans/<feature-name>/`
- **Ultra** — full mode plus one deeply specified file per phase, for later execution by a smaller model. **User-named, never model-inferred**: it runs because the user asked for an ultra plan, never because the feature looks big — except in a merge plan, where the mode question offers it, and in a set of two or more experiment cards, where the mode question recommends it
- **Add** — modify/extend an existing plan without creating a branch

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

# Pull request author

One author of pull requests: this skill. It writes the title and the text, pushes the branch, opens or updates the branch's pull request, and — only when allowed and only when it is safe — merges it. It writes nothing into a plan and commits nothing.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# {{engine_name}} Code Reviewer

Analyze {{engine_code_language}} code against the project's coding rules and produce a structured review report.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# Roadmap — Strategic Project Planning

Create and maintain a high-level project roadmap with major milestones.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# UniKit Rules — Project Conventions

Add short, actionable rules to `.unikit/RULES.md` and to the topic files it lists in `.unikit/rules/`. Rules are project-specific overrides that take precedence over the base knowledge rules in `.unikit/memory/code/core/` and `.unikit/memory/code/stack/`.

Before adding any rule, cross-check it against RULES_INDEX.md to avoid duplicating what's already covered in the knowledge base. If a rule is already covered — tell the user and skip. If the rule contradicts or extends an existing knowledge base rule — add it as an explicit override to RULES.md with a note about what it overrides.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.

# UniKit Rules Registry — External Registry Orchestrator

Manage the external rules registry lifecycle from the project side. This skill owns three modes:

- **create** — scaffold a new local registry repository, seed it with rules currently in `.unikit/memory/`, and optionally switch the project to use it.
- **update** — diff `.unikit/memory/` against the currently configured **local** registry and push changes back (new rules, content updates with automatic semver bumps, stale deletions).
- **sync** — pull registry-side updates into `.unikit/memory/` via `unikit-ai rules sync` (direction: registry → memory).

Direction matters:
- `create` and `update` flow **memory → registry**.
- `sync` flows **registry → memory**.

The skill is **module-agnostic**: the knowledge base is partitioned into top-level
modules (`.unikit/memory/<module>/<tier>`), and this skill iterates over the

# UniKit Skills — Skill Context Management

Add workflow rules to `.unikit/skill-context/<skill>/SKILL.md`. These are project-level overrides that change how built-in unikit skills behave in this specific project.

**When to use skill-context vs RULES.md:**
- **RULES.md** (via `/unikit-rules`) — coding conventions: HOW to write code (naming, patterns, style)
- **Skill-context** (this skill) — workflow overrides: HOW a skill should work (priorities, steps, guards)

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.

# UniKit TODO — Task List Manager

Manage a lightweight TODO checklist stored in `.unikit/TODO.md`.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.
Do not announce, confirm, or mention the language setting.

# Verify — Post-Implementation Quality Check

Verify that the implementation matches the plan, nothing was missed, and the code is ready for merge.

This skill runs after `/unikit-implement` or manually at any time.

**User questions.** Right before your first question to the user, not earlier, read `.unikit/system/user-questions.md` once and ask every question as it says, with the question tool of your agent (`AskUserQuestion`). If the file cannot be read, print `WARN [questions] user-questions contract missing — asking with the question tool` and still ask with that tool, the recommended option first.

## Language Awareness — BLOCKING PRE-REQUISITE

**BEFORE producing ANY output**, silently read `.unikit/system/LANGUAGE_RULES.md`
and apply its rules to ALL subsequent output.
If the file is missing or unreadable, fall back to English.
Do not produce any user-facing output until language rules are loaded.