3.0.1

🚀 3.0.1 - Tests on your terms, hash checks without Git Bash

This release stops the agent from writing or running tests unless you ask for them. The checks that compare a plan with its research and with its last test run now work in any shell on Windows.

✨ Tests only when you ask

/unikit-execute and /unikit-fix no longer write or run tests by themselves. They ask first and say which tests would run. With no answer, nothing is written and nothing runs.

What's included

• /unikit-execute asks once after a logic change: no tests (the first option), tests written after you accept the result, or a run of the existing tests.
• Tests you ask for in the task wait until you accept the result. The closing question then offers Accept and write the tests first.
• /unikit-fix asks once before its test run. Your answer also covers one repeat after a red result.
• Unsaved changes in an open scene are never saved or thrown away without asking. You choose: save them yourself (recommended), let the agent save them, or discard them.
• The testing.run settings now also decide how wide a /unikit-execute run goes.

🧩 Hash checks work in any shell

The research drift check and the test-run record now use two small Node scripts installed into .unikit/system/. They give the same result in PowerShell and in Git Bash, and Git Bash is no longer required. The test-run record now depends only on file content, so a commit no longer makes it stale, whoever made it.

Details

• research-hash.mjs needs only Node. If it cannot run, you get one info line and the drift check is skipped. Verification does not fail because of it.
• tree-hash.mjs needs Node and git. If it cannot run, you get a warning saying the test record was not checked.
• A project in a subfolder of a repository counts only its own files. If you change a file next to it, run the tests yourself.

⚠️ After you update

Test-run records written by an older version will show as stale until all tests run once again. A plan in progress runs the full suite one extra time at its final checkpoint. A finished plan keeps the warning until /unikit-verify --strict runs the suite.

📇 Shorter research indexes

researches/INDEX.md is now a compact table with one row per research. Each row's description comes from the research's Topic: line, up to 250 characters, and older longer topics are shortened in the table. The research files themselves are not changed.

Details

• Archived research gets its own archive/researches/INDEX.md. Archiving or restoring rebuilds both indexes once.
• Restoring a research will not overwrite an active one with the same name.
• If an index is missing, the agent searches the research folders instead, without changing anything.
• Planning offers only active research. Reading the archive never restores anything.

---

Full Changelog: 3.0.0...development

3.0.0

🚀 3.0.0 - Engine bridges and the Unity CLI

Agents can now reach the game editor through several bridges at once, including Unity's own command line. unikit-ai update moves 2.x projects to the new layout.

⚠️ Breaking Changes

• Engine MCP servers became engine bridges. unikit-ai update moves them from mcp.servers to engineBridges.selected in .unikit.json and moves the findings logs to .unikit/bridge-notes/. It also rewrites ## MCP Findings in your plans but does not commit the change, so review that diff and commit it yourself. Until a 2.x project is updated, rules sync and rules install stop with exit code 8.
• Three skills were renamed. /unikit-mcp-trap is now /unikit-bridge-trap, /unikit-mcp-audit is now /unikit-bridge-audit and /unikit-devcontext is now /unikit-execute. update installs the new names in place of the old ones. Two things are left to you: move .unikit/skill-context/unikit-devcontext/ to .unikit/skill-context/unikit-execute/, and change studio rules whose Required By names unikit-devcontext to name unikit-execute.
• Four template variables for extensions were replaced. {{system_engine_mcp_dir}}, {{engine_mcp_rules_index}}, {{engine_mcp_rules_verification}} and {{engine_mcp_tool}} are no longer filled in. Use {{system_engine_bridges_dir}}, {{engine_bridges_manifest}} and {{engine_bridge_mcp_code}} instead.

Upgrade guide: Migrating to 3.0.0

🧩 Engine Bridges

Pick any number of editor bridges, MCP servers or the Unity CLI, and agents try them in the order you set. A check that one bridge cannot do moves on to the next.

What's included

• Unity CLI bridge (Unity 6000.0+, com.unity.pipeline package), checked by default on a fresh Unity setup; /unikit checks the environment and asks before running unity pipeline install
• The order lives in .unikit/bridges.yaml: edit it by hand or ask /unikit-bridge-route, and nothing gets reinstalled
• New /unikit-bridge-route saves rules like "run tests only through the CLI" in .unikit/bridge-routing.md
• Each bridge has its own findings file in .unikit/bridge-notes/; when you drop a bridge its file is archived, and it comes back when you re-add the bridge
• init offers optional registry rules for the selected MCP servers and bridges; update asks before adding new ones and remembers what you declined

