# Changelog

## 3.0.4 (2026-09-08)

- Version bump for publishing; includes the key-entry and macOS Keychain changes from 3.0.3 with no additional runtime changes.

## 3.0.3 (2026-09-08)

- Make API key entry the first Open Cloud menu option and reserve space for choices in short terminals.
- Add macOS Keychain saving, reading, replacement, and removal alongside Windows DPAPI. Secrets are passed through stdin; local Mac settings contain only a Keychain reference.
- Enable key entry on macOS in the terminal and control panel. Native Keychain behavior still needs validation on a Mac; adapter behavior is covered by mocked tests.

## 3.0.2 (2026-09-07)

- Register MCP clients as `romcp` with direct Node and installed-server paths, migrate standard Dominus entries, and preserve custom configurations and backups.
- Add optional Open Cloud setup with masked key entry, encrypted Windows storage, and permission verification. Reopen it with `romcp cloud`.
- Add active-key verification to the control panel and describe Open Cloud setup in its MCP tool.

## 3.0.1 (2026-09-07)

- Replaced interactive setup's scrolling prompts with a responsive terminal UI: step navigation, keyboard client checkboxes, safe replacement choices, animated connection progress, and completion guidance. Ctrl+C restores terminal state and keeps completed changes. Unattended, piped, and small/dumb terminals retain the plain setup flow.
- Added `pnpm dev:setup-ui` to preview the setup screens without changing configuration or installing a plugin.

## 3.0.0 (2026-09-07) — romcp

Dominus is now romcp. The npm package remains `dominus-cli` for upgrade compatibility; `romcp`, `romcp-mcp`, and `romcp-install-plugin` are available alongside the existing commands.

- Added analytics and dimension queries, selected data-store reads, event creation/read/list, developer-product updates and batch creation, and durable local discount jobs. Availability depends on the configured Open Cloud key's scopes and universe access. Direct product operations remain MCP-only.
- Added plain Luau and React Luau static UI export, project initialization and Rojo source mapping, compact startup guidance with an on-demand workflow reference, and batched scene/input QA scenarios.
- Added optional LibMP profiler integration. LibMP is not bundled; populated live captures and full React renderer compatibility remain unverified.
- Verified managed run timeout, normal play completion, cleanup, and a four-node plain-Luau UI round trip in an empty Studio place. Simulated input, multiplayer, and complete runtime-discovery coverage remain unverified in live Studio.
- Hardened plugin upgrades to preserve the installed copy on replacement failure, refresh changed version stamps, and archive legacy duplicate plugins.
- Added isolated package installation and strict compilation of shipped SDK examples. Release CI publishes the checked tarball.

Known limits: analytics requires `universe.analytics:read`; the existing validation key returned 403. Discount jobs require the local machine and bridge to remain running. Automatic test-runtime discovery requires a published place ID. Native experiments, transaction/receipt verification, thumbnail management, hosted scheduling, and telemetry are not included. The HTTP API retains its `1-preview` contract.

- Added managed test sessions with nonblocking start/status, explicit connection targeting, server-context stop requests, and a temporary server deadline helper. Gameplay readiness requires scenario assertions.
- Removed the legacy timeout's incorrect use of client `LeaveTest` as a whole-test stop operation.

- Connected MCP output reads to the shared journal through capability-negotiated controller requests, eliminating repeated Studio calls for incremental logs while retaining a legacy-daemon snapshot fallback.

- Added per-connection output journals and cursor-based HTTP/SDK reads, with bounded pages, UTF-8-safe message truncation, eviction-gap reporting, and reconnect invalidation.

- Bounded simulated input to 30 seconds of waits/holds per batch; the Studio handler validates all actions before dispatch, rejects concurrent batches, and attempts held-key/button cleanup after success or failure.
- Input failures now retain completed-action counts and cleanup errors in MCP results. Held input no longer intentionally spans separate batches; keep down/wait/up sequences in one call.

- Added visual Open Cloud key setup with Windows DPAPI storage, revision checks, and key-free status responses. Asset uploads and commerce now share credential resolution.

- Added a visual build-preference editor to the local control panel, with explicit Studio targets, shared persistence, stale-revision protection, and responsive layouts.
- Added same-origin checks to authenticated control-panel requests.

