Tiny Tool Development

// AI Plugins / Advanced Preview

Project Restructure Service

Guarded project restructuring after a plan has been reviewed, not a planner that mutates projects on its own.

Safe, gated project restructuring and placement execution for reviewed Unreal workflow plans.

Keep mutation separate from evidence and planning: PRS validates a reviewed plan, previews the diff, applies through an explicit gate, and keeps rollback attached to the run.

Ask on Discord Read GitHub documentation Back to catalogue
Project Restructure Service system overview
system artCanonical schematic media; status, proof, and roadmap remain data-driven in the page.
// THE PAIN

Before the plugin enters the chat.

Reviewed restructure ideas still become risky when the actual move/apply step is informal.

PAIN

A team can agree that files, assets, or placement structure should change, but the execution step often becomes manual edits, half-documented scripts, or an agent with too much authority.

PRS exists so the mutation side has a narrow contract: validate the plan, preview the diff, require the gate, apply the reviewed change, and keep rollback concrete.

What that feels like

  • Dry-run and apply behavior are not the same command path.
  • Execution depends on a person remembering what was approved.
  • Rollback is discussed after the change instead of built into the run model.
// WHAT YOU GET

After — in the editor, not in a slide deck.

Plans from people or tools can become guarded, reviewable, reversible project changes.

GAIN

Project Restructure Service keeps retrieval, analysis, and decision systems out of the mutation boundary while it owns validation, dry-run, apply gates, hashes, and rollback execution.

  • Plan loading and validation before any project mutation.
  • Dry-run diffs and explicit apply gates.
  • Rollback-oriented run history for controlled restructure work.

// HOW IT WORKS

The product architecture, inspected from the plugin surface.

These are the moving parts I would place on the page so buyers can understand what they are actually getting beyond the slide narrative.

01 / Plan

PRS consumes reviewed structure intent.

Plans can come from a human review, UII evidence, IIS context, SCD placement proposals, or UCM routes, but PRS does not invent the decision by itself.

02 / Dry-run

Validation and diff output happen before mutation.

The dry-run path checks plan shape, preflight state, expected changes, hashes, and policy assumptions before an apply gate is available.

03 / Execute

Apply and rollback stay in the executor layer.

PRS owns the mutation boundary: apply reviewed diffs, record the run, and roll back through a concrete run id instead of memory.

// FIT

Who actually reaches for this.

Teams that want AI-assisted or tool-assisted restructuring without letting evidence and planning layers mutate the project directly.

Project Restructure Service is an advanced-preview mutation authority for approved structural plans: validation, dry-run diffs, gate/hash checks, clean-git preflight, apply handlers, verification, run metadata, and rollback.

// SURFACE

Where it lives in Unreal.

Plan files, validation reports, dry-run diff output, apply confirmation gates, run hashes, preflight checks, and rollback actions.

// CAPABILITY MAP

Feature groups with the value of each part made explicit.

Grouped from plugin modules, public APIs, automation hooks, and documented workflow surfaces.

Gated execution

The important feature is not moving files; it is making the dangerous step reviewable.

  • Load and validate restructure or placement plans.
  • Generate dry-run diffs before applying changes.
  • Require explicit gates for mutation workflows.
  • Keep hashes and run state tied to the reviewed diff.

Rollback discipline

A restructure tool is only useful when recovery is part of the workflow.

  • Record applied runs for follow-up review.
  • Roll back the last or selected run where the contract supports it.
  • Keep preflight checks visible before apply.
  • Avoid mixing planning correctness with execution mechanics.

Ecosystem execution layer

PRS becomes more useful when other tools prepare better plans while PRS keeps the mutation boundary narrow.

  • IIS supplies retrieval context without becoming writable.
  • UII supplies structured evidence and handoff material.
  • Smart Content Diet can provide reviewed placement proposals.
  • UCM can expose route policy, dry-run requirements, and MCP-visible metadata.

// OPERATOR TOOLS

Concrete actions, expected result, and mutation boundary.

This is the part that keeps product marketing honest: buyers can see which buttons, APIs, or MCP tools matter and what they change.

// ACTION

Validate plan

Why it matters
Checks whether the restructure input is shaped correctly for PRS execution.
Operator result
Bad or incomplete plans stop before dry-run.
Change surface
Read-only validation.
// ACTION

Dry-run restructure

Why it matters
Builds the expected change set without applying it.
Operator result
Reviewers can inspect what PRS would change.
Change surface
Read-only planning pass.
// ACTION

Apply reviewed run

Why it matters
Applies the validated and reviewed plan through the executor.
Operator result
The project structure changes according to the approved diff.
Change surface
Project mutation behind an explicit gate.
// ACTION

Rollback run

Why it matters
Uses recorded run state to reverse an applied restructure where supported.
Operator result
Recovery is tied to execution evidence rather than memory.
Change surface
Project mutation for recovery.

// TYPICAL FLOW

From inspection to use without losing the product boundary.

01

Prepare a restructure or placement plan from a human review, IIS context, UII evidence, or SCD proposal.

02

Run validation and dry-run diff generation before applying anything.

03

Apply only after explicit confirmation and keep rollback tied to the run id.

// PROOF AND BOUNDARIES

Signals that make the product specific, plus the limits worth saying out loud.