🏗 Architecture Topics

/unikit-architecture can split a large .unikit/ARCHITECTURE.md into a short root file and topic files in .unikit/architecture/. Skills then load only the topics that match the work at hand.

Details

• update mode rescans the project and adds what is missing, removing nothing
• optimise mode moves the existing text into topics word for word, only after you confirm
• Planning, implementation, checks and reviews pick topics by the task or the changed files

✨ Skills and Agents

Small tasks can now be done without a plan, and a project that is already set up gets a menu instead of the full setup again. To add the new skills to an existing project, run unikit-ai update --install-new.

What's included

• /unikit-execute does one task straight from its description, in code or in the editor, and checks that the code compiles
• /unikit-references keeps your own documents and links for the agents in .unikit/references/, with an index
• On a project that is already set up, /unikit offers four actions: add missing config keys, check the environment, create stack rules, or rescan and rewrite the project description
• /unikit-archive now also archives and restores code researches, and plans still find a linked research after it is archived
• Kimi Code can set subagent models per role (subagents.model.kimi.<role>), using the template .kimi-code/kimi-subagent-models.toml, which you merge into your Kimi config by hand

🐛 Fixes

• Plan task fields (WHY:, Files:, Editor:, …) are now separate paragraphs, so Markdown viewers no longer merge them into one line
• Reviewers started by /unikit-review now use the subagent model and effort set in .unikit/config.yaml

---

Full Changelog: 2.5.0...3.0.0

2.5.0

🚀 2.5.0 - Balance, experiments and extension control

Two new game-design skills cover balancing and cheap experiments, and extensions get finer control. Two settings behave differently, so read the next block before you upgrade.

⚠️ Breaking Changes

• subagents.model.<agent> is now a map of roles - a single value such as model.claude: sonnet is no longer read, so the built-in model applies until you move it under reader, validator or executor. /unikit config update leaves the old line as it is and lists it as skipped.
• Runs without a terminal no longer install new extension items by themselves - in CI or scripts, add --install-new to unikit-ai update or unikit-ai extension update to install what a new extension version brings. Items you switched off stay off.

⚙️ Subagent Model and Effort

Subagent settings are now split by role (reader, validator, executor), and a new subagents.effort block sets reasoning effort the same way. Edits apply on the next command; unikit-ai update is not needed.

Details

• A reader collects facts, a validator checks a finished result, an executor produces pralled as .unikit/system/subagent-roles.md
• Claude Code defaults: sonnet and medium for readers and validators, the session's own for executors; Codex and Antigravity have their own values, and Antigravity has no effort key
• Words in a request, such as "use opus for the subagents" or "effort high", win over the config for that run
• The implement and plan coordinators pass model and effort to their workers, sidecars a
• Cursor, OpenCode, Kimi Code, Qwen Code and Universal / Other pass nothing; set the model in the client itself

✨ Balance Checkpoints

New /unikit-gd-balance keeps a balance document for a topic and hands out one measurement checkpoint at a time. You bring the results back, and it revises the roadmap and issues the next checkpoint.

What's included

• Documents live in .unikit/gamedesign/balance/; the skill never edits the GDD or code
• /unikit-plan builds a plan only up to the current checkpoint, with Measure: tasks and a final Hand-back: task
• /unikit-implement takes the measurements, /unikit-verify checks the report, and /unikit-improve keeps the plan in step with the document
• A plan waits as ⏳ AWAITING RESULT until the measurements come back
• A checkpoint can go to /unikit-gd-experiment instead of a direct measurement

✨ Design Experiments

New /unikit-gd-experiment turns a design problem into cheap, testable experiment cards and keeps an honest record of what players showed. /unikit-plan can build a disposable prototype from a card.

What's included

• Finds at least five ideas and thinks one through (precedents, options, how a test can mislead); a deep pass also searches the web, and nothing is saved before you approve
• A card can start from a design research or a balance checkpoint and keeps a Based on link that the plan reads
• Evaluates pasted feedback, chats or files over several rounds
• Manages the catalog in .unikit/gamedesign/experiments/: list, compare, best, failed, retest, edit, archive, or find a card by its description
• Plans built from cards run on an experiment/ branch (git.experiment_branch_prefix); /unikit-gd-explore gains an experiment design lens