- Added persistent per-place build preferences, revision-checked updates, and inherited defaults for direct part creation and procedural generators. Explicit part/property overrides take precedence.
- Added six-face surface readback to spatial reviews so stud conventions can be inspected alongside material.

- Added explicit, place-scoped filesystem/generated/Studio source ownership for MCP script operations, exact sync hashes, local-file guidance, and protection against writing through the wrong source owner.
- Matched local scripts omit duplicated source by default; explicit retrieval and diverged-source comparison remain available.
- Updated workflow guidance to reuse fresh connection and mutation evidence instead of repeating unnecessary inspections.

- Added an opt-in, authenticated loopback HTTP API for Studio discovery and scene reads.
- Added the `dominus-cli/sdk` JavaScript/TypeScript entry point with packaged declarations and no startup side effects.
- Shared tree, instance inspection, and selection operations between MCP and the API.
- Bound API operations to explicit Studio connection IDs; stale handles cannot follow reconnects or active-window changes.
- Added bounded requests/responses, structured errors, SDK timeouts, and redirect rejection.
- Fixed tree truncation reporting when the node budget omits remaining siblings or services.
- Added API/SDK integration coverage and a developer quickstart. Profiling and the remaining v3 workflows are still in development.

## 2.11.4 (2026-09-04)

- Replaced the MIT license with the proprietary Dominus License 1.0. Users may
  modify their own copy, but may not sell, redistribute, rebrand, or claim the
  software or a modified version as entirely their own.
- npm releases no longer include JavaScript source maps, embedded TypeScript
  sources, the raw plugin source tree, its Rojo project file, or editable icon
  assets.

## 2.11.3 (2026-09-03)

### Reliable updates and Studio notifications

- `dominus update` now bypasses the four-hour passive update cache. A release
  published after the last background check is discovered immediately instead
  of being incorrectly reported as already current.
- Package-manager commands use a Windows-safe process path and preserve useful
  stderr when an update fails. Linked installs are detected before the normal
  global-package path.
- After replacing the CLI, the updater launches the newly installed Dominus to
  personalize and install its matching Studio plugin. The old in-memory release
  can no longer stamp its own version back onto the new plugin.
- Current bridge daemons accept an authenticated graceful-restart request, so
  plugin installation also replaces the long-lived local bridge with the code
  from the new package.
- The local authenticated bridge checks for releases and tells connected Studio
  plugins when one is available. Studio logs the notice and opens a persistent
  update card once per release with the exact `dominus update` command.

## 2.11.2 (2026-09-03)

### Group-owned asset uploads

- `roblox_upload_asset` now accepts `creatorGroupId` and sends it as the Open
  Cloud creation context, so meshes, audio, and images can be owned by a Roblox
  group instead of the API-key owner's account.
- Group ownership can default from `ROBLOX_CREATOR_GROUP_ID` or
  `robloxGroupId` in Dominus config. Explicit group selection takes priority
  over saved user defaults, while passing both creator parameters is rejected
  as ambiguous.
- Upload results now identify the resolved creator type and ID.

### Non-invasive Windows Studio screenshots

- Added `studio_capture_window`, a Windows-only fallback when Roblox Studio's
  screenshot permission is unavailable. It captures the active authenticated
  Dominus Studio window through `PrintWindow` without focusing the app or
  injecting input.
- A request can return the full client/window area or up to 12 labeled pixel
  crops, all cut from one consistent frame. Capture is bounded by source and
  total-region pixel limits.
- Window resolution is restricted to visible `RobloxStudioBeta` processes and
  the active Dominus place name. Ambiguous windows require an explicit title
  fragment and minimized windows fail clearly. DirectX windows use a visible-
  pixel fallback only after an overlap check proves the target is unobscured,
  preventing capture of an overlapping non-Roblox app.

### Reliable setup and reconnects on Windows

- Fixed plugin personalization replacing the bridge-token placeholder inside
  the runtime guard as well as `BridgeConfig`. Freshly installed plugins could
  then ignore the new embedded credential, reuse a stale saved credential, and
  loop on `Authentication failed. Run dominus setup` after a restart.
- The installer now rejects packaged plugins unless the credential placeholder
  appears exactly once, preventing the same failure mode from shipping again.
- Codex setup and doctor checks now launch the Windows command shim through
  `ComSpec`, recognize `.CMD` paths case-insensitively, and report process-start
  failures instead of crashing while trimming missing output.

## 2.11.1 (2026-08-27)