Each card turns implementation facts into buyer-facing proof without pretending the tool solves the wrong problem.

Status Advanced preview, not listed on Fab yet
Boundary Execution layer, not AI planner
Inputs Reviewed plans, SCD placement proposals, UII/IIS context
Controls Validate, dry-run, gate, apply, rollback
Route model UCM-first ecosystem exposure

Outputs

What the plugin leaves behind when the workflow is doing useful work.

  • Validation result

    Whether a plan is acceptable before PRS considers mutation.

  • Dry-run diff

    The reviewable change preview.

  • Applied run

    Execution state tied to the approved plan.

  • Rollback result

    Recovery evidence for a previously applied run.

Integrations

Where the product connects without losing ownership of its own domain.

  • Internal Index Service

    Can supply project-local retrieval context while staying read-only.

  • Unreal Integration Intelligence

    Can produce evidence and planning packages that inform restructure work.

  • Smart Content Diet

    Can provide reviewed placement proposals through the documented bridge pattern.

  • Unreal Capability Mesh

    Preferred route layer for policy, dry-run requirements, and tool visibility.

  • Unified MCP Server

    Can expose PRS routes to local agents when provider contracts are declared.

Safety model

The boundaries that make the tool understandable before automation enters.

  • Decision separation

    PRS executes reviewed plans; it does not decide project architecture by itself.

  • Dry-run first

    The reviewable diff comes before mutation.

  • Explicit apply

    Mutation requires an apply gate instead of being a side effect of analysis.

  • Rollback evidence

    Recovery is connected to recorded run state.

Not for

The cases where the product promise would be the wrong expectation.

  • Teams expecting an autonomous AI refactoring product.

  • Workflows where dry-run and rollback evidence are not required.

  • Projects that want IIS or UII to mutate structure directly.

// PRODUCT MEDIA

Tutorial and platform embeds stay attached to product context.

YouTube, Discord, LinkedIn, and Fab widgets are reserved for product presentation, explanation, support context, or tutorials. No third-party widget loads automatically.

Tutorial video

YouTube

Product walkthroughs, setup explanations, and tutorial material.

Embed source pending. No third-party widget is loaded here.

Open platform
Primary support context

Discord

Discord-first product support, quick questions, setup discussion, and community context.

Embed source pending. No third-party widget is loaded here.

Open platform
Professional context

LinkedIn

Company background, provider identity, project credibility, and listing context.

Embed source pending. No third-party widget is loaded here.

Open platform
Marketplace context

Fab

Product listing context, license details, purchase route, and marketplace availability.

Embed source pending. No third-party widget is loaded here.

Open platform

// INFORMATION

All essential product signals in one place.

Status Advanced Preview
Category AI Plugins
Unreal Engine 5.4
Source state ProjectRestructureService.uplugin VersionName 1.0.1 / Version 2
Primary surface Plan files, validation reports, dry-run diff output, apply confirmation gates, run hashes, preflight checks, and rollback actions.
Marketplace No product checkout linked
Direct sales None on this website
Support route Discord first; product context lives on this page
Listing context Fab for marketplace, LinkedIn for public provider identity
Fact surface 3 functions / 3 settings / 3 failure modes / 1 bridge
Boundary Gated project restructuring executor for reviewed placement plans, deterministic dry-run diffs, hash-checked apply, verification, and rollback.
Primary workflow Load a reviewed plan, validate trusted roots, build a dry-run diff, review hashes, apply with matching gate evidence, verify, and roll back by run id when needed.

// NOTES

Practical boundaries.

PRS is announced as an advanced preview and is not linked to a Fab checkout yet.

The product boundary is execution, not AI planning or retrieval.

UCM is the preferred ecosystem route layer; direct bridge examples remain no-UCM/reference paths.

// LEGAL / PRIVACY

Static information page.

Purchases, downloads, marketplace accounts, and platform-specific license details are handled outside this website. Product or tutorial widgets are loaded only after activation, where configured.

Provider details are listed in the legal notice. The current site template does not set first-party cookies and does not load analytics scripts.

Legal Notice Privacy Policy

// RESOURCES

Open the channel that matches the next question.

Fab seller profile

No product-specific Fab listing is linked yet. The public seller profile remains available.

Open

GitHub documentation

Manuals, quickstarts, settings references, troubleshooting, technical notes, and release material live in GitHub.

Open

Discord support (primary)

Start quick questions, setup help, support context, and product-fit discussion on Discord.

Open

Plugin support email

Formal plugin support requests can be sent to the dedicated support mailbox.

Open

LinkedIn company context

Company background, public provider identity, and listing context are available on LinkedIn; support still starts on Discord.

Open

// RELATED

Nearby tools in the catalogue.

AI Plugins

Internal Index Service

Local indexes, retrieval, context packs, embedding jobs, and agent-facing search.

View page
AI Plugins

LLM Store

Central management for AI providers, models, routes, policies, costs, and secrets.

View page
AI Plugins

Unified MCP Server

Editor-only loopback MCP host with provider registry, bearer-token auth, and modular tool aggregation.

View page

// TOOL NAVIGATION

Continue through the catalogue.

Each tool page keeps the product overview here and routes deep technical material to GitHub.

Previous: Tiny Tool Execution Integration Bridge Next: Unreal Integration Intelligence