♻️ Research and Questions

/unikit-gd-explore research is easier to resume and check, and skills now ask questions the same way, with the options listed first.

Details

• Research records start with an Active Summary and keep a Sessions log; a coherence che
• ultra <topic> pins the dialogue log and saves extra artifacts
• A named slice of code can be investigated without a GDD
• Options and what each one changes are printed as a numbered list, then asked with yourquestions carry no made-up answers
• /unikit-plan ends with a printed list of next steps instead of a closing question

🧩 Extension Control

Extensions can now add text to base skills at named places, and you choose which of an extension's skills, subagents and MCP servers are installed. Extension authors also get fixed variables for system file paths.

What's included

• Extension points: a bootstrap anchor in 35 base skills; manifest entries use point and id with optional reference files (UniKit versions before 2.5.0 reject such a manifest)
• unikit-ai extension add shows a menu in a terminal, or takes --skip-skills, --skip-subagents, --skip-mcp and --yes; new unikit-ai extension select <name> changes the choice later
• Choices survive update, update --force and init; --install-new and --skip-new now work on update and extension update, and extension list shows Skipped: and Not decided:
• 28 system-file path variables, such as {{user_questions_contract}}; an unknown {{name}} stays as written and is listed only under --verbose
• Extension text no longer makes installed skills look locally modified

🐛 Fixes

• /unikit-verify on an unfinished plan checks only the tasks that were executed, instead of reporting the rest as missing and blocking
• /unikit-implement asks whether to merge test runs when the scope holds one phase run plus the final full run; it skipped the question before

---

Full Changelog: 2.4.1...2.5.0

2.4.1

🚀 2.4.1 - Branch merges and leaner tests

Agents can now analyse and plan a branch merge before it happens. They also write fewer, more meaningful tests and save nothing to disk while you explore.

✨ Merge a branch with a plan

Ask /unikit-explore or /unikit-plan to merge a named branch into the current one. They predict the conflicts first and give the agent per-file instructions for resolving each one, so you resolve none by hand.

Details

• /unikit-explore saves a read-only prediction as a research
• /unikit-plan writes a fast, full or ultra plan whose last task makes the merge commit; no branch is created or switched
• While a merge is unfinished, /unikit-implement and /unikit-fix do not offer to stash, and /unikit-commit does not split the commit
• Run unikit-ai update to install the shared protocol file; without it, merge exploration stops with a warning

♻️ Tests follow what the code owns

Tests now cover logic and fixed system values, not balance numbers or authored content. Edits made while you review a result wait for your acceptance before any tests are written.

Details

• After acceptance, tests are written and run once for the logic that changed
• A test run covers a scope fixed beforehand and starts once; a repeat after a failure is one launch too
• /unikit-fix suggests a regression test only for logic defects
• /unikit-review no longer asks for blanket coverage
• /unikit-commit names the tests left unwritten when a review closes without acceptance

♻️ Exploring saves nothing until you agree

An ordinary /unikit-explore session no longer writes files while you talk. Ultra research still keeps its dialogue log as the conversation goes on.

Details

• The dialogue log is written first when you agree to save
• Questions about saving and folder names are left out of the log
• After a long session is summarised, the log marks the part that is not verbatim

🛠 Internal Improvements

• Update helpers moved into their own file; behaviour unchanged
• New checks pin the test policy and the merge modes

---

Full Changelog: 2.4.0...2.4.1

2.4.0

UniKit 2.4.0

Two new agents, a model setting for subagents, and more reliable skill hand-offs between agents.

🤖 Kimi Code is now supported

UniKit now sets up Kimi Code like the other agents. Skills, subagents and MCP servers all go into its own .kimi-code/ folder, so it can be installed next to any other agent without clashes.

Details

• Subagent files are adapted to the way Kimi Code reads them, including the skills they depend on.
• MCP servers use Kimi's environment-variable token field, so no secrets land in the config.
• Not yet confirmed in a live Kimi session.

🧩 "Universal / Other" agent for everything else