### Image uploads return a usable texture ID

- Open Cloud returns the Decal asset ID for an image upload, but `Decal.Texture`
  and `ImageLabel.Image` need the underlying texture ID. Studio performs that
  conversion silently when an ID is pasted into the property; done through the
  API the raw asset ID was stored verbatim and the image would not render.
- `roblox_upload_asset` now resolves the texture ID through
  `InsertService:LoadAsset` and applies that when a target is given. Results
  carry `assetId`, `textureId`, and `usableUri` so callers can pick the right
  one, plus `textureIdError` when resolution fails.
- Resolution is best effort: a fresh upload can be unavailable until moderation
  finishes, and some newer image assets do not expand through `LoadAsset`. A
  failure reports what it found instead of failing the upload, which already
  succeeded.

### Claude Code is a first-class MCP client

- `dominus setup` and `dominus doctor` now detect and configure Claude Code.
  It was previously the one major client left out, so its users had to register
  the server by hand and `doctor` reported nothing about it.
- The target drives the `claude mcp` CLI rather than editing `~/.claude.json`.
  That file carries Claude Code's project and session state and is rewritten
  constantly, so letting the CLI own it avoids racing those writes.
- Registration is pinned to user scope. `claude mcp add` defaults to local
  scope, which silently binds the server to whichever directory setup ran from
  and leaves it missing everywhere else; `doctor` now reports a local-scope
  entry as a misconfiguration rather than a pass.

## 2.11.0 (2026-08-27)

### Simulated input and device emulation

- Added `studio_send_input`, which sends ordered batches of keyboard, mouse,
  and text events through `VirtualInput`. Events are processed like real
  hardware input, so an agent can drive UI and gameplay during a playtest and
  then verify the result. `VirtualInputManager` is deliberately not used: it is
  an internal benchmarking service with no supported creator functionality.
- Added `studio_list_devices` and `studio_simulate_device` for emulating real
  phone and tablet viewports through `StudioDeviceSimulatorService`, covering
  all 42 built-in device profiles with orientation control.

### Mesh generation, gated

- Added `studio_generate_model` and `studio_generation_status` for Cube 3D
  generation through `GenerationService`. The API requires the
  `DynamicGeneration` capability and is shaped for in-experience runtime rather
  than edit-mode plugins, so availability is probed and reported rather than
  assumed; `studio_generation_status` names the missing step instead of
  failing opaquely. Verified reachable from the plugin against a live Studio
  session, with all three generation methods present.

## 2.10.0 (2026-08-27)

### Keeping the CLI and the Studio plugin in step

- `dominus update` upgrades the CLI and reinstalls the matching Studio plugin
  in one step. Updating the npm package replaces the packaged plugin but cannot
  touch the copy in the Studio plugins folder, so the two used to drift apart
  silently after the first setup.
- The MCP server reconciles the packaged and installed plugin on startup and
  reports the result on stderr, leaving stdout clean for the MCP transport.
- The installed plugin is now stamped with its version and a content
  fingerprint, so drift is detectable rather than inferred. A version
  comparison alone cannot see a rebuild at the same version, which is the
  normal case during development, so the fingerprint is authoritative and the
  version is the fallback for plugins predating the stamp. Sync results say
  whether a reinstall came from a version change or a rebuild. Added
  `readInstalledPluginStamp`, `packagedPluginFingerprint`, and
  `ensurePluginCurrent`.
- `dominus setup` and `dominus doctor` print a notice when a newer release is
  available. The update checker existed but had no call sites, so it never ran.
- `DOMINUS_VERSION` is read from `package.json` instead of a hand-maintained
  constant, which had drifted to 2.7.0 while the package shipped 2.8.x.

### Responsive control panel

- The panel now scales instead of relying on fixed offsets and hardcoded card
  heights, which clipped wrapped text at narrow widths. Cards size themselves
  to their contents through list layouts and `AutomaticSize`.
- Added a compact layout below 300 px and a narrow layout below 240 px, both
  driven by a single metrics table, so padding, type sizes, and control widths
  scale together. The minimum dock size drops to 210x260 to make them reachable.

## 2.9.0 (2026-08-27)

### Studio theme support

- The control panel now resolves every color through
  `settings().Studio.Theme`, so it matches the Light and Dark Studio themes
  instead of a hardcoded light palette, and repaints live on `ThemeChanged`.
