[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M71BK9DFACFR0N59Y9R60VVZ":3,"skill-same:01M71BK9DFACFR0N59Y9R60VVZ":107},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":34,"publishedAt":55,"linkOnly":56,"markdownContent":57,"markdownBody":58,"frontMatter":59,"refName":79,"commitSha":80,"skillDirectory":81,"forksCount":82,"repositoryHtmlUrl":83,"repositoryHomepageUrl":84,"ownerHtmlUrl":85,"ownerBlogUrl":6,"ownerDescription":86,"updatedAt":87,"install":88,"resources":100},"01M71BK9DFACFR0N59Y9R60VVZ","unikit-gd-recon",null,"Cold-start brownfield reconnaissance — reconstruct the WHOLE game design from an existing codebase when there is no GDD yet. Optionally accepts a free-text game description, notes, or reference links to guide and enrich the scan. Use when the user wants to build the game design from the code, e.g. \"create a GDD from this codebase\", \"reconstruct the design from our code — it's a roguelike deck-builder\", \"build a design doc from the existing project, here are some refs\". Scans the project (engine auto-detected), extracts a system roster + dependency graph and content-type schemas \u002F resources \u002F entities into one passive .unikit\u002Fgamedesign\u002FRECON.md, tags every fact provenance:extracted-from-code, and writes a mandatory Intent Gap for what code cannot know (pillars, fantasy, the \"why\"). Writes nothing else and calls no skill. STRICTLY whole-project cold-start — if a GDD already exists and the user wants a specific part investigated, use \u002Funikit-gd-explore (code lens); to author the GDD use \u002Funikit-gd-spec.","NintendaDev\u002Funikit-ai","NintendaDev","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F181320258?v=4","01M71BFH8JJ6EBGRXBWRZK894Y","Dmitrii Vasilev","01M71BFH9T4K66TTBFNV1ZWFN5",22,"MIT","https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai\u002Fblob\u002Fmain\u002Fskills\u002Funikit-gd-recon\u002FSKILL.md",[18,23,26,31],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":24,"categoryName":25,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000023","Skill与智能体开发",{"categoryNo":27,"categoryName":28,"taxonomyType":29,"taxonomyTypeDesc":30},"01JBSEEDCAT000000000000030","开发工程师","PROFESSION","适用职业",{"categoryNo":32,"categoryName":33,"taxonomyType":29,"taxonomyTypeDesc":30},"01JBSEEDCAT000000000000032","设计师",[35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54],"recon","unikit gd recon","guide","start","write","read","why","notes","create","text","free","auto","design","cold-start","explore","project","enrich","dependency graph","resources","cold","2026-11-10 10:12:30",false,"---\nname: unikit-gd-recon\ndescription: >-\n  Cold-start brownfield reconnaissance — reconstruct the WHOLE game design from an\n  existing codebase when there is no GDD yet. Optionally accepts a free-text game\n  description, notes, or reference links to guide and enrich the scan. Use when the\n  user wants to build the game design from the code, e.g. \"create a GDD from this\n  codebase\", \"reconstruct the design from our code — it's a roguelike deck-builder\",\n  \"build a design doc from the existing project, here are some refs\". Scans the\n  project (engine auto-detected), extracts a system roster + dependency graph and\n  content-type schemas \u002F resources \u002F entities into one passive\n  .unikit\u002Fgamedesign\u002FRECON.md, tags every fact provenance:extracted-from-code, and\n  writes a mandatory Intent Gap for what code cannot know (pillars, fantasy, the\n  \"why\"). Writes nothing else and calls no skill. STRICTLY whole-project cold-start —\n  if a GDD already exists and the user wants a specific part investigated, use\n  \u002Funikit-gd-explore (code lens); to author the GDD use \u002Funikit-gd-spec.\nargument-hint: \"[optional: a game description, notes, or links — and\u002For a subsystem to focus the scan]  (cold-start only; writes RECON.md, calls no skill)\"\nallowed-tools:\n  - Read\n  - Glob\n  - Grep\n  - Write\n  - Bash(mkdir *)\n  - Bash(ls *)\n  - Bash(find *)\n  - Bash(grep *)\n  - Bash(wc *)\n  - Bash(date *)\n  - Agent\n  - AskUserQuestion\ndisable-model-invocation: false\nuser-invocable: true\nmetadata:\n  author: unikit\n  version: \"1.0\"\n  category: game-design\n---\n\n# Game Design — Brownfield Reconnaissance (code → RECON.md)\n\nReconstruct **candidate** design facts from a working codebase into one passive\n`RECON.md`, for the brownfield case the rest of the module cannot serve: a team with a\n**live game and no GDD** has nothing to import — the only source of design facts is the\ncode itself. This skill quantises that one allowed crossing of the one-way boundary into a\n**read-only research verb**: it reads code, writes a single document, and **calls no one**.\n\n**This skill is honest about its limit.** Code carries *structure*, never *intent*. It\nyields a roster, a dependency graph, content schemas — a **skeleton**. It cannot yield\npillars, the target fantasy, or the \"why\". A filled-but-soulless GDD is **worse** than an\nempty one, so every reconstructed fact is tagged `provenance: extracted from code` (held to\n≥ Major on review) and everything code cannot answer goes into a mandatory **`## Intent\nGap`** for a human to fill. The membrane is one-directional: **code → `RECON.md` →\n(ordinary import)**. Downstream, `RECON.md` is just a document.\n\n**This skill writes only `RECON.md` and invokes no skill.** It has **no `Skill` tool** — the\ndispatch to `\u002Funikit-gd-spec` is a printed *recommendation*, never an inline call (the same\nmechanical guarantee `unikit-gd-apply` gets from owning no `Write`).\n\n**Optional seed — what the user may pass in.** Recon runs with **no argument** (scan the\nwhole project) or with an **optional seed**: a free-text game description, design notes,\nfile or folder paths to look at first, or reference links. The seed is *context, never a\nconstraint* — it sharpens the scan (the model knows what systems \u002F genre to expect) and lets\nrecon **pre-answer** Intent-Gap items the code is silent on (pillars, fantasy, the \"why\").\nWhatever the user passes is **recorded in `RECON.md`** under a `## Provided Context` section —\ndescription text inline (verbatim), files and folders as path references, links as URLs — and\ntagged `provenance: author-supplied (import prompt)`: author-sourced **intent**, the trusted\ncomplement to the *suspect* `extracted from code` facts (a recon-local label; on import it\nbecomes ordinary trusted source content). Recon still reads code, still writes only\n`RECON.md`, still calls no one. It has **no `WebFetch`** — links are recorded, not opened (if\ntheir content matters, ask the user to paste it).\n\n**User questions.** Right before your first question to the user, not earlier, read `.unikit\u002Fsystem\u002Fuser-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.\n\n## Language Awareness — BLOCKING PRE-REQUISITE\n\n**BEFORE producing ANY output**, silently read `.unikit\u002Fsystem\u002FLANGUAGE_RULES.md` and apply\nit to all output (fall back to English if it is missing) — including **translate concepts,\nnot transliterate jargon**. `gd-principles` → \"Language\" adds the game-design specifics:\nIDs, keywords, canonical terms, and stored field values stay English; the RECON.md prose is\nauthored in the project's artifact language. Do not announce the language setting.\n\n**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.\n\n## Phase 0 — Bootstrap\n\nSilently load — do not narrate:\n\n1. **`.unikit\u002Fsystem\u002Fgamedesign\u002Fgd-principles.md`** (the core) — for the **One-Way\n   Boundary** and its **third sanctioned exception** (the read-only research verbs read code\n   to extract candidate facts into a document; authoring zones never do) and the\n   facts-registry \u002F ID conventions.\n2. **`.unikit\u002Fsystem\u002Fgamedesign\u002Fgd-provenance.md`** — for the **`extracted from code`**\n   marker and the durable-banner contract this skill must emit so the import membrane does\n   not launder code-facts into trusted author-sourced content.\n3. **`{{skills_dir}}\u002F{{self_name}}\u002Freferences\u002Fcode-recon.md`** — the **shared `code →\n   design-fact` engine** (engine inference, the P0\u002FP1 extraction heuristics, the per-fact\n   record format). This is the source of truth for *what to look for*; this skill owns the\n   output document and the orchestration. If missing, warn (`unikit-ai update`) and proceed\n   with the summary below.\n\n**One-way boundary, the sanctioned half:** this verb **does** read project source, configs,\nand asset definitions — that is its purpose and its exception. It **never** writes anything\nbut `RECON.md`, and it **never** calls an authoring zone.\n\n## Cold-start gate — BLOCKING\n\nRecon is **strictly cold-start**. Check the workspace **first**:\n\n- If **`.unikit\u002Fgamedesign\u002FGAME.md`** exists (or `GD-IDS.yaml` exists) → a GDD is already\n  underway. **STOP** and recommend the **`unikit-gd-explore` code-grounded lens** instead:\n  it grounds a *targeted in-flight slice* against code without re-bootstrapping the whole\n  design (\"how is loot wired in the code?\"). Recon's whole-project scan is wrong once a GDD\n  exists. Do not proceed.\n- If neither exists → this is the cold-start case recon is for. Continue.\n\n\u003C!-- unikit:extension-point:bootstrap -->\n\n## Subagent launches\n\n**Subagent arguments.** Before the first subagent you launch, read `.unikit\u002Fsystem\u002Fsubagent-arguments.md`\nand `.unikit\u002Fconfig.yaml` once and settle the model and effort of every launch as that file says.\nKeys: `subagents.model.{{agent_id}}.\u003Crole>`, `subagents.effort.{{agent_id}}.\u003Crole>`;\nbuilt-in model of a reader and a validator: `\"{{agent_model_default}}\"`, of an executor: none.\nIf the file cannot be read, print\n`WARN [delegation] subagent-arguments contract missing — built-in model tier used, effort not passed`\nand use that model, no effort.\n\n## Delegation agents\n\nThis skill uses a named delegation alias for `Agent(...)` calls. The alias is the single\nplace where its delegate's agent type and call arguments are declared — call sites name\nthe alias and never carry a type or a model argument of their own.\n\n- **`recon-agent`** — read-only parallel reconnaissance. Expands to:\n\n  ```\n  Agent({{agent_call_reader}} prompt: \"\u003Cfocused question> You are read-only: edit and write nothing.\")\n  ```\n\n  Every question you send ends with the sentence `You are read-only: edit and write nothing.`, verbatim.\n\n  Fallback: if the `Agent` tool is unavailable, investigate inline with `Glob`\u002F`Grep`\u002F`Read`.\n\n## Scan delegation\n\nThe scan is a **map-reduce**: fan out one read-only investigator per candidate subsystem,\nthen reduce their reports into `RECON.md`. Use the `recon-agent` alias — **not**\n`unity-source-parser` (a dev-repo-local agent that will not exist in a user's project; this\nmodule ships **no new subagents**). Engine is inferred from the cold-start scan, not assumed.\n\n```\nrecon-agent(prompt:\n  \"In [project root], investigate the [subsystem] code. Seed from the user (a HINT, not\n   ground truth — verify every claim against the code, never invent a fact to match it):\n   [the game description \u002F notes the user provided, or 'none']. Report, per code-recon.md\n   heuristics: candidate systems (module\u002Fnamespace\u002Fasmdef boundaries) + depends_on edges;\n   data-asset definitions → CT.fields schema + scale; RES\u002FENT\u002FFORM shapes. Give a\n   file:line source pointer and a confidence grade for every fact. Do NOT infer intent\n   (pillars\u002Ffantasy\u002Fwhy) — list what you could NOT determine. Be concise: structured facts,\n   not file contents.\")\n```\n\n**Fallback (inline).** If the `Agent` tool is unavailable, the assistant scans **inline**\nitself with `Glob` \u002F `Grep` \u002F `Read` over the same `code-recon.md` heuristics — slower, same\noutput. Never skip the scan; never ask the user to run it by hand.\n\n## Pipeline — CAPTURE → SCAN → SYNTHESISE → RECOMMEND\n\n### Step 0 — Capture the provided context (optional seed)\n\nLook at what the user passed with the invocation and **classify it** — there may be several\nkinds at once, and none is required:\n\n- **Free-text game description \u002F design notes** — keep the text **verbatim** for the\n  `## Provided Context` section, and mine it for **intent** (pillars, fantasy, win\u002Flose,\n  genre, tone) to pre-answer Intent-Gap items in Step 4.\n- **A file path** — record it as a reference. If it reads as design material (a pitch, a\n  notes doc, a spec), `Read` it and fold its stated intent into the seed; if it is code,\n  treat it as a **scan-focus** pointer (Step 3). Either way the reference lands in\n  `## Provided Context`.\n- **A folder path** — record it as a reference and use it as a **scan-focus** for Step 3\n  (still one whole-project `RECON.md`).\n- **A link (URL)** — record it as-is. There is **no `WebFetch`**: do not pretend to read it;\n  if its content matters, say so and ask with the question tool of your agent (`AskUserQuestion`): `I'll paste the relevant part` (recommended) · `Go on without it`; the pasted text is the free-text answer.\n- **A bare subsystem name** (e.g. `combat`) — the existing scan-focus behaviour; this is a\n  Step 3 hint, not author-intent, so it gets no `## Provided Context` entry.\n\nCarry the seed forward to **two places**: the Step 3 scan (as a hint — never as a fact) and\nthe Step 4 `## Provided Context` section + Intent-Gap pre-fill. The seed **never overrides\ncode**: if a code fact and the description disagree, record the code fact (with its pointer)\nand flag the mismatch in the Intent Gap — never bend an extracted fact to fit the description.\n\n### Step 1 — Ensure the workspace (cold-start)\n\nOn cold-start the design workspace does not exist yet (recon runs *before* `unikit-gd-spec`).\n**Create it** before writing — the same guarantee `unikit-gd-spec` makes with its \"Ensure\nthe Workspace\" step:\n\n```\nBash: mkdir -p .unikit\u002Fgamedesign\n```\n\n`RECON.md` lands at `.unikit\u002Fgamedesign\u002FRECON.md` — a sibling of the `GAME.md` the import\nwill produce, not inside `researches\u002F` (it is a top-level seed, consumed once).\n\n### Step 2 — Infer the engine\n\nDetect the engine and its asset conventions from a cold-start scan **per `code-recon.md` →\nStep 1** (the project markers and the per-engine asset-form matrix live there — this skill\nstays engine-agnostic and defers the specifics to the reference), and read the project's\n`.unikit\u002FRULES.md` if present for house conventions — **Rule topics:** with the topic files listed under its `## Topics` whose `Load when` names code conventions, folders or types. Record the detected engine (or the\nambiguity) in the RECON.md banner. Never fabricate an engine.\n\n### Step 3 — Scan (map-reduce)\n\nPartition the project into candidate subsystems (top-level modules \u002F namespaces \u002F asmdefs \u002F\nsource folders), fan out one `recon-agent` per partition (or inline-scan\non fallback), and collect the per-subsystem fact reports. **Pass the Step 0 seed into every\ninvestigator prompt as a hint** (it tells them what systems \u002F genre to expect — but each fact\nstill needs a code pointer; nothing is emitted just because the description claimed it), and\nscan any **seed-named file \u002F folder \u002F subsystem first**. Apply the `code-recon.md`\npriorities: **P0 systems** (roster + `depends_on`), **P1 content** (`CT.fields` + `scale`,\n`RES`\u002F`ENT`\u002F`FORM`). **Flows are excluded** — never emit a flow fact (dynamics are not\nrecoverable from code).\n\n### Step 4 — Synthesise `RECON.md`\n\nReduce the reports into a single `RECON.md` (format below). Every **extracted** fact carries\n`confidence` + a `source` pointer + `provenance: extracted from code`; everything the code\ncould not establish goes into the **`## Intent Gap`**. Write the **durable code-provenance\nbanner** at the very top (it must survive the verbatim copy the import makes into\n`SOURCE.md` — it is the signal the review lens uses to hold the import to ≥ Major).\n\nThen fold in the **Step 0 seed**:\n\n- Write the **`## Provided Context`** section (verbatim description text; files and folders as\n  path references; links as URLs), tagged `provenance: author-supplied (import prompt)` so it\n  is never confused with the code-extracted facts.\n- **Pre-answer the Intent Gap** from that context: when the description states a pillar, the\n  fantasy, the win\u002Flose intent, etc., fill the matching Intent-Gap item with the author's\n  words tagged `(author-supplied — confirm on import)` instead of leaving it open. The gap\n  shrinks honestly; whatever the user did not address stays an open question.\n- If a description claim and a code fact **disagree**, keep the code fact (with its pointer)\n  and record the discrepancy as an Intent-Gap question — the human resolves it on import.\n\n### Step 5 — Recommend (never call)\n\nPrint the recommended next step and **stop**. Do **not** invoke any skill — this skill has\nno `Skill` tool by construction:\n\n- 🗺️ Import into the master spec — \u002Funikit-gd-spec .unikit\u002Fgamedesign\u002FRECON.md\n  ↳ import mode (interactive): extracts a GAME.md from RECON.md and ASKS you to fill the\n    Intent Gap — pillars, fantasy, win\u002Flose intent, the \"why\" code could not carry.\n\n## `RECON.md` format — an import-seed for `GAME.md`\n\n`RECON.md` is shaped so `\u002Funikit-gd-spec \u003Cpath>` **import mode** can consume it as an\nordinary source document (it is preserved verbatim as `SOURCE.md`, then a `GAME.md` is\nextracted and the gaps are asked). It is **not** seeded through the `researches\u002F` research-\nbrief machinery (that is found only by a `research:` \u002F `Target:` pointer; a standalone\n`RECON.md` is not). The shape:\n\n```markdown\n\u003C!-- provenance: extracted from code — brownfield reconstruction by unikit-gd-recon.\n     Every RECONSTRUCTED fact below (Systems \u002F Content Types \u002F Resources·Entities·Forms) is\n     CANDIDATE design INFERRED FROM AN IMPLEMENTATION, not authored design. Review holds it to\n     >= Major (gd-provenance -> extracted from code). The ## Provided Context section is\n     author-supplied INTENT (not code-extracted); the ## Intent Gap lists what code could not\n     answer — a human confirms\u002Ffills it on import. -->\n\n# RECON — Reconstructed Design Skeleton (brownfield, code-extracted)\n\n> Engine: \u003Cdetected> · Project root: \u003Cpath> · Generated: \u003Cdate> by \u002Funikit-gd-recon.\n> This is a SKELETON, not a design. Import with:  \u002Funikit-gd-spec .unikit\u002Fgamedesign\u002FRECON.md\n\n## Provided Context  (author-supplied seed from the invocation — NOT extracted from code)\n\u003C!-- provenance: author-supplied (import prompt) -->\n- **Description \u002F notes** (verbatim): \u003Cthe game description the user gave, or \"—\">\n- **Referenced files**: `path\u002Fto\u002FFile.ext` — \u003Cwhat it is>   (or \"—\")\n- **Referenced folders**: `path\u002Fto\u002Fdir\u002F` — \u003Cwhat it is>   (or \"—\")\n- **Links**: \u003Curl>   (recorded, not fetched — no WebFetch)   (or \"—\")\n\n## Systems (roster skeleton — P0)\n| slug | candidate category | candidate tier | depends_on | confidence | source |\n|------|--------------------|----------------|------------|------------|--------|\n| …    | … (low conf.)      | … (low conf.)  | …          | high\u002F…     | File.cs:42 |\n\n## Content Types (P1)\n### CT-\u003Cslug>  — scale: bulk|curated  ·  belongs_to: \u003CSYS or \"?\">  ·  confidence · source\n`CT.fields`: \u003Cfield:type, …>   (typed per gd-content-axis; ref\u003C> for links)\n\n## Resources · Entities · Forms (facts — P1)\n- RES-\u003Cslug> · ENT-\u003Cslug> · FORM-\u003Cslug>  — confidence · source\n\n## Intent Gap  (MANDATORY — what the code cannot know; a human must confirm\u002Ffill this)\n> Items the ## Provided Context already answers are pre-filled here, tagged\n> \"(author-supplied — confirm on import)\"; everything the seed did not cover stays open.\n- **Pillars \u002F core fantasy \u002F the \"why\"** — code is silent on intent.\n- **Win\u002FLose intent, monetization stance, target aesthetics.**\n- **Are these numbers balanced, or merely current?**\n- **Flows (the dynamics axis)** — not reconstructable from code at all.\n- (…anything a subagent flagged as \"could not determine\"…)\n\n## Explorations  (research backlinks — appended by \u002Funikit-gd-explore; NOT code-extracted)\n\u003C!-- provenance: author-supplied (exploration) -->\n> An accumulating registry of `research:` pointers — the cold-start mirror of the\n> `GD-IDS` `research:` pointer. `\u002Funikit-gd-recon` leaves this empty (or omits it);\n> `\u002Funikit-gd-explore` (RECON-input mode) appends one line per research it works out of\n> the Intent Gap. Recon never writes here.\n- research: `researches\u002F\u003Cslug>\u002F` — \u003C1-line topic>  (Target: \u003CSYS-slug | Intent-Gap item>)\n```\n\nThe `## Intent Gap` is the load-bearing section: it is what stops a confident-looking but\nhollow skeleton from masquerading as a finished GDD. Never trim it to look more complete.\nThe `## Explorations` section is **explore's** to append (RECON-input mode) — recon emits\nit empty or omits it; the backlinks are author-supplied research pointers, never\ncode-extracted facts.\n\n## Ownership Boundaries\n\n- **Owns:** the single `.unikit\u002Fgamedesign\u002FRECON.md` document — nothing else. No `GD-IDS`,\n  no `GAME.md`, no `SYSTEM.md` \u002F `CONTENT-TYPE.md` \u002F `FLOW.md`, no registry fact, no `[gen]`\n  render. `Write` is in `allowed-tools` for `RECON.md` alone (a path scope is not\n  expressible, so the guarantee is the body + the absence of any other write). One other\n  writer is **sanctioned**: `unikit-gd-explore` (RECON-input mode) appends `research:`\n  backlinks to the **`## Explorations`** section — recorded here and in that skill's\n  Ownership. Recon writes the rest of `RECON.md`; it never writes `## Explorations`.\n- **Reads:** project source, configs, and asset definitions (the sanctioned third exception\n  to the one-way boundary) + any file or folder the user names in the seed + the gd-principles\n  core, `gd-provenance`, and `code-recon.md`. The optional **seed** (a game description,\n  notes, file\u002Ffolder paths, links) is recorded verbatim in `## Provided Context` and used as a\n  scan hint — never as a code fact.\n- **Never:** call any skill (there is **no `Skill` tool** — the handoff to `\u002Funikit-gd-spec`\n  is a printed recommendation); run once a GDD exists (cold-start gate → `unikit-gd-explore`);\n  emit a flow fact; invent intent (it goes in the Intent Gap); bend an extracted fact to match\n  the seed; fetch a URL (no `WebFetch` — provided links are recorded, never opened); promote a\n  fact off `extracted from code` (only a human, downstream, may).\n\n## Quick Reference\n\n```\n\u002Funikit-gd-recon                      → scan the whole project → .unikit\u002Fgamedesign\u002FRECON.md → recommend \u002Funikit-gd-spec import\n\u002Funikit-gd-recon combat               → focus the scan on the combat subsystem (still one whole RECON.md)\n\u002Funikit-gd-recon \"it's a roguelike deck-builder; pillars: …\"  → seed the scan + record the description in ## Provided Context, pre-fill the Intent Gap\n\u002Funikit-gd-recon docs\u002Fpitch.md Assets\u002FEconomy\u002F  → record the file + folder as references in ## Provided Context, scan them first\n\u002Funikit-gd-recon  (GDD already exists) → STOP → recommend \u002Funikit-gd-explore code lens (targeted slice, not cold-start)\n```\n","# Game Design — Brownfield Reconnaissance (code → RECON.md)\n\nReconstruct **candidate** design facts from a working codebase into one passive\n`RECON.md`, for the brownfield case the rest of the module cannot serve: a team with a\n**live game and no GDD** has nothing to import — the only source of design facts is the\ncode itself. This skill quantises that one allowed crossing of the one-way boundary into a\n**read-only research verb**: it reads code, writes a single document, and **calls no one**.\n\n**This skill is honest about its limit.** Code carries *structure*, never *intent*. It\nyields a roster, a dependency graph, content schemas — a **skeleton**. It cannot yield\npillars, the target fantasy, or the \"why\". A filled-but-soulless GDD is **worse** than an\nempty one, so every reconstructed fact is tagged `provenance: extracted from code` (held to\n≥ Major on review) and everything code cannot answer goes into a mandatory **`## Intent\nGap`** for a human to fill. The membrane is one-directional: **code → `RECON.md` →\n(ordinary import)**. Downstream, `RECON.md` is just a document.\n\n**This skill writes only `RECON.md` and invokes no skill.** It has **no `Skill` tool** — the\ndispatch to `\u002Funikit-gd-spec` is a printed *recommendation*, never an inline call (the same\nmechanical guarantee `unikit-gd-apply` gets from owning no `Write`).\n\n**Optional seed — what the user may pass in.** Recon runs with **no argument** (scan the\nwhole project) or with an **optional seed**: a free-text game description, design notes,\nfile or folder paths to look at first, or reference links. The seed is *context, never a\nconstraint* — it sharpens the scan (the model knows what systems \u002F genre to expect) and lets\nrecon **pre-answer** Intent-Gap items the code is silent on (pillars, fantasy, the \"why\").\nWhatever the user passes is **recorded in `RECON.md`** under a `## Provided Context` section —\ndescription text inline (verbatim), files and folders as path references, links as URLs — and\ntagged `provenance: author-supplied (import prompt)`: author-sourced **intent**, the trusted\ncomplement to the *suspect* `extracted from code` facts (a recon-local label; on import it\nbecomes ordinary trusted source content). Recon still reads code, still writes only\n`RECON.md`, still calls no one. It has **no `WebFetch`** — links are recorded, not opened (if\ntheir content matters, ask the user to paste it).\n\n**User questions.** Right before your first question to the user, not earlier, read `.unikit\u002Fsystem\u002Fuser-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.\n\n## Language Awareness — BLOCKING PRE-REQUISITE\n\n**BEFORE producing ANY output**, silently read `.unikit\u002Fsystem\u002FLANGUAGE_RULES.md` and apply\nit to all output (fall back to English if it is missing) — including **translate concepts,\nnot transliterate jargon**. `gd-principles` → \"Language\" adds the game-design specifics:\nIDs, keywords, canonical terms, and stored field values stay English; the RECON.md prose is\nauthored in the project's artifact language. Do not announce the language setting.\n\n**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.\n\n## Phase 0 — Bootstrap\n\nSilently load — do not narrate:\n\n1. **`.unikit\u002Fsystem\u002Fgamedesign\u002Fgd-principles.md`** (the core) — for the **One-Way\n   Boundary** and its **third sanctioned exception** (the read-only research verbs read code\n   to extract candidate facts into a document; authoring zones never do) and the\n   facts-registry \u002F ID conventions.\n2. **`.unikit\u002Fsystem\u002Fgamedesign\u002Fgd-provenance.md`** — for the **`extracted from code`**\n   marker and the durable-banner contract this skill must emit so the import membrane does\n   not launder code-facts into trusted author-sourced content.\n3. **`{{skills_dir}}\u002F{{self_name}}\u002Freferences\u002Fcode-recon.md`** — the **shared `code →\n   design-fact` engine** (engine inference, the P0\u002FP1 extraction heuristics, the per-fact\n   record format). This is the source of truth for *what to look for*; this skill owns the\n   output document and the orchestration. If missing, warn (`unikit-ai update`) and proceed\n   with the summary below.\n\n**One-way boundary, the sanctioned half:** this verb **does** read project source, configs,\nand asset definitions — that is its purpose and its exception. It **never** writes anything\nbut `RECON.md`, and it **never** calls an authoring zone.\n\n## Cold-start gate — BLOCKING\n\nRecon is **strictly cold-start**. Check the workspace **first**:\n\n- If **`.unikit\u002Fgamedesign\u002FGAME.md`** exists (or `GD-IDS.yaml` exists) → a GDD is already\n  underway. **STOP** and recommend the **`unikit-gd-explore` code-grounded lens** instead:\n  it grounds a *targeted in-flight slice* against code without re-bootstrapping the whole\n  design (\"how is loot wired in the code?\"). Recon's whole-project scan is wrong once a GDD\n  exists. Do not proceed.\n- If neither exists → this is the cold-start case recon is for. Continue.\n\n\u003C!-- unikit:extension-point:bootstrap -->\n\n## Subagent launches\n\n**Subagent arguments.** Before the first subagent you launch, read `.unikit\u002Fsystem\u002Fsubagent-arguments.md`\nand `.unikit\u002Fconfig.yaml` once and settle the model and effort of every launch as that file says.\nKeys: `subagents.model.{{agent_id}}.\u003Crole>`, `subagents.effort.{{agent_id}}.\u003Crole>`;\nbuilt-in model of a reader and a validator: `\"{{agent_model_default}}\"`, of an executor: none.\nIf the file cannot be read, print\n`WARN [delegation] subagent-arguments contract missing — built-in model tier used, effort not passed`\nand use that model, no effort.\n\n## Delegation agents\n\nThis skill uses a named delegation alias for `Agent(...)` calls. The alias is the single\nplace where its delegate's agent type and call arguments are declared — call sites name\nthe alias and never carry a type or a model argument of their own.\n\n- **`recon-agent`** — read-only parallel reconnaissance. Expands to:\n\n  ```\n  Agent({{agent_call_reader}} prompt: \"\u003Cfocused question> You are read-only: edit and write nothing.\")\n  ```\n\n  Every question you send ends with the sentence `You are read-only: edit and write nothing.`, verbatim.\n\n  Fallback: if the `Agent` tool is unavailable, investigate inline with `Glob`\u002F`Grep`\u002F`Read`.\n\n## Scan delegation\n\nThe scan is a **map-reduce**: fan out one read-only investigator per candidate subsystem,\nthen reduce their reports into `RECON.md`. Use the `recon-agent` alias — **not**\n`unity-source-parser` (a dev-repo-local agent that will not exist in a user's project; this\nmodule ships **no new subagents**). Engine is inferred from the cold-start scan, not assumed.\n\n```\nrecon-agent(prompt:\n  \"In [project root], investigate the [subsystem] code. Seed from the user (a HINT, not\n   ground truth — verify every claim against the code, never invent a fact to match it):\n   [the game description \u002F notes the user provided, or 'none']. Report, per code-recon.md\n   heuristics: candidate systems (module\u002Fnamespace\u002Fasmdef boundaries) + depends_on edges;\n   data-asset definitions → CT.fields schema + scale; RES\u002FENT\u002FFORM shapes. Give a\n   file:line source pointer and a confidence grade for every fact. Do NOT infer intent\n   (pillars\u002Ffantasy\u002Fwhy) — list what you could NOT determine. Be concise: structured facts,\n   not file contents.\")\n```\n\n**Fallback (inline).** If the `Agent` tool is unavailable, the assistant scans **inline**\nitself with `Glob` \u002F `Grep` \u002F `Read` over the same `code-recon.md` heuristics — slower, same\noutput. Never skip the scan; never ask the user to run it by hand.\n\n## Pipeline — CAPTURE → SCAN → SYNTHESISE → RECOMMEND\n\n### Step 0 — Capture the provided context (optional seed)\n\nLook at what the user passed with the invocation and **classify it** — there may be several\nkinds at once, and none is required:\n\n- **Free-text game description \u002F design notes** — keep the text **verbatim** for the\n  `## Provided Context` section, and mine it for **intent** (pillars, fantasy, win\u002Flose,\n  genre, tone) to pre-answer Intent-Gap items in Step 4.\n- **A file path** — record it as a reference. If it reads as design material (a pitch, a\n  notes doc, a spec), `Read` it and fold its stated intent into the seed; if it is code,\n  treat it as a **scan-focus** pointer (Step 3). Either way the reference lands in\n  `## Provided Context`.\n- **A folder path** — record it as a reference and use it as a **scan-focus** for Step 3\n  (still one whole-project `RECON.md`).\n- **A link (URL)** — record it as-is. There is **no `WebFetch`**: do not pretend to read it;\n  if its content matters, say so and ask with the question tool of your agent (`AskUserQuestion`): `I'll paste the relevant part` (recommended) · `Go on without it`; the pasted text is the free-text answer.\n- **A bare subsystem name** (e.g. `combat`) — the existing scan-focus behaviour; this is a\n  Step 3 hint, not author-intent, so it gets no `## Provided Context` entry.\n\nCarry the seed forward to **two places**: the Step 3 scan (as a hint — never as a fact) and\nthe Step 4 `## Provided Context` section + Intent-Gap pre-fill. The seed **never overrides\ncode**: if a code fact and the description disagree, record the code fact (with its pointer)\nand flag the mismatch in the Intent Gap — never bend an extracted fact to fit the description.\n\n### Step 1 — Ensure the workspace (cold-start)\n\nOn cold-start the design workspace does not exist yet (recon runs *before* `unikit-gd-spec`).\n**Create it** before writing — the same guarantee `unikit-gd-spec` makes with its \"Ensure\nthe Workspace\" step:\n\n```\nBash: mkdir -p .unikit\u002Fgamedesign\n```\n\n`RECON.md` lands at `.unikit\u002Fgamedesign\u002FRECON.md` — a sibling of the `GAME.md` the import\nwill produce, not inside `researches\u002F` (it is a top-level seed, consumed once).\n\n### Step 2 — Infer the engine\n\nDetect the engine and its asset conventions from a cold-start scan **per `code-recon.md` →\nStep 1** (the project markers and the per-engine asset-form matrix live there — this skill\nstays engine-agnostic and defers the specifics to the reference), and read the project's\n`.unikit\u002FRULES.md` if present for house conventions — **Rule topics:** with the topic files listed under its `## Topics` whose `Load when` names code conventions, folders or types. Record the detected engine (or the\nambiguity) in the RECON.md banner. Never fabricate an engine.\n\n### Step 3 — Scan (map-reduce)\n\nPartition the project into candidate subsystems (top-level modules \u002F namespaces \u002F asmdefs \u002F\nsource folders), fan out one `recon-agent` per partition (or inline-scan\non fallback), and collect the per-subsystem fact reports. **Pass the Step 0 seed into every\ninvestigator prompt as a hint** (it tells them what systems \u002F genre to expect — but each fact\nstill needs a code pointer; nothing is emitted just because the description claimed it), and\nscan any **seed-named file \u002F folder \u002F subsystem first**. Apply the `code-recon.md`\npriorities: **P0 systems** (roster + `depends_on`), **P1 content** (`CT.fields` + `scale`,\n`RES`\u002F`ENT`\u002F`FORM`). **Flows are excluded** — never emit a flow fact (dynamics are not\nrecoverable from code).\n\n### Step 4 — Synthesise `RECON.md`\n\nReduce the reports into a single `RECON.md` (format below). Every **extracted** fact carries\n`confidence` + a `source` pointer + `provenance: extracted from code`; everything the code\ncould not establish goes into the **`## Intent Gap`**. Write the **durable code-provenance\nbanner** at the very top (it must survive the verbatim copy the import makes into\n`SOURCE.md` — it is the signal the review lens uses to hold the import to ≥ Major).\n\nThen fold in the **Step 0 seed**:\n\n- Write the **`## Provided Context`** section (verbatim description text; files and folders as\n  path references; links as URLs), tagged `provenance: author-supplied (import prompt)` so it\n  is never confused with the code-extracted facts.\n- **Pre-answer the Intent Gap** from that context: when the description states a pillar, the\n  fantasy, the win\u002Flose intent, etc., fill the matching Intent-Gap item with the author's\n  words tagged `(author-supplied — confirm on import)` instead of leaving it open. The gap\n  shrinks honestly; whatever the user did not address stays an open question.\n- If a description claim and a code fact **disagree**, keep the code fact (with its pointer)\n  and record the discrepancy as an Intent-Gap question — the human resolves it on import.\n\n### Step 5 — Recommend (never call)\n\nPrint the recommended next step and **stop**. Do **not** invoke any skill — this skill has\nno `Skill` tool by construction:\n\n- 🗺️ Import into the master spec — \u002Funikit-gd-spec .unikit\u002Fgamedesign\u002FRECON.md\n  ↳ import mode (interactive): extracts a GAME.md from RECON.md and ASKS you to fill the\n    Intent Gap — pillars, fantasy, win\u002Flose intent, the \"why\" code could not carry.\n\n## `RECON.md` format — an import-seed for `GAME.md`\n\n`RECON.md` is shaped so `\u002Funikit-gd-spec \u003Cpath>` **import mode** can consume it as an\nordinary source document (it is preserved verbatim as `SOURCE.md`, then a `GAME.md` is\nextracted and the gaps are asked). It is **not** seeded through the `researches\u002F` research-\nbrief machinery (that is found only by a `research:` \u002F `Target:` pointer; a standalone\n`RECON.md` is not). The shape:\n\n```markdown\n\u003C!-- provenance: extracted from code — brownfield reconstruction by unikit-gd-recon.\n     Every RECONSTRUCTED fact below (Systems \u002F Content Types \u002F Resources·Entities·Forms) is\n     CANDIDATE design INFERRED FROM AN IMPLEMENTATION, not authored design. Review holds it to\n     >= Major (gd-provenance -> extracted from code). The ## Provided Context section is\n     author-supplied INTENT (not code-extracted); the ## Intent Gap lists what code could not\n     answer — a human confirms\u002Ffills it on import. -->\n\n# RECON — Reconstructed Design Skeleton (brownfield, code-extracted)\n\n> Engine: \u003Cdetected> · Project root: \u003Cpath> · Generated: \u003Cdate> by \u002Funikit-gd-recon.\n> This is a SKELETON, not a design. Import with:  \u002Funikit-gd-spec .unikit\u002Fgamedesign\u002FRECON.md\n\n## Provided Context  (author-supplied seed from the invocation — NOT extracted from code)\n\u003C!-- provenance: author-supplied (import prompt) -->\n- **Description \u002F notes** (verbatim): \u003Cthe game description the user gave, or \"—\">\n- **Referenced files**: `path\u002Fto\u002FFile.ext` — \u003Cwhat it is>   (or \"—\")\n- **Referenced folders**: `path\u002Fto\u002Fdir\u002F` — \u003Cwhat it is>   (or \"—\")\n- **Links**: \u003Curl>   (recorded, not fetched — no WebFetch)   (or \"—\")\n\n## Systems (roster skeleton — P0)\n| slug | candidate category | candidate tier | depends_on | confidence | source |\n|------|--------------------|----------------|------------|------------|--------|\n| …    | … (low conf.)      | … (low conf.)  | …          | high\u002F…     | File.cs:42 |\n\n## Content Types (P1)\n### CT-\u003Cslug>  — scale: bulk|curated  ·  belongs_to: \u003CSYS or \"?\">  ·  confidence · source\n`CT.fields`: \u003Cfield:type, …>   (typed per gd-content-axis; ref\u003C> for links)\n\n## Resources · Entities · Forms (facts — P1)\n- RES-\u003Cslug> · ENT-\u003Cslug> · FORM-\u003Cslug>  — confidence · source\n\n## Intent Gap  (MANDATORY — what the code cannot know; a human must confirm\u002Ffill this)\n> Items the ## Provided Context already answers are pre-filled here, tagged\n> \"(author-supplied — confirm on import)\"; everything the seed did not cover stays open.\n- **Pillars \u002F core fantasy \u002F the \"why\"** — code is silent on intent.\n- **Win\u002FLose intent, monetization stance, target aesthetics.**\n- **Are these numbers balanced, or merely current?**\n- **Flows (the dynamics axis)** — not reconstructable from code at all.\n- (…anything a subagent flagged as \"could not determine\"…)\n\n## Explorations  (research backlinks — appended by \u002Funikit-gd-explore; NOT code-extracted)\n\u003C!-- provenance: author-supplied (exploration) -->\n> An accumulating registry of `research:` pointers — the cold-start mirror of the\n> `GD-IDS` `research:` pointer. `\u002Funikit-gd-recon` leaves this empty (or omits it);\n> `\u002Funikit-gd-explore` (RECON-input mode) appends one line per research it works out of\n> the Intent Gap. Recon never writes here.\n- research: `researches\u002F\u003Cslug>\u002F` — \u003C1-line topic>  (Target: \u003CSYS-slug | Intent-Gap item>)\n```\n\nThe `## Intent Gap` is the load-bearing section: it is what stops a confident-looking but\nhollow skeleton from masquerading as a finished GDD. Never trim it to look more complete.\nThe `## Explorations` section is **explore's** to append (RECON-input mode) — recon emits\nit empty or omits it; the backlinks are author-supplied research pointers, never\ncode-extracted facts.\n\n## Ownership Boundaries\n\n- **Owns:** the single `.unikit\u002Fgamedesign\u002FRECON.md` document — nothing else. No `GD-IDS`,\n  no `GAME.md`, no `SYSTEM.md` \u002F `CONTENT-TYPE.md` \u002F `FLOW.md`, no registry fact, no `[gen]`\n  render. `Write` is in `allowed-tools` for `RECON.md` alone (a path scope is not\n  expressible, so the guarantee is the body + the absence of any other write). One other\n  writer is **sanctioned**: `unikit-gd-explore` (RECON-input mode) appends `research:`\n  backlinks to the **`## Explorations`** section — recorded here and in that skill's\n  Ownership. Recon writes the rest of `RECON.md`; it never writes `## Explorations`.\n- **Reads:** project source, configs, and asset definitions (the sanctioned third exception\n  to the one-way boundary) + any file or folder the user names in the seed + the gd-principles\n  core, `gd-provenance`, and `code-recon.md`. The optional **seed** (a game description,\n  notes, file\u002Ffolder paths, links) is recorded verbatim in `## Provided Context` and used as a\n  scan hint — never as a code fact.\n- **Never:** call any skill (there is **no `Skill` tool** — the handoff to `\u002Funikit-gd-spec`\n  is a printed recommendation); run once a GDD exists (cold-start gate → `unikit-gd-explore`);\n  emit a flow fact; invent intent (it goes in the Intent Gap); bend an extracted fact to match\n  the seed; fetch a URL (no `WebFetch` — provided links are recorded, never opened); promote a\n  fact off `extracted from code` (only a human, downstream, may).\n\n## Quick Reference\n\n```\n\u002Funikit-gd-recon                      → scan the whole project → .unikit\u002Fgamedesign\u002FRECON.md → recommend \u002Funikit-gd-spec import\n\u002Funikit-gd-recon combat               → focus the scan on the combat subsystem (still one whole RECON.md)\n\u002Funikit-gd-recon \"it's a roguelike deck-builder; pillars: …\"  → seed the scan + record the description in ## Provided Context, pre-fill the Intent Gap\n\u002Funikit-gd-recon docs\u002Fpitch.md Assets\u002FEconomy\u002F  → record the file + folder as references in ## Provided Context, scan them first\n\u002Funikit-gd-recon  (GDD already exists) → STOP → recommend \u002Funikit-gd-explore code lens (targeted slice, not cold-start)\n```\n",{"name":5,"metadata":60,"description":7,"allowed-tools":64,"argument-hint":77,"user-invocable":78,"disable-model-invocation":56},{"author":61,"version":62,"category":63},"unikit","1.0","game-design",[65,66,67,68,69,70,71,72,73,74,75,76],"Read","Glob","Grep","Write","Bash(mkdir *)","Bash(ls *)","Bash(find *)","Bash(grep *)","Bash(wc *)","Bash(date *)","Agent","AskUserQuestion","[optional: a game description, notes, or links — and\u002For a subsystem to focus the scan]  (cold-start only; writes RECON.md, calls no skill)",true,"main","ae3c6dfffd26d9b45b9d96d71ba2c122c50b67ae","skills\u002Funikit-gd-recon",1,"https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai","https:\u002F\u002Funikit.nintenda.dev","https:\u002F\u002Fgithub.com\u002FNintendaDev","Unity Developer. Building games and UniKit AI","2026-11-08 15:05:51",{"source":8,"skillName":5,"commands":89,"prompt":99,"zipAvailable":78},[90,93,96],{"tool":91,"command":92},"npx","npx skills add NintendaDev\u002Funikit-ai --skill unikit-gd-recon",{"tool":94,"command":95},"bunx","bunx skills add NintendaDev\u002Funikit-ai --skill unikit-gd-recon",{"tool":97,"command":98},"pnpm","pnpm dlx skills add NintendaDev\u002Funikit-ai --skill unikit-gd-recon","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai\u002Fblob\u002Fmain\u002Fskills\u002Funikit-gd-recon\u002FSKILL.md",[101],{"path":102,"resourceType":103,"resourceTypeDesc":104,"sizeBytes":105,"sourceHtmlUrl":106},"references\u002Fcode-recon.md","REFERENCE","参考文档",9397,"https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai\u002Fblob\u002Fmain\u002Fskills\u002Funikit-gd-recon\u002Freferences\u002Fcode-recon.md",[108,131,156,178,197,223],{"skillNo":109,"name":61,"nameZh":6,"description":110,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":111,"categories":112,"keywords":114,"publishedAt":55},"01M71BQ00EXGX51PPCDY7VG334","Initialize the UniKit framework in a project. Scans the current project to detect the engine and real tech stack, then generates the base framework documents that give AI agents context about the project — the resolved project description, the architecture doc, AGENTS.md, and the user-editable .unikit\u002Fconfig.yaml. This is the one-time, whole-project setup run before any other unikit skill. Use whenever the user wants to initialize, set up, or onboard the framework, e.g. \"initialize unikit\", \"init the framework\", \"set up unikit\", \"set up the project\", \"configure AI context\", \"scan my project and set it up\", \"bootstrap the project\". It also actualizes the config of a project already set up — say \"update the config\", \"add missing settings\", \"actualize configuration\", \"fix my config\". On a set-up project it offers the actions to choose from.","https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai\u002Fblob\u002Fmain\u002Fskills\u002Funikit\u002FSKILL.md",[113],{"categoryNo":24,"categoryName":25,"taxonomyType":21,"taxonomyTypeDesc":22},[61,50,115,116,117,118,119,120,121,122,40,39,123,124,125,126,127,128,129,130],"time","actions","fix","documents","architecture","stack","run","update","config","edit","git","context","initialize","tech","scan","use",{"skillNo":132,"name":133,"nameZh":6,"description":134,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":135,"categories":136,"keywords":141,"publishedAt":55},"01M71BPRTMKW7FRAZZBN44NW5Q","unikit-verify","Verify a completed implementation against the plan in .unikit\u002Fcode\u002Fplans\u002F. Checks that every task was implemented, nothing was forgotten, the code compiles, the recorded test run still matches the code, and {{engine_name}} conventions are followed. Use after \u002Funikit-implement completes, or when the user says \"verify\", \"check the work\", \"did we miss anything\". For code review use \u002Funikit-review instead.","https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai\u002Fblob\u002Fmain\u002Fskills\u002Funikit-verify\u002FSKILL.md",[137,140],{"categoryNo":138,"categoryName":139,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000007","代码审查",{"categoryNo":24,"categoryName":25,"taxonomyType":21,"taxonomyTypeDesc":22},[142,143,144,145,146,147,121,40,39,124,125,148,149,130,150,151,152,153,154,155],"unikit verify","verify","powershell","code review","phase","plan","for","system","implement","check","engine","research","name","quality",{"skillNo":157,"name":158,"nameZh":6,"description":159,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":160,"categories":161,"keywords":162,"publishedAt":55},"01M71BPM35M5ETPA4E7EKQYRWD","unikit-todo","Manage the project's TODO list in .unikit\u002FTODO.md — capture work to remember for later, not to do right now. Use it to add a deferred item, mark a todo complete, or show the list. The point is to park tasks you don't want to act on in the moment but don't want to forget. Trigger on \"add a todo\", \"add this to the todo list\", \"put X on the todo list\", \"remind me to...\", \"don't forget to...\", \"note this for later\", \"we should do this later\", \"mark this todo done\", \"what's on the todo list\", \"what's left to do\". This is only for parking reminders — to actually plan or do the work now, use \u002Funikit-plan, \u002Funikit-implement, or \u002Funikit-execute.","https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai\u002Fblob\u002Fmain\u002Fskills\u002Funikit-todo\u002FSKILL.md",[],[163,164,165,166,50,167,168,169,170,171,172,173,147,174,175,176,40,39,124,177],"unikit todo","todo","remind","show","todo list","only","now","you","done","tasks","work","me","reminders","later","act",{"skillNo":179,"name":180,"nameZh":6,"description":181,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":182,"categories":183,"keywords":185,"publishedAt":55},"01M71BPEQDVD7DTGFQBQJQ7JKY","unikit-skills-context","Customize how a built-in unikit skill behaves in this specific project by writing workflow overrides into its skill-context file. These are per-skill workflow rules (e.g. \"\u002Funikit-review should also flag TODO comments\", \"\u002Funikit-implement should run tests after each task\"), not coding conventions. Use when the user wants to change, customize, or override how a particular unikit skill works in this project — \"customize the review skill\", \"make \u002Funikit-fix always add logging here\", \"the implement skill should do X differently\", \"add a skill rule for \u002Funikit-commit\". Use \"validate\" to find stale overrides against updated base skills. For a general coding convention (not tied to one skill) use \u002Funikit-rules; to derive rules from past mistakes use \u002Funikit-evolve.","https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai\u002Fblob\u002Fmain\u002Fskills\u002Funikit-skills-context\u002FSKILL.md",[184],{"categoryNo":24,"categoryName":25,"taxonomyType":21,"taxonomyTypeDesc":22},[186,126,50,117,187,188,189,190,191,192,193,44,164,194,195,121,196,40,39,124],"unikit skills context","coding conventions","writing","when","workflow","commit","review","general coding","change","how","past",{"skillNo":198,"name":199,"nameZh":6,"description":200,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":201,"categories":202,"keywords":210,"publishedAt":55},"01M71BP7K5KEGJV4ASRKPG1DM8","unikit-rules","Add a short, project-specific rule, convention, or override to .unikit\u002FRULES.md — the quick-capture inbox for this project's rules (common rules always load; topic files in .unikit\u002Frules\u002F load when the work matches), automatically loaded by \u002Funikit-implement (later promotable via \u002Funikit-memory migrate-rules). Works only with a rule typed as a prompt — it does NOT read files, folders, URLs, or PDFs. Cross-checks the knowledge base (RULES_INDEX.md) to avoid duplicating core\u002Fstack entries. Use for one-line conventions and corrections: \"add a rule\", \"remember this\", \"convention\", \"always do X\", \"never use Y\", \"from now on do Z\", or when the user corrects agent behavior and wants it remembered; also \"split the rules into topics\" (optimise), \"clean up the rules\" (prune), \"shorten RULES.md\" (compact), by keyword or in plain words. If the user points to a source (file, folder, URL, PDF, article, book) or wants to research\u002Fdocument framework usage, use \u002Funikit-memory; for architecture decisions use ARCHITECTURE.md.","https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai\u002Fblob\u002Fmain\u002Fskills\u002Funikit-rules\u002FSKILL.md",[203,206,209],{"categoryNo":204,"categoryName":205,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000002","文档处理",{"categoryNo":207,"categoryName":208,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000021","资料检索与研究",{"categoryNo":24,"categoryName":25,"taxonomyType":21,"taxonomyTypeDesc":22},[211,212,213,214,50,215,216,217,218,219,119,220,44,221,120,176,40,39,124,222],"Rules","unikit rules","quick","PDF","clean","knowledge","files","URL","migrate","batch","knowledge base","prune",{"skillNo":224,"name":225,"nameZh":6,"description":226,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":227,"categories":228,"keywords":229,"publishedAt":55},"01M71BP02S49HHD4R5X6N12C9Q","unikit-rules-registry","Orchestrate the remote rules registry — the shared registry (often connected as a local folder or git repo) that the project's rules are published to and pulled from. Three modes, picked from the user's wording: create scaffolds a new local rules registry (\"create a local rules registry\", \"init a rules registry\"); update migrates\u002Fpromotes local knowledge-base rules from .unikit\u002Fmemory\u002F into the remote registry with automatic semver bumps (\"migrate local rules to the remote registry\", \"promote my rules to the registry\", \"push local rules\", \"publish local rules\", \"update the rules registry\"); sync pulls registry updates back into memory (\"sync the rules registry\", \"pull registry updates\"). Pass \"--module \u003Cid>\" to scope to one knowledge-base module. This skill ONLY orchestrates the CLI (`unikit-ai rules *`) — it never edits .unikit.json or .unikit\u002Fmemory\u002F sources directly.","https:\u002F\u002Fgithub.com\u002FNintendaDev\u002Funikit-ai\u002Fblob\u002Fmain\u002Fskills\u002Funikit-rules-registry\u002FSKILL.md",[],[230,211,231,232,50,233,216,234,219,43,122,40,39,125,235,236,237,238,239,240],"registry","unikit rules registry","shared","local","remote","ai rules","automatic","semver","knowledge-base","as","three"]