If your tool isn't on the list, choose Universal / Other. Skills go into the shared .agents/skills folder and MCP servers into .mcp.json.

Details

• It can't be installed together with Antigravity, which uses the same folder.
• The setup wizard refuses such a pair. update and the extension commands stop with exit code 1 before writing anything.
• It does not set a subagent model.

🎛️ Choose the subagent model per agent

Subagents started by skills can now run on a model you choose. Set it per agent in the new subagents.model block of .unikit/config.yaml. Changes apply on the next command, with no update needed.

Details

• Only Claude Code, Codex and Antigravity have a key. For the other agents the missing key means "use the session's model".
• Default value is inherit.

🔧 Skills reach subagents reliably on every agent

Skills now hand work to subagents in the way each agent actually supports. Before, a subagent could be started without the skill text it needed.

Details

• Claude Code gets an explicit Skill-tool call. The other agents get the skill file path to read.
• Codex subagents now launch with the settings Codex expects. The Codex-only delegation blocks in skills are gone.
• Qwen Code skills are installed with /unikit-* as written, and /unikit-* rewriting no longer breaks file paths on Codex and Qwen.
• A plain unikit-ai update now refreshes an agent's files when UniKit changes how it adapts them.
• The "stable/beta" label on agents is gone from the wizard and the docs.

🐛 Fixes

• Deselecting an agent now removes only the skills UniKit installed. Before, it deleted the whole skills folder, including other tools' skills.
• The +check validator now works on any agent and skips an empty findings table.
• Ultra planning no longer stalls when the agent can't run a writing subagent. The session writes the research notes itself.
• The Antigravity guardrails and docs now describe its slash invocation correctly.
• Skill wording about modules, rule origins and language.rules is corrected.

📚 Docs

The README is now a short landing page, and the docs pages are checked against the current code and commands.

Upgrading

Run unikit-ai update. Installed skills are reinstalled once because of the subagent and model changes.

Full Changelog: 2.3.0...2.4.0

2.3.0

🚀 2.3.0 - Pull requests and resilient ultra planning

This release adds a built-in pull-request workflow and splits large plans into mergeable modules. Planning for very large features can now resume after an interruption, and verification reuses test results instead of rerunning them.

🧩 Resilient Ultra Planning

Ultra plans can now save their research to disk, so planning survives a context reset or a new session. /unikit-improve builds on that same research instead of re-exploring the codebase from scratch.

What's included

• Choose standard (writes the plan directly, the default) or with saved state when starting an ultra plan; a standard plan over 12 phases is offered the switch
• An interrupted saved-state plan resumes with /unikit-plan ultra <name> instead of starting over
• /unikit-improve shows which research is still fresh and which code changed, and asks what to refine instead of re-exploring everything

✨ Pull Requests

A new /unikit-pr skill writes your PR description, opens or updates the branch's pull request, and merges it safely. Large plans now split into modules the base branch can merge one at a time.

What's included

• /unikit-pr [remind|create|merge] - print the PR text, open/update it, or merge with a merge commit, capped by git.pull_requests.max_level
• Enable checkpoints with git.pull_requests.checkpoints: true; every module but the last then stops for a PR before the next one starts
• /unikit-verify Phases N-M checks one module - its tasks and its test state - before that module's PR
• Merges only with a merge commit, only when the PR brings nothing new from the base branch, and only after you confirm
• Adds GitHub's official remote MCP server (unchecked by default); your token is read from an environment variable and never written into a settings file

♻️ Smarter Test Runs

/unikit-verify now trusts the test run your plan already recorded instead of re-running everything. A phase's own test run can also be narrowed to just the changed modules instead of the whole suite.

What's included

• New testing.run.use_affected_modules key narrows a phase checkpoint, and a /unikit-fix run, to the changed modules and whatever depends on them
• testing.run.full_run_threshold_percent (default 30%) falls back to running everything once narrowing would not save much anyway
• /unikit-verify --strict asks to run the full suite only when the recorded run no longer matches the code
• A plan's closing full run is skipped and reused when nothing has changed since the last one

---

Full Changelog: 2.2.0...2.3.0

2.2.0

🚀 2.2.0 - Rule topics, readable commits and a plan archive

Project rules can now be split into topics that load only when relevant. Commits read like notes for the team, and finished plans move to an archive.

✨ Project Rule Topics