- Added `plugin/src/Theme.lua`, which maps semantic panel colors onto
  `Enum.StudioStyleGuideColor`, binds instance properties for the lifetime of
  the instance, and exposes a change hook for state-dependent colors such as
  the connection indicator and the Luau toggle.
- Buttons adopt Studio's native `Hover` style guide modifier. The brand accent
  stays constant across themes, and the success color gains a lighter variant
  so it stays legible on dark backgrounds.

## 2.8.2 (2026-08-27)

- Toolbar buttons now use the uploaded Roblox decal IDs for the Dominus panel
  and Luau execution icons instead of the shared placeholder asset.

## 2.7.0 (2026-08-26)

### Guided setup and diagnostics

- Added the `dominus` executable and a guided `dominus setup` flow with Node and
  plugin-path preflight, atomic credential-personalized plugin installation,
  detected MCP-client selection, config backups, and a live Studio
  authentication check.
- Added `dominus doctor` for repeatable plugin, credential, bridge, MCP-client,
  and Studio-session health checks. `dominus-install-plugin` remains available as
  a compatibility installer.
- Codex setup uses the supported `codex mcp` CLI rather than editing its TOML
  configuration directly. JSON-based clients are updated atomically without
  discarding unrelated servers or invalid files.

### Studio plugin panel and icons

- Added a dockable Studio control panel with live connection state, reconnect,
  an explicit generated-Luau safety toggle, and persistent project rules.
- Project rules and the current Luau opt-in state are synchronized over the
  authenticated bridge and surfaced in `dominus_status` for the selected Studio
  session.
- Generated Luau remains disabled on new installations and still requires
  `confirm=true` for every request. Failed setting writes no longer enable it
  only in memory.
- Added editable SVG and 256 px Roblox-upload PNG artwork for the Dominus panel
  and Luau execution toolbar features.

### Security and reliability

- Updated the MCP SDK, WebSocket library, Nano ID, Vitest/Vite toolchain, and
  resolved transitive packages; the full `pnpm audit` now reports no known
  vulnerabilities. The production-only baseline previously contained 49
  advisories (13 high), and the old development tree contained an additional
  critical Vitest advisory.
- Malformed bridge handshakes are now closed immediately instead of leaving an
  unauthenticated socket alive after its timeout was cancelled.
- Protocol parse failures no longer echo raw payload fragments that could contain
  the bridge credential, and Studio hello/settings metadata now has strict type
  and size validation.
- Config, rules, tokens, personalized plugins, and installer backups use private
  permissions where supported. Plugin and MCP config writes are atomic and
  existing files are archived before replacement.

### Code quality

- Added StyLua to the repeatable lint gate, formatted the TypeScript and Luau
  source, and expanded the suite to 116 tests covering setup, backups, transport
  hardening, and plugin-setting synchronization.

## 2.6.0 (2026-08-01)

### Asset uploads

- Added the MCP-native `roblox_upload_asset` tool for local image, model, and
  audio uploads through Roblox Open Cloud.
- Image uploads now accept PNG, JPG, JPEG, BMP, and TGA files under Roblox's
  20 MB content limit, wait for Roblox's asynchronous asset operation, return the usable `rbxassetid://` URI, and can
  apply it directly to a Studio Decal, Texture, ImageLabel, ImageButton, or
  SurfaceAppearance.
- Asset requests now require the numeric creator user ID Roblox's current API
  expects instead of sending the invalid `me` placeholder.
- Fixed the older agent `upload_asset` path so it uses the same operation polling
  and image validation instead of returning an unusable operation ID.

### Open Cloud commerce

- Added authenticated creation and listing tools for developer products and game
  passes using Roblox's current beta Open Cloud endpoints. Creation returns the
  real non-zero product/pass ID and requires `confirm=true`.
- Added exact-name duplicate protection, optional local PNG/JPEG/BMP icons,
  scoped-key diagnostics, and environment/config key resolution without exposing
  the Open Cloud secret to Studio.
- Studio now reports `game.GameId` during its authenticated handshake so commerce
  tools default to the selected experience's universe instead of guessing.

### Spatial review and solid modeling

- Added `studio_run_luau` for real generated Luau execution in Studio. It is
  guarded by a persistent Studio toolbar opt-in and `confirm=true`; each run
  creates one Undo history action and can automatically review and screenshot
  returned or `dominus.track`ed geometry.