.unikit/RULES.md can now keep common rules at the top and move the rest into topic files in .unikit/rules/. Each topic loads only when the work at hand matches it; existing flat files keep working and are offered the split.

What's included

• New rules go into the matching topic, a new topic, or ## Common when the right place is unclear
• /unikit-rules optimise previews the move, and a bundled script refuses to write if any rule would be lost or changed
• /unikit-rules prune proposes deletions with evidence and removes only what you choose; contradicting rules are resolved, not deleted
• Planning, implementation, verification and background checks load the topics that match their work
• Every /unikit-rules mode says what it is about to do before it reads anything

✨ Readable Commits and a Plan Archive

/unikit-commit now writes what changed and why it matters, then at most three lines of technical detail. The new /unikit-archive moves finished plans out of the active list.

What's included

• Commits link their plan with a Plan: <folder> trailer instead of phase and task numbers
• At an /unikit-implement checkpoint, Yes, and from now on commit without asking commits the rest of the session without questions or pushes; safety errors still stop it
• Every commit the pipeline makes, including during coordinated runs, goes through /unikit-commit
• /unikit-archive lists plans with their created and last-change dates; an unfinished plan moves only when you pick it and is marked as unfinished
• The archive never deletes or commits anything, and /unikit-plan and /unikit-explore still read archived plans as history

♻️ Test Runs for a Phase Range

When one /unikit-implement call covers several test points, it lists them and asks once: run the tests a single time at the end, or at every point. Words in the call, such as Phases 5-6, tests at the end of phase 6, answer in advance.

Details

• The answer holds for that call only, so the next call can choose differently
• A merged point's extra checks, such as a negative control or a manual smoke test, run at the point that is kept
• Test runs left over from an earlier call are recorded and closed by the run that carries them
• The implement coordinator asks the same question before its first layer

✨ Research That Keeps Your Words

/unikit-explore now logs the conversation word for word as it happens and ties each requirement to what you said. Before saving, it asks you to confirm requirements it inferred, changed or found ambiguous.

What's included

• Each requirement is marked as stated by you, inferred, or different from your proposal
• One confirmation question per requirement; agents without a question tool print numbered options
• Requirements you never confirmed become open questions instead of reaching the plan
• A session that ends before saving leaves an unfinished research you can resume with /unikit-explore <folder>

🐛 Fixes

• The configured language now holds for the whole session, including results passed back from background agents
• Split commits no longer pick up edits you left unstaged
• A direct editor edit no longer goes ahead when the safety commit before it is cancelled; the task returns to manual
• /unikit-implement uses the branch's own plan while it has pending work, instead of asking which plan to run
• /unikit-rules compact stops with a note when the file holds no rules

🛠 Internal Improvements

Technical changes

• Long skill instructions moved into reference files that are read only when a run needs them
• The research-link rules live in one installed file, .unikit/system/research-link.md, instead of four copies
• The test suite caps every SKILL.md at 70 000 bytes
• New maintainer pages under docs/skills/ explain why the skill rules are written as they are

---

Full Changelog: 2.1.0...2.2.0

2.1.0

🚀 2.1.0 - Test run placement and rule capture

Where tests run in a plan, and what becomes a project rule, are no longer left implicit - both are now explicit, visible decisions. /unikit can also bring an already-configured project's config file up to date with the current template.

✨ Test runs become their own tasks, placed by policy

A test run is now its own checklist task, carrying a Test checkpoint: <scope> line instead of a command hidden inside another task - and where it lands comes from the new testing section of .unikit/config.yaml rather than a question on every plan. /unikit-verify now skips re-running a full suite when nothing has changed since the last one, and says so instead of repeating it.

What's included

• testing.plan.checkpoints.{ultra,full,fast} sets where runs land (defaults phase/phase/plan); testing.implement.merge_checkpoints.<mode> can collapse every run in scope into one
• A run's width follows its scope on its own - one task's fixtures, a touched module's tests plus whatever depends on them, or everything at the end of a plan
• Writing tests is unchanged - still done inside the task that introduces them, in any phase
• The plan logs every run plus a Full run: marker that /unikit-verify checks before deciding to reuse it
• Plans written before this update have no run-placement line and are left exactly as they were

♻️ Project rules are proposed, never written behind your back