- Added `studio_run_build_program`, a bounded procedural geometry runtime for
  deterministic line, helix, ring, grid, and Fibonacci-sphere generators. One
  atomic program can create up to 1,000 tapered, path-oriented parts and then
  automatically run a target-framed spatial and screenshot review.
- Procedural programs remain the optimized path for spiral trees, curved
  branches, coils, stairs, towers, and layered canopies when arbitrary Luau is
  unnecessary.
- Added `studio_union_parts`, an undoable, allowlisted CSG operation backed by
  `GeometryService:UnionAsync`. It validates stable refs, supports collision and
  render fidelity controls, preserves supported constraints, and returns every
  generated result.
- Added `studio_review_3d`, which reports exact target and aggregate bounds,
  pivots, relative part transforms, geometry metrics, and compact nearest-part
  relationships. Its automatic visual pass activates only for complex geometry.
- Added target-aware Studio screenshots through `StudioCaptureService`. Dominus
  frames the target from its computed bounds, crops the viewport, scales PNGs to
  stay inside the authenticated bridge limit, and returns them as MCP image
  content without duplicating base64 data in structured output.

## 2.5.0 (2026-07-25)

### Dominus admin UI

- Added `show_dominus_ui`, an MCP tool that starts a tokened localhost admin
  panel for live bridge status, active Studio sessions, target selection, and
  database diagnostics.
- Added a daemon-level forced Studio reconnect command. The admin UI can close
  authenticated Studio sockets through the controller bridge, letting the plugin
  reconnect without relying on stale MCP-side state.
- Database diagnostics now report the Dominus database path, file size, table
  row counts, project/session totals, and masked config health without exposing
  stored memory contents.
- Updated MCP instructions and regression tests for the new admin tool and
  forced reconnect transport path.

## 2.4.1 (2026-07-22)

### Bridge recovery and live connection state

- Controller clients now reconnect automatically with bounded exponential backoff
  after the background bridge daemon restarts, while explicit shutdown still
  cancels pending reconnects and requests.
- Connection tools and the `dominus://connections` resource now refresh their
  target state from the daemon before reporting sessions, preventing stale or
  missing Studio targets after a reconnect.
- Added regression coverage for daemon restart recovery and refreshed target
  discovery.

## 2.4.0 (2026-07-15)

### Native instance metadata and method capabilities

- Added `studio_get_metadata`, `studio_set_attributes`, and
  `studio_update_tags`. Dominus can now read and persist real typed Roblox
  attributes and tags in edit mode without generating runtime bootstrap scripts
  or maintaining attribute mirrors.
- Added `studio_list_callable_methods` and `studio_invoke_methods`. Agents can
  discover and invoke a guarded set of common hierarchy, metadata, pivot, scale,
  and bounding-box methods using typed arguments and typed return values.
- Method invocation is protected twice: the MCP schema rejects unknown method
  names and the Studio plugin independently enforces class requirements,
  argument types, item limits, and a default-deny method policy.
- Extended atomic `studio_apply` and multi-agent worker proposals with
  `setAttributes` and `updateTags`. The coordinator now checks scope conflicts,
  reads metadata back, reports exact mismatches, and includes failed metadata in
  its single bounded repair pass.

### Safety and reliability

- Metadata and method writes run through dedicated allowlisted plugin commands and one
  ChangeHistoryService recording, with stable-ref validation, item limits,
  rollback, and read-back-ready refs. Arbitrary `run_code` remains unavailable.
- Added tests for the 30-tool MCP catalog, clone routing, batch part creation,
  metadata routing, method rejection, transform validation, coordinated
  metadata proposals, and packaged command hardening.

## 2.3.0 (2026-07-15)

### Roblox building toolkit

- Added `studio_clone_instances` for safe deep cloning of Parts, Models, UI,
  scripts, and arbitrary instance trees. Clones support renaming, reparenting,
  root property overrides, repeated copies, and spatial offsets without arbitrary
  Luau execution.
- Added `studio_create_parts` for building up to 200 Parts, Wedges, MeshParts,
  Seats, SpawnLocations, and related BaseParts in one batch, with optional Model
  or Folder grouping.
- Added `studio_transform_instances` using `PVInstance:PivotTo()`, so Models and
  BaseParts support exact CFrames plus world/local position and rotation offsets.