Patterns worth keeping are now collected while you work and offered to you as a single question at the end of the run - no skill writes to .unikit/RULES.md on its own any more. The file itself is now a flat list, one rule per line with no sections, and /unikit-rules compact can tidy an older file into that shape without deleting anything.

Details

• Candidates come from /unikit-implement, /unikit-verify, and the implement worker/coordinator; only /unikit-rules, called with the rules you picked, writes the file
• Up to three candidates are offered per run alongside an explicit "Add nothing"; a declined candidate is not offered again
• The background-agent alias used for rule capture was removed - the choice needs a person, so it is asked in the same session instead
• RULES.md has no length limit and flags nothing - a rule that cannot be shortened is kept exactly as written

⚙️ /unikit can actualize an existing config

Asking /unikit to "update the config", "add missing settings", or "fix my config" on an already-configured project now run the full setup - it compares .unikit/config.yaml against the current template, fills in safe defaults silently, and asksonly about placeholders or out-of-range values. Keys it does not recognize are reported, never deleted, and the two language-selection keys are never written or asked about by this mode.

🛠 Internal Improvements

Technical changes

• New test-suite guard families cover run placement, rule-candidate capture, and the config actualization branch
• The ultra plan-bundle integrity check grew from 9 to 11 checks, plus 4 template assertions for the new run-placement secti
• Documentation updated across configuration.md, subagents.md, skills.md, and workflow.md

---

Full Changelog: 2.0.1...2.1.0

2.0.1

🚀 2.0.1 - Editor tasks on all four engines

Planning and verifying editor-side changes is no longer Unity-only. Godot 4, Godot 4 .NET and Unreal Engine 5 now ship their own planning vocabulary and verification checks, alongside a stricter direct-edit safeguard that applies to every engine.

✨ Planning and verification vocabulary for Godot 4, Godot 4 .NET and Unreal Engine 5

/unikit-plan used to write Editor: steps for Unity only; the other three engines got none. Each engine now has its own vocabulary for what counts as an editor change, and /unikit-verify knows how to confirm it through that engine's MCP server.

What's included

• Editor: tasks now resolve into Godot, Godot .NET and Unreal Engine 5 concepts - scenes, UI, VFX, animation, assets and project settings, the same six kinds Unity already uses
• Editing a Blueprint graph in Unreal Engine 5 always counts as an editor change; it lives inside a binary asset with no text to review
• /unikit-verify confirms each change by reading it back from the live editor, with engine-specific guidance (e.g. a stale read on Godot after a file is written outside the editor, or batching checks on Godot .NET to avoid repeated project rebuilds)
• Each new engine's pitfalls guidance is a placeholder for now, pending validation on a real project - Unity's is already filled in

♻️ The direct editor-edit route fails closed

/unikit-implement now reads whether a direct text edit is safe from /unikit-plan's own installed rules, since it never shipped that check itself. When those rules are missing, every format is treated as unsafe and the task is handed back for manual editing instead of being edited blind.

• On Unreal Engine 5, direct is now offered only for settings files (Config/Default*.ini) - levels and assets are binary and can't be edited as text

🐛 Fixes

• /unikit-verify no longer treats a missing editor-check section as a dead end - it falls back to a general evidence rule instead of stalling
• Unity's planning rules pointed at the wrong rules folder; the path is corrected

🛠 Internal Improvements

Technical changes

• Install tests now cover all four engines' planning templates, including the one engine where the docs and planning vocabularies diverge (Godot 4 .NET)
• New checks keep each engine's verification rules in sync with its planning rules
• Engine template files are checked project-wide for stray template variables that would otherwise leak to users as literal text

---

Full Changelog: 2.0.0...2.0.1

2.0.0

🚀 2.0.0 - The engine editor joins the pipeline

This release adds the engine editor as a third pipeline layer next to design and code - editor work is now planned, executed through an MCP server, and verified automatically. MCP server identity is reworked, plans and research each collapse to one file, and an ultra planning mode arrives for both.

⚠️ Breaking Changes

Every change below migrates automatically on the next unikit-ai init or unikit-ai update; rules sync/rules install refuse with exit code 8 until it has run.