- Added `studio_group_instances`, `studio_ungroup_instances`,
  `studio_create_welds`, `studio_query_parts`, and `studio_set_selection` for
  hierarchy organization, rigid assemblies, spatial inspection, and Studio UX.
- Extended atomic `studio_apply` and parallel worker proposals with a typed
  `clone` operation. Coordinators validate clone source and destination scopes,
  detect destination conflicts, and verify the resulting hierarchy.

### Safety and reliability

- All building writes run through dedicated allowlisted plugin commands and one
  ChangeHistoryService recording, with stable-ref validation, item limits,
  rollback, and read-back-ready refs. Arbitrary `run_code` remains unavailable.
- Added tests for the 25-tool MCP catalog, clone routing, batch part creation,
  transform validation, and packaged building command hardening.
- Pinned Rojo `7.6.1` with Rokit so plugin builds use a current reflection database
  and consistently preserve `RunContext.Plugin`.

## 2.2.1 (2026-07-13)

### Stable Studio bridge architecture

- Moved WebSocket ownership out of individual MCP stdio processes and into one
  detached local bridge daemon. MCP hosts now act as controllers, so closing or
  restarting one agent no longer disconnects Studio or other agents.
- Added race-safe bridge startup and reuse. Concurrent MCP launches converge on
  the same loopback bridge instead of creating separate connection state.
- The plugin installer now starts the bridge automatically and provisions the
  user-specific 256-bit credential into the local plugin. Manual connection IDs
  and six-digit pairing codes are no longer part of setup or recovery.
- Built the plugin root with `RunContext.Plugin` and added an entry-point guard.
  Starting a Play test can no longer launch duplicate Client and Server Dominus
  sessions from one Studio window.
- Added regressions for plugin run context, seamless credential provisioning,
  unauthorized plugin rejection, and bridge survival across MCP controller exits.

## 2.2.0 (2026-07-13)

### MCP-native multi-agent coordinator

- Added `run_parallel_task` to the published MCP server. It uses the MCP client's
  model through standard Sampling, so Dominus still requires no AI provider key.
- Added deterministic path-based task partitioning. UI and generic roots are split
  by immediate child branches and distributed across one to five workers.
- Workers run concurrently and receive bounded hierarchy plus live typed property
  evidence for only their owned scopes. Workers are proposal-only and never receive
  Studio mutation tools.
- Added strict worker proposal and coordinator decision schemas. Existing instance
  refs must exactly match supplied ID/path pairs, and every mutation must remain
  inside the worker's owned branches.
- Added ancestor/descendant conflict detection and coordinator-only operation
  ordering. The coordinator may select complete validated proposals but cannot
  invent, rewrite, or partially accept worker operations.
- Final writes use one atomic `studio_apply` batch. Dominus then reads the root and
  affected properties back, checks creates and moves, and performs at most one
  bounded repair pass before reporting verification evidence.
- Parallel planning refuses truncated hierarchy evidence, and generic property
  mutations can no longer bypass revision checks by writing script `Source`.
- Added summary-level MCP logging events for worker starts/completions, proposal
  decisions, application, and verification without exposing full model traces.
- Clients without Sampling receive a clear capability response and keep the normal
  single-agent inspect-plan-apply-verify workflow.

### Studio connection reliability

- Made pending WebStream connection attempts cancellable so overlapping retries
  cannot strand a waiting coroutine or deadlock future reconnects.
- Serialized reconnect attempts and reset failed open transports explicitly.
- Changed the Dominus 2 toolbar button to always force an immediate reconnect
  instead of toggling automatic reconnection off.

### Typed mutations and packaging

- Fixed valid Enum values such as `Slate`, `Wood`, `Glass`, and `Ball` being
  rejected by resolving names against the live Enum type's items.
- Removed the stale binary `.rbxm` build artifact. The package and installer now
  use the single canonical `.rbxmx` plugin build.
- Corrected documentation for the 17-tool MCP catalog, canonical plugin format,
  and optional Studio restart behavior.

## 2.1.0 (2026-07-12)

Dominus has been rewritten as an MCP-first Roblox Studio engineering server.

### MCP-native agent harness

- Removed the Ink/TUI command from the published binaries. Dominus now relies on
  the MCP host's model, context, consent UI, and agent runtime.
- Replaced the monolithic legacy catalog with 16 focused tools for connection
  management, inspection, transactional changes, UI, scripts, tests, and docs.
- Added strict input schemas, output schemas, `structuredContent`, text fallbacks,
  `isError`, and accurate read-only/destructive/idempotent/open-world annotations.
- Added the `dominus-workflow` MCP prompt and `dominus://status` resource.
- Added explicit inspect, plan, apply, read-back, and test instructions, including
  UI fidelity checks for fonts, UDim2 values, colors, strokes, and hierarchy.
- Updated the official MCP TypeScript SDK from 1.27.0 to 1.29.0.

### Secure Studio bridge

- Bound the WebSocket bridge to `127.0.0.1` instead of every network interface.
- Added a persistent 256-bit bridge token that is provisioned directly into the
  local plugin by `dominus-install-plugin`; users do not complete a pairing flow.
- Authenticated relay/controller processes as well as Studio plugin connections.
- Added one MiB payload limits, socket rate limits, handshake timeouts, bounded
  request timeouts, and strict message-envelope validation.
- Removed arbitrary `run_code` from the MCP surface and removed the plugin's
  `loadstring` executor from the packaged model.
- Isolated in-flight requests to the exact Studio WebSocket that owns them;
  wrong-session responses are ignored and one disconnect cannot cancel another
  session's work.

### Multi-Studio correctness

- Replaced place-ID targeting with unique connection IDs. Multiple windows on the
  same place ID are now safe and independently selectable.
- Relay clients carry their selected connection on each request, so separate MCP
  processes cannot overwrite each other's active target.
- Added `dominus_status` and `dominus_select_studio`.

### Studio plugin harness

- Replaced the broken ten-port scanner with one configurable loopback endpoint and
  exponential reconnect backoff.
- `WsClient` now waits for the real `WebStreamClient.Opened` event and handles
  `Error`, `Closed`, timeouts, stale attempts, and signal cleanup correctly.
- Added a strict command allowlist and bounded command router.
- Added session-scoped instance references with path-segment fallback. Dots and
  duplicate sibling names are no longer silently misresolved.
- Updated ReflectionService integration to current `Type`, `Display`, and `Permits`
  fields.
- Added typed Roblox value encoding/decoding with surfaced property failures.
- Added atomic mutation batches backed by ChangeHistoryService recordings. Failed
  batches cancel and automatically undo in-progress work.
- UI trees are fully built and validated off-tree before an existing UI is
  replaced. Ambiguous replacements and silent property failures are rejected.
- Script reads return a revision hash; writes require it and reject stale edits.
- Studio tests now use bounded Run, Play, or Multiplayer StudioTestService flows,
  reject overlapping runs, and leave timed-out sessions.
- Output forwarding excludes all Dominus-prefixed messages, closing the previous
  WebSocket warning feedback loop.

### Packaging and tests

- Added the `dominus-install-plugin` executable and fixed the previously missing
  installer implementation.
- The published runtime dependency set is MCP-only; old CLI dependencies are
  development-only and excluded from the MCP bundle.
- Added transport tests for auth, credential rejection, relays, duplicate places, wrong-target
  responses, and disconnect isolation.
- Added in-memory MCP conformance tests for the tool catalog, structured outputs,
  resources, prompts, routing, and error results.
- Added static plugin hardening tests and Rojo package verification.

### Breaking changes

- The `dominus` TUI command is removed. Configure `dominus-mcp` in an MCP host.
- Legacy tool names such as `run_code`, `set_properties`, and `create_ui` are
  replaced by the v2 tool catalog.
- Dot-separated instance paths are replaced by instance refs containing
  `instanceId` and/or `pathSegments`.
- Script updates require `expectedRevision` from `studio_read_script`.
- Existing UI is not replaced unless `replaceExisting: true` is supplied.

## 0.5.5 (2026-04-23)

### New MCP Tools (30 total, up from 24)

- **`move_instance`** — Reparent an instance preserving all descendants. Sets ChangeHistoryService waypoint.
- **`bulk_set_properties`** — Set properties on multiple instances in one call. Explicit paths or className filter mode.
- **`find_replace_scripts`** — Find and replace across all scripts with optional Lua pattern matching and dry run preview.
- **`undo`** — Undo last action (ChangeHistoryService). Like Ctrl+Z.
- **`redo`** — Redo last undone action. Like Ctrl+Y.

### Improvements