• mcp.servers in .unikit.json changes from an array to a key → code map - a server's settings identity (code) is now tracked separately from its package file name (key), so an engine's alternative servers no longer have to share one name.
• MCP config files are renamed to a <vendor>-<engine>-mcp.json shape (e.g. unity-mcp-coplay.json → coplay-unity-mcp.json).
• Context7 now connects over HTTP instead of a local npx process. Projects installed before this change keep their old entry - nothing is migrated.
• Plan and research folders no longer carry a date prefix - a plan's folder name now matches its branch name; older dated names still resolve.
• A plan's TASKS.md + PLAN-BRIEF.md merge into one PLAN.md. A finished plan with no open tasks is left alone, so plans/ stays a mix of old and new shapes by design.
• A research's result and source files rename to RESEARCH.md + SOURCE.md. Its old brief file is left in place, untouched.

🧩 Editor tasks: the Editor: grammar, rules trees, and a findings log

A task that touches the editor's saved state now carries an Editor: [kind] <container> → <target> : <action> line, across six kinds - scene, ui, vfx, anim, asset, settings. A project setting decides how it's carried out: through the configured engine MCP server, by hand with an exact instruction, or as a direct text edit - then /unikit-verify checks the result.

What's included

• A rules tree copied from the selected MCP server into .unikit/system/engine-mcp/ - exceptions only, no tool names, nothing it grants is ever taken away
• A per-project findings log, .unikit/MCP-RECHECK-NOTES.md, plus a ## MCP Findings table written into the plan the moment a task finishes
• Two new skills: /unikit-mcp-trap records a finding, /unikit-mcp-audit re-checks and retires old ones
• The development principles grow from 23 to 244 lines with a claim/evidence/verdict model and nine named failure classes (false success, eaten parameter, catalog phantom, and six more), plus a six-field diagnosis in /unikit-fix
• Unity only, for now - Godot and UE5 plans don't yet generate Editor: lines

🔌 MCP: seven configs, six rules trees, settings that hold

The catalog grows from five configs to seven - Unity Biome MCP and Fennara Godot AI are new - and all six engine servers now ship a rules tree. Writing a server into an agent's settings file is now handled on both init and update, not just init, so a dropped server's entry and permissions no longer survive future runs.

Details

• Unity: Unity Biome and Coplay; Godot: Fennara (free), GDAI (paid), Coding-Solo (free); UE5: ChiR24
• OpenCode can now connect to a remote MCP server, not only a local command
• New per-server fields: docs (where it documents itself), rules (its rules tree), order, and per-OS config variants

✨ Ultra mode for plans and research

/unikit-plan ultra writes a bundle - the same PLAN.md plus one deeply detailed file per phase, for a strong model to write and a smaller one to execute. /unikit-explore ultra adds matching research artifacts (architecture views, ADRs, a dependency graph) only when they're warranted; both modes are strictly opt-in, triggered only when asked for by name.

What's included

• Nine integrity checks gate every ultra plan before it's used
• A reader contract (.unikit/system/ultra-plan-read.md) gives each pipeline skill its own read depth, from one phase to the whole bundle
• Phase files are read-only during execution - the manifest is the only thing ever edited
• A coherence gate checks every saved research, ultra or not, in at most two passes before asking the user
• Drift detection by hash: /unikit-plan records a Summary SHA256, later steps recompute it to catch an out-of-date plan

♻️ One manifest per plan and per research

The overview, settings, checklist, commit plan and technical notes of a plan now live in one PLAN.md instead of two separate files. Re-running /unikit-explore on an existing topic continues that research instead of starting a second one.

🐛 Fixes

Fixes

• /unikit-evolve could edit installed skill files through an unused permission; the write boundary is now explicit and enforced
• /unikit-rules reports one row per rule for a batch, instead of writing the confirmation as if only one rule had been added
• /unikit's stack-selection summary is now plain markdown instead of <details> tags a terminal rendered literally

🛠 Internal Improvements

Technical changes

• inquirer now loads lazily, trimming ~240ms off every non-interactive CLI run
• Tests no longer depend on a live GitHub connection - the registry's "official" level reads a local fixture
• New test coverage for the migration chain and the ultra plan/research bundle contract
• Installer tests run against a fixture MCP catalog instead of the shipped configs
• Six documentation audits found and fixed 59 places where the docs no longer matched the code; the README is rewritten around three layers - design, code, and the editor

---

Full Changelog: 1.1.0...2.0.0