- **`get_properties` now supports compact mode** — Same filtering as `get_descendants_properties`. Strips read-only, nil, deprecated, and default-valued properties by default. The previous version returned all ~50 properties per instance even though most were noise.
- **Fixed code injection in `clone_instance`, `group_instances`, `build_multiple`** — Instance names and paths with special characters (quotes, backslashes) no longer break generated Luau code.
- **`build_multiple` now supports `rgb()` colors and `canCollide`** — Previously only handled `#hex` and BrickColor names; `rgb(255,0,0)` would silently fail.
- **Better tool descriptions** — More specific descriptions help AI models pick the right tool. `get_properties` disambiguates vs `serialize_ui` and `get_descendants_properties`.
- **Shared `luaStr()` and `resolvePath()` helpers** — Centralized safe string generation for all code-gen tools.

## 0.5.4 (2026-04-23)

### Fixes

- **Rebuilt plugin** — 0.5.3 shipped a stale `Dominus.rbxm` missing the compact property filtering and protocol changes. This release includes the correctly built plugin.

## 0.5.3 (2026-04-23)

### Improvements

- **Compact `get_descendants_properties`** — Now strips read-only, nil, deprecated, and default-valued properties by default, reducing response size by ~80%. Pass `compact: false` for the full dump.
- **`serialize_ui` exposed as MCP tool** — Was previously only in the internal tool registry. Now available to all MCP clients (Copilot, Cursor, Claude, etc.) for converting existing Roblox UI into clean JSON trees.
- **UI → Roact/React conversion guidance** — System prompt and internal memory now teach the agent the full workflow: `serialize_ui` → JSON tree → Roact/React component with correct type mappings (UDim2, Color3, Vector2, enums, FontFace).
- **Smarter tool selection** — Agent now prefers `serialize_ui` over `get_descendants_properties` for UI conversion tasks, avoiding context bloat.

## 0.2.1 (2026-02-24)

### New

- **Auto-update checker** — On startup, Dominus checks npm for newer versions
  and prints an upgrade notice. Cached for 4 hours, non-blocking, never throws.

### Bug Fixes

- **MCP server crashes on EADDRINUSE** — `dominus mcp` would crash if port 18088
  was already held by a running `dominus start` (or another MCP instance). The MCP
  server now checks for an existing listener and connects as a relay client instead
  of trying to bind the same port.

### New MCP Tools (22 total, up from 14)

- **`get_class_info`** — Look up the full schema of any Roblox class via
  ReflectionService (properties, methods, events with types).
- **`create_ui`** — Create an entire UI tree in one call with a declarative JSON
  spec. Auto-coerces UDim2, Color3, Font, and enums. ~10x faster than `run_code`.
- **`create_part`** — One-call Part creation with position, size, color, material,
  shape, transparency, anchored, and collision settings.
- **`clone_instance`** — Clone an instance with optional rename, reparent, and
  position offset.
- **`group_instances`** — Group multiple instances into a Model or Folder.
- **`build_multiple`** — Batch-create many parts/instances in a single round-trip.
- **`execute_run_test`** — Enter Run mode via `StudioTestService:ExecuteRunModeAsync()`
  with pass-through args and result capture.
- **`execute_play_test`** — Enter Play mode via `StudioTestService:ExecutePlayModeAsync()`
  for full client-server simulation tests.

### New CLI Features

- **`dominus mcp-install`** — Auto-install MCP config into Cursor, VS Code,
  Claude Desktop, Windsurf, and Claude Code with one command.
- **`dominus mcp-setup`** — Print manual MCP configuration instructions.
- **Relay client architecture** — `dominus start` can now connect as a relay
  client to an existing MCP-owned WebSocket server, allowing the TUI and MCP
  to coexist on the same port.

### Plugin Improvements

- Enhanced `Properties.lua` with broader property type support.
- Improved `Reflection.lua` for richer class metadata.
- Updated `TestRunner.lua` with Run/Play mode test support.
- New `UIBuilder.lua` module for server-side declarative UI construction.

### Other Changes

- Multi-provider AI config improvements (OpenRouter, xAI, Gemini, custom).
- TUI setup wizard for first-run API key and provider configuration.
- Improved system prompt with builder-tool awareness.
- WebSocket server now supports controller relay connections.

## 0.1.0 (2026-02-23)

- Initial release — 14 MCP tools, TUI agent, persistent memory, Roblox Studio
  WebSocket bridge.