Refine ship orders and viewer controls

Replaces string-based `SpaceLayerKinds` constants with a strongly-typed `SpaceLayerKind` enum. Updates backend services, runtime models, and projection logic to use the new enum. Adds `ToContractValue` method for compatibility with existing contracts.

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

.gitignore

@@ -17,3 +17,5 @@ pnpm-debug.log*
 .env
 .env.*
 !.env.example
+
+.codex

.idea/.idea.SpaceGame/.idea/.gitignore

@@ -0,0 +1,15 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Rider ignored files
+/contentModel.xml
+/modules.xml
+/projectSettingsUpdater.xml
+/.idea.SpaceGame.iml
+# Ignored default folder with query files
+/queries/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/

.idea/.idea.SpaceGame/.idea/.name

@@ -0,0 +1 @@
+SpaceGame

.idea/.idea.SpaceGame/.idea/encodings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding" addBOMForNewFiles="with BOM under Windows, with no BOM otherwise" />
+</project>

.idea/.idea.SpaceGame/.idea/indexLayout.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="UserContentModel">
+    <attachedFolders />
+    <explicitIncludes />
+    <explicitExcludes />
+  </component>
+</project>

.idea/.idea.SpaceGame/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

AGENTS.md

@@ -0,0 +1,29 @@
+# Pair Programming Mode
+
+When working in this repository, act as a pair programming partner by default.
+
+## Collaboration Rules
+
+- Do not broaden scope on your own.
+- Before coding, restate the request in your own words.
+- Ask clarifying questions when scope, ownership, or design intent is ambiguous.
+- Push back on weak assumptions, risky changes, or hidden refactors.
+- Prefer discussion first, implementation second.
+- Do not refactor adjacent code unless explicitly approved.
+- Separate proposed work into:
+  - required
+  - optional
+  - recommended
+- After scope is agreed, implement only that scope.
+
+## Ambiguity Rules
+
+- If the request is underspecified, stop and ask instead of assuming.
+- If the requested change may interfere with an in-progress refactor, call that out before editing.
+- If a request sounds small, keep the first response small and scoped unless asked to expand.
+
+## Working Style
+
+- Treat the user as an active collaborator, not a ticket queue.
+- Surface tradeoffs before making structural changes.
+- Prefer explicit approval before changing architecture, bootstrapping, dependency wiring, or data flow.

SpaceGame.slnx

@@ -3,4 +3,8 @@
   <Folder Name="/apps/backend/">
     <Project Path="apps/backend/SpaceGame.Api.csproj" />
   </Folder>
+  <Folder Name="/tests/" />
+  <Folder Name="/tests/backend/">
+    <Project Path="tests/backend/SpaceGame.Api.Tests.csproj" />
+  </Folder>
 </Solution>

apps/backend/.editorconfig

@@ -0,0 +1,52 @@
+root = true
+
+[*.{cs,csx}]
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4
+
+# .NET/C# conventions
+dotnet_sort_system_directives_first = true
+dotnet_separate_import_directive_groups = false
+dotnet_style_qualification_for_field = false:suggestion
+dotnet_style_qualification_for_property = false:suggestion
+dotnet_style_qualification_for_method = false:suggestion
+dotnet_style_qualification_for_event = false:suggestion
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+dotnet_style_predefined_type_for_member_access = true:suggestion
+dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggestion
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+dotnet_style_explicit_tuple_names = true:suggestion
+dotnet_style_prefer_auto_properties = true:suggestion
+dotnet_style_prefer_collection_expression = true:suggestion
+dotnet_style_prefer_conditional_expression_over_assignment = true:suggestion
+dotnet_style_prefer_conditional_expression_over_return = true:suggestion
+
+csharp_prefer_braces = true:suggestion
+
+csharp_style_var_for_built_in_types = true:suggestion
+csharp_style_var_when_type_is_apparent = true:suggestion
+csharp_style_var_elsewhere = true:suggestion
+csharp_prefer_simple_using_statement = true:suggestion
+csharp_style_prefer_switch_expression = true:suggestion
+csharp_style_prefer_primary_constructors = false:silent
+csharp_new_line_before_open_brace = all
+
+[*.{csproj,props,targets,sln,slnx}]
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+[*.{json,jsonc}]
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2

apps/backend/Auth/Api/ForgotPasswordHandler.cs

@@ -0,0 +1,17 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Auth.Api;
+
+public sealed class ForgotPasswordHandler(AuthService authService) : Endpoint<ForgotPasswordRequest, ForgotPasswordResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/auth/forgot-password");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(ForgotPasswordRequest request, CancellationToken cancellationToken)
+    {
+        await SendOkAsync(await authService.ForgotPasswordAsync(request, cancellationToken), cancellationToken);
+    }
+}

apps/backend/Auth/Api/GetRacesHandler.cs

@@ -0,0 +1,22 @@
+using FastEndpoints;
+using SpaceGame.Api.Universe.Bootstrap;
+
+namespace SpaceGame.Api.Auth.Api;
+
+public sealed class GetRacesHandler(IStaticDataProvider staticData) : EndpointWithoutRequest<IReadOnlyList<RaceSnapshot>>
+{
+    public override void Configure()
+    {
+        Get("/api/auth/races");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken cancellationToken)
+    {
+        var races = staticData.RaceDefinitions.Values
+          .OrderBy(race => race.Name, StringComparer.Ordinal)
+          .Select(race => new RaceSnapshot(race.Id, race.Name, race.Description, race.Icon))
+          .ToList();
+        await SendOkAsync(races, cancellationToken);
+    }
+}

apps/backend/Auth/Api/LoginHandler.cs

@@ -0,0 +1,25 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Auth.Api;
+
+public sealed class LoginHandler(AuthService authService) : Endpoint<LoginRequest, AuthSessionResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/auth/login");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(LoginRequest request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await SendOkAsync(await authService.LoginAsync(request, cancellationToken), cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
+    }
+}

apps/backend/Auth/Api/RefreshTokenHandler.cs

@@ -0,0 +1,25 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Auth.Api;
+
+public sealed class RefreshTokenHandler(AuthService authService) : Endpoint<RefreshTokenRequest, AuthSessionResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/auth/refresh");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(RefreshTokenRequest request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await SendOkAsync(await authService.RefreshAsync(request, cancellationToken), cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
+    }
+}

apps/backend/Auth/Api/RegisterHandler.cs

@@ -0,0 +1,25 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Auth.Api;
+
+public sealed class RegisterHandler(AuthService authService) : Endpoint<RegisterRequest, RegisterResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/auth/register");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(RegisterRequest request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await SendOkAsync(await authService.RegisterAsync(request, cancellationToken), cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
+    }
+}

apps/backend/Auth/Api/ResetPasswordHandler.cs

@@ -0,0 +1,26 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Auth.Api;
+
+public sealed class ResetPasswordHandler(AuthService authService) : Endpoint<ResetPasswordRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/auth/reset-password");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(ResetPasswordRequest request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await authService.ResetPasswordAsync(request, cancellationToken);
+            await SendNoContentAsync(cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
+    }
+}

apps/backend/Auth/Contracts/AuthContracts.cs

@@ -0,0 +1,47 @@
+namespace SpaceGame.Api.Auth.Contracts;
+
+public sealed class RegisterRequest
+{
+    public string Email { get; set; } = string.Empty;
+    public string Password { get; set; } = string.Empty;
+}
+
+public sealed class LoginRequest
+{
+    public string Email { get; set; } = string.Empty;
+    public string Password { get; set; } = string.Empty;
+}
+
+public sealed class RefreshTokenRequest
+{
+    public string RefreshToken { get; set; } = string.Empty;
+}
+
+public sealed class ForgotPasswordRequest
+{
+    public string Email { get; set; } = string.Empty;
+}
+
+public sealed class ResetPasswordRequest
+{
+    public string Token { get; set; } = string.Empty;
+    public string NewPassword { get; set; } = string.Empty;
+}
+
+public sealed record AuthSessionResponse(
+  Guid UserId,
+  string Email,
+  IReadOnlyList<string> Roles,
+  string AccessToken,
+  DateTimeOffset AccessTokenExpiresAtUtc,
+  string RefreshToken,
+  DateTimeOffset RefreshTokenExpiresAtUtc);
+
+public sealed record RegisterResponse(
+  Guid UserId,
+  string Email,
+  bool RequiresLogin);
+
+public sealed record ForgotPasswordResponse(
+  bool Accepted,
+  string? ResetToken = null);

apps/backend/Auth/Contracts/Races.cs

@@ -0,0 +1,7 @@
+namespace SpaceGame.Api.Auth.Contracts;
+
+public sealed record RaceSnapshot(
+  string Id,
+  string Name,
+  string Description,
+  string Icon);

apps/backend/Auth/Runtime/AuthRuntimeModels.cs

@@ -0,0 +1,24 @@
+namespace SpaceGame.Api.Auth.Runtime;
+
+public sealed record UserAccount(
+  Guid Id,
+  string Email,
+  string PasswordHash,
+  DateTimeOffset CreatedAtUtc,
+  IReadOnlyList<string> Roles);
+
+public sealed record RefreshTokenRecord(
+  Guid Id,
+  Guid UserId,
+  string TokenHash,
+  DateTimeOffset CreatedAtUtc,
+  DateTimeOffset ExpiresAtUtc,
+  DateTimeOffset? RevokedAtUtc);
+
+public sealed record PasswordResetTokenRecord(
+  Guid Id,
+  Guid UserId,
+  string TokenHash,
+  DateTimeOffset CreatedAtUtc,
+  DateTimeOffset ExpiresAtUtc,
+  DateTimeOffset? ConsumedAtUtc);

apps/backend/Auth/Simulation/AuthOptions.cs

@@ -0,0 +1,14 @@
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class AuthOptions
+{
+    public string ConnectionString { get; set; } = string.Empty;
+    public List<SeedUserOptions> DevSeedUsers { get; set; } = [];
+}
+
+public sealed class SeedUserOptions
+{
+    public string Email { get; set; } = string.Empty;
+    public string Password { get; set; } = string.Empty;
+    public List<string> Roles { get; set; } = [];
+}

apps/backend/Auth/Simulation/AuthPolicyNames.cs

@@ -0,0 +1,13 @@
+namespace SpaceGame.Api.Auth.Simulation;
+
+public static class AuthPolicyNames
+{
+    public const string AdminAccess = "AdminAccess";
+    public const string GmAccess = "GmAccess";
+}
+
+public static class AuthRoleNames
+{
+    public const string Gm = "gm";
+    public const string Admin = "admin";
+}

apps/backend/Auth/Simulation/AuthSchemaInitializer.cs

@@ -0,0 +1,41 @@
+using Npgsql;
+
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class AuthSchemaInitializer(NpgsqlDataSource dataSource)
+{
+    public async Task EnsureSchemaAsync(CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            create table if not exists auth_users (
+                id uuid primary key,
+                email text not null unique,
+                password_hash text not null,
+                created_at_utc timestamptz not null,
+                roles text[] not null default '{}'
+            );
+
+            alter table auth_users
+            add column if not exists roles text[] not null default '{}';
+
+            create table if not exists auth_refresh_tokens (
+                id uuid primary key,
+                user_id uuid not null references auth_users(id) on delete cascade,
+                token_hash text not null unique,
+                created_at_utc timestamptz not null,
+                expires_at_utc timestamptz not null,
+                revoked_at_utc timestamptz null
+            );
+
+            create table if not exists auth_password_reset_tokens (
+                id uuid primary key,
+                user_id uuid not null references auth_users(id) on delete cascade,
+                token_hash text not null unique,
+                created_at_utc timestamptz not null,
+                expires_at_utc timestamptz not null,
+                consumed_at_utc timestamptz null
+            );
+            """);
+        await command.ExecuteNonQueryAsync(cancellationToken);
+    }
+}

apps/backend/Auth/Simulation/AuthService.cs

@@ -0,0 +1,120 @@
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class AuthService(
+    IAuthRepository authRepository,
+    LocalPasswordHasher passwordHasher,
+    ITokenService tokenService,
+    RefreshTokenFactory refreshTokenFactory,
+    IPasswordResetDelivery passwordResetDelivery)
+{
+    public async Task<RegisterResponse> RegisterAsync(RegisterRequest request, CancellationToken cancellationToken)
+    {
+        var email = NormalizeEmail(request.Email);
+        ValidatePassword(request.Password);
+
+        if (await authRepository.FindUserByEmailAsync(email, cancellationToken) is not null)
+        {
+            throw new InvalidOperationException("An account already exists for that email.");
+        }
+
+        var user = await authRepository.CreateUserAsync(email, passwordHasher.HashPassword(request.Password), [], cancellationToken);
+        return new RegisterResponse(user.Id, user.Email, true);
+    }
+
+    public async Task<AuthSessionResponse> LoginAsync(LoginRequest request, CancellationToken cancellationToken)
+    {
+        var email = NormalizeEmail(request.Email);
+        var user = await authRepository.FindUserByEmailAsync(email, cancellationToken)
+          ?? throw new InvalidOperationException("Invalid email or password.");
+        if (!passwordHasher.VerifyPassword(request.Password, user.PasswordHash))
+        {
+            throw new InvalidOperationException("Invalid email or password.");
+        }
+
+        return await CreateSessionAsync(user, cancellationToken);
+    }
+
+    public async Task<AuthSessionResponse> RefreshAsync(RefreshTokenRequest request, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(request.RefreshToken))
+        {
+            throw new InvalidOperationException("Refresh token is required.");
+        }
+
+        var tokenHash = refreshTokenFactory.HashToken(request.RefreshToken);
+        var record = await authRepository.FindRefreshTokenAsync(tokenHash, cancellationToken)
+          ?? throw new InvalidOperationException("Refresh token is invalid.");
+        if (record.RevokedAtUtc is not null || record.ExpiresAtUtc <= DateTimeOffset.UtcNow)
+        {
+            throw new InvalidOperationException("Refresh token is expired.");
+        }
+
+        var user = await authRepository.FindUserByIdAsync(record.UserId, cancellationToken)
+          ?? throw new InvalidOperationException("User account was not found.");
+        await authRepository.RevokeRefreshTokenAsync(record.Id, cancellationToken);
+        return await CreateSessionAsync(user, cancellationToken);
+    }
+
+    public async Task<ForgotPasswordResponse> ForgotPasswordAsync(ForgotPasswordRequest request, CancellationToken cancellationToken)
+    {
+        var email = NormalizeEmail(request.Email);
+        var user = await authRepository.FindUserByEmailAsync(email, cancellationToken);
+        if (user is null)
+        {
+            return new ForgotPasswordResponse(true);
+        }
+
+        var resetToken = refreshTokenFactory.CreateToken();
+        var resetTokenHash = refreshTokenFactory.HashToken(resetToken);
+        var expiresAtUtc = DateTimeOffset.UtcNow.AddMinutes(30);
+        await authRepository.StorePasswordResetTokenAsync(user.Id, resetTokenHash, expiresAtUtc, cancellationToken);
+        return await passwordResetDelivery.DeliverAsync(user, resetToken, cancellationToken);
+    }
+
+    public async Task ResetPasswordAsync(ResetPasswordRequest request, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(request.Token))
+        {
+            throw new InvalidOperationException("Reset token is required.");
+        }
+
+        ValidatePassword(request.NewPassword);
+        var tokenHash = refreshTokenFactory.HashToken(request.Token);
+        var record = await authRepository.FindPasswordResetTokenAsync(tokenHash, cancellationToken)
+          ?? throw new InvalidOperationException("Reset token is invalid.");
+        if (record.ConsumedAtUtc is not null || record.ExpiresAtUtc <= DateTimeOffset.UtcNow)
+        {
+            throw new InvalidOperationException("Reset token is expired.");
+        }
+
+        await authRepository.UpdatePasswordHashAsync(record.UserId, passwordHasher.HashPassword(request.NewPassword), cancellationToken);
+        await authRepository.ConsumePasswordResetTokenAsync(record.Id, cancellationToken);
+        await authRepository.RevokeAllRefreshTokensAsync(record.UserId, cancellationToken);
+    }
+
+    private async Task<AuthSessionResponse> CreateSessionAsync(UserAccount user, CancellationToken cancellationToken)
+    {
+        var (accessToken, accessExpiresAtUtc) = tokenService.CreateAccessToken(user);
+        var (refreshToken, refreshTokenHash, refreshExpiresAtUtc) = tokenService.CreateRefreshToken();
+        await authRepository.StoreRefreshTokenAsync(user.Id, refreshTokenHash, refreshExpiresAtUtc, cancellationToken);
+        return new AuthSessionResponse(user.Id, user.Email, user.Roles, accessToken, accessExpiresAtUtc, refreshToken, refreshExpiresAtUtc);
+    }
+
+    private static string NormalizeEmail(string email)
+    {
+        if (string.IsNullOrWhiteSpace(email))
+        {
+            throw new InvalidOperationException("Email is required.");
+        }
+
+        return email.Trim().ToLowerInvariant();
+    }
+
+    private static void ValidatePassword(string password)
+    {
+        if (string.IsNullOrWhiteSpace(password) || password.Length < 8)
+        {
+            throw new InvalidOperationException("Password must be at least 8 characters.");
+        }
+    }
+}

apps/backend/Auth/Simulation/DevAuthSeeder.cs

@@ -0,0 +1,33 @@
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Options;
+
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class DevAuthSeeder(
+    IHostEnvironment hostEnvironment,
+    IOptions<AuthOptions> authOptions,
+    IAuthRepository authRepository,
+    LocalPasswordHasher passwordHasher)
+{
+    public async Task SeedAsync(CancellationToken cancellationToken)
+    {
+        if (!hostEnvironment.IsDevelopment())
+        {
+            return;
+        }
+
+        foreach (var seedUser in authOptions.Value.DevSeedUsers)
+        {
+            if (string.IsNullOrWhiteSpace(seedUser.Email) || string.IsNullOrWhiteSpace(seedUser.Password))
+            {
+                continue;
+            }
+
+            await authRepository.UpsertUserAsync(
+              seedUser.Email.Trim().ToLowerInvariant(),
+              passwordHasher.HashPassword(seedUser.Password),
+              seedUser.Roles,
+              cancellationToken);
+        }
+    }
+}

apps/backend/Auth/Simulation/DevPasswordResetDelivery.cs

@@ -0,0 +1,7 @@
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class DevPasswordResetDelivery : IPasswordResetDelivery
+{
+    public Task<ForgotPasswordResponse> DeliverAsync(UserAccount user, string resetToken, CancellationToken cancellationToken) =>
+      Task.FromResult(new ForgotPasswordResponse(true, resetToken));
+}

apps/backend/Auth/Simulation/HttpContextPlayerIdentityResolver.cs

@@ -0,0 +1,40 @@
+using System.Security.Claims;
+using Microsoft.AspNetCore.Http;
+
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class HttpContextPlayerIdentityResolver(IHttpContextAccessor httpContextAccessor) : IPlayerIdentityResolver
+{
+    public const string EffectivePlayerHeaderName = "X-Act-As-Player-Id";
+
+    public Guid? GetCurrentPlayerId()
+    {
+        var subject = httpContextAccessor.HttpContext?.User.FindFirstValue(ClaimTypes.NameIdentifier)
+          ?? httpContextAccessor.HttpContext?.User.FindFirstValue("sub");
+        return Guid.TryParse(subject, out var playerId) ? playerId : null;
+    }
+
+    public Guid GetRequiredPlayerId() =>
+      GetCurrentPlayerId() ?? throw new InvalidOperationException("Authenticated player identity is required.");
+
+    public Guid? GetEffectivePlayerId()
+    {
+        var currentPlayerId = GetCurrentPlayerId();
+        if (!CanAccessGm())
+        {
+            return currentPlayerId;
+        }
+
+        var requestedIdentity = httpContextAccessor.HttpContext?.Request.Headers[EffectivePlayerHeaderName].FirstOrDefault();
+        return Guid.TryParse(requestedIdentity, out var effectivePlayerId) ? effectivePlayerId : currentPlayerId;
+    }
+
+    public Guid GetRequiredEffectivePlayerId() =>
+      GetEffectivePlayerId() ?? throw new InvalidOperationException("Authenticated player identity is required.");
+
+    public bool CanAccessGm()
+    {
+        var user = httpContextAccessor.HttpContext?.User;
+        return user?.IsInRole("gm") == true || user?.IsInRole("admin") == true;
+    }
+}

apps/backend/Auth/Simulation/IAuthRepository.cs

@@ -0,0 +1,18 @@
+namespace SpaceGame.Api.Auth.Simulation;
+
+public interface IAuthRepository
+{
+    Task<UserAccount?> FindUserByEmailAsync(string email, CancellationToken cancellationToken);
+    Task<UserAccount?> FindUserByIdAsync(Guid userId, CancellationToken cancellationToken);
+    Task<IReadOnlyList<UserAccount>> ListUsersAsync(CancellationToken cancellationToken);
+    Task<UserAccount> CreateUserAsync(string email, string passwordHash, IReadOnlyCollection<string> roles, CancellationToken cancellationToken);
+    Task<UserAccount> UpsertUserAsync(string email, string passwordHash, IReadOnlyCollection<string> roles, CancellationToken cancellationToken);
+    Task StoreRefreshTokenAsync(Guid userId, string tokenHash, DateTimeOffset expiresAtUtc, CancellationToken cancellationToken);
+    Task<RefreshTokenRecord?> FindRefreshTokenAsync(string tokenHash, CancellationToken cancellationToken);
+    Task RevokeRefreshTokenAsync(Guid refreshTokenId, CancellationToken cancellationToken);
+    Task RevokeAllRefreshTokensAsync(Guid userId, CancellationToken cancellationToken);
+    Task StorePasswordResetTokenAsync(Guid userId, string tokenHash, DateTimeOffset expiresAtUtc, CancellationToken cancellationToken);
+    Task<PasswordResetTokenRecord?> FindPasswordResetTokenAsync(string tokenHash, CancellationToken cancellationToken);
+    Task ConsumePasswordResetTokenAsync(Guid passwordResetTokenId, CancellationToken cancellationToken);
+    Task UpdatePasswordHashAsync(Guid userId, string passwordHash, CancellationToken cancellationToken);
+}

apps/backend/Auth/Simulation/IPasswordResetDelivery.cs

@@ -0,0 +1,6 @@
+namespace SpaceGame.Api.Auth.Simulation;
+
+public interface IPasswordResetDelivery
+{
+    Task<ForgotPasswordResponse> DeliverAsync(UserAccount user, string resetToken, CancellationToken cancellationToken);
+}

apps/backend/Auth/Simulation/IPlayerIdentityResolver.cs

@@ -0,0 +1,10 @@
+namespace SpaceGame.Api.Auth.Simulation;
+
+public interface IPlayerIdentityResolver
+{
+    Guid? GetCurrentPlayerId();
+    Guid GetRequiredPlayerId();
+    Guid? GetEffectivePlayerId();
+    Guid GetRequiredEffectivePlayerId();
+    bool CanAccessGm();
+}

apps/backend/Auth/Simulation/ITokenService.cs

@@ -0,0 +1,7 @@
+namespace SpaceGame.Api.Auth.Simulation;
+
+public interface ITokenService
+{
+    (string Token, DateTimeOffset ExpiresAtUtc) CreateAccessToken(UserAccount user);
+    (string Token, string TokenHash, DateTimeOffset ExpiresAtUtc) CreateRefreshToken();
+}

apps/backend/Auth/Simulation/JwtOptions.cs

@@ -0,0 +1,10 @@
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class JwtOptions
+{
+    public string Issuer { get; set; } = "space-game";
+    public string Audience { get; set; } = "space-game-viewer";
+    public string SigningKey { get; set; } = string.Empty;
+    public int AccessTokenLifetimeMinutes { get; set; } = 30;
+    public int RefreshTokenLifetimeDays { get; set; } = 30;
+}

apps/backend/Auth/Simulation/JwtTokenService.cs

@@ -0,0 +1,51 @@
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class JwtTokenService(
+    IOptions<JwtOptions> jwtOptions,
+    RefreshTokenFactory refreshTokenFactory) : ITokenService
+{
+    public (string Token, DateTimeOffset ExpiresAtUtc) CreateAccessToken(UserAccount user)
+    {
+        var options = jwtOptions.Value;
+        var expiresAtUtc = DateTimeOffset.UtcNow.AddMinutes(Math.Max(options.AccessTokenLifetimeMinutes, 5));
+        var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(options.SigningKey));
+        var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
+        var claims = new[]
+        {
+            new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
+            new Claim(JwtRegisteredClaimNames.Email, user.Email),
+            new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
+            new Claim(ClaimTypes.Email, user.Email),
+        }.ToList();
+
+        foreach (var role in user.Roles)
+        {
+            claims.Add(new Claim(ClaimTypes.Role, role));
+            claims.Add(new Claim("role", role));
+        }
+
+        var token = new JwtSecurityToken(
+          issuer: options.Issuer,
+          audience: options.Audience,
+          claims: claims,
+          notBefore: DateTime.UtcNow,
+          expires: expiresAtUtc.UtcDateTime,
+          signingCredentials: credentials);
+
+        return (new JwtSecurityTokenHandler().WriteToken(token), expiresAtUtc);
+    }
+
+    public (string Token, string TokenHash, DateTimeOffset ExpiresAtUtc) CreateRefreshToken()
+    {
+        var token = refreshTokenFactory.CreateToken();
+        var tokenHash = refreshTokenFactory.HashToken(token);
+        var expiresAtUtc = DateTimeOffset.UtcNow.AddDays(Math.Max(jwtOptions.Value.RefreshTokenLifetimeDays, 1));
+        return (token, tokenHash, expiresAtUtc);
+    }
+}

apps/backend/Auth/Simulation/LocalPasswordHasher.cs

@@ -0,0 +1,42 @@
+using System.Security.Cryptography;
+
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class LocalPasswordHasher
+{
+    private const int SaltSize = 16;
+    private const int KeySize = 32;
+    private const int IterationCount = 120_000;
+
+    public string HashPassword(string password)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(password);
+
+        Span<byte> salt = stackalloc byte[SaltSize];
+        RandomNumberGenerator.Fill(salt);
+        var hash = Rfc2898DeriveBytes.Pbkdf2(password, salt, IterationCount, HashAlgorithmName.SHA256, KeySize);
+        return $"pbkdf2-sha256${IterationCount}${Convert.ToBase64String(salt)}${Convert.ToBase64String(hash)}";
+    }
+
+    public bool VerifyPassword(string password, string encodedHash)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(password);
+        ArgumentException.ThrowIfNullOrWhiteSpace(encodedHash);
+
+        var parts = encodedHash.Split('$', StringSplitOptions.RemoveEmptyEntries);
+        if (parts.Length != 4 || !string.Equals(parts[0], "pbkdf2-sha256", StringComparison.Ordinal))
+        {
+            return false;
+        }
+
+        if (!int.TryParse(parts[1], out var iterations))
+        {
+            return false;
+        }
+
+        var salt = Convert.FromBase64String(parts[2]);
+        var expected = Convert.FromBase64String(parts[3]);
+        var actual = Rfc2898DeriveBytes.Pbkdf2(password, salt, iterations, HashAlgorithmName.SHA256, expected.Length);
+        return CryptographicOperations.FixedTimeEquals(actual, expected);
+    }
+}

apps/backend/Auth/Simulation/PostgresAuthRepository.cs

@@ -0,0 +1,216 @@
+using Npgsql;
+
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class PostgresAuthRepository(NpgsqlDataSource dataSource) : IAuthRepository
+{
+    public async Task<UserAccount?> FindUserByEmailAsync(string email, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            select id, email, password_hash, created_at_utc, roles
+            from auth_users
+            where email = $1
+            """);
+        command.Parameters.AddWithValue(email);
+        await using var reader = await command.ExecuteReaderAsync(cancellationToken);
+        return await reader.ReadAsync(cancellationToken) ? ReadUser(reader) : null;
+    }
+
+    public async Task<UserAccount?> FindUserByIdAsync(Guid userId, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            select id, email, password_hash, created_at_utc, roles
+            from auth_users
+            where id = $1
+            """);
+        command.Parameters.AddWithValue(userId);
+        await using var reader = await command.ExecuteReaderAsync(cancellationToken);
+        return await reader.ReadAsync(cancellationToken) ? ReadUser(reader) : null;
+    }
+
+    public async Task<IReadOnlyList<UserAccount>> ListUsersAsync(CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            select id, email, password_hash, created_at_utc, roles
+            from auth_users
+            order by email asc
+            """);
+        await using var reader = await command.ExecuteReaderAsync(cancellationToken);
+        var users = new List<UserAccount>();
+        while (await reader.ReadAsync(cancellationToken))
+        {
+            users.Add(ReadUser(reader));
+        }
+
+        return users;
+    }
+
+    public async Task<UserAccount> CreateUserAsync(string email, string passwordHash, IReadOnlyCollection<string> roles, CancellationToken cancellationToken)
+    {
+        var userId = Guid.NewGuid();
+        var createdAtUtc = DateTimeOffset.UtcNow;
+        await using var command = dataSource.CreateCommand("""
+            insert into auth_users (id, email, password_hash, created_at_utc, roles)
+            values ($1, $2, $3, $4, $5)
+            """);
+        command.Parameters.AddWithValue(userId);
+        command.Parameters.AddWithValue(email);
+        command.Parameters.AddWithValue(passwordHash);
+        command.Parameters.AddWithValue(createdAtUtc);
+        command.Parameters.AddWithValue(roles.Select(role => role.Trim().ToLowerInvariant()).Where(role => role.Length > 0).Distinct(StringComparer.Ordinal).ToArray());
+        await command.ExecuteNonQueryAsync(cancellationToken);
+        return new UserAccount(userId, email, passwordHash, createdAtUtc, roles.Select(role => role.Trim().ToLowerInvariant()).Where(role => role.Length > 0).Distinct(StringComparer.Ordinal).ToArray());
+    }
+
+    public async Task<UserAccount> UpsertUserAsync(string email, string passwordHash, IReadOnlyCollection<string> roles, CancellationToken cancellationToken)
+    {
+        var normalizedRoles = roles.Select(role => role.Trim().ToLowerInvariant()).Where(role => role.Length > 0).Distinct(StringComparer.Ordinal).ToArray();
+        var userId = Guid.NewGuid();
+        var createdAtUtc = DateTimeOffset.UtcNow;
+        await using var command = dataSource.CreateCommand("""
+            insert into auth_users (id, email, password_hash, created_at_utc, roles)
+            values ($1, $2, $3, $4, $5)
+            on conflict (email) do update
+            set password_hash = excluded.password_hash,
+                roles = excluded.roles
+            returning id, email, password_hash, created_at_utc, roles
+            """);
+        command.Parameters.AddWithValue(userId);
+        command.Parameters.AddWithValue(email);
+        command.Parameters.AddWithValue(passwordHash);
+        command.Parameters.AddWithValue(createdAtUtc);
+        command.Parameters.AddWithValue(normalizedRoles);
+        await using var reader = await command.ExecuteReaderAsync(cancellationToken);
+        await reader.ReadAsync(cancellationToken);
+        return ReadUser(reader);
+    }
+
+    public async Task StoreRefreshTokenAsync(Guid userId, string tokenHash, DateTimeOffset expiresAtUtc, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            insert into auth_refresh_tokens (id, user_id, token_hash, created_at_utc, expires_at_utc, revoked_at_utc)
+            values ($1, $2, $3, $4, $5, null)
+            """);
+        command.Parameters.AddWithValue(Guid.NewGuid());
+        command.Parameters.AddWithValue(userId);
+        command.Parameters.AddWithValue(tokenHash);
+        command.Parameters.AddWithValue(DateTimeOffset.UtcNow);
+        command.Parameters.AddWithValue(expiresAtUtc);
+        await command.ExecuteNonQueryAsync(cancellationToken);
+    }
+
+    public async Task<RefreshTokenRecord?> FindRefreshTokenAsync(string tokenHash, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            select id, user_id, token_hash, created_at_utc, expires_at_utc, revoked_at_utc
+            from auth_refresh_tokens
+            where token_hash = $1
+            """);
+        command.Parameters.AddWithValue(tokenHash);
+        await using var reader = await command.ExecuteReaderAsync(cancellationToken);
+        if (!await reader.ReadAsync(cancellationToken))
+        {
+            return null;
+        }
+
+        return new RefreshTokenRecord(
+          reader.GetGuid(0),
+          reader.GetGuid(1),
+          reader.GetString(2),
+          reader.GetFieldValue<DateTimeOffset>(3),
+          reader.GetFieldValue<DateTimeOffset>(4),
+          reader.IsDBNull(5) ? null : reader.GetFieldValue<DateTimeOffset>(5));
+    }
+
+    public async Task RevokeRefreshTokenAsync(Guid refreshTokenId, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            update auth_refresh_tokens
+            set revoked_at_utc = $2
+            where id = $1 and revoked_at_utc is null
+            """);
+        command.Parameters.AddWithValue(refreshTokenId);
+        command.Parameters.AddWithValue(DateTimeOffset.UtcNow);
+        await command.ExecuteNonQueryAsync(cancellationToken);
+    }
+
+    public async Task RevokeAllRefreshTokensAsync(Guid userId, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            update auth_refresh_tokens
+            set revoked_at_utc = $2
+            where user_id = $1 and revoked_at_utc is null
+            """);
+        command.Parameters.AddWithValue(userId);
+        command.Parameters.AddWithValue(DateTimeOffset.UtcNow);
+        await command.ExecuteNonQueryAsync(cancellationToken);
+    }
+
+    public async Task StorePasswordResetTokenAsync(Guid userId, string tokenHash, DateTimeOffset expiresAtUtc, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            insert into auth_password_reset_tokens (id, user_id, token_hash, created_at_utc, expires_at_utc, consumed_at_utc)
+            values ($1, $2, $3, $4, $5, null)
+            """);
+        command.Parameters.AddWithValue(Guid.NewGuid());
+        command.Parameters.AddWithValue(userId);
+        command.Parameters.AddWithValue(tokenHash);
+        command.Parameters.AddWithValue(DateTimeOffset.UtcNow);
+        command.Parameters.AddWithValue(expiresAtUtc);
+        await command.ExecuteNonQueryAsync(cancellationToken);
+    }
+
+    public async Task<PasswordResetTokenRecord?> FindPasswordResetTokenAsync(string tokenHash, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            select id, user_id, token_hash, created_at_utc, expires_at_utc, consumed_at_utc
+            from auth_password_reset_tokens
+            where token_hash = $1
+            """);
+        command.Parameters.AddWithValue(tokenHash);
+        await using var reader = await command.ExecuteReaderAsync(cancellationToken);
+        if (!await reader.ReadAsync(cancellationToken))
+        {
+            return null;
+        }
+
+        return new PasswordResetTokenRecord(
+          reader.GetGuid(0),
+          reader.GetGuid(1),
+          reader.GetString(2),
+          reader.GetFieldValue<DateTimeOffset>(3),
+          reader.GetFieldValue<DateTimeOffset>(4),
+          reader.IsDBNull(5) ? null : reader.GetFieldValue<DateTimeOffset>(5));
+    }
+
+    public async Task ConsumePasswordResetTokenAsync(Guid passwordResetTokenId, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            update auth_password_reset_tokens
+            set consumed_at_utc = $2
+            where id = $1 and consumed_at_utc is null
+            """);
+        command.Parameters.AddWithValue(passwordResetTokenId);
+        command.Parameters.AddWithValue(DateTimeOffset.UtcNow);
+        await command.ExecuteNonQueryAsync(cancellationToken);
+    }
+
+    public async Task UpdatePasswordHashAsync(Guid userId, string passwordHash, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand("""
+            update auth_users
+            set password_hash = $2
+            where id = $1
+            """);
+        command.Parameters.AddWithValue(userId);
+        command.Parameters.AddWithValue(passwordHash);
+        await command.ExecuteNonQueryAsync(cancellationToken);
+    }
+
+    private static UserAccount ReadUser(NpgsqlDataReader reader) => new(
+      reader.GetGuid(0),
+      reader.GetString(1),
+      reader.GetString(2),
+      reader.GetFieldValue<DateTimeOffset>(3),
+      reader.GetFieldValue<string[]>(4));
+}

apps/backend/Auth/Simulation/RefreshTokenFactory.cs

@@ -0,0 +1,21 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace SpaceGame.Api.Auth.Simulation;
+
+public sealed class RefreshTokenFactory
+{
+    public string CreateToken()
+    {
+        Span<byte> bytes = stackalloc byte[32];
+        RandomNumberGenerator.Fill(bytes);
+        return Convert.ToBase64String(bytes);
+    }
+
+    public string HashToken(string token)
+    {
+        using var sha = SHA256.Create();
+        var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(token));
+        return Convert.ToHexString(bytes);
+    }
+}

apps/backend/Definitions/WorldDefinitions.cs

@@ -1,326 +1,597 @@
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json.Serialization;
+using SpaceGame.Api.Shared.Runtime;
+using SpaceGame.Api.Shared.Runtime;
+using SpaceGame.Api.Universe.Simulation;
 
 namespace SpaceGame.Api.Definitions;
 
 public sealed class ConstructionDefinition
 {
-  public string? RecipeId { get; set; }
-  public string FacilityCategory { get; set; } = "station";
-  public List<string> RequiredModules { get; set; } = [];
-  public List<RecipeInputDefinition> Requirements { get; set; } = [];
-  public float CycleTime { get; set; }
-  public float BatchSize { get; set; } = 1f;
-  public float ProductsPerHour { get; set; }
-  public float MaxEfficiency { get; set; } = 1f;
-  public int Priority { get; set; }
+    public string? RecipeId { get; set; }
+    public string FacilityCategory { get; set; } = "station";
+    public List<string> RequiredModules { get; set; } = [];
+    public List<RecipeInputDefinition> Requirements { get; set; } = [];
+    public float CycleTime { get; set; }
+    public float BatchSize { get; set; } = 1f;
+    public float ProductsPerHour { get; set; }
+    public float MaxEfficiency { get; set; } = 1f;
+    public int Priority { get; set; }
 }
 
 public sealed class ItemPriceDefinition
 {
-  public float Min { get; set; }
-  public float Max { get; set; }
-  public float Avg { get; set; }
+    public float Min { get; set; }
+    public float Max { get; set; }
+    public float Avg { get; set; }
 }
 
 public sealed class ItemEffectDefinition
 {
-  public required string Type { get; set; }
-  public float Product { get; set; }
+    public required string Type { get; set; }
+    public float Product { get; set; }
 }
 
 public sealed class ItemProductionDefinition
 {
-  public float Time { get; set; }
-  public float Amount { get; set; }
-  public string Method { get; set; } = "default";
-  public string Name { get; set; } = "Universal";
-  public List<RecipeInputDefinition> Wares { get; set; } = [];
-  public List<ItemEffectDefinition> Effects { get; set; } = [];
-}
-
-public sealed class BalanceDefinition
-{
-  public float SimulationSpeedMultiplier { get; set; } = 1f;
-  public float YPlane { get; set; }
-  public float ArrivalThreshold { get; set; }
-  public float MiningRate { get; set; }
-  public float MiningCycleSeconds { get; set; }
-  public float TransferRate { get; set; }
-  public float DockingDuration { get; set; }
-  public float UndockingDuration { get; set; }
-  public float UndockDistance { get; set; }
+    public float Time { get; set; }
+    public float Amount { get; set; }
+    public string Method { get; set; } = "default";
+    public string Name { get; set; } = "Universal";
+    public List<RecipeInputDefinition> Wares { get; set; } = [];
+    public List<ItemEffectDefinition> Effects { get; set; } = [];
 }
 
 public sealed class StarDefinition
 {
-  public string Kind { get; set; } = "main-sequence";
-  public required string Color { get; set; }
-  public required string Glow { get; set; }
-  public float Size { get; set; }
-  public float OrbitRadius { get; set; }
-  public float OrbitSpeed { get; set; }
-  public float OrbitPhaseAtEpoch { get; set; }
+    public string Kind { get; set; } = "main-sequence";
+    public required string Color { get; set; }
+    public required string Glow { get; set; }
+    public float Size { get; set; }
+    public float OrbitRadius { get; set; }
+    public float OrbitSpeed { get; set; }
+    public float OrbitPhaseAtEpoch { get; set; }
 }
 
 public sealed class MoonDefinition
 {
-  public required string Label { get; set; }
-  public float Size { get; set; }
-  public required string Color { get; set; }
-  public float OrbitRadius { get; set; }
-  public float OrbitSpeed { get; set; }
-  public float OrbitPhaseAtEpoch { get; set; }
-  public float OrbitInclination { get; set; }
-  public float OrbitLongitudeOfAscendingNode { get; set; }
+    public required string Label { get; set; }
+    public float Size { get; set; }
+    public required string Color { get; set; }
+    public float OrbitRadius { get; set; }
+    public float OrbitSpeed { get; set; }
+    public float OrbitPhaseAtEpoch { get; set; }
+    public float OrbitInclination { get; set; }
+    public float OrbitLongitudeOfAscendingNode { get; set; }
 }
 
 public sealed class SolarSystemDefinition
 {
-  public required string Id { get; set; }
-  public required string Label { get; set; }
-  public required float[] Position { get; set; }
-  public required List<StarDefinition> Stars { get; set; }
-  public required AsteroidFieldDefinition AsteroidField { get; set; }
-  public required List<ResourceNodeDefinition> ResourceNodes { get; set; }
-  public required List<PlanetDefinition> Planets { get; set; }
+    public required string Id { get; set; }
+    public required string Label { get; set; }
+    public required float[] Position { get; set; }
+    public required List<StarDefinition> Stars { get; set; }
+    public required AsteroidFieldDefinition AsteroidField { get; set; }
+    public required List<ResourceNodeDefinition> ResourceNodes { get; set; }
+    public required List<PlanetDefinition> Planets { get; set; }
+}
+
+public sealed class RaceDefinition
+{
+    public required string Id { get; set; }
+    public required string Name { get; set; }
+    public string Description { get; set; } = string.Empty;
+    public string Icon { get; set; } = string.Empty;
+    [JsonIgnore]
+    public string Label => Name;
+}
+
+public sealed class FactionDefinition
+{
+    public required string Id { get; set; }
+    public int Version { get; set; }
+    public required string Name { get; set; }
+    public string Description { get; set; } = string.Empty;
+    public string Icon { get; set; } = string.Empty;
+    public string? Race { get; set; }
+    public List<FactionLicenseDefinition> Licenses { get; set; } = [];
+    [JsonIgnore]
+    public string Label => Name;
+    [JsonIgnore]
+    public string? RaceId => Race;
+}
+
+public sealed class FactionLicenseDefinition
+{
+    public required string Type { get; set; }
+    public string Name { get; set; } = string.Empty;
+    public string Icon { get; set; } = string.Empty;
+    public float Price { get; set; }
 }
 
 public sealed class AsteroidFieldDefinition
 {
-  public int DecorationCount { get; set; }
-  public float RadiusOffset { get; set; }
-  public float RadiusVariance { get; set; }
-  public float HeightVariance { get; set; }
+    public int DecorationCount { get; set; }
+    public float RadiusOffset { get; set; }
+    public float RadiusVariance { get; set; }
+    public float HeightVariance { get; set; }
 }
 
 public sealed class ResourceNodeDefinition
 {
-  public string SourceKind { get; set; } = "local-space";
-  public string? AnchorReference { get; set; }
-  public float Angle { get; set; }
-  public float RadiusOffset { get; set; }
-  public float InclinationDegrees { get; set; }
-  public int? AnchorPlanetIndex { get; set; }
-  public int? AnchorMoonIndex { get; set; }
-  public float OreAmount { get; set; }
-  public required string ItemId { get; set; }
-  public int ShardCount { get; set; }
+    public string SourceKind { get; set; } = "local-space";
+    public string? AnchorReference { get; set; }
+    public float Angle { get; set; }
+    public float RadiusOffset { get; set; }
+    public float InclinationDegrees { get; set; }
+    public int? AnchorPlanetIndex { get; set; }
+    public int? AnchorMoonIndex { get; set; }
+    public float OreAmount { get; set; }
+    public required string ItemId { get; set; }
+    public int ShardCount { get; set; }
 }
 
 public sealed class ItemDefinition
 {
-  public required string Id { get; set; }
-  public required string Name { get; set; }
-  public string Description { get; set; } = string.Empty;
-  public string Type { get; set; } = "material";
-  public string CargoKind { get; set; } = string.Empty;
-  public float Volume { get; set; } = 1f;
-  public int Version { get; set; }
-  public string FactoryName { get; set; } = string.Empty;
-  public string Icon { get; set; } = string.Empty;
-  public string Group { get; set; } = string.Empty;
-  public ItemPriceDefinition? Price { get; set; }
-  public List<string> Illegal { get; set; } = [];
-  public List<ItemProductionDefinition> Production { get; set; } = [];
-  public ConstructionDefinition? Construction { get; set; }
-  [JsonPropertyName("transport")]
-  public string Transport
-  {
-    set => CargoKind = value;
-  }
+    public required string Id { get; set; }
+    public required string Name { get; set; }
+    public string Description { get; set; } = string.Empty;
+    [JsonIgnore]
+    public StorageKind? CargoKind { get; set; }
+    public float Volume { get; set; } = 1f;
+    public int Version { get; set; }
+    public string FactoryName { get; set; } = string.Empty;
+    public string Icon { get; set; } = string.Empty;
+    public string Group { get; set; } = string.Empty;
+    public ItemPriceDefinition? Price { get; set; }
+    public List<string> Illegal { get; set; } = [];
+    public List<ItemProductionDefinition> Production { get; set; } = [];
+    public ConstructionDefinition? Construction { get; set; }
+    [JsonPropertyName("transport")]
+    public string Transport
+    {
+        get => CargoKind?.ToDataValue() ?? string.Empty;
+        set => CargoKind = value.ToNullableStorageKind();
+    }
 }
 
 public sealed class RecipeOutputDefinition
 {
-  public required string ItemId { get; set; }
-  public float Amount { get; set; }
+    public required string ItemId { get; set; }
+    public float Amount { get; set; }
 }
 
 public sealed class RecipeInputDefinition
 {
-  public string ItemId { get; set; } = string.Empty;
-  public float Amount { get; set; }
-  [JsonPropertyName("ware")]
-  public string Ware
-  {
-    set => ItemId = value;
-  }
-}
-
-public sealed class ModuleConstructionDefinition
-{
-  public required List<RecipeInputDefinition> Requirements { get; set; }
-  public float ProductionTime { get; set; }
+    public string ItemId { get; set; } = string.Empty;
+    public float Amount { get; set; }
+    [JsonPropertyName("ware")]
+    public string Ware
+    {
+        set => ItemId = value;
+    }
 }
 
 public sealed class ModuleDockDefinition
 {
-  public int Capacity { get; set; }
-  public required string Size { get; set; }
+    public int Capacity { get; set; }
+    public required string Size { get; set; }
 }
 
 public sealed class ModuleCargoDefinition
 {
-  public float Max { get; set; }
-  public required string Type { get; set; }
+    public float Max { get; set; }
+    public required string Type { get; set; }
 }
 
-public sealed class ModuleWorkForceDefinition
+public sealed class ModuleWorkforceDefinition
 {
-  public float Capacity { get; set; }
-  public float Max { get; set; }
-  public string Race { get; set; } = string.Empty;
+    [JsonPropertyName("capacity")]
+    public float SupportedPopulation { get; set; }
+
+    [JsonPropertyName("max")]
+    public float RequiredWorkforce { get; set; }
+
+    public string Race { get; set; } = string.Empty;
 }
 
 public sealed class ModuleMountDefinition
 {
-  public required string Group { get; set; }
-  public required string Size { get; set; }
-  public bool Hittable { get; set; }
-  public List<string> Types { get; set; } = [];
+    public required string Group { get; set; }
+    public required string Size { get; set; }
+    public bool Hittable { get; set; }
+    public List<string> Types { get; set; } = [];
 }
 
-public sealed class ModuleProductionDefinition
+public sealed class ModuleBuildRecipeDefinition
 {
-  public float Time { get; set; }
-  public float Amount { get; set; }
-  public string Method { get; set; } = "default";
-  public string Name { get; set; } = "Universal";
-  public List<RecipeInputDefinition> Wares { get; set; } = [];
+    public float Time { get; set; }
+    public float Amount { get; set; }
+    public string Method { get; set; } = "default";
+    public string Name { get; set; } = "Universal";
+    public List<RecipeInputDefinition> Wares { get; set; } = [];
 }
 
-public sealed class ModuleDefinition
+public class ModuleDefinition
 {
-  public required string Id { get; set; }
-  public required string Name { get; set; }
-  public string Description { get; set; } = string.Empty;
-  public required string Type { get; set; }
-  [JsonIgnore]
-  public string? Product { get; set; }
-  public List<string> Products { get; set; } = [];
-  public string ProductionMode { get; set; } = "passive";
-  public float Radius { get; set; } = 12f;
-  public float Hull { get; set; } = 100f;
-  public float WorkforceNeeded { get; set; }
-  public int Version { get; set; }
-  public string Macro { get; set; } = string.Empty;
-  public string MakerRace { get; set; } = string.Empty;
-  public int ExplosionDamage { get; set; }
-  public ItemPriceDefinition? Price { get; set; }
-  public List<string> Owners { get; set; } = [];
-  public ModuleCargoDefinition? Cargo { get; set; }
-  public ModuleWorkForceDefinition? WorkForce { get; set; }
-  public List<ModuleDockDefinition> Docks { get; set; } = [];
-  public List<ModuleMountDefinition> Shields { get; set; } = [];
-  public List<ModuleMountDefinition> Turrets { get; set; } = [];
-  public List<ModuleProductionDefinition> Production { get; set; } = [];
-  public ModuleConstructionDefinition? Construction { get; set; }
-  [JsonPropertyName("product")]
-  public List<string> ProductIds
-  {
-    get => Products;
-    set => Products = value ?? [];
-  }
+    public ModuleDefinition()
+    {
+    }
+
+    [SetsRequiredMembers]
+    protected ModuleDefinition(ModuleDefinition source)
+    {
+        Id = source.Id;
+        Name = source.Name;
+        Description = source.Description;
+        Type = source.Type;
+        ModuleType = source.ModuleType;
+        ProductIds = [.. source.ProductIds];
+        Radius = source.Radius;
+        Hull = source.Hull;
+        Version = source.Version;
+        Macro = source.Macro;
+        MakerRace = source.MakerRace;
+        ExplosionDamage = source.ExplosionDamage;
+        Price = source.Price;
+        Owners = [.. source.Owners];
+        Cargo = source.Cargo;
+        SerializedWorkforce = source.SerializedWorkforce;
+        Docks = [.. source.Docks];
+        Shields = [.. source.Shields];
+        Turrets = [.. source.Turrets];
+        BuildRecipes = [.. source.BuildRecipes];
+    }
+
+    public required string Id { get; set; }
+    public required string Name { get; set; }
+    public string Description { get; set; } = string.Empty;
+    public required string Type { get; set; }
+    [JsonIgnore]
+    public ModuleType ModuleType { get; set; }
+    [JsonPropertyName("product")]
+    public List<string> ProductIds { get; set; } = [];
+    [JsonIgnore]
+    public virtual IReadOnlyList<string> ProductItemIds => [];
+    public float Radius { get; set; } = 12f;
+    public float Hull { get; set; } = 100f;
+    public int Version { get; set; }
+    public string Macro { get; set; } = string.Empty;
+    public string MakerRace { get; set; } = string.Empty;
+    public int ExplosionDamage { get; set; }
+    public ItemPriceDefinition? Price { get; set; }
+    public List<string> Owners { get; set; } = [];
+    public ModuleCargoDefinition? Cargo { get; set; }
+    [JsonPropertyName("workForce")]
+    public ModuleWorkforceDefinition? SerializedWorkforce { get; set; }
+    public List<ModuleDockDefinition> Docks { get; set; } = [];
+    public List<ModuleMountDefinition> Shields { get; set; } = [];
+    public List<ModuleMountDefinition> Turrets { get; set; } = [];
+    [JsonPropertyName("production")]
+    public List<ModuleBuildRecipeDefinition> BuildRecipes { get; set; } = [];
+}
+
+public abstract class ProductionLaneModuleDefinition : ModuleDefinition
+{
+    [SetsRequiredMembers]
+    protected ProductionLaneModuleDefinition(ModuleDefinition source, float requiredWorkforce)
+        : base(source)
+    {
+        RequiredWorkforce = requiredWorkforce;
+    }
+
+    public float RequiredWorkforce { get; init; }
+}
+
+public sealed class ProductionModuleDefinition : ProductionLaneModuleDefinition
+{
+    [SetsRequiredMembers]
+    internal ProductionModuleDefinition(ModuleDefinition source, float requiredWorkforce)
+        : base(source, requiredWorkforce)
+    {
+        ProductItemIds = [.. source.ProductIds];
+    }
+
+    public override IReadOnlyList<string> ProductItemIds { get; } = [];
+}
+
+public sealed class BuildModuleDefinition : ProductionLaneModuleDefinition
+{
+    [SetsRequiredMembers]
+    internal BuildModuleDefinition(ModuleDefinition source, float requiredWorkforce)
+        : base(source, requiredWorkforce)
+    {
+    }
+}
+
+public sealed class HabitationModuleDefinition : ModuleDefinition
+{
+    [SetsRequiredMembers]
+    internal HabitationModuleDefinition(ModuleDefinition source, float supportedPopulation)
+        : base(source)
+    {
+        SupportedPopulation = supportedPopulation;
+    }
+
+    public float SupportedPopulation { get; init; }
+}
+
+public sealed class StorageModuleDefinition : ModuleDefinition
+{
+    [SetsRequiredMembers]
+    internal StorageModuleDefinition(ModuleDefinition source, StorageKind storageKind, float storageCapacity)
+        : base(source)
+    {
+        StorageKind = storageKind;
+        StorageCapacity = storageCapacity;
+    }
+
+    public StorageKind StorageKind { get; init; }
+    public float StorageCapacity { get; init; }
 }
 
 public sealed class ModuleRecipeDefinition
 {
-  public required string ModuleId { get; set; }
-  public float Duration { get; set; }
-  public required List<RecipeInputDefinition> Inputs { get; set; }
+    public required string ModuleId { get; set; }
+    public float Duration { get; set; }
+    public required List<RecipeInputDefinition> Inputs { get; set; }
 }
 
 public sealed class RecipeDefinition
 {
-  public required string Id { get; set; }
-  public required string Label { get; set; }
-  public required string FacilityCategory { get; set; }
-  public float Duration { get; set; }
-  public int Priority { get; set; }
-  public List<string> RequiredModules { get; set; } = [];
-  public List<RecipeInputDefinition> Inputs { get; set; } = [];
-  public List<RecipeOutputDefinition> Outputs { get; set; } = [];
-  public string? ShipOutputId { get; set; }
+    public required string Id { get; set; }
+    public required string Label { get; set; }
+    public required string FacilityCategory { get; set; }
+    public float Duration { get; set; }
+    public int Priority { get; set; }
+    public List<string> RequiredModules { get; set; } = [];
+    public List<RecipeInputDefinition> Inputs { get; set; } = [];
+    public List<RecipeOutputDefinition> Outputs { get; set; } = [];
+    public string? ShipOutputId { get; set; }
 }
 
 public sealed class PlanetDefinition
 {
-  public required string Label { get; set; }
-  public string PlanetType { get; set; } = "terrestrial";
-  public string Shape { get; set; } = "sphere";
-  public List<MoonDefinition> Moons { get; set; } = [];
-  public float OrbitRadius { get; set; }
-  public float OrbitSpeed { get; set; }
-  public float OrbitEccentricity { get; set; }
-  public float OrbitInclination { get; set; }
-  public float OrbitLongitudeOfAscendingNode { get; set; }
-  public float OrbitArgumentOfPeriapsis { get; set; }
-  public float OrbitPhaseAtEpoch { get; set; }
-  public float Size { get; set; }
-  public required string Color { get; set; }
-  public float Tilt { get; set; }
-  public bool HasRing { get; set; }
+    public required string Label { get; set; }
+    public string PlanetType { get; set; } = "terrestrial";
+    public string Shape { get; set; } = "sphere";
+    public List<MoonDefinition> Moons { get; set; } = [];
+    public float OrbitRadius { get; set; }
+    public float OrbitSpeed { get; set; }
+    public float OrbitEccentricity { get; set; }
+    public float OrbitInclination { get; set; }
+    public float OrbitLongitudeOfAscendingNode { get; set; }
+    public float OrbitArgumentOfPeriapsis { get; set; }
+    public float OrbitPhaseAtEpoch { get; set; }
+    public float Size { get; set; }
+    public required string Color { get; set; }
+    public float Tilt { get; set; }
+    public bool HasRing { get; set; }
+}
+
+public enum ShipPurpose
+{
+    [JsonStringEnumMemberName("auxiliary")]
+    Auxiliary,
+    [JsonStringEnumMemberName("mine")]
+    Mine,
+    [JsonStringEnumMemberName("build")]
+    Build,
+    [JsonStringEnumMemberName("fight")]
+    Fight,
+    [JsonStringEnumMemberName("trade")]
+    Trade,
+    [JsonStringEnumMemberName("salvage")]
+    Salvage,
+    [JsonStringEnumMemberName("dismantling")]
+    Dismantling,
+}
+
+public enum ShipType
+{
+    [JsonStringEnumMemberName("resupplier")]
+    Resupplier,
+    [JsonStringEnumMemberName("miner")]
+    Miner,
+    [JsonStringEnumMemberName("carrier")]
+    Carrier,
+    [JsonStringEnumMemberName("fighter")]
+    Fighter,
+    [JsonStringEnumMemberName("heavyfighter")]
+    HeavyFighter,
+    [JsonStringEnumMemberName("destroyer")]
+    Destroyer,
+    [JsonStringEnumMemberName("largeminer")]
+    LargeMiner,
+    [JsonStringEnumMemberName("freighter")]
+    Freighter,
+    [JsonStringEnumMemberName("bomber")]
+    Bomber,
+    [JsonStringEnumMemberName("scavenger")]
+    Scavenger,
+    [JsonStringEnumMemberName("frigate")]
+    Frigate,
+    [JsonStringEnumMemberName("transporter")]
+    Transporter,
+    [JsonStringEnumMemberName("interceptor")]
+    Interceptor,
+    [JsonStringEnumMemberName("scout")]
+    Scout,
+    [JsonStringEnumMemberName("courier")]
+    Courier,
+    [JsonStringEnumMemberName("builder")]
+    Builder,
+    [JsonStringEnumMemberName("corvette")]
+    Corvette,
+    [JsonStringEnumMemberName("police")]
+    Police,
+    [JsonStringEnumMemberName("battleship")]
+    Battleship,
+    [JsonStringEnumMemberName("gunboat")]
+    Gunboat,
+    [JsonStringEnumMemberName("tug")]
+    Tug,
+    [JsonStringEnumMemberName("compactor")]
+    Compactor,
 }
 
 public sealed class ShipDefinition
 {
-  public required string Id { get; set; }
-  public required string Label { get; set; }
-  public required string Kind { get; set; }
-  public required string Class { get; set; }
-  public float Speed { get; set; }
-  public float WarpSpeed { get; set; }
-  public float FtlSpeed { get; set; }
-  public float SpoolTime { get; set; }
-  public float CargoCapacity { get; set; }
-  public string? CargoKind { get; set; }
-  public required string Color { get; set; }
-  public required string HullColor { get; set; }
-  public float Size { get; set; }
-  public float MaxHealth { get; set; }
-  public List<string> Capabilities { get; set; } = [];
-  public ConstructionDefinition? Construction { get; set; }
+    public required string Id { get; set; }
+    public int Version { get; set; }
+    public required string Name { get; set; }
+    public string Description { get; set; } = string.Empty;
+    public string Size { get; set; } = string.Empty;
+    public float ExplosionDamage { get; set; }
+    public float Hull { get; set; }
+    public Dictionary<string, float> Storage { get; set; } = new(StringComparer.Ordinal);
+    public int People { get; set; }
+    public ShipPurpose Purpose { get; set; }
+    public string Thruster { get; set; } = string.Empty;
+    public ShipType Type { get; set; }
+    public float Mass { get; set; }
+    public ShipInertiaDefinition? Inertia { get; set; }
+    public ShipDragDefinition? Drag { get; set; }
+    public List<ShipMountDefinition> Engines { get; set; } = [];
+    public List<ShipMountDefinition> Shields { get; set; } = [];
+    public List<ShipMountDefinition> Weapons { get; set; } = [];
+    public List<ShipMountDefinition> Turrets { get; set; } = [];
+    public List<ShipCargoDefinition> Cargo { get; set; } = [];
+    public List<ModuleDockDefinition> Docks { get; set; } = [];
+    public List<string> Owners { get; set; } = [];
+    public ItemPriceDefinition? Price { get; set; }
+    public List<ItemProductionDefinition> Production { get; set; } = [];
+    [JsonIgnore]
+    public float Speed => InferLocalSpeed(Size);
+    [JsonIgnore]
+    public float WarpSpeed => InferWarpSpeed(Size);
+    [JsonIgnore]
+    public float FtlSpeed => InferFtlSpeed(Size);
+    [JsonIgnore]
+    public float SpoolTime => InferSpoolTime(Size);
+    public float GetTotalCargoCapacity() => Cargo.Sum(entry => entry.Max);
+
+    public float GetCargoCapacity(StorageKind kind) =>
+      Cargo
+        .Where(entry => entry.Types.Any(type => type.ToNullableStorageKind() == kind))
+        .Sum(entry => entry.Max);
+
+    public bool SupportsCargoKind(StorageKind kind) =>
+      GetCargoCapacity(kind) > 0f;
+
+    private static float InferWarpSpeed(string size) =>
+      size switch
+      {
+          "extrasmall" => 4.8f,
+          "small" => 4.2f,
+          "medium" => 3.4f,
+          "large" => 2.4f,
+          "extralarge" => 1.8f,
+          _ => 3f,
+      };
+
+    private static float InferLocalSpeed(string size) =>
+      size switch
+      {
+          "extrasmall" => 420f,
+          "small" => 320f,
+          "medium" => 230f,
+          "large" => 150f,
+          "extralarge" => 110f,
+          _ => 200f,
+      };
+
+    private static float InferFtlSpeed(string size) =>
+      size switch
+      {
+          "extrasmall" => 1f,
+          "small" => 0.85f,
+          "medium" => 0.7f,
+          "large" => 0.55f,
+          "extralarge" => 0.45f,
+          _ => 0.6f,
+      };
+
+    private static float InferSpoolTime(string size) =>
+      size switch
+      {
+          "extrasmall" => 0.8f,
+          "small" => 1f,
+          "medium" => 1.4f,
+          "large" => 2f,
+          "extralarge" => 2.6f,
+          _ => 1.5f,
+      };
+}
+
+public sealed class ShipInertiaDefinition
+{
+    public float Pitch { get; set; }
+    public float Yaw { get; set; }
+    public float Roll { get; set; }
+}
+
+public sealed class ShipDragDefinition
+{
+    public float Forward { get; set; }
+    public float Reverse { get; set; }
+    public float Horizontal { get; set; }
+    public float Vertical { get; set; }
+    public float Pitch { get; set; }
+    public float Yaw { get; set; }
+    public float Roll { get; set; }
+}
+
+public sealed class ShipMountDefinition
+{
+    public string? Group { get; set; }
+    public required string Size { get; set; }
+    public bool Hittable { get; set; }
+    public List<string> Types { get; set; } = [];
+}
+
+public sealed class ShipCargoDefinition
+{
+    public float Max { get; set; }
+    public List<string> Types { get; set; } = [];
 }
 
 public sealed class ScenarioDefinition
 {
-  public required List<InitialStationDefinition> InitialStations { get; set; }
-  public required List<ShipFormationDefinition> ShipFormations { get; set; }
-  public required List<PatrolRouteDefinition> PatrolRoutes { get; set; }
-  public required MiningDefaultsDefinition MiningDefaults { get; set; }
+    public required WorldGenerationOptions WorldGeneration { get; set; }
+    // Temporary QA escape hatch so a scenario can pin an exact topology.
+    // Do not treat this as the long-term world authoring model.
+    public List<SolarSystemDefinition>? Systems { get; set; }
+    public required List<InitialStationDefinition> InitialStations { get; set; }
+    public required List<ShipFormationDefinition> ShipFormations { get; set; }
+    public required List<PatrolRouteDefinition> PatrolRoutes { get; set; }
 }
 
 public sealed class InitialStationDefinition
 {
-  public required string SystemId { get; set; }
-  public string Label { get; set; } = "Orbital Station";
-  public string Color { get; set; } = "#8df0d2";
-  public string Objective { get; set; } = "general";
-  public List<string> StartingModules { get; set; } = [];
-  public string? FactionId { get; set; }
-  public int? PlanetIndex { get; set; }
-  public int? LagrangeSide { get; set; }
-  public float[]? Position { get; set; }
+    public required string SystemId { get; set; }
+    public string Label { get; set; } = "Orbital Station";
+    public string Color { get; set; } = "#8df0d2";
+    public string Objective { get; set; } = "general";
+    public List<string> StartingModules { get; set; } = [];
+    public string? FactionId { get; set; }
+    public int? PlanetIndex { get; set; }
+    public int? LagrangeSide { get; set; }
+    public float[]? Position { get; set; }
 }
 
 public sealed class ShipFormationDefinition
 {
-  public required string ShipId { get; set; }
-  public int Count { get; set; }
-  public required float[] Center { get; set; }
-  public required string SystemId { get; set; }
-  public string? FactionId { get; set; }
-  public Dictionary<string, float> StartingInventory { get; set; } = new(StringComparer.Ordinal);
+    public required string ShipId { get; set; }
+    public int Count { get; set; }
+    public required float[] Center { get; set; }
+    public required string SystemId { get; set; }
+    public string? FactionId { get; set; }
+    public Dictionary<string, float> StartingInventory { get; set; } = new(StringComparer.Ordinal);
 }
 
 public sealed class PatrolRouteDefinition
 {
-  public required string SystemId { get; set; }
-  public required List<float[]> Points { get; set; }
-}
-
-public sealed class MiningDefaultsDefinition
-{
-  public required string NodeSystemId { get; set; }
-  public required string RefinerySystemId { get; set; }
+    public required string SystemId { get; set; }
+    public required List<float[]> Points { get; set; }
 }

apps/backend/Economy/Runtime/CommerceRuntimeModels.cs

@@ -2,33 +2,33 @@ namespace SpaceGame.Api.Economy.Runtime;
 
 public sealed class MarketOrderRuntime
 {
-  public required string Id { get; init; }
-  public required string FactionId { get; init; }
-  public string? StationId { get; init; }
-  public string? ConstructionSiteId { get; init; }
-  public required string Kind { get; init; }
-  public required string ItemId { get; init; }
-  public float Amount { get; init; }
-  public float RemainingAmount { get; set; }
-  public float Valuation { get; set; }
-  public float? ReserveThreshold { get; set; }
-  public string? PolicySetId { get; set; }
-  public string State { get; set; } = MarketOrderStateKinds.Open;
-  public string LastDeltaSignature { get; set; } = string.Empty;
+    public required string Id { get; init; }
+    public required string FactionId { get; init; }
+    public string? StationId { get; init; }
+    public string? ConstructionSiteId { get; init; }
+    public required string Kind { get; init; }
+    public required string ItemId { get; init; }
+    public float Amount { get; init; }
+    public float RemainingAmount { get; set; }
+    public float Valuation { get; set; }
+    public float? ReserveThreshold { get; set; }
+    public string? PolicySetId { get; set; }
+    public string State { get; set; } = MarketOrderStateKinds.Open;
+    public string LastDeltaSignature { get; set; } = string.Empty;
 }
 
 public sealed class PolicySetRuntime
 {
-  public required string Id { get; init; }
-  public required string OwnerKind { get; init; }
-  public required string OwnerId { get; init; }
-  public string TradeAccessPolicy { get; set; } = "owner-and-allies";
-  public string DockingAccessPolicy { get; set; } = "owner-and-allies";
-  public string ConstructionAccessPolicy { get; set; } = "owner-only";
-  public string OperationalRangePolicy { get; set; } = "unrestricted";
-  public string CombatEngagementPolicy { get; set; } = "defensive";
-  public bool AvoidHostileSystems { get; set; } = true;
-  public float FleeHullRatio { get; set; } = 0.35f;
-  public HashSet<string> BlacklistedSystemIds { get; } = new(StringComparer.Ordinal);
-  public string LastDeltaSignature { get; set; } = string.Empty;
+    public required string Id { get; init; }
+    public required string OwnerKind { get; init; }
+    public required string OwnerId { get; init; }
+    public string TradeAccessPolicy { get; set; } = "owner-and-allies";
+    public string DockingAccessPolicy { get; set; } = "owner-and-allies";
+    public string ConstructionAccessPolicy { get; set; } = "owner-only";
+    public string OperationalRangePolicy { get; set; } = "unrestricted";
+    public string CombatEngagementPolicy { get; set; } = "defensive";
+    public bool AvoidHostileSystems { get; set; } = true;
+    public float FleeHullRatio { get; set; } = 0.35f;
+    public HashSet<string> BlacklistedSystemIds { get; } = new(StringComparer.Ordinal);
+    public string LastDeltaSignature { get; set; } = string.Empty;
 }

apps/backend/Factions/Runtime/FactionRuntimeModels.cs

@@ -2,347 +2,347 @@ namespace SpaceGame.Api.Factions.Runtime;
 
 public sealed class FactionRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; init; }
-  public required string Color { get; init; }
-  public float Credits { get; set; }
-  public float PopulationTotal { get; set; }
-  public float OreMined { get; set; }
-  public float GoodsProduced { get; set; }
-  public int ShipsBuilt { get; set; }
-  public int ShipsLost { get; set; }
-  public HashSet<string> CommanderIds { get; } = new(StringComparer.Ordinal);
-  public string? DefaultPolicySetId { get; set; }
-  public FactionDoctrineRuntime Doctrine { get; set; } = new();
-  public FactionMemoryRuntime Memory { get; set; } = new();
-  public FactionStrategicStateRuntime StrategicState { get; set; } = new();
-  public List<FactionDecisionLogEntryRuntime> DecisionLog { get; } = [];
-  public string LastDeltaSignature { get; set; } = string.Empty;
+    public required string Id { get; init; }
+    public required string Label { get; init; }
+    public required string Color { get; init; }
+    public float Credits { get; set; }
+    public float PopulationTotal { get; set; }
+    public float OreMined { get; set; }
+    public float GoodsProduced { get; set; }
+    public int ShipsBuilt { get; set; }
+    public int ShipsLost { get; set; }
+    public HashSet<string> CommanderIds { get; } = new(StringComparer.Ordinal);
+    public string? DefaultPolicySetId { get; set; }
+    public FactionDoctrineRuntime Doctrine { get; set; } = new();
+    public FactionMemoryRuntime Memory { get; set; } = new();
+    public FactionStrategicStateRuntime StrategicState { get; set; } = new();
+    public List<FactionDecisionLogEntryRuntime> DecisionLog { get; } = [];
+    public string LastDeltaSignature { get; set; } = string.Empty;
 }
 
 public sealed class CommanderRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public required string FactionId { get; init; }
-  public string? ParentCommanderId { get; set; }
-  public string? ControlledEntityId { get; set; }
-  public string? PolicySetId { get; set; }
-  public string? Doctrine { get; set; }
-  public float ReplanTimer { get; set; }
-  public bool NeedsReplan { get; set; } = true;
-  public CommanderAssignmentRuntime? Assignment { get; set; }
-  public CommanderSkillProfileRuntime Skills { get; set; } = new();
-  public HashSet<string> SubordinateCommanderIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> ActiveObjectiveIds { get; } = new(StringComparer.Ordinal);
-  public bool IsAlive { get; set; } = true;
-  public int PlanningCycle { get; set; }
-  public string LastDeltaSignature { get; set; } = string.Empty;
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public required string FactionId { get; init; }
+    public string? ParentCommanderId { get; set; }
+    public string? ControlledEntityId { get; set; }
+    public string? PolicySetId { get; set; }
+    public string? Doctrine { get; set; }
+    public float ReplanTimer { get; set; }
+    public bool NeedsReplan { get; set; } = true;
+    public CommanderAssignmentRuntime? Assignment { get; set; }
+    public CommanderSkillProfileRuntime Skills { get; set; } = new();
+    public HashSet<string> SubordinateCommanderIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> ActiveObjectiveIds { get; } = new(StringComparer.Ordinal);
+    public bool IsAlive { get; set; } = true;
+    public int PlanningCycle { get; set; }
+    public string LastDeltaSignature { get; set; } = string.Empty;
 }
 
 public sealed class CommanderAssignmentRuntime
 {
-  public required string ObjectiveId { get; set; }
-  public string? CampaignId { get; set; }
-  public string? TheaterId { get; set; }
-  public required string Kind { get; set; }
-  public required string BehaviorKind { get; set; }
-  public string Status { get; set; } = "active";
-  public float Priority { get; set; }
-  public string? HomeSystemId { get; set; }
-  public string? HomeStationId { get; set; }
-  public string? TargetSystemId { get; set; }
-  public string? TargetEntityId { get; set; }
-  public Vector3? TargetPosition { get; set; }
-  public string? ItemId { get; set; }
-  public string? Notes { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string ObjectiveId { get; set; }
+    public string? CampaignId { get; set; }
+    public string? TheaterId { get; set; }
+    public required string Kind { get; set; }
+    public required string BehaviorKind { get; set; }
+    public string Status { get; set; } = "active";
+    public float Priority { get; set; }
+    public string? HomeSystemId { get; set; }
+    public string? HomeStationId { get; set; }
+    public string? TargetSystemId { get; set; }
+    public string? TargetEntityId { get; set; }
+    public Vector3? TargetPosition { get; set; }
+    public string? ItemId { get; set; }
+    public string? Notes { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class CommanderSkillProfileRuntime
 {
-  public int Leadership { get; set; } = 3;
-  public int Coordination { get; set; } = 3;
-  public int Strategy { get; set; } = 3;
+    public int Leadership { get; set; } = 3;
+    public int Coordination { get; set; } = 3;
+    public int Strategy { get; set; } = 3;
 }
 
 public sealed class FactionDoctrineRuntime
 {
-  public string StrategicPosture { get; set; } = "balanced";
-  public string ExpansionPosture { get; set; } = "measured";
-  public string MilitaryPosture { get; set; } = "defensive";
-  public string EconomicPosture { get; set; } = "self-sufficient";
-  public int DesiredControlledSystems { get; set; } = 3;
-  public int DesiredMilitaryPerFront { get; set; } = 2;
-  public int DesiredMinersPerSystem { get; set; } = 1;
-  public int DesiredTransportsPerSystem { get; set; } = 1;
-  public int DesiredConstructors { get; set; } = 1;
-  public float ReserveCreditsRatio { get; set; } = 0.2f;
-  public float ExpansionBudgetRatio { get; set; } = 0.25f;
-  public float WarBudgetRatio { get; set; } = 0.35f;
-  public float ReserveMilitaryRatio { get; set; } = 0.2f;
-  public float OffensiveReadinessThreshold { get; set; } = 0.62f;
-  public float SupplySecurityBias { get; set; } = 0.55f;
-  public float FailureAversion { get; set; } = 0.45f;
-  public int ReinforcementLeadPerFront { get; set; } = 1;
+    public string StrategicPosture { get; set; } = "balanced";
+    public string ExpansionPosture { get; set; } = "measured";
+    public string MilitaryPosture { get; set; } = "defensive";
+    public string EconomicPosture { get; set; } = "self-sufficient";
+    public int DesiredControlledSystems { get; set; } = 3;
+    public int DesiredMilitaryPerFront { get; set; } = 2;
+    public int DesiredMinersPerSystem { get; set; } = 1;
+    public int DesiredTransportsPerSystem { get; set; } = 1;
+    public int DesiredConstructors { get; set; } = 1;
+    public float ReserveCreditsRatio { get; set; } = 0.2f;
+    public float ExpansionBudgetRatio { get; set; } = 0.25f;
+    public float WarBudgetRatio { get; set; } = 0.35f;
+    public float ReserveMilitaryRatio { get; set; } = 0.2f;
+    public float OffensiveReadinessThreshold { get; set; } = 0.62f;
+    public float SupplySecurityBias { get; set; } = 0.55f;
+    public float FailureAversion { get; set; } = 0.45f;
+    public int ReinforcementLeadPerFront { get; set; } = 1;
 }
 
 public sealed class FactionMemoryRuntime
 {
-  public int LastPlanCycle { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; }
-  public int LastObservedShipsBuilt { get; set; }
-  public int LastObservedShipsLost { get; set; }
-  public float LastObservedCredits { get; set; }
-  public HashSet<string> KnownSystemIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> KnownEnemyFactionIds { get; } = new(StringComparer.Ordinal);
-  public List<FactionSystemMemoryRuntime> SystemMemories { get; } = [];
-  public List<FactionCommodityMemoryRuntime> CommodityMemories { get; } = [];
-  public List<FactionOutcomeRecordRuntime> RecentOutcomes { get; } = [];
+    public int LastPlanCycle { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; }
+    public int LastObservedShipsBuilt { get; set; }
+    public int LastObservedShipsLost { get; set; }
+    public float LastObservedCredits { get; set; }
+    public HashSet<string> KnownSystemIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> KnownEnemyFactionIds { get; } = new(StringComparer.Ordinal);
+    public List<FactionSystemMemoryRuntime> SystemMemories { get; } = [];
+    public List<FactionCommodityMemoryRuntime> CommodityMemories { get; } = [];
+    public List<FactionOutcomeRecordRuntime> RecentOutcomes { get; } = [];
 }
 
 public sealed class FactionSystemMemoryRuntime
 {
-  public required string SystemId { get; init; }
-  public DateTimeOffset LastSeenAtUtc { get; set; }
-  public int LastEnemyShipCount { get; set; }
-  public int LastEnemyStationCount { get; set; }
-  public bool ControlledByFaction { get; set; }
-  public string? LastRole { get; set; }
-  public float FrontierPressure { get; set; }
-  public float RouteRisk { get; set; }
-  public float HistoricalShortagePressure { get; set; }
-  public int OffensiveFailures { get; set; }
-  public int DefensiveFailures { get; set; }
-  public int OffensiveSuccesses { get; set; }
-  public int DefensiveSuccesses { get; set; }
-  public DateTimeOffset? LastContestedAtUtc { get; set; }
-  public DateTimeOffset? LastShortageAtUtc { get; set; }
+    public required string SystemId { get; init; }
+    public DateTimeOffset LastSeenAtUtc { get; set; }
+    public int LastEnemyShipCount { get; set; }
+    public int LastEnemyStationCount { get; set; }
+    public bool ControlledByFaction { get; set; }
+    public string? LastRole { get; set; }
+    public float FrontierPressure { get; set; }
+    public float RouteRisk { get; set; }
+    public float HistoricalShortagePressure { get; set; }
+    public int OffensiveFailures { get; set; }
+    public int DefensiveFailures { get; set; }
+    public int OffensiveSuccesses { get; set; }
+    public int DefensiveSuccesses { get; set; }
+    public DateTimeOffset? LastContestedAtUtc { get; set; }
+    public DateTimeOffset? LastShortageAtUtc { get; set; }
 }
 
 public sealed class FactionCommodityMemoryRuntime
 {
-  public required string ItemId { get; init; }
-  public float HistoricalShortageScore { get; set; }
-  public float HistoricalSurplusScore { get; set; }
-  public float LastObservedBacklog { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; }
-  public DateTimeOffset? LastCriticalAtUtc { get; set; }
+    public required string ItemId { get; init; }
+    public float HistoricalShortageScore { get; set; }
+    public float HistoricalSurplusScore { get; set; }
+    public float LastObservedBacklog { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; }
+    public DateTimeOffset? LastCriticalAtUtc { get; set; }
 }
 
 public sealed class FactionOutcomeRecordRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public required string Summary { get; set; }
-  public string? RelatedCampaignId { get; set; }
-  public string? RelatedObjectiveId { get; set; }
-  public DateTimeOffset OccurredAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public required string Summary { get; set; }
+    public string? RelatedCampaignId { get; set; }
+    public string? RelatedObjectiveId { get; set; }
+    public DateTimeOffset OccurredAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class FactionStrategicStateRuntime
 {
-  public int PlanCycle { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; }
-  public string Status { get; set; } = "stable";
-  public FactionBudgetRuntime Budget { get; set; } = new();
-  public FactionEconomicAssessmentRuntime EconomicAssessment { get; set; } = new();
-  public FactionThreatAssessmentRuntime ThreatAssessment { get; set; } = new();
-  public List<FactionTheaterRuntime> Theaters { get; } = [];
-  public List<FactionCampaignRuntime> Campaigns { get; } = [];
-  public List<FactionOperationalObjectiveRuntime> Objectives { get; } = [];
-  public List<FactionAssetReservationRuntime> Reservations { get; } = [];
-  public List<FactionProductionProgramRuntime> ProductionPrograms { get; } = [];
+    public int PlanCycle { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; }
+    public string Status { get; set; } = "stable";
+    public FactionBudgetRuntime Budget { get; set; } = new();
+    public FactionEconomicAssessmentRuntime EconomicAssessment { get; set; } = new();
+    public FactionThreatAssessmentRuntime ThreatAssessment { get; set; } = new();
+    public List<FactionTheaterRuntime> Theaters { get; } = [];
+    public List<FactionCampaignRuntime> Campaigns { get; } = [];
+    public List<FactionOperationalObjectiveRuntime> Objectives { get; } = [];
+    public List<FactionAssetReservationRuntime> Reservations { get; } = [];
+    public List<FactionProductionProgramRuntime> ProductionPrograms { get; } = [];
 }
 
 public sealed class FactionBudgetRuntime
 {
-  public float ReservedCredits { get; set; }
-  public float ExpansionCredits { get; set; }
-  public float WarCredits { get; set; }
-  public int ReservedMilitaryAssets { get; set; }
-  public int ReservedLogisticsAssets { get; set; }
-  public int ReservedConstructionAssets { get; set; }
+    public float ReservedCredits { get; set; }
+    public float ExpansionCredits { get; set; }
+    public float WarCredits { get; set; }
+    public int ReservedMilitaryAssets { get; set; }
+    public int ReservedLogisticsAssets { get; set; }
+    public int ReservedConstructionAssets { get; set; }
 }
 
 public sealed class FactionEconomicAssessmentRuntime
 {
-  public int PlanCycle { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; }
-  public int MilitaryShipCount { get; set; }
-  public int MinerShipCount { get; set; }
-  public int TransportShipCount { get; set; }
-  public int ConstructorShipCount { get; set; }
-  public int ControlledSystemCount { get; set; }
-  public int TargetMilitaryShipCount { get; set; }
-  public int TargetMinerShipCount { get; set; }
-  public int TargetTransportShipCount { get; set; }
-  public int TargetConstructorShipCount { get; set; }
-  public bool HasShipyard { get; set; }
-  public bool HasWarIndustrySupplyChain { get; set; }
-  public string? PrimaryExpansionSiteId { get; set; }
-  public string? PrimaryExpansionSystemId { get; set; }
-  public float ReplacementPressure { get; set; }
-  public float SustainmentScore { get; set; }
-  public float LogisticsSecurityScore { get; set; }
-  public int CriticalShortageCount { get; set; }
-  public string? IndustrialBottleneckItemId { get; set; }
-  public List<FactionCommoditySignalRuntime> CommoditySignals { get; } = [];
+    public int PlanCycle { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; }
+    public int MilitaryShipCount { get; set; }
+    public int MinerShipCount { get; set; }
+    public int TransportShipCount { get; set; }
+    public int ConstructorShipCount { get; set; }
+    public int ControlledSystemCount { get; set; }
+    public int TargetMilitaryShipCount { get; set; }
+    public int TargetMinerShipCount { get; set; }
+    public int TargetTransportShipCount { get; set; }
+    public int TargetConstructorShipCount { get; set; }
+    public bool HasShipyard { get; set; }
+    public bool HasWarIndustrySupplyChain { get; set; }
+    public string? PrimaryExpansionSiteId { get; set; }
+    public string? PrimaryExpansionSystemId { get; set; }
+    public float ReplacementPressure { get; set; }
+    public float SustainmentScore { get; set; }
+    public float LogisticsSecurityScore { get; set; }
+    public int CriticalShortageCount { get; set; }
+    public string? IndustrialBottleneckItemId { get; set; }
+    public List<FactionCommoditySignalRuntime> CommoditySignals { get; } = [];
 }
 
 public sealed class FactionThreatAssessmentRuntime
 {
-  public int PlanCycle { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; }
-  public int EnemyFactionCount { get; set; }
-  public int EnemyShipCount { get; set; }
-  public int EnemyStationCount { get; set; }
-  public string? PrimaryThreatFactionId { get; set; }
-  public string? PrimaryThreatSystemId { get; set; }
-  public List<FactionThreatSignalRuntime> ThreatSignals { get; } = [];
+    public int PlanCycle { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; }
+    public int EnemyFactionCount { get; set; }
+    public int EnemyShipCount { get; set; }
+    public int EnemyStationCount { get; set; }
+    public string? PrimaryThreatFactionId { get; set; }
+    public string? PrimaryThreatSystemId { get; set; }
+    public List<FactionThreatSignalRuntime> ThreatSignals { get; } = [];
 }
 
 public sealed class FactionTheaterRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public required string SystemId { get; set; }
-  public string Status { get; set; } = "active";
-  public float Priority { get; set; }
-  public float SupplyRisk { get; set; }
-  public float FriendlyAssetValue { get; set; }
-  public string? TargetFactionId { get; set; }
-  public string? AnchorEntityId { get; set; }
-  public Vector3? AnchorPosition { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> CampaignIds { get; } = [];
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public required string SystemId { get; set; }
+    public string Status { get; set; } = "active";
+    public float Priority { get; set; }
+    public float SupplyRisk { get; set; }
+    public float FriendlyAssetValue { get; set; }
+    public string? TargetFactionId { get; set; }
+    public string? AnchorEntityId { get; set; }
+    public Vector3? AnchorPosition { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> CampaignIds { get; } = [];
 }
 
 public sealed class FactionCampaignRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public string Status { get; set; } = "planned";
-  public float Priority { get; set; }
-  public string? TheaterId { get; set; }
-  public string? TargetFactionId { get; set; }
-  public string? TargetSystemId { get; set; }
-  public string? TargetEntityId { get; set; }
-  public string? CommodityId { get; set; }
-  public string? SupportStationId { get; set; }
-  public int CurrentStepIndex { get; set; }
-  public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public string? Summary { get; set; }
-  public string? PauseReason { get; set; }
-  public float ContinuationScore { get; set; }
-  public float SupplyAdequacy { get; set; }
-  public float ReplacementPressure { get; set; }
-  public int FailureCount { get; set; }
-  public int SuccessCount { get; set; }
-  public string? FleetCommanderId { get; set; }
-  public bool RequiresReinforcement { get; set; }
-  public List<FactionPlanStepRuntime> Steps { get; } = [];
-  public List<string> ObjectiveIds { get; } = [];
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public string Status { get; set; } = "planned";
+    public float Priority { get; set; }
+    public string? TheaterId { get; set; }
+    public string? TargetFactionId { get; set; }
+    public string? TargetSystemId { get; set; }
+    public string? TargetEntityId { get; set; }
+    public string? CommodityId { get; set; }
+    public string? SupportStationId { get; set; }
+    public int CurrentStepIndex { get; set; }
+    public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public string? Summary { get; set; }
+    public string? PauseReason { get; set; }
+    public float ContinuationScore { get; set; }
+    public float SupplyAdequacy { get; set; }
+    public float ReplacementPressure { get; set; }
+    public int FailureCount { get; set; }
+    public int SuccessCount { get; set; }
+    public string? FleetCommanderId { get; set; }
+    public bool RequiresReinforcement { get; set; }
+    public List<FactionPlanStepRuntime> Steps { get; } = [];
+    public List<string> ObjectiveIds { get; } = [];
 }
 
 public sealed class FactionOperationalObjectiveRuntime
 {
-  public required string Id { get; init; }
-  public required string CampaignId { get; set; }
-  public string? TheaterId { get; set; }
-  public required string Kind { get; set; }
-  public required string DelegationKind { get; set; }
-  public required string BehaviorKind { get; set; }
-  public string Status { get; set; } = "planned";
-  public float Priority { get; set; }
-  public string? CommanderId { get; set; }
-  public string? HomeSystemId { get; set; }
-  public string? HomeStationId { get; set; }
-  public string? TargetSystemId { get; set; }
-  public string? TargetEntityId { get; set; }
-  public Vector3? TargetPosition { get; set; }
-  public string? ItemId { get; set; }
-  public string? Notes { get; set; }
-  public int CurrentStepIndex { get; set; }
-  public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public bool UseOrders { get; set; }
-  public string? StagingOrderKind { get; set; }
-  public int ReinforcementLevel { get; set; }
-  public List<FactionPlanStepRuntime> Steps { get; } = [];
-  public List<string> ReservedAssetIds { get; } = [];
+    public required string Id { get; init; }
+    public required string CampaignId { get; set; }
+    public string? TheaterId { get; set; }
+    public required string Kind { get; set; }
+    public required string DelegationKind { get; set; }
+    public required string BehaviorKind { get; set; }
+    public string Status { get; set; } = "planned";
+    public float Priority { get; set; }
+    public string? CommanderId { get; set; }
+    public string? HomeSystemId { get; set; }
+    public string? HomeStationId { get; set; }
+    public string? TargetSystemId { get; set; }
+    public string? TargetEntityId { get; set; }
+    public Vector3? TargetPosition { get; set; }
+    public string? ItemId { get; set; }
+    public string? Notes { get; set; }
+    public int CurrentStepIndex { get; set; }
+    public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public bool UseOrders { get; set; }
+    public string? StagingOrderKind { get; set; }
+    public int ReinforcementLevel { get; set; }
+    public List<FactionPlanStepRuntime> Steps { get; } = [];
+    public List<string> ReservedAssetIds { get; } = [];
 }
 
 public sealed class FactionPlanStepRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public string Status { get; set; } = "planned";
-  public string? Summary { get; set; }
-  public string? BlockingReason { get; set; }
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public string Status { get; set; } = "planned";
+    public string? Summary { get; set; }
+    public string? BlockingReason { get; set; }
 }
 
 public sealed class FactionAssetReservationRuntime
 {
-  public required string Id { get; init; }
-  public required string ObjectiveId { get; set; }
-  public string? CampaignId { get; set; }
-  public required string AssetKind { get; set; }
-  public required string AssetId { get; set; }
-  public float Priority { get; set; }
-  public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string ObjectiveId { get; set; }
+    public string? CampaignId { get; set; }
+    public required string AssetKind { get; set; }
+    public required string AssetId { get; set; }
+    public float Priority { get; set; }
+    public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class FactionProductionProgramRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public string Status { get; set; } = "planned";
-  public float Priority { get; set; }
-  public string? CampaignId { get; set; }
-  public string? CommodityId { get; set; }
-  public string? ModuleId { get; set; }
-  public string? ShipKind { get; set; }
-  public string? TargetSystemId { get; set; }
-  public int TargetCount { get; set; }
-  public int CurrentCount { get; set; }
-  public string? Notes { get; set; }
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public string Status { get; set; } = "planned";
+    public float Priority { get; set; }
+    public string? CampaignId { get; set; }
+    public string? CommodityId { get; set; }
+    public string? ModuleId { get; set; }
+    public string? ShipKind { get; set; }
+    public string? TargetSystemId { get; set; }
+    public int TargetCount { get; set; }
+    public int CurrentCount { get; set; }
+    public string? Notes { get; set; }
 }
 
 public sealed class FactionDecisionLogEntryRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public required string Summary { get; set; }
-  public string? RelatedEntityId { get; set; }
-  public int PlanCycle { get; set; }
-  public DateTimeOffset OccurredAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public required string Summary { get; set; }
+    public string? RelatedEntityId { get; set; }
+    public int PlanCycle { get; set; }
+    public DateTimeOffset OccurredAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class FactionCommoditySignalRuntime
 {
-  public required string ItemId { get; init; }
-  public float AvailableStock { get; set; }
-  public float OnHand { get; set; }
-  public float ProductionRatePerSecond { get; set; }
-  public float CommittedProductionRatePerSecond { get; set; }
-  public float UsageRatePerSecond { get; set; }
-  public float NetRatePerSecond { get; set; }
-  public float ProjectedNetRatePerSecond { get; set; }
-  public float LevelSeconds { get; set; }
-  public string Level { get; set; } = "unknown";
-  public float ProjectedProductionRatePerSecond { get; set; }
-  public float BuyBacklog { get; set; }
-  public float ReservedForConstruction { get; set; }
+    public required string ItemId { get; init; }
+    public float AvailableStock { get; set; }
+    public float OnHand { get; set; }
+    public float ProductionRatePerSecond { get; set; }
+    public float CommittedProductionRatePerSecond { get; set; }
+    public float UsageRatePerSecond { get; set; }
+    public float NetRatePerSecond { get; set; }
+    public float ProjectedNetRatePerSecond { get; set; }
+    public float LevelSeconds { get; set; }
+    public string Level { get; set; } = "unknown";
+    public float ProjectedProductionRatePerSecond { get; set; }
+    public float BuyBacklog { get; set; }
+    public float ReservedForConstruction { get; set; }
 }
 
 public sealed class FactionThreatSignalRuntime
 {
-  public required string ScopeId { get; init; }
-  public required string ScopeKind { get; init; }
-  public int EnemyShipCount { get; set; }
-  public int EnemyStationCount { get; set; }
-  public string? EnemyFactionId { get; set; }
+    public required string ScopeId { get; init; }
+    public required string ScopeKind { get; init; }
+    public int EnemyShipCount { get; set; }
+    public int EnemyStationCount { get; set; }
+    public string? EnemyFactionId { get; set; }
 }

apps/backend/Geopolitics/Contracts/Geopolitics.cs

@@ -88,7 +88,7 @@ public sealed record TerritoryClaimSnapshot(
   string? SourceClaimId,
   string FactionId,
   string SystemId,
-  string CelestialId,
+  string AnchorId,
   string Status,
   string ClaimKind,
   float ClaimStrength,

apps/backend/Geopolitics/Runtime/GeopoliticalRuntimeModels.cs

@@ -2,335 +2,335 @@ namespace SpaceGame.Api.Geopolitics.Runtime;
 
 public sealed class GeopoliticalStateRuntime
 {
-  public int Cycle { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<SystemRouteLinkRuntime> Routes { get; } = [];
-  public DiplomaticStateRuntime Diplomacy { get; set; } = new();
-  public TerritoryStateRuntime Territory { get; set; } = new();
-  public EconomyRegionStateRuntime EconomyRegions { get; set; } = new();
-  public string LastDeltaSignature { get; set; } = string.Empty;
+    public int Cycle { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<SystemRouteLinkRuntime> Routes { get; } = [];
+    public DiplomaticStateRuntime Diplomacy { get; set; } = new();
+    public TerritoryStateRuntime Territory { get; set; } = new();
+    public EconomyRegionStateRuntime EconomyRegions { get; set; } = new();
+    public string LastDeltaSignature { get; set; } = string.Empty;
 }
 
 public sealed class SystemRouteLinkRuntime
 {
-  public required string Id { get; init; }
-  public required string SourceSystemId { get; set; }
-  public required string DestinationSystemId { get; set; }
-  public float Distance { get; set; }
-  public bool IsPrimaryLane { get; set; } = true;
+    public required string Id { get; init; }
+    public required string SourceSystemId { get; set; }
+    public required string DestinationSystemId { get; set; }
+    public float Distance { get; set; }
+    public bool IsPrimaryLane { get; set; } = true;
 }
 
 public sealed class DiplomaticStateRuntime
 {
-  public List<DiplomaticRelationRuntime> Relations { get; } = [];
-  public List<TreatyRuntime> Treaties { get; } = [];
-  public List<DiplomaticIncidentRuntime> Incidents { get; } = [];
-  public List<BorderTensionRuntime> BorderTensions { get; } = [];
-  public List<WarStateRuntime> Wars { get; } = [];
+    public List<DiplomaticRelationRuntime> Relations { get; } = [];
+    public List<TreatyRuntime> Treaties { get; } = [];
+    public List<DiplomaticIncidentRuntime> Incidents { get; } = [];
+    public List<BorderTensionRuntime> BorderTensions { get; } = [];
+    public List<WarStateRuntime> Wars { get; } = [];
 }
 
 public sealed class DiplomaticRelationRuntime
 {
-  public required string Id { get; init; }
-  public required string FactionAId { get; set; }
-  public required string FactionBId { get; set; }
-  public string Status { get; set; } = "active";
-  public string Posture { get; set; } = "neutral";
-  public float TrustScore { get; set; }
-  public float TensionScore { get; set; }
-  public float GrievanceScore { get; set; }
-  public string TradeAccessPolicy { get; set; } = "restricted";
-  public string MilitaryAccessPolicy { get; set; } = "restricted";
-  public string? WarStateId { get; set; }
-  public DateTimeOffset? CeasefireUntilUtc { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> ActiveTreatyIds { get; } = [];
-  public List<string> ActiveIncidentIds { get; } = [];
+    public required string Id { get; init; }
+    public required string FactionAId { get; set; }
+    public required string FactionBId { get; set; }
+    public string Status { get; set; } = "active";
+    public string Posture { get; set; } = "neutral";
+    public float TrustScore { get; set; }
+    public float TensionScore { get; set; }
+    public float GrievanceScore { get; set; }
+    public string TradeAccessPolicy { get; set; } = "restricted";
+    public string MilitaryAccessPolicy { get; set; } = "restricted";
+    public string? WarStateId { get; set; }
+    public DateTimeOffset? CeasefireUntilUtc { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> ActiveTreatyIds { get; } = [];
+    public List<string> ActiveIncidentIds { get; } = [];
 }
 
 public sealed class TreatyRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public string Status { get; set; } = "active";
-  public string TradeAccessPolicy { get; set; } = "restricted";
-  public string MilitaryAccessPolicy { get; set; } = "restricted";
-  public string? Summary { get; set; }
-  public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> FactionIds { get; } = [];
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public string Status { get; set; } = "active";
+    public string TradeAccessPolicy { get; set; } = "restricted";
+    public string MilitaryAccessPolicy { get; set; } = "restricted";
+    public string? Summary { get; set; }
+    public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> FactionIds { get; } = [];
 }
 
 public sealed class DiplomaticIncidentRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public string Status { get; set; } = "active";
-  public required string SourceFactionId { get; set; }
-  public required string TargetFactionId { get; set; }
-  public string? SystemId { get; set; }
-  public string? BorderEdgeId { get; set; }
-  public required string Summary { get; set; }
-  public float Severity { get; set; }
-  public float EscalationScore { get; set; }
-  public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public DateTimeOffset LastObservedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public string Status { get; set; } = "active";
+    public required string SourceFactionId { get; set; }
+    public required string TargetFactionId { get; set; }
+    public string? SystemId { get; set; }
+    public string? BorderEdgeId { get; set; }
+    public required string Summary { get; set; }
+    public float Severity { get; set; }
+    public float EscalationScore { get; set; }
+    public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public DateTimeOffset LastObservedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class BorderTensionRuntime
 {
-  public required string Id { get; init; }
-  public required string RelationId { get; set; }
-  public required string BorderEdgeId { get; set; }
-  public required string FactionAId { get; set; }
-  public required string FactionBId { get; set; }
-  public string Status { get; set; } = "active";
-  public float TensionScore { get; set; }
-  public float IncidentScore { get; set; }
-  public float MilitaryPressure { get; set; }
-  public float AccessFriction { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> SystemIds { get; } = [];
+    public required string Id { get; init; }
+    public required string RelationId { get; set; }
+    public required string BorderEdgeId { get; set; }
+    public required string FactionAId { get; set; }
+    public required string FactionBId { get; set; }
+    public string Status { get; set; } = "active";
+    public float TensionScore { get; set; }
+    public float IncidentScore { get; set; }
+    public float MilitaryPressure { get; set; }
+    public float AccessFriction { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> SystemIds { get; } = [];
 }
 
 public sealed class WarStateRuntime
 {
-  public required string Id { get; init; }
-  public required string RelationId { get; set; }
-  public required string FactionAId { get; set; }
-  public required string FactionBId { get; set; }
-  public string Status { get; set; } = "active";
-  public string WarGoal { get; set; } = "territorial-pressure";
-  public float EscalationScore { get; set; }
-  public DateTimeOffset StartedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public DateTimeOffset? CeasefireUntilUtc { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> ActiveFrontLineIds { get; } = [];
+    public required string Id { get; init; }
+    public required string RelationId { get; set; }
+    public required string FactionAId { get; set; }
+    public required string FactionBId { get; set; }
+    public string Status { get; set; } = "active";
+    public string WarGoal { get; set; } = "territorial-pressure";
+    public float EscalationScore { get; set; }
+    public DateTimeOffset StartedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public DateTimeOffset? CeasefireUntilUtc { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> ActiveFrontLineIds { get; } = [];
 }
 
 public sealed class TerritoryStateRuntime
 {
-  public List<TerritoryClaimRuntime> Claims { get; } = [];
-  public List<TerritoryInfluenceRuntime> Influences { get; } = [];
-  public List<TerritoryControlStateRuntime> ControlStates { get; } = [];
-  public List<SectorStrategicProfileRuntime> StrategicProfiles { get; } = [];
-  public List<BorderEdgeRuntime> BorderEdges { get; } = [];
-  public List<FrontLineRuntime> FrontLines { get; } = [];
-  public List<TerritoryZoneRuntime> Zones { get; } = [];
-  public List<TerritoryPressureRuntime> Pressures { get; } = [];
+    public List<TerritoryClaimRuntime> Claims { get; } = [];
+    public List<TerritoryInfluenceRuntime> Influences { get; } = [];
+    public List<TerritoryControlStateRuntime> ControlStates { get; } = [];
+    public List<SectorStrategicProfileRuntime> StrategicProfiles { get; } = [];
+    public List<BorderEdgeRuntime> BorderEdges { get; } = [];
+    public List<FrontLineRuntime> FrontLines { get; } = [];
+    public List<TerritoryZoneRuntime> Zones { get; } = [];
+    public List<TerritoryPressureRuntime> Pressures { get; } = [];
 }
 
 public sealed class TerritoryClaimRuntime
 {
-  public required string Id { get; init; }
-  public string? SourceClaimId { get; set; }
-  public required string FactionId { get; set; }
-  public required string SystemId { get; set; }
-  public required string CelestialId { get; set; }
-  public string Status { get; set; } = "active";
-  public string ClaimKind { get; set; } = "infrastructure";
-  public float ClaimStrength { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public string? SourceClaimId { get; set; }
+    public required string FactionId { get; set; }
+    public required string SystemId { get; set; }
+    public required string AnchorId { get; set; }
+    public string Status { get; set; } = "active";
+    public string ClaimKind { get; set; } = "infrastructure";
+    public float ClaimStrength { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class TerritoryInfluenceRuntime
 {
-  public required string Id { get; init; }
-  public required string SystemId { get; set; }
-  public required string FactionId { get; set; }
-  public float ClaimStrength { get; set; }
-  public float AssetStrength { get; set; }
-  public float LogisticsStrength { get; set; }
-  public float TotalInfluence { get; set; }
-  public bool IsContesting { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string SystemId { get; set; }
+    public required string FactionId { get; set; }
+    public float ClaimStrength { get; set; }
+    public float AssetStrength { get; set; }
+    public float LogisticsStrength { get; set; }
+    public float TotalInfluence { get; set; }
+    public bool IsContesting { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class TerritoryControlStateRuntime
 {
-  public required string SystemId { get; init; }
-  public string? ControllerFactionId { get; set; }
-  public string? PrimaryClaimantFactionId { get; set; }
-  public string ControlKind { get; set; } = "unclaimed";
-  public bool IsContested { get; set; }
-  public float ControlScore { get; set; }
-  public float StrategicValue { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> ClaimantFactionIds { get; } = [];
-  public List<string> InfluencingFactionIds { get; } = [];
+    public required string SystemId { get; init; }
+    public string? ControllerFactionId { get; set; }
+    public string? PrimaryClaimantFactionId { get; set; }
+    public string ControlKind { get; set; } = "unclaimed";
+    public bool IsContested { get; set; }
+    public float ControlScore { get; set; }
+    public float StrategicValue { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> ClaimantFactionIds { get; } = [];
+    public List<string> InfluencingFactionIds { get; } = [];
 }
 
 public sealed class SectorStrategicProfileRuntime
 {
-  public required string SystemId { get; init; }
-  public string? ControllerFactionId { get; set; }
-  public string ZoneKind { get; set; } = "unclaimed";
-  public bool IsContested { get; set; }
-  public float StrategicValue { get; set; }
-  public float SecurityRating { get; set; }
-  public float TerritorialPressure { get; set; }
-  public float LogisticsValue { get; set; }
-  public string? EconomicRegionId { get; set; }
-  public string? FrontLineId { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string SystemId { get; init; }
+    public string? ControllerFactionId { get; set; }
+    public string ZoneKind { get; set; } = "unclaimed";
+    public bool IsContested { get; set; }
+    public float StrategicValue { get; set; }
+    public float SecurityRating { get; set; }
+    public float TerritorialPressure { get; set; }
+    public float LogisticsValue { get; set; }
+    public string? EconomicRegionId { get; set; }
+    public string? FrontLineId { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class BorderEdgeRuntime
 {
-  public required string Id { get; init; }
-  public required string SourceSystemId { get; set; }
-  public required string DestinationSystemId { get; set; }
-  public string? SourceFactionId { get; set; }
-  public string? DestinationFactionId { get; set; }
-  public bool IsContested { get; set; }
-  public string? RelationId { get; set; }
-  public float TensionScore { get; set; }
-  public float CorridorImportance { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string SourceSystemId { get; set; }
+    public required string DestinationSystemId { get; set; }
+    public string? SourceFactionId { get; set; }
+    public string? DestinationFactionId { get; set; }
+    public bool IsContested { get; set; }
+    public string? RelationId { get; set; }
+    public float TensionScore { get; set; }
+    public float CorridorImportance { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class FrontLineRuntime
 {
-  public required string Id { get; init; }
-  public string Kind { get; set; } = "border-front";
-  public string Status { get; set; } = "active";
-  public string? AnchorSystemId { get; set; }
-  public float PressureScore { get; set; }
-  public float SupplyRisk { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> FactionIds { get; } = [];
-  public List<string> SystemIds { get; } = [];
-  public List<string> BorderEdgeIds { get; } = [];
+    public required string Id { get; init; }
+    public string Kind { get; set; } = "border-front";
+    public string Status { get; set; } = "active";
+    public string? AnchorSystemId { get; set; }
+    public float PressureScore { get; set; }
+    public float SupplyRisk { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> FactionIds { get; } = [];
+    public List<string> SystemIds { get; } = [];
+    public List<string> BorderEdgeIds { get; } = [];
 }
 
 public sealed class TerritoryZoneRuntime
 {
-  public required string Id { get; init; }
-  public required string SystemId { get; set; }
-  public string? FactionId { get; set; }
-  public string Kind { get; set; } = "unclaimed";
-  public string Status { get; set; } = "active";
-  public string? Reason { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string SystemId { get; set; }
+    public string? FactionId { get; set; }
+    public string Kind { get; set; } = "unclaimed";
+    public string Status { get; set; } = "active";
+    public string? Reason { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class TerritoryPressureRuntime
 {
-  public required string Id { get; init; }
-  public required string SystemId { get; set; }
-  public string? FactionId { get; set; }
-  public string Kind { get; set; } = "border-pressure";
-  public float PressureScore { get; set; }
-  public float SecurityScore { get; set; }
-  public float HostileInfluence { get; set; }
-  public float CorridorRisk { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string SystemId { get; set; }
+    public string? FactionId { get; set; }
+    public string Kind { get; set; } = "border-pressure";
+    public float PressureScore { get; set; }
+    public float SecurityScore { get; set; }
+    public float HostileInfluence { get; set; }
+    public float CorridorRisk { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class EconomyRegionStateRuntime
 {
-  public List<EconomicRegionRuntime> Regions { get; } = [];
-  public List<SupplyNetworkRuntime> SupplyNetworks { get; } = [];
-  public List<LogisticsCorridorRuntime> Corridors { get; } = [];
-  public List<RegionalProductionProfileRuntime> ProductionProfiles { get; } = [];
-  public List<RegionalTradeBalanceRuntime> TradeBalances { get; } = [];
-  public List<RegionalBottleneckRuntime> Bottlenecks { get; } = [];
-  public List<RegionalSecurityAssessmentRuntime> SecurityAssessments { get; } = [];
-  public List<RegionalEconomicAssessmentRuntime> EconomicAssessments { get; } = [];
+    public List<EconomicRegionRuntime> Regions { get; } = [];
+    public List<SupplyNetworkRuntime> SupplyNetworks { get; } = [];
+    public List<LogisticsCorridorRuntime> Corridors { get; } = [];
+    public List<RegionalProductionProfileRuntime> ProductionProfiles { get; } = [];
+    public List<RegionalTradeBalanceRuntime> TradeBalances { get; } = [];
+    public List<RegionalBottleneckRuntime> Bottlenecks { get; } = [];
+    public List<RegionalSecurityAssessmentRuntime> SecurityAssessments { get; } = [];
+    public List<RegionalEconomicAssessmentRuntime> EconomicAssessments { get; } = [];
 }
 
 public sealed class EconomicRegionRuntime
 {
-  public required string Id { get; init; }
-  public string? FactionId { get; set; }
-  public required string Label { get; set; }
-  public string Kind { get; set; } = "balanced-region";
-  public string Status { get; set; } = "active";
-  public required string CoreSystemId { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> SystemIds { get; } = [];
-  public List<string> StationIds { get; } = [];
-  public List<string> FrontLineIds { get; } = [];
-  public List<string> CorridorIds { get; } = [];
+    public required string Id { get; init; }
+    public string? FactionId { get; set; }
+    public required string Label { get; set; }
+    public string Kind { get; set; } = "balanced-region";
+    public string Status { get; set; } = "active";
+    public required string CoreSystemId { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> SystemIds { get; } = [];
+    public List<string> StationIds { get; } = [];
+    public List<string> FrontLineIds { get; } = [];
+    public List<string> CorridorIds { get; } = [];
 }
 
 public sealed class SupplyNetworkRuntime
 {
-  public required string Id { get; init; }
-  public required string RegionId { get; set; }
-  public float ThroughputScore { get; set; }
-  public float RiskScore { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> StationIds { get; } = [];
-  public List<string> ProducerItemIds { get; } = [];
-  public List<string> ConsumerItemIds { get; } = [];
-  public List<string> ConstructionItemIds { get; } = [];
+    public required string Id { get; init; }
+    public required string RegionId { get; set; }
+    public float ThroughputScore { get; set; }
+    public float RiskScore { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> StationIds { get; } = [];
+    public List<string> ProducerItemIds { get; } = [];
+    public List<string> ConsumerItemIds { get; } = [];
+    public List<string> ConstructionItemIds { get; } = [];
 }
 
 public sealed class LogisticsCorridorRuntime
 {
-  public required string Id { get; init; }
-  public string? FactionId { get; set; }
-  public string Kind { get; set; } = "supply-corridor";
-  public string Status { get; set; } = "active";
-  public float RiskScore { get; set; }
-  public float ThroughputScore { get; set; }
-  public string AccessState { get; set; } = "restricted";
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> SystemPathIds { get; } = [];
-  public List<string> RegionIds { get; } = [];
-  public List<string> BorderEdgeIds { get; } = [];
+    public required string Id { get; init; }
+    public string? FactionId { get; set; }
+    public string Kind { get; set; } = "supply-corridor";
+    public string Status { get; set; } = "active";
+    public float RiskScore { get; set; }
+    public float ThroughputScore { get; set; }
+    public string AccessState { get; set; } = "restricted";
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> SystemPathIds { get; } = [];
+    public List<string> RegionIds { get; } = [];
+    public List<string> BorderEdgeIds { get; } = [];
 }
 
 public sealed class RegionalProductionProfileRuntime
 {
-  public required string RegionId { get; set; }
-  public string PrimaryIndustry { get; set; } = "mixed";
-  public int ShipyardCount { get; set; }
-  public int StationCount { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public List<string> ProducedItemIds { get; } = [];
-  public List<string> ScarceItemIds { get; } = [];
+    public required string RegionId { get; set; }
+    public string PrimaryIndustry { get; set; } = "mixed";
+    public int ShipyardCount { get; set; }
+    public int StationCount { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public List<string> ProducedItemIds { get; } = [];
+    public List<string> ScarceItemIds { get; } = [];
 }
 
 public sealed class RegionalTradeBalanceRuntime
 {
-  public required string RegionId { get; set; }
-  public int ImportsRequiredCount { get; set; }
-  public int ExportsSurplusCount { get; set; }
-  public int CriticalShortageCount { get; set; }
-  public float NetTradeScore { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string RegionId { get; set; }
+    public int ImportsRequiredCount { get; set; }
+    public int ExportsSurplusCount { get; set; }
+    public int CriticalShortageCount { get; set; }
+    public float NetTradeScore { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class RegionalBottleneckRuntime
 {
-  public required string Id { get; init; }
-  public required string RegionId { get; set; }
-  public required string ItemId { get; set; }
-  public string Cause { get; set; } = "regional-shortage";
-  public string Status { get; set; } = "active";
-  public float Severity { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string RegionId { get; set; }
+    public required string ItemId { get; set; }
+    public string Cause { get; set; } = "regional-shortage";
+    public string Status { get; set; } = "active";
+    public float Severity { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class RegionalSecurityAssessmentRuntime
 {
-  public required string RegionId { get; set; }
-  public float SupplyRisk { get; set; }
-  public float BorderPressure { get; set; }
-  public int ActiveWarCount { get; set; }
-  public int HostileRelationCount { get; set; }
-  public float AccessFriction { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string RegionId { get; set; }
+    public float SupplyRisk { get; set; }
+    public float BorderPressure { get; set; }
+    public int ActiveWarCount { get; set; }
+    public int HostileRelationCount { get; set; }
+    public float AccessFriction { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class RegionalEconomicAssessmentRuntime
 {
-  public required string RegionId { get; set; }
-  public float SustainmentScore { get; set; }
-  public float ProductionDepth { get; set; }
-  public float ConstructionPressure { get; set; }
-  public float CorridorDependency { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string RegionId { get; set; }
+    public float SustainmentScore { get; set; }
+    public float ProductionDepth { get; set; }
+    public float ConstructionPressure { get; set; }
+    public float CorridorDependency { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }

apps/backend/GlobalUsings.cs

@@ -1,3 +1,6 @@
+global using SpaceGame.Api.Auth.Contracts;
+global using SpaceGame.Api.Auth.Runtime;
+global using SpaceGame.Api.Auth.Simulation;
 global using SpaceGame.Api.Definitions;
 global using SpaceGame.Api.Economy.Contracts;
 global using SpaceGame.Api.Economy.Runtime;
@@ -15,7 +18,7 @@ global using SpaceGame.Api.Shared.Contracts;
 global using SpaceGame.Api.Shared.Runtime;
 global using SpaceGame.Api.Ships.Contracts;
 global using SpaceGame.Api.Ships.Runtime;
-global using SpaceGame.Api.Ships.Simulation;
+global using SpaceGame.Api.Ships.AI;
 global using SpaceGame.Api.Simulation.Core;
 global using SpaceGame.Api.Stations.Contracts;
 global using SpaceGame.Api.Stations.Runtime;

apps/backend/Industry/Planning/CommodityOperationalSignal.cs

@@ -2,53 +2,53 @@ namespace SpaceGame.Api.Industry.Planning;
 
 internal static class CommodityOperationalSignal
 {
-  internal static float ComputeNeedScore(FactionCommoditySnapshot commodity, float targetLevelSeconds)
-  {
-    var productionDeficit = MathF.Max(0f, commodity.ConsumptionRatePerSecond - commodity.ProjectedProductionRatePerSecond);
-    var levelDeficit = MathF.Max(0f, targetLevelSeconds - commodity.LevelSeconds) / MathF.Max(targetLevelSeconds, 1f);
-    var backlogPressure = MathF.Max(0f, commodity.BuyBacklog + commodity.ReservedForConstruction - commodity.AvailableStock);
-
-    var levelWeight = commodity.Level switch
+    internal static float ComputeNeedScore(FactionCommoditySnapshot commodity, float targetLevelSeconds)
     {
-      CommodityLevelKind.Critical => 140f,
-      CommodityLevelKind.Low => 80f,
-      CommodityLevelKind.Stable => 20f,
-      _ => 0f,
-    };
+        var productionDeficit = MathF.Max(0f, commodity.ConsumptionRatePerSecond - commodity.ProjectedProductionRatePerSecond);
+        var levelDeficit = MathF.Max(0f, targetLevelSeconds - commodity.LevelSeconds) / MathF.Max(targetLevelSeconds, 1f);
+        var backlogPressure = MathF.Max(0f, commodity.BuyBacklog + commodity.ReservedForConstruction - commodity.AvailableStock);
 
-    return levelWeight
-      + (productionDeficit * 140f)
-      + (levelDeficit * 120f)
-      + backlogPressure;
-  }
+        var levelWeight = commodity.Level switch
+        {
+            CommodityLevelKind.Critical => 140f,
+            CommodityLevelKind.Low => 80f,
+            CommodityLevelKind.Stable => 20f,
+            _ => 0f,
+        };
 
-  internal static bool IsOperational(FactionCommoditySnapshot commodity, float targetLevelSeconds) =>
-    commodity.ProjectedProductionRatePerSecond > 0.01f
-    && commodity.ProjectedNetRatePerSecond >= -0.01f
-    && commodity.LevelSeconds >= targetLevelSeconds
-    && commodity.Level is CommodityLevelKind.Stable or CommodityLevelKind.Surplus;
-
-  internal static bool IsStrained(FactionCommoditySnapshot commodity, float targetLevelSeconds) =>
-    !IsOperational(commodity, targetLevelSeconds)
-    || commodity.Level is CommodityLevelKind.Critical or CommodityLevelKind.Low;
-
-  internal static float ComputeFeasibilityFactor(FactionCommoditySnapshot commodity, float targetLevelSeconds)
-  {
-    if (commodity.AvailableStock <= 0.01f && commodity.ProjectedProductionRatePerSecond <= 0.01f)
-    {
-      return 0.65f;
+        return levelWeight
+          + (productionDeficit * 140f)
+          + (levelDeficit * 120f)
+          + backlogPressure;
     }
 
-    if (commodity.Level is CommodityLevelKind.Critical)
-    {
-      return 0.72f;
-    }
+    internal static bool IsOperational(FactionCommoditySnapshot commodity, float targetLevelSeconds) =>
+      commodity.ProjectedProductionRatePerSecond > 0.01f
+      && commodity.ProjectedNetRatePerSecond >= -0.01f
+      && commodity.LevelSeconds >= targetLevelSeconds
+      && commodity.Level is CommodityLevelKind.Stable or CommodityLevelKind.Surplus;
 
-    if (commodity.Level is CommodityLevelKind.Low || commodity.LevelSeconds < targetLevelSeconds)
-    {
-      return 0.84f;
-    }
+    internal static bool IsStrained(FactionCommoditySnapshot commodity, float targetLevelSeconds) =>
+      !IsOperational(commodity, targetLevelSeconds)
+      || commodity.Level is CommodityLevelKind.Critical or CommodityLevelKind.Low;
 
-    return 1f;
-  }
+    internal static float ComputeFeasibilityFactor(FactionCommoditySnapshot commodity, float targetLevelSeconds)
+    {
+        if (commodity.AvailableStock <= 0.01f && commodity.ProjectedProductionRatePerSecond <= 0.01f)
+        {
+            return 0.65f;
+        }
+
+        if (commodity.Level is CommodityLevelKind.Critical)
+        {
+            return 0.72f;
+        }
+
+        if (commodity.Level is CommodityLevelKind.Low || commodity.LevelSeconds < targetLevelSeconds)
+        {
+            return 0.84f;
+        }
+
+        return 1f;
+    }
 }

apps/backend/Industry/Planning/FactionEconomySnapshot.cs

@@ -4,202 +4,202 @@ using static SpaceGame.Api.Shared.Runtime.SimulationRuntimeSupport;
 
 internal sealed class FactionEconomySnapshot
 {
-  private readonly Dictionary<string, FactionCommoditySnapshot> commodities = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, FactionCommoditySnapshot> commodities = new(StringComparer.Ordinal);
 
-  internal IReadOnlyDictionary<string, FactionCommoditySnapshot> Commodities => commodities;
+    internal IReadOnlyDictionary<string, FactionCommoditySnapshot> Commodities => commodities;
 
-  internal FactionCommoditySnapshot GetCommodity(string itemId)
-  {
-    if (!commodities.TryGetValue(itemId, out var commodity))
+    internal FactionCommoditySnapshot GetCommodity(string itemId)
     {
-      commodity = new FactionCommoditySnapshot(itemId);
-      commodities[itemId] = commodity;
-    }
+        if (!commodities.TryGetValue(itemId, out var commodity))
+        {
+            commodity = new FactionCommoditySnapshot(itemId);
+            commodities[itemId] = commodity;
+        }
 
-    return commodity;
-  }
+        return commodity;
+    }
 }
 
 internal sealed class FactionCommoditySnapshot
 {
-  internal FactionCommoditySnapshot(string itemId)
-  {
-    ItemId = itemId;
-  }
+    internal FactionCommoditySnapshot(string itemId)
+    {
+        ItemId = itemId;
+    }
 
-  internal string ItemId { get; }
-  internal float OnHand { get; set; }
-  internal float ReservedForConstruction { get; set; }
-  internal float BuyBacklog { get; set; }
-  internal float SellBacklog { get; set; }
-  internal float Inbound { get; set; }
-  internal float ProductionRatePerSecond { get; set; }
-  internal float CommittedProductionRatePerSecond { get; set; }
-  internal float ConsumptionRatePerSecond { get; set; }
+    internal string ItemId { get; }
+    internal float OnHand { get; set; }
+    internal float ReservedForConstruction { get; set; }
+    internal float BuyBacklog { get; set; }
+    internal float SellBacklog { get; set; }
+    internal float Inbound { get; set; }
+    internal float ProductionRatePerSecond { get; set; }
+    internal float CommittedProductionRatePerSecond { get; set; }
+    internal float ConsumptionRatePerSecond { get; set; }
 
-  internal float AvailableStock => MathF.Max(0f, OnHand + Inbound - ReservedForConstruction);
-  internal float NetRatePerSecond => ProductionRatePerSecond - ConsumptionRatePerSecond;
-  internal float ProjectedProductionRatePerSecond => ProductionRatePerSecond + CommittedProductionRatePerSecond;
-  internal float ProjectedNetRatePerSecond => ProjectedProductionRatePerSecond - ConsumptionRatePerSecond;
-  internal float OperationalUsageRatePerSecond => MathF.Max(ConsumptionRatePerSecond, BuyBacklog / 180f);
-  internal float LevelSeconds => AvailableStock <= 0.01f
-      ? 0f
-      : AvailableStock / MathF.Max(OperationalUsageRatePerSecond, 0.01f);
+    internal float AvailableStock => MathF.Max(0f, OnHand + Inbound - ReservedForConstruction);
+    internal float NetRatePerSecond => ProductionRatePerSecond - ConsumptionRatePerSecond;
+    internal float ProjectedProductionRatePerSecond => ProductionRatePerSecond + CommittedProductionRatePerSecond;
+    internal float ProjectedNetRatePerSecond => ProjectedProductionRatePerSecond - ConsumptionRatePerSecond;
+    internal float OperationalUsageRatePerSecond => MathF.Max(ConsumptionRatePerSecond, BuyBacklog / 180f);
+    internal float LevelSeconds => AvailableStock <= 0.01f
+        ? 0f
+        : AvailableStock / MathF.Max(OperationalUsageRatePerSecond, 0.01f);
 
-  internal CommodityLevelKind Level =>
-      LevelSeconds switch
-      {
-        <= 60f => CommodityLevelKind.Critical,
-        <= 180f => CommodityLevelKind.Low,
-        <= 480f => CommodityLevelKind.Stable,
-        _ => CommodityLevelKind.Surplus,
-      };
+    internal CommodityLevelKind Level =>
+        LevelSeconds switch
+        {
+            <= 60f => CommodityLevelKind.Critical,
+            <= 180f => CommodityLevelKind.Low,
+            <= 480f => CommodityLevelKind.Stable,
+            _ => CommodityLevelKind.Surplus,
+        };
 }
 
 internal enum CommodityLevelKind
 {
-  Critical,
-  Low,
-  Stable,
-  Surplus,
+    Critical,
+    Low,
+    Stable,
+    Surplus,
 }
 
 internal static class FactionEconomyAnalyzer
 {
-  internal static FactionEconomySnapshot Build(SimulationWorld world, string factionId)
-  {
-    var snapshot = new FactionEconomySnapshot();
-
-    foreach (var station in world.Stations.Where(station => string.Equals(station.FactionId, factionId, StringComparison.Ordinal)))
+    internal static FactionEconomySnapshot Build(SimulationWorld world, string factionId)
     {
-      foreach (var (itemId, amount) in station.Inventory)
-      {
-        snapshot.GetCommodity(itemId).OnHand += amount;
-      }
+        var snapshot = new FactionEconomySnapshot();
 
-      foreach (var laneKey in StationSimulationService.GetStationProductionLanes(world, station))
-      {
-        var recipe = StationSimulationService.SelectProductionRecipe(world, station, laneKey);
-        if (recipe is null)
+        foreach (var station in world.Stations.Where(station => string.Equals(station.FactionId, factionId, StringComparison.Ordinal)))
         {
-          continue;
+            foreach (var (itemId, amount) in station.Inventory)
+            {
+                snapshot.GetCommodity(itemId).OnHand += amount;
+            }
+
+            foreach (var laneKey in StationSimulationService.GetStationProductionLanes(world, station))
+            {
+                var recipe = StationSimulationService.SelectProductionRecipe(world, station, laneKey);
+                if (recipe is null)
+                {
+                    continue;
+                }
+
+                var throughput = StationSimulationService.GetStationProductionThroughput(world, station, recipe);
+                var cyclesPerSecond = (station.WorkforceEffectiveRatio * throughput) / MathF.Max(recipe.Duration, 0.01f);
+                if (cyclesPerSecond <= 0.0001f)
+                {
+                    continue;
+                }
+
+                foreach (var input in recipe.Inputs)
+                {
+                    snapshot.GetCommodity(input.ItemId).ConsumptionRatePerSecond += input.Amount * cyclesPerSecond;
+                }
+
+                foreach (var output in recipe.Outputs)
+                {
+                    snapshot.GetCommodity(output.ItemId).ProductionRatePerSecond += output.Amount * cyclesPerSecond;
+                }
+            }
         }
 
-        var throughput = StationSimulationService.GetStationProductionThroughput(world, station, recipe);
-        var cyclesPerSecond = (station.WorkforceEffectiveRatio * throughput) / MathF.Max(recipe.Duration, 0.01f);
-        if (cyclesPerSecond <= 0.0001f)
+        foreach (var order in world.MarketOrders.Where(order =>
+            string.Equals(order.FactionId, factionId, StringComparison.Ordinal)
+            && order.State != MarketOrderStateKinds.Cancelled
+            && order.RemainingAmount > 0.01f))
         {
-          continue;
+            var commodity = snapshot.GetCommodity(order.ItemId);
+            if (string.Equals(order.Kind, MarketOrderKinds.Buy, StringComparison.Ordinal))
+            {
+                commodity.BuyBacklog += order.RemainingAmount;
+            }
+            else if (string.Equals(order.Kind, MarketOrderKinds.Sell, StringComparison.Ordinal))
+            {
+                commodity.SellBacklog += order.RemainingAmount;
+            }
         }
 
-        foreach (var input in recipe.Inputs)
+        foreach (var site in world.ConstructionSites.Where(site =>
+            string.Equals(site.FactionId, factionId, StringComparison.Ordinal)
+            && site.State is not ConstructionSiteStateKinds.Completed and not ConstructionSiteStateKinds.Destroyed))
         {
-          snapshot.GetCommodity(input.ItemId).ConsumptionRatePerSecond += input.Amount * cyclesPerSecond;
+            ApplyCommittedProduction(world, snapshot, site);
+
+            foreach (var required in site.RequiredItems)
+            {
+                var remaining = MathF.Max(0f, required.Value - GetConstructionDeliveredAmount(world, site, required.Key));
+                if (remaining > 0.01f)
+                {
+                    snapshot.GetCommodity(required.Key).ReservedForConstruction += remaining;
+                }
+            }
         }
 
-        foreach (var output in recipe.Outputs)
+        return snapshot;
+    }
+
+    private static void ApplyCommittedProduction(
+        SimulationWorld world,
+        FactionEconomySnapshot snapshot,
+        ConstructionSiteRuntime site)
+    {
+        if (string.IsNullOrWhiteSpace(site.BlueprintId)
+            || !world.ModuleRecipes.TryGetValue(site.BlueprintId, out var recipe))
         {
-          snapshot.GetCommodity(output.ItemId).ProductionRatePerSecond += output.Amount * cyclesPerSecond;
+            return;
         }
-      }
-    }
 
-    foreach (var order in world.MarketOrders.Where(order =>
-        string.Equals(order.FactionId, factionId, StringComparison.Ordinal)
-        && order.State != MarketOrderStateKinds.Cancelled
-        && order.RemainingAmount > 0.01f))
-    {
-      var commodity = snapshot.GetCommodity(order.ItemId);
-      if (string.Equals(order.Kind, MarketOrderKinds.Buy, StringComparison.Ordinal))
-      {
-        commodity.BuyBacklog += order.RemainingAmount;
-      }
-      else if (string.Equals(order.Kind, MarketOrderKinds.Sell, StringComparison.Ordinal))
-      {
-        commodity.SellBacklog += order.RemainingAmount;
-      }
-    }
-
-    foreach (var site in world.ConstructionSites.Where(site =>
-        string.Equals(site.FactionId, factionId, StringComparison.Ordinal)
-        && site.State is not ConstructionSiteStateKinds.Completed and not ConstructionSiteStateKinds.Destroyed))
-    {
-      ApplyCommittedProduction(world, snapshot, site);
-
-      foreach (var required in site.RequiredItems)
-      {
-        var remaining = MathF.Max(0f, required.Value - GetConstructionDeliveredAmount(world, site, required.Key));
-        if (remaining > 0.01f)
+        var recipeOutputs = world.Recipes.Values
+          .Where(candidate => string.Equals(StationSimulationService.GetStationProductionLaneKey(world, candidate), site.BlueprintId, StringComparison.Ordinal))
+          .SelectMany(candidate => candidate.Outputs)
+          .GroupBy(output => output.ItemId, StringComparer.Ordinal)
+          .ToDictionary(group => group.Key, group => group.Sum(output => output.Amount), StringComparer.Ordinal);
+        if (recipeOutputs.Count == 0)
         {
-          snapshot.GetCommodity(required.Key).ReservedForConstruction += remaining;
+            return;
+        }
+
+        var materialFraction = 0f;
+        var materialTerms = 0;
+        foreach (var required in site.RequiredItems)
+        {
+            materialTerms += 1;
+            materialFraction += required.Value <= 0.01f
+              ? 1f
+              : Math.Clamp(GetConstructionDeliveredAmount(world, site, required.Key) / required.Value, 0f, 1f);
+        }
+
+        materialFraction = materialTerms == 0 ? 1f : materialFraction / materialTerms;
+
+        var buildFraction = recipe.Duration <= 0.01f
+          ? 0f
+          : Math.Clamp(site.Progress / recipe.Duration, 0f, 1f);
+        var readiness = site.State switch
+        {
+            ConstructionSiteStateKinds.Active => 0.3f,
+            ConstructionSiteStateKinds.Planned => 0.15f,
+            _ => 0f,
+        };
+
+        readiness += materialFraction * 0.45f;
+        readiness += buildFraction * 0.25f;
+
+        if (site.AssignedConstructorShipIds.Count > 0)
+        {
+            readiness += 0.1f;
+        }
+
+        readiness = Math.Clamp(readiness, 0f, 1f);
+        if (readiness <= 0.01f)
+        {
+            return;
+        }
+
+        var cyclesPerSecond = readiness / MathF.Max(recipe.Duration, 0.01f);
+        foreach (var (productItemId, amount) in recipeOutputs)
+        {
+            snapshot.GetCommodity(productItemId).CommittedProductionRatePerSecond += amount * cyclesPerSecond;
         }
-      }
     }
-
-    return snapshot;
-  }
-
-  private static void ApplyCommittedProduction(
-      SimulationWorld world,
-      FactionEconomySnapshot snapshot,
-      ConstructionSiteRuntime site)
-  {
-    if (string.IsNullOrWhiteSpace(site.BlueprintId)
-        || !world.ModuleRecipes.TryGetValue(site.BlueprintId, out var recipe))
-    {
-      return;
-    }
-
-    var recipeOutputs = world.Recipes.Values
-      .Where(candidate => string.Equals(StationSimulationService.GetStationProductionLaneKey(world, candidate), site.BlueprintId, StringComparison.Ordinal))
-      .SelectMany(candidate => candidate.Outputs)
-      .GroupBy(output => output.ItemId, StringComparer.Ordinal)
-      .ToDictionary(group => group.Key, group => group.Sum(output => output.Amount), StringComparer.Ordinal);
-    if (recipeOutputs.Count == 0)
-    {
-      return;
-    }
-
-    var materialFraction = 0f;
-    var materialTerms = 0;
-    foreach (var required in site.RequiredItems)
-    {
-      materialTerms += 1;
-      materialFraction += required.Value <= 0.01f
-        ? 1f
-        : Math.Clamp(GetConstructionDeliveredAmount(world, site, required.Key) / required.Value, 0f, 1f);
-    }
-
-    materialFraction = materialTerms == 0 ? 1f : materialFraction / materialTerms;
-
-    var buildFraction = recipe.Duration <= 0.01f
-      ? 0f
-      : Math.Clamp(site.Progress / recipe.Duration, 0f, 1f);
-    var readiness = site.State switch
-    {
-      ConstructionSiteStateKinds.Active => 0.3f,
-      ConstructionSiteStateKinds.Planned => 0.15f,
-      _ => 0f,
-    };
-
-    readiness += materialFraction * 0.45f;
-    readiness += buildFraction * 0.25f;
-
-    if (site.AssignedConstructorShipIds.Count > 0)
-    {
-      readiness += 0.1f;
-    }
-
-    readiness = Math.Clamp(readiness, 0f, 1f);
-    if (readiness <= 0.01f)
-    {
-      return;
-    }
-
-    var cyclesPerSecond = readiness / MathF.Max(recipe.Duration, 0.01f);
-    foreach (var (productItemId, amount) in recipeOutputs)
-    {
-      snapshot.GetCommodity(productItemId).CommittedProductionRatePerSecond += amount * cyclesPerSecond;
-    }
-  }
 }

apps/backend/Industry/Planning/ProductionGraph.cs

@@ -2,52 +2,52 @@ namespace SpaceGame.Api.Industry.Planning;
 
 public sealed class ProductionGraph
 {
-  public required IReadOnlyDictionary<string, ProductionCommodityNode> Commodities { get; init; }
-  public required IReadOnlyDictionary<string, ProductionProcessNode> Processes { get; init; }
-  public required IReadOnlyDictionary<string, IReadOnlyList<ProductionProcessNode>> ProcessesByOutputId { get; init; }
-  public required IReadOnlyDictionary<string, IReadOnlyList<ProductionProcessNode>> ProcessesByInputId { get; init; }
-  public required IReadOnlyDictionary<string, IReadOnlyList<string>> OutputsByModuleId { get; init; }
+    public required IReadOnlyDictionary<string, ProductionCommodityNode> Commodities { get; init; }
+    public required IReadOnlyDictionary<string, ProductionProcessNode> Processes { get; init; }
+    public required IReadOnlyDictionary<string, IReadOnlyList<ProductionProcessNode>> ProcessesByOutputId { get; init; }
+    public required IReadOnlyDictionary<string, IReadOnlyList<ProductionProcessNode>> ProcessesByInputId { get; init; }
+    public required IReadOnlyDictionary<string, IReadOnlyList<string>> OutputsByModuleId { get; init; }
 
-  public IReadOnlyList<ProductionProcessNode> GetProcessesForOutput(string itemId) =>
-      ProcessesByOutputId.TryGetValue(itemId, out var processes) ? processes : [];
+    public IReadOnlyList<ProductionProcessNode> GetProcessesForOutput(string itemId) =>
+        ProcessesByOutputId.TryGetValue(itemId, out var processes) ? processes : [];
 
-  public IReadOnlyList<ProductionProcessNode> GetProcessesForInput(string itemId) =>
-      ProcessesByInputId.TryGetValue(itemId, out var processes) ? processes : [];
+    public IReadOnlyList<ProductionProcessNode> GetProcessesForInput(string itemId) =>
+        ProcessesByInputId.TryGetValue(itemId, out var processes) ? processes : [];
 
-  public string? GetPrimaryProducerModule(string itemId) =>
-      GetProcessesForOutput(itemId)
-        .SelectMany(process => process.RequiredModuleIds)
-        .FirstOrDefault();
+    public string? GetPrimaryProducerModule(string itemId) =>
+        GetProcessesForOutput(itemId)
+          .SelectMany(process => process.RequiredModuleIds)
+          .FirstOrDefault();
 
-  public string? GetPrimaryOutputForModule(string moduleId) =>
-      OutputsByModuleId.TryGetValue(moduleId, out var outputs)
-        ? outputs.FirstOrDefault()
-        : null;
+    public string? GetPrimaryOutputForModule(string moduleId) =>
+        OutputsByModuleId.TryGetValue(moduleId, out var outputs)
+          ? outputs.FirstOrDefault()
+          : null;
 
-  public IReadOnlyList<string> GetImmediateInputs(string itemId) =>
-      GetProcessesForOutput(itemId)
-        .SelectMany(process => process.Inputs.Keys)
-        .Distinct(StringComparer.Ordinal)
-        .ToList();
+    public IReadOnlyList<string> GetImmediateInputs(string itemId) =>
+        GetProcessesForOutput(itemId)
+          .SelectMany(process => process.Inputs.Keys)
+          .Distinct(StringComparer.Ordinal)
+          .ToList();
 }
 
 public sealed class ProductionCommodityNode
 {
-  public required string ItemId { get; init; }
-  public required string Name { get; init; }
-  public required string Group { get; init; }
-  public required string CargoKind { get; init; }
-  public List<string> ProducerProcessIds { get; } = [];
-  public List<string> ConsumerProcessIds { get; } = [];
+    public required string ItemId { get; init; }
+    public required string Name { get; init; }
+    public required string Group { get; init; }
+    public required string CargoKind { get; init; }
+    public List<string> ProducerProcessIds { get; } = [];
+    public List<string> ConsumerProcessIds { get; } = [];
 }
 
 public sealed class ProductionProcessNode
 {
-  public required string Id { get; init; }
-  public required string Label { get; init; }
-  public required string FacilityCategory { get; init; }
-  public required IReadOnlyList<string> RequiredModuleIds { get; init; }
-  public required IReadOnlyDictionary<string, float> Inputs { get; init; }
-  public required IReadOnlyDictionary<string, float> Outputs { get; init; }
-  public required bool ProducesShip { get; init; }
+    public required string Id { get; init; }
+    public required string Label { get; init; }
+    public required string FacilityCategory { get; init; }
+    public required IReadOnlyList<string> RequiredModuleIds { get; init; }
+    public required IReadOnlyDictionary<string, float> Inputs { get; init; }
+    public required IReadOnlyDictionary<string, float> Outputs { get; init; }
+    public required bool ProducesShip { get; init; }
 }

apps/backend/Industry/Planning/ProductionGraphBuilder.cs

@@ -2,104 +2,104 @@ namespace SpaceGame.Api.Industry.Planning;
 
 internal static class ProductionGraphBuilder
 {
-  internal static ProductionGraph Build(
-    IReadOnlyCollection<ItemDefinition> items,
-    IReadOnlyCollection<RecipeDefinition> recipes,
-    IReadOnlyCollection<ModuleDefinition> modules)
-  {
-    var commodities = items.ToDictionary(
-      item => item.Id,
-      item => new ProductionCommodityNode
-      {
-        ItemId = item.Id,
-        Name = item.Name,
-        Group = item.Group,
-        CargoKind = item.CargoKind,
-      },
-      StringComparer.Ordinal);
-
-    var processes = new Dictionary<string, ProductionProcessNode>(StringComparer.Ordinal);
-    var processesByOutputId = new Dictionary<string, List<ProductionProcessNode>>(StringComparer.Ordinal);
-    var processesByInputId = new Dictionary<string, List<ProductionProcessNode>>(StringComparer.Ordinal);
-    var outputsByModuleId = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
-
-    foreach (var recipe in recipes)
+    internal static ProductionGraph Build(
+      IReadOnlyCollection<ItemDefinition> items,
+      IReadOnlyCollection<RecipeDefinition> recipes,
+      IReadOnlyCollection<ModuleDefinition> modules)
     {
-      var outputs = recipe.Outputs
-        .GroupBy(output => output.ItemId, StringComparer.Ordinal)
-        .ToDictionary(group => group.Key, group => group.Sum(output => output.Amount), StringComparer.Ordinal);
-      var inputs = recipe.Inputs
-        .GroupBy(input => input.ItemId, StringComparer.Ordinal)
-        .ToDictionary(group => group.Key, group => group.Sum(input => input.Amount), StringComparer.Ordinal);
-      var process = new ProductionProcessNode
-      {
-        Id = recipe.Id,
-        Label = recipe.Label,
-        FacilityCategory = recipe.FacilityCategory,
-        RequiredModuleIds = recipe.RequiredModules.ToList(),
-        Inputs = inputs,
-        Outputs = outputs,
-        ProducesShip = recipe.ShipOutputId is not null,
-      };
+        var commodities = items.ToDictionary(
+          item => item.Id,
+          item => new ProductionCommodityNode
+          {
+              ItemId = item.Id,
+              Name = item.Name,
+              Group = item.Group,
+              CargoKind = item.CargoKind?.ToDataValue() ?? string.Empty,
+          },
+          StringComparer.Ordinal);
 
-      processes[process.Id] = process;
+        var processes = new Dictionary<string, ProductionProcessNode>(StringComparer.Ordinal);
+        var processesByOutputId = new Dictionary<string, List<ProductionProcessNode>>(StringComparer.Ordinal);
+        var processesByInputId = new Dictionary<string, List<ProductionProcessNode>>(StringComparer.Ordinal);
+        var outputsByModuleId = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
 
-      foreach (var output in outputs.Keys)
-      {
-        if (!commodities.ContainsKey(output))
+        foreach (var recipe in recipes)
         {
-          continue;
+            var outputs = recipe.Outputs
+              .GroupBy(output => output.ItemId, StringComparer.Ordinal)
+              .ToDictionary(group => group.Key, group => group.Sum(output => output.Amount), StringComparer.Ordinal);
+            var inputs = recipe.Inputs
+              .GroupBy(input => input.ItemId, StringComparer.Ordinal)
+              .ToDictionary(group => group.Key, group => group.Sum(input => input.Amount), StringComparer.Ordinal);
+            var process = new ProductionProcessNode
+            {
+                Id = recipe.Id,
+                Label = recipe.Label,
+                FacilityCategory = recipe.FacilityCategory,
+                RequiredModuleIds = recipe.RequiredModules.ToList(),
+                Inputs = inputs,
+                Outputs = outputs,
+                ProducesShip = recipe.ShipOutputId is not null,
+            };
+
+            processes[process.Id] = process;
+
+            foreach (var output in outputs.Keys)
+            {
+                if (!commodities.ContainsKey(output))
+                {
+                    continue;
+                }
+
+                commodities[output].ProducerProcessIds.Add(process.Id);
+                if (!processesByOutputId.TryGetValue(output, out var outputProcesses))
+                {
+                    outputProcesses = [];
+                    processesByOutputId[output] = outputProcesses;
+                }
+
+                outputProcesses.Add(process);
+            }
+
+            foreach (var input in inputs.Keys)
+            {
+                if (!commodities.ContainsKey(input))
+                {
+                    continue;
+                }
+
+                commodities[input].ConsumerProcessIds.Add(process.Id);
+                if (!processesByInputId.TryGetValue(input, out var inputProcesses))
+                {
+                    inputProcesses = [];
+                    processesByInputId[input] = inputProcesses;
+                }
+
+                inputProcesses.Add(process);
+            }
         }
 
-        commodities[output].ProducerProcessIds.Add(process.Id);
-        if (!processesByOutputId.TryGetValue(output, out var outputProcesses))
+        foreach (var module in modules)
         {
-          outputProcesses = [];
-          processesByOutputId[output] = outputProcesses;
+            if (!outputsByModuleId.TryGetValue(module.Id, out var outputs))
+            {
+                outputs = new HashSet<string>(StringComparer.Ordinal);
+                outputsByModuleId[module.Id] = outputs;
+            }
+
+            foreach (var product in module.ProductItemIds)
+            {
+                outputs.Add(product);
+            }
         }
 
-        outputProcesses.Add(process);
-      }
-
-      foreach (var input in inputs.Keys)
-      {
-        if (!commodities.ContainsKey(input))
+        return new ProductionGraph
         {
-          continue;
-        }
-
-        commodities[input].ConsumerProcessIds.Add(process.Id);
-        if (!processesByInputId.TryGetValue(input, out var inputProcesses))
-        {
-          inputProcesses = [];
-          processesByInputId[input] = inputProcesses;
-        }
-
-        inputProcesses.Add(process);
-      }
+            Commodities = commodities,
+            Processes = processes,
+            ProcessesByOutputId = processesByOutputId.ToDictionary(entry => entry.Key, entry => (IReadOnlyList<ProductionProcessNode>)entry.Value, StringComparer.Ordinal),
+            ProcessesByInputId = processesByInputId.ToDictionary(entry => entry.Key, entry => (IReadOnlyList<ProductionProcessNode>)entry.Value, StringComparer.Ordinal),
+            OutputsByModuleId = outputsByModuleId.ToDictionary(entry => entry.Key, entry => (IReadOnlyList<string>)entry.Value.OrderBy(value => value, StringComparer.Ordinal).ToList(), StringComparer.Ordinal),
+        };
     }
-
-    foreach (var module in modules)
-    {
-      if (!outputsByModuleId.TryGetValue(module.Id, out var outputs))
-      {
-        outputs = new HashSet<string>(StringComparer.Ordinal);
-        outputsByModuleId[module.Id] = outputs;
-      }
-
-      foreach (var product in module.Products)
-      {
-        outputs.Add(product);
-      }
-    }
-
-    return new ProductionGraph
-    {
-      Commodities = commodities,
-      Processes = processes,
-      ProcessesByOutputId = processesByOutputId.ToDictionary(entry => entry.Key, entry => (IReadOnlyList<ProductionProcessNode>)entry.Value, StringComparer.Ordinal),
-      ProcessesByInputId = processesByInputId.ToDictionary(entry => entry.Key, entry => (IReadOnlyList<ProductionProcessNode>)entry.Value, StringComparer.Ordinal),
-      OutputsByModuleId = outputsByModuleId.ToDictionary(entry => entry.Key, entry => (IReadOnlyList<string>)entry.Value.OrderBy(value => value, StringComparer.Ordinal).ToList(), StringComparer.Ordinal),
-    };
-  }
 }

apps/backend/PlayerFaction/Api/CompletePlayerOnboardingHandler.cs

@@ -0,0 +1,31 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.PlayerFaction.Api;
+
+public sealed class CompletePlayerOnboardingHandler(WorldService worldService) : Endpoint<CompletePlayerOnboardingRequest, PlayerFactionSnapshot>
+{
+    public override void Configure()
+    {
+        Post("/api/player-faction/onboarding");
+    }
+
+    public override async Task HandleAsync(CompletePlayerOnboardingRequest request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var snapshot = worldService.CompletePlayerOnboarding(request);
+            if (snapshot is null)
+            {
+                await SendNotFoundAsync(cancellationToken);
+                return;
+            }
+
+            await SendOkAsync(snapshot, cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
+    }
+}

apps/backend/PlayerFaction/Api/CreatePlayerOrganizationHandler.cs

@@ -4,29 +4,28 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class CreatePlayerOrganizationHandler(WorldService worldService) : Endpoint<PlayerOrganizationCommandRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Post("/api/player-faction/organizations");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(PlayerOrganizationCommandRequest request, CancellationToken cancellationToken)
-  {
-    try
+    public override void Configure()
     {
-      var snapshot = worldService.CreatePlayerOrganization(request);
-      if (snapshot is null)
-      {
-        await SendNotFoundAsync(cancellationToken);
-        return;
-      }
+        Post("/api/player-faction/organizations");
+    }
 
-      await SendOkAsync(snapshot, cancellationToken);
-    }
-    catch (InvalidOperationException ex)
+    public override async Task HandleAsync(PlayerOrganizationCommandRequest request, CancellationToken cancellationToken)
     {
-      AddError(ex.Message);
-      await SendErrorsAsync(cancellation: cancellationToken);
+        try
+        {
+            var snapshot = worldService.CreatePlayerOrganization(request);
+            if (snapshot is null)
+            {
+                await SendNotFoundAsync(cancellationToken);
+                return;
+            }
+
+            await SendOkAsync(snapshot, cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
     }
-  }
 }

apps/backend/PlayerFaction/Api/DeletePlayerDirectiveHandler.cs

@@ -4,26 +4,25 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class DeletePlayerDirectiveRequest
 {
-  public string DirectiveId { get; set; } = string.Empty;
+    public string DirectiveId { get; set; } = string.Empty;
 }
 
 public sealed class DeletePlayerDirectiveHandler(WorldService worldService) : Endpoint<DeletePlayerDirectiveRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Delete("/api/player-faction/directives/{directiveId}");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(DeletePlayerDirectiveRequest request, CancellationToken cancellationToken)
-  {
-    var snapshot = worldService.DeletePlayerDirective(request.DirectiveId);
-    if (snapshot is null)
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Delete("/api/player-faction/directives/{directiveId}");
     }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+    public override async Task HandleAsync(DeletePlayerDirectiveRequest request, CancellationToken cancellationToken)
+    {
+        var snapshot = worldService.DeletePlayerDirective(request.DirectiveId);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/PlayerFaction/Api/DeletePlayerOrganizationHandler.cs

@@ -4,34 +4,33 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class DeletePlayerOrganizationRequest
 {
-  public string OrganizationId { get; set; } = string.Empty;
+    public string OrganizationId { get; set; } = string.Empty;
 }
 
 public sealed class DeletePlayerOrganizationHandler(WorldService worldService) : Endpoint<DeletePlayerOrganizationRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Delete("/api/player-faction/organizations/{organizationId}");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(DeletePlayerOrganizationRequest request, CancellationToken cancellationToken)
-  {
-    try
+    public override void Configure()
     {
-      var snapshot = worldService.DeletePlayerOrganization(request.OrganizationId);
-      if (snapshot is null)
-      {
-        await SendNotFoundAsync(cancellationToken);
-        return;
-      }
+        Delete("/api/player-faction/organizations/{organizationId}");
+    }
 
-      await SendOkAsync(snapshot, cancellationToken);
-    }
-    catch (InvalidOperationException ex)
+    public override async Task HandleAsync(DeletePlayerOrganizationRequest request, CancellationToken cancellationToken)
     {
-      AddError(ex.Message);
-      await SendErrorsAsync(cancellation: cancellationToken);
+        try
+        {
+            var snapshot = worldService.DeletePlayerOrganization(request.OrganizationId);
+            if (snapshot is null)
+            {
+                await SendNotFoundAsync(cancellationToken);
+                return;
+            }
+
+            await SendOkAsync(snapshot, cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
     }
-  }
 }

apps/backend/PlayerFaction/Api/GetPlayerFactionHandler.cs

@@ -4,21 +4,20 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class GetPlayerFactionHandler(WorldService worldService) : EndpointWithoutRequest<PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Get("/api/player-faction");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(CancellationToken cancellationToken)
-  {
-    var snapshot = worldService.GetPlayerFaction();
-    if (snapshot is null)
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Get("/api/player-faction");
     }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+    public override async Task HandleAsync(CancellationToken cancellationToken)
+    {
+        var snapshot = worldService.GetPlayerFaction();
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/PlayerFaction/Api/GetPlayerIdentitiesHandler.cs

@@ -0,0 +1,73 @@
+using FastEndpoints;
+using SpaceGame.Api.Auth.Runtime;
+using SpaceGame.Api.Auth.Simulation;
+using SpaceGame.Api.PlayerFaction.Simulation;
+
+namespace SpaceGame.Api.PlayerFaction.Api;
+
+public sealed class GetPlayerIdentitiesHandler(IAuthRepository authRepository, IPlayerStateStore playerStateStore)
+  : EndpointWithoutRequest<IReadOnlyList<PlayerIdentitySummaryResponse>>
+{
+    public override void Configure()
+    {
+        Get("/api/player-faction/identities");
+        Policies(AuthPolicyNames.GmAccess);
+    }
+
+    public override async Task HandleAsync(CancellationToken cancellationToken)
+    {
+        var users = await authRepository.ListUsersAsync(cancellationToken);
+        var playerFactionsByPlayerId = playerStateStore.GetPlayerFactionsByPlayerId();
+
+        var responses = new List<PlayerIdentitySummaryResponse>(users.Count + playerFactionsByPlayerId.Count);
+        var seenIds = new HashSet<string>(StringComparer.Ordinal);
+
+        foreach (var user in users)
+        {
+            var userId = user.Id.ToString("N");
+            playerFactionsByPlayerId.TryGetValue(userId, out var playerFaction);
+            responses.Add(new PlayerIdentitySummaryResponse(
+              userId,
+              user.Email,
+              user.Roles,
+              playerFaction is not null,
+              playerFaction?.Id,
+              playerFaction?.Label,
+              playerFaction?.SovereignFactionId));
+            seenIds.Add(userId);
+        }
+
+        foreach (var (playerId, playerFaction) in playerFactionsByPlayerId)
+        {
+            if (!seenIds.Add(playerId))
+            {
+                continue;
+            }
+
+            responses.Add(new PlayerIdentitySummaryResponse(
+              playerId,
+              $"{playerId}@unknown",
+              Array.Empty<string>(),
+              true,
+              playerId,
+              playerFaction.Label,
+              playerFaction.SovereignFactionId));
+        }
+
+        await SendOkAsync(
+          responses
+            .OrderBy(response => response.Email, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(response => response.UserId, StringComparer.Ordinal)
+            .ToList(),
+          cancellationToken);
+    }
+}
+
+public sealed record PlayerIdentitySummaryResponse(
+  string UserId,
+  string Email,
+  IReadOnlyList<string> Roles,
+  bool HasPlayerFaction,
+  string? PlayerFactionId,
+  string? PlayerFactionLabel,
+  string? SovereignFactionId);

apps/backend/PlayerFaction/Api/UpdatePlayerOrganizationMembershipHandler.cs

@@ -4,37 +4,36 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class UpdatePlayerOrganizationMembershipHandler(WorldService worldService) : Endpoint<PlayerOrganizationMembershipCommandRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Put("/api/player-faction/organizations/{organizationId}/membership");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(PlayerOrganizationMembershipCommandRequest request, CancellationToken cancellationToken)
-  {
-    try
+    public override void Configure()
     {
-      var organizationId = Route<string>("organizationId");
-      if (string.IsNullOrWhiteSpace(organizationId))
-      {
-        AddError("organizationId route parameter is required.");
-        await SendErrorsAsync(cancellation: cancellationToken);
-        return;
-      }
-
-      var snapshot = worldService.UpdatePlayerOrganizationMembership(organizationId, request);
-      if (snapshot is null)
-      {
-        await SendNotFoundAsync(cancellationToken);
-        return;
-      }
-
-      await SendOkAsync(snapshot, cancellationToken);
+        Put("/api/player-faction/organizations/{organizationId}/membership");
     }
-    catch (InvalidOperationException ex)
+
+    public override async Task HandleAsync(PlayerOrganizationMembershipCommandRequest request, CancellationToken cancellationToken)
     {
-      AddError(ex.Message);
-      await SendErrorsAsync(cancellation: cancellationToken);
+        try
+        {
+            var organizationId = Route<string>("organizationId");
+            if (string.IsNullOrWhiteSpace(organizationId))
+            {
+                AddError("organizationId route parameter is required.");
+                await SendErrorsAsync(cancellation: cancellationToken);
+                return;
+            }
+
+            var snapshot = worldService.UpdatePlayerOrganizationMembership(organizationId, request);
+            if (snapshot is null)
+            {
+                await SendNotFoundAsync(cancellationToken);
+                return;
+            }
+
+            await SendOkAsync(snapshot, cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
     }
-  }
 }

apps/backend/PlayerFaction/Api/UpdatePlayerStrategicIntentHandler.cs

@@ -4,21 +4,20 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class UpdatePlayerStrategicIntentHandler(WorldService worldService) : Endpoint<PlayerStrategicIntentCommandRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Put("/api/player-faction/strategic-intent");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(PlayerStrategicIntentCommandRequest request, CancellationToken cancellationToken)
-  {
-    var snapshot = worldService.UpdatePlayerStrategicIntent(request);
-    if (snapshot is null)
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Put("/api/player-faction/strategic-intent");
     }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+    public override async Task HandleAsync(PlayerStrategicIntentCommandRequest request, CancellationToken cancellationToken)
+    {
+        var snapshot = worldService.UpdatePlayerStrategicIntent(request);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/PlayerFaction/Api/UpsertPlayerAssignmentHandler.cs

@@ -4,28 +4,27 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class UpsertPlayerAssignmentHandler(WorldService worldService) : Endpoint<PlayerAssetAssignmentCommandRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Put("/api/player-faction/assets/{assetId}/assignment");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(PlayerAssetAssignmentCommandRequest request, CancellationToken cancellationToken)
-  {
-    var assetId = Route<string>("assetId");
-    if (string.IsNullOrWhiteSpace(assetId))
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Put("/api/player-faction/assets/{assetId}/assignment");
     }
 
-    var snapshot = worldService.UpsertPlayerAssignment(assetId, request);
-    if (snapshot is null)
+    public override async Task HandleAsync(PlayerAssetAssignmentCommandRequest request, CancellationToken cancellationToken)
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
-    }
+        var assetId = Route<string>("assetId");
+        if (string.IsNullOrWhiteSpace(assetId))
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+        var snapshot = worldService.UpsertPlayerAssignment(assetId, request);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/PlayerFaction/Api/UpsertPlayerAutomationPolicyHandler.cs

@@ -4,23 +4,22 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class UpsertPlayerAutomationPolicyHandler(WorldService worldService) : Endpoint<PlayerAutomationPolicyCommandRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Post("/api/player-faction/automation-policies");
-    Put("/api/player-faction/automation-policies/{automationPolicyId}");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(PlayerAutomationPolicyCommandRequest request, CancellationToken cancellationToken)
-  {
-    var automationPolicyId = Route<string?>("automationPolicyId");
-    var snapshot = worldService.UpsertPlayerAutomationPolicy(string.IsNullOrWhiteSpace(automationPolicyId) ? null : automationPolicyId, request);
-    if (snapshot is null)
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Post("/api/player-faction/automation-policies");
+        Put("/api/player-faction/automation-policies/{automationPolicyId}");
     }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+    public override async Task HandleAsync(PlayerAutomationPolicyCommandRequest request, CancellationToken cancellationToken)
+    {
+        var automationPolicyId = Route<string?>("automationPolicyId");
+        var snapshot = worldService.UpsertPlayerAutomationPolicy(string.IsNullOrWhiteSpace(automationPolicyId) ? null : automationPolicyId, request);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/PlayerFaction/Api/UpsertPlayerDirectiveHandler.cs

@@ -4,23 +4,22 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class UpsertPlayerDirectiveHandler(WorldService worldService) : Endpoint<PlayerDirectiveCommandRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Post("/api/player-faction/directives");
-    Put("/api/player-faction/directives/{directiveId}");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(PlayerDirectiveCommandRequest request, CancellationToken cancellationToken)
-  {
-    var directiveId = Route<string?>("directiveId");
-    var snapshot = worldService.UpsertPlayerDirective(string.IsNullOrWhiteSpace(directiveId) ? null : directiveId, request);
-    if (snapshot is null)
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Post("/api/player-faction/directives");
+        Put("/api/player-faction/directives/{directiveId}");
     }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+    public override async Task HandleAsync(PlayerDirectiveCommandRequest request, CancellationToken cancellationToken)
+    {
+        var directiveId = Route<string?>("directiveId");
+        var snapshot = worldService.UpsertPlayerDirective(string.IsNullOrWhiteSpace(directiveId) ? null : directiveId, request);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/PlayerFaction/Api/UpsertPlayerPolicyHandler.cs

@@ -4,23 +4,22 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class UpsertPlayerPolicyHandler(WorldService worldService) : Endpoint<PlayerPolicyCommandRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Post("/api/player-faction/policies");
-    Put("/api/player-faction/policies/{policyId}");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(PlayerPolicyCommandRequest request, CancellationToken cancellationToken)
-  {
-    var policyId = Route<string?>("policyId");
-    var snapshot = worldService.UpsertPlayerPolicy(string.IsNullOrWhiteSpace(policyId) ? null : policyId, request);
-    if (snapshot is null)
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Post("/api/player-faction/policies");
+        Put("/api/player-faction/policies/{policyId}");
     }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+    public override async Task HandleAsync(PlayerPolicyCommandRequest request, CancellationToken cancellationToken)
+    {
+        var policyId = Route<string?>("policyId");
+        var snapshot = worldService.UpsertPlayerPolicy(string.IsNullOrWhiteSpace(policyId) ? null : policyId, request);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/PlayerFaction/Api/UpsertPlayerProductionProgramHandler.cs

@@ -4,23 +4,22 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class UpsertPlayerProductionProgramHandler(WorldService worldService) : Endpoint<PlayerProductionProgramCommandRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Post("/api/player-faction/production-programs");
-    Put("/api/player-faction/production-programs/{productionProgramId}");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(PlayerProductionProgramCommandRequest request, CancellationToken cancellationToken)
-  {
-    var productionProgramId = Route<string?>("productionProgramId");
-    var snapshot = worldService.UpsertPlayerProductionProgram(string.IsNullOrWhiteSpace(productionProgramId) ? null : productionProgramId, request);
-    if (snapshot is null)
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Post("/api/player-faction/production-programs");
+        Put("/api/player-faction/production-programs/{productionProgramId}");
     }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+    public override async Task HandleAsync(PlayerProductionProgramCommandRequest request, CancellationToken cancellationToken)
+    {
+        var productionProgramId = Route<string?>("productionProgramId");
+        var snapshot = worldService.UpsertPlayerProductionProgram(string.IsNullOrWhiteSpace(productionProgramId) ? null : productionProgramId, request);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/PlayerFaction/Api/UpsertPlayerReinforcementPolicyHandler.cs

@@ -4,23 +4,22 @@ namespace SpaceGame.Api.PlayerFaction.Api;
 
 public sealed class UpsertPlayerReinforcementPolicyHandler(WorldService worldService) : Endpoint<PlayerReinforcementPolicyCommandRequest, PlayerFactionSnapshot>
 {
-  public override void Configure()
-  {
-    Post("/api/player-faction/reinforcement-policies");
-    Put("/api/player-faction/reinforcement-policies/{reinforcementPolicyId}");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(PlayerReinforcementPolicyCommandRequest request, CancellationToken cancellationToken)
-  {
-    var reinforcementPolicyId = Route<string?>("reinforcementPolicyId");
-    var snapshot = worldService.UpsertPlayerReinforcementPolicy(string.IsNullOrWhiteSpace(reinforcementPolicyId) ? null : reinforcementPolicyId, request);
-    if (snapshot is null)
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Post("/api/player-faction/reinforcement-policies");
+        Put("/api/player-faction/reinforcement-policies/{reinforcementPolicyId}");
     }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+    public override async Task HandleAsync(PlayerReinforcementPolicyCommandRequest request, CancellationToken cancellationToken)
+    {
+        var reinforcementPolicyId = Route<string?>("reinforcementPolicyId");
+        var snapshot = worldService.UpsertPlayerReinforcementPolicy(string.IsNullOrWhiteSpace(reinforcementPolicyId) ? null : reinforcementPolicyId, request);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/PlayerFaction/Contracts/PlayerFaction.cs

@@ -194,7 +194,7 @@ public sealed record PlayerDirectiveSnapshot(
   bool UseOrders,
   string? StagingOrderKind,
   string? ItemId,
-  string? PreferredNodeId,
+  string? PreferredAnchorId,
   string? PreferredConstructionSiteId,
   string? PreferredModuleId,
   int Priority,
@@ -249,7 +249,10 @@ public sealed record PlayerAlertSnapshot(
 public sealed record PlayerFactionSnapshot(
   string Id,
   string Label,
+  string? PersonaName,
+  string? RaceId,
   string SovereignFactionId,
+  bool RequiresOnboarding,
   string Status,
   DateTimeOffset CreatedAtUtc,
   DateTimeOffset UpdatedAtUtc,

apps/backend/PlayerFaction/Contracts/PlayerFactionCommands.cs

@@ -1,5 +1,9 @@
 namespace SpaceGame.Api.PlayerFaction.Contracts;
 
+public sealed record CompletePlayerOnboardingRequest(
+  string Name,
+  string RaceId);
+
 public sealed record PlayerOrganizationCommandRequest(
   string Kind,
   string Label,
@@ -41,7 +45,7 @@ public sealed record PlayerDirectiveCommandRequest(
   string? SourceStationId,
   string? DestinationStationId,
   string? ItemId,
-  string? PreferredNodeId,
+  string? PreferredAnchorId,
   string? PreferredConstructionSiteId,
   string? PreferredModuleId,
   int Priority,

apps/backend/PlayerFaction/Runtime/PlayerFactionRuntimeModels.cs

@@ -1,306 +1,311 @@
+using static SpaceGame.Api.Shared.Runtime.ShipBehaviorKinds;
+
 namespace SpaceGame.Api.PlayerFaction.Runtime;
 
 public sealed class PlayerFactionRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public required string SovereignFactionId { get; set; }
-  public string Status { get; set; } = "active";
-  public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public PlayerAssetRegistryRuntime AssetRegistry { get; set; } = new();
-  public PlayerStrategicIntentRuntime StrategicIntent { get; set; } = new();
-  public List<PlayerFleetRuntime> Fleets { get; } = [];
-  public List<PlayerTaskForceRuntime> TaskForces { get; } = [];
-  public List<PlayerStationGroupRuntime> StationGroups { get; } = [];
-  public List<PlayerEconomicRegionRuntime> EconomicRegions { get; } = [];
-  public List<PlayerFrontRuntime> Fronts { get; } = [];
-  public List<PlayerReserveGroupRuntime> Reserves { get; } = [];
-  public List<PlayerFactionPolicyRuntime> Policies { get; } = [];
-  public List<PlayerAutomationPolicyRuntime> AutomationPolicies { get; } = [];
-  public List<PlayerReinforcementPolicyRuntime> ReinforcementPolicies { get; } = [];
-  public List<PlayerProductionProgramRuntime> ProductionPrograms { get; } = [];
-  public List<PlayerDirectiveRuntime> Directives { get; } = [];
-  public List<PlayerAssignmentRuntime> Assignments { get; } = [];
-  public List<PlayerDecisionLogEntryRuntime> DecisionLog { get; } = [];
-  public List<PlayerAlertRuntime> Alerts { get; } = [];
-  public string LastDeltaSignature { get; set; } = string.Empty;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string? PersonaName { get; set; }
+    public string? RaceId { get; set; }
+    public required string SovereignFactionId { get; set; }
+    public bool RequiresOnboarding { get; set; } = true;
+    public string Status { get; set; } = "active";
+    public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public PlayerAssetRegistryRuntime AssetRegistry { get; set; } = new();
+    public PlayerStrategicIntentRuntime StrategicIntent { get; set; } = new();
+    public List<PlayerFleetRuntime> Fleets { get; } = [];
+    public List<PlayerTaskForceRuntime> TaskForces { get; } = [];
+    public List<PlayerStationGroupRuntime> StationGroups { get; } = [];
+    public List<PlayerEconomicRegionRuntime> EconomicRegions { get; } = [];
+    public List<PlayerFrontRuntime> Fronts { get; } = [];
+    public List<PlayerReserveGroupRuntime> Reserves { get; } = [];
+    public List<PlayerFactionPolicyRuntime> Policies { get; } = [];
+    public List<PlayerAutomationPolicyRuntime> AutomationPolicies { get; } = [];
+    public List<PlayerReinforcementPolicyRuntime> ReinforcementPolicies { get; } = [];
+    public List<PlayerProductionProgramRuntime> ProductionPrograms { get; } = [];
+    public List<PlayerDirectiveRuntime> Directives { get; } = [];
+    public List<PlayerAssignmentRuntime> Assignments { get; } = [];
+    public List<PlayerDecisionLogEntryRuntime> DecisionLog { get; } = [];
+    public List<PlayerAlertRuntime> Alerts { get; } = [];
+    public string LastDeltaSignature { get; set; } = string.Empty;
 }
 
 public sealed class PlayerAssetRegistryRuntime
 {
-  public HashSet<string> ShipIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> StationIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> CommanderIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> ClaimIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> ConstructionSiteIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> PolicySetIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> MarketOrderIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> FleetIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> TaskForceIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> StationGroupIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> EconomicRegionIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> FrontIds { get; } = new(StringComparer.Ordinal);
-  public HashSet<string> ReserveIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> ShipIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> StationIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> CommanderIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> ClaimIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> ConstructionSiteIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> PolicySetIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> MarketOrderIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> FleetIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> TaskForceIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> StationGroupIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> EconomicRegionIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> FrontIds { get; } = new(StringComparer.Ordinal);
+    public HashSet<string> ReserveIds { get; } = new(StringComparer.Ordinal);
 }
 
 public sealed class PlayerStrategicIntentRuntime
 {
-  public string StrategicPosture { get; set; } = "balanced";
-  public string EconomicPosture { get; set; } = "delegated";
-  public string MilitaryPosture { get; set; } = "layered-defense";
-  public string LogisticsPosture { get; set; } = "stable";
-  public float DesiredReserveRatio { get; set; } = 0.2f;
-  public bool AllowDelegatedCombatAutomation { get; set; } = true;
-  public bool AllowDelegatedEconomicAutomation { get; set; } = true;
-  public string? Notes { get; set; }
+    public string StrategicPosture { get; set; } = "balanced";
+    public string EconomicPosture { get; set; } = "delegated";
+    public string MilitaryPosture { get; set; } = "layered-defense";
+    public string LogisticsPosture { get; set; } = "stable";
+    public float DesiredReserveRatio { get; set; } = 0.2f;
+    public bool AllowDelegatedCombatAutomation { get; set; } = true;
+    public bool AllowDelegatedEconomicAutomation { get; set; } = true;
+    public string? Notes { get; set; }
 }
 
 public sealed class PlayerFleetRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string Status { get; set; } = "active";
-  public string Role { get; set; } = "general-purpose";
-  public string? CommanderId { get; set; }
-  public string? FrontId { get; set; }
-  public string? HomeSystemId { get; set; }
-  public string? HomeStationId { get; set; }
-  public string? PolicyId { get; set; }
-  public string? AutomationPolicyId { get; set; }
-  public string? ReinforcementPolicyId { get; set; }
-  public List<string> AssetIds { get; } = [];
-  public List<string> TaskForceIds { get; } = [];
-  public List<string> DirectiveIds { get; } = [];
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string Status { get; set; } = "active";
+    public string Role { get; set; } = "general-purpose";
+    public string? CommanderId { get; set; }
+    public string? FrontId { get; set; }
+    public string? HomeSystemId { get; set; }
+    public string? HomeStationId { get; set; }
+    public string? PolicyId { get; set; }
+    public string? AutomationPolicyId { get; set; }
+    public string? ReinforcementPolicyId { get; set; }
+    public List<string> AssetIds { get; } = [];
+    public List<string> TaskForceIds { get; } = [];
+    public List<string> DirectiveIds { get; } = [];
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerTaskForceRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string Status { get; set; } = "active";
-  public string Role { get; set; } = "task-force";
-  public string? FleetId { get; set; }
-  public string? CommanderId { get; set; }
-  public string? FrontId { get; set; }
-  public string? PolicyId { get; set; }
-  public string? AutomationPolicyId { get; set; }
-  public List<string> AssetIds { get; } = [];
-  public List<string> DirectiveIds { get; } = [];
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string Status { get; set; } = "active";
+    public string Role { get; set; } = "task-force";
+    public string? FleetId { get; set; }
+    public string? CommanderId { get; set; }
+    public string? FrontId { get; set; }
+    public string? PolicyId { get; set; }
+    public string? AutomationPolicyId { get; set; }
+    public List<string> AssetIds { get; } = [];
+    public List<string> DirectiveIds { get; } = [];
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerStationGroupRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string Status { get; set; } = "active";
-  public string Role { get; set; } = "industrial-group";
-  public string? EconomicRegionId { get; set; }
-  public string? PolicyId { get; set; }
-  public string? AutomationPolicyId { get; set; }
-  public List<string> StationIds { get; } = [];
-  public List<string> DirectiveIds { get; } = [];
-  public List<string> FocusItemIds { get; } = [];
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string Status { get; set; } = "active";
+    public string Role { get; set; } = "industrial-group";
+    public string? EconomicRegionId { get; set; }
+    public string? PolicyId { get; set; }
+    public string? AutomationPolicyId { get; set; }
+    public List<string> StationIds { get; } = [];
+    public List<string> DirectiveIds { get; } = [];
+    public List<string> FocusItemIds { get; } = [];
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerEconomicRegionRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string Status { get; set; } = "active";
-  public string Role { get; set; } = "balanced-region";
-  public string? SharedEconomicRegionId { get; set; }
-  public string? PolicyId { get; set; }
-  public string? AutomationPolicyId { get; set; }
-  public List<string> SystemIds { get; } = [];
-  public List<string> StationGroupIds { get; } = [];
-  public List<string> DirectiveIds { get; } = [];
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string Status { get; set; } = "active";
+    public string Role { get; set; } = "balanced-region";
+    public string? SharedEconomicRegionId { get; set; }
+    public string? PolicyId { get; set; }
+    public string? AutomationPolicyId { get; set; }
+    public List<string> SystemIds { get; } = [];
+    public List<string> StationGroupIds { get; } = [];
+    public List<string> DirectiveIds { get; } = [];
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerFrontRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string Status { get; set; } = "active";
-  public float Priority { get; set; } = 50f;
-  public string Posture { get; set; } = "hold";
-  public string? SharedFrontLineId { get; set; }
-  public string? TargetFactionId { get; set; }
-  public List<string> SystemIds { get; } = [];
-  public List<string> FleetIds { get; } = [];
-  public List<string> ReserveIds { get; } = [];
-  public List<string> DirectiveIds { get; } = [];
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string Status { get; set; } = "active";
+    public float Priority { get; set; } = 50f;
+    public string Posture { get; set; } = "hold";
+    public string? SharedFrontLineId { get; set; }
+    public string? TargetFactionId { get; set; }
+    public List<string> SystemIds { get; } = [];
+    public List<string> FleetIds { get; } = [];
+    public List<string> ReserveIds { get; } = [];
+    public List<string> DirectiveIds { get; } = [];
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerReserveGroupRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string Status { get; set; } = "ready";
-  public string ReserveKind { get; set; } = "military";
-  public string? HomeSystemId { get; set; }
-  public string? PolicyId { get; set; }
-  public List<string> AssetIds { get; } = [];
-  public List<string> FrontIds { get; } = [];
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string Status { get; set; } = "ready";
+    public string ReserveKind { get; set; } = "military";
+    public string? HomeSystemId { get; set; }
+    public string? PolicyId { get; set; }
+    public List<string> AssetIds { get; } = [];
+    public List<string> FrontIds { get; } = [];
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerFactionPolicyRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string ScopeKind { get; set; } = "player-faction";
-  public string? ScopeId { get; set; }
-  public string? PolicySetId { get; set; }
-  public bool AllowDelegatedCombat { get; set; } = true;
-  public bool AllowDelegatedTrade { get; set; } = true;
-  public float ReserveCreditsRatio { get; set; } = 0.2f;
-  public float ReserveMilitaryRatio { get; set; } = 0.2f;
-  public string TradeAccessPolicy { get; set; } = "owner-and-allies";
-  public string DockingAccessPolicy { get; set; } = "owner-and-allies";
-  public string ConstructionAccessPolicy { get; set; } = "owner-only";
-  public string OperationalRangePolicy { get; set; } = "unrestricted";
-  public string CombatEngagementPolicy { get; set; } = "defensive";
-  public bool AvoidHostileSystems { get; set; } = true;
-  public float FleeHullRatio { get; set; } = 0.35f;
-  public HashSet<string> BlacklistedSystemIds { get; } = new(StringComparer.Ordinal);
-  public string? Notes { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string ScopeKind { get; set; } = "player-faction";
+    public string? ScopeId { get; set; }
+    public string? PolicySetId { get; set; }
+    public bool AllowDelegatedCombat { get; set; } = true;
+    public bool AllowDelegatedTrade { get; set; } = true;
+    public float ReserveCreditsRatio { get; set; } = 0.2f;
+    public float ReserveMilitaryRatio { get; set; } = 0.2f;
+    public string TradeAccessPolicy { get; set; } = "owner-and-allies";
+    public string DockingAccessPolicy { get; set; } = "owner-and-allies";
+    public string ConstructionAccessPolicy { get; set; } = "owner-only";
+    public string OperationalRangePolicy { get; set; } = "unrestricted";
+    public string CombatEngagementPolicy { get; set; } = "defensive";
+    public bool AvoidHostileSystems { get; set; } = true;
+    public float FleeHullRatio { get; set; } = 0.35f;
+    public HashSet<string> BlacklistedSystemIds { get; } = new(StringComparer.Ordinal);
+    public string? Notes { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerAutomationPolicyRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string ScopeKind { get; set; } = "player-faction";
-  public string? ScopeId { get; set; }
-  public bool Enabled { get; set; } = true;
-  public string BehaviorKind { get; set; } = "idle";
-  public bool UseOrders { get; set; }
-  public string? StagingOrderKind { get; set; }
-  public int MaxSystemRange { get; set; }
-  public bool KnownStationsOnly { get; set; }
-  public float Radius { get; set; } = 24f;
-  public float WaitSeconds { get; set; } = 3f;
-  public string? PreferredItemId { get; set; }
-  public string? Notes { get; set; }
-  public List<ShipOrderTemplateRuntime> RepeatOrders { get; } = [];
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string ScopeKind { get; set; } = "player-faction";
+    public string? ScopeId { get; set; }
+    public bool Enabled { get; set; } = true;
+    public string BehaviorKind { get; set; } = Idle;
+    public bool UseOrders { get; set; }
+    public string? StagingOrderKind { get; set; }
+    public int MaxSystemRange { get; set; }
+    public bool KnownStationsOnly { get; set; }
+    public float Radius { get; set; } = 24f;
+    public float WaitSeconds { get; set; } = 3f;
+    public string? PreferredItemId { get; set; }
+    public string? Notes { get; set; }
+    public List<ShipOrderTemplateRuntime> RepeatOrders { get; } = [];
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerReinforcementPolicyRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string ScopeKind { get; set; } = "player-faction";
-  public string? ScopeId { get; set; }
-  public string ShipKind { get; set; } = "military";
-  public int DesiredAssetCount { get; set; }
-  public int MinimumReserveCount { get; set; }
-  public bool AutoTransferReserves { get; set; } = true;
-  public bool AutoQueueProduction { get; set; } = true;
-  public string? SourceReserveId { get; set; }
-  public string? TargetFrontId { get; set; }
-  public string? Notes { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string ScopeKind { get; set; } = "player-faction";
+    public string? ScopeId { get; set; }
+    public string ShipKind { get; set; } = "military";
+    public int DesiredAssetCount { get; set; }
+    public int MinimumReserveCount { get; set; }
+    public bool AutoTransferReserves { get; set; } = true;
+    public bool AutoQueueProduction { get; set; } = true;
+    public string? SourceReserveId { get; set; }
+    public string? TargetFrontId { get; set; }
+    public string? Notes { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerProductionProgramRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string Status { get; set; } = "active";
-  public string Kind { get; set; } = "ship-production";
-  public string? TargetShipKind { get; set; }
-  public string? TargetModuleId { get; set; }
-  public string? TargetItemId { get; set; }
-  public int TargetCount { get; set; }
-  public int CurrentCount { get; set; }
-  public string? StationGroupId { get; set; }
-  public string? ReinforcementPolicyId { get; set; }
-  public string? Notes { get; set; }
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string Status { get; set; } = "active";
+    public string Kind { get; set; } = "ship-production";
+    public string? TargetShipKind { get; set; }
+    public string? TargetModuleId { get; set; }
+    public string? TargetItemId { get; set; }
+    public int TargetCount { get; set; }
+    public int CurrentCount { get; set; }
+    public string? StationGroupId { get; set; }
+    public string? ReinforcementPolicyId { get; set; }
+    public string? Notes { get; set; }
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerDirectiveRuntime
 {
-  public required string Id { get; init; }
-  public required string Label { get; set; }
-  public string Status { get; set; } = "active";
-  public string Kind { get; set; } = "hold";
-  public string ScopeKind { get; set; } = "asset";
-  public string ScopeId { get; set; } = string.Empty;
-  public string? TargetEntityId { get; set; }
-  public string? TargetSystemId { get; set; }
-  public Vector3? TargetPosition { get; set; }
-  public string? HomeSystemId { get; set; }
-  public string? HomeStationId { get; set; }
-  public string? SourceStationId { get; set; }
-  public string? DestinationStationId { get; set; }
-  public string BehaviorKind { get; set; } = "idle";
-  public bool UseOrders { get; set; }
-  public string? StagingOrderKind { get; set; }
-  public string? ItemId { get; set; }
-  public string? PreferredNodeId { get; set; }
-  public string? PreferredConstructionSiteId { get; set; }
-  public string? PreferredModuleId { get; set; }
-  public int Priority { get; set; } = 50;
-  public float Radius { get; set; } = 24f;
-  public float WaitSeconds { get; set; } = 3f;
-  public int MaxSystemRange { get; set; }
-  public bool KnownStationsOnly { get; set; }
-  public List<Vector3> PatrolPoints { get; } = [];
-  public List<ShipOrderTemplateRuntime> RepeatOrders { get; } = [];
-  public string? PolicyId { get; set; }
-  public string? AutomationPolicyId { get; set; }
-  public string? Notes { get; set; }
-  public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Label { get; set; }
+    public string Status { get; set; } = "active";
+    public string Kind { get; set; } = "hold";
+    public string ScopeKind { get; set; } = "asset";
+    public string ScopeId { get; set; } = string.Empty;
+    public string? TargetEntityId { get; set; }
+    public string? TargetSystemId { get; set; }
+    public Vector3? TargetPosition { get; set; }
+    public string? HomeSystemId { get; set; }
+    public string? HomeStationId { get; set; }
+    public string? SourceStationId { get; set; }
+    public string? DestinationStationId { get; set; }
+    public string BehaviorKind { get; set; } = Idle;
+    public bool UseOrders { get; set; }
+    public string? StagingOrderKind { get; set; }
+    public string? ItemId { get; set; }
+    public string? PreferredAnchorId { get; set; }
+    public string? PreferredConstructionSiteId { get; set; }
+    public string? PreferredModuleId { get; set; }
+    public int Priority { get; set; } = 50;
+    public float Radius { get; set; } = 24f;
+    public float WaitSeconds { get; set; } = 3f;
+    public int MaxSystemRange { get; set; }
+    public bool KnownStationsOnly { get; set; }
+    public List<Vector3> PatrolPoints { get; } = [];
+    public List<ShipOrderTemplateRuntime> RepeatOrders { get; } = [];
+    public string? PolicyId { get; set; }
+    public string? AutomationPolicyId { get; set; }
+    public string? Notes { get; set; }
+    public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerAssignmentRuntime
 {
-  public required string Id { get; init; }
-  public required string AssetKind { get; set; }
-  public required string AssetId { get; set; }
-  public string? FleetId { get; set; }
-  public string? TaskForceId { get; set; }
-  public string? StationGroupId { get; set; }
-  public string? EconomicRegionId { get; set; }
-  public string? FrontId { get; set; }
-  public string? ReserveId { get; set; }
-  public string? DirectiveId { get; set; }
-  public string? PolicyId { get; set; }
-  public string? AutomationPolicyId { get; set; }
-  public string Role { get; set; } = "line";
-  public string Status { get; set; } = "active";
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string AssetKind { get; set; }
+    public required string AssetId { get; set; }
+    public string? FleetId { get; set; }
+    public string? TaskForceId { get; set; }
+    public string? StationGroupId { get; set; }
+    public string? EconomicRegionId { get; set; }
+    public string? FrontId { get; set; }
+    public string? ReserveId { get; set; }
+    public string? DirectiveId { get; set; }
+    public string? PolicyId { get; set; }
+    public string? AutomationPolicyId { get; set; }
+    public string Role { get; set; } = "line";
+    public string Status { get; set; } = "active";
+    public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerDecisionLogEntryRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public required string Summary { get; set; }
-  public string? RelatedEntityKind { get; set; }
-  public string? RelatedEntityId { get; set; }
-  public DateTimeOffset OccurredAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public required string Summary { get; set; }
+    public string? RelatedEntityKind { get; set; }
+    public string? RelatedEntityId { get; set; }
+    public DateTimeOffset OccurredAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }
 
 public sealed class PlayerAlertRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; set; }
-  public required string Severity { get; set; }
-  public required string Summary { get; set; }
-  public string? AssetKind { get; set; }
-  public string? AssetId { get; set; }
-  public string? RelatedDirectiveId { get; set; }
-  public string Status { get; set; } = "open";
-  public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
+    public required string Id { get; init; }
+    public required string Kind { get; set; }
+    public required string Severity { get; set; }
+    public required string Summary { get; set; }
+    public string? AssetKind { get; set; }
+    public string? AssetId { get; set; }
+    public string? RelatedDirectiveId { get; set; }
+    public string Status { get; set; } = "open";
+    public DateTimeOffset CreatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
 }

apps/backend/PlayerFaction/Simulation/IPlayerStateStore.cs

@@ -0,0 +1,10 @@
+namespace SpaceGame.Api.PlayerFaction.Simulation;
+
+public interface IPlayerStateStore
+{
+    bool TryGetPlayerFaction(string playerId, out PlayerFactionRuntime playerFaction);
+    PlayerFactionRuntime GetOrAddPlayerFaction(string playerId, Func<PlayerFactionRuntime> factory);
+    IReadOnlyCollection<PlayerFactionRuntime> GetPlayerFactions();
+    IReadOnlyDictionary<string, PlayerFactionRuntime> GetPlayerFactionsByPlayerId();
+    void Clear();
+}

apps/backend/PlayerFaction/Simulation/PlayerFactionProjectionService.cs

@@ -0,0 +1,273 @@
+namespace SpaceGame.Api.PlayerFaction.Simulation;
+
+public sealed class PlayerFactionProjectionService
+{
+    public PlayerFactionSnapshot? ToSnapshot(PlayerFactionRuntime? player)
+    {
+        if (player is null)
+        {
+            return null;
+        }
+
+        return new PlayerFactionSnapshot(
+          player.Id,
+          player.Label,
+          player.PersonaName,
+          player.RaceId,
+          player.SovereignFactionId,
+          player.RequiresOnboarding,
+          player.Status,
+          player.CreatedAtUtc,
+          player.UpdatedAtUtc,
+          new PlayerAssetRegistrySnapshot(
+            player.AssetRegistry.ShipIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.StationIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.CommanderIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.ClaimIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.ConstructionSiteIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.PolicySetIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.MarketOrderIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.FleetIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.TaskForceIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.StationGroupIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.EconomicRegionIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.FrontIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            player.AssetRegistry.ReserveIds.OrderBy(id => id, StringComparer.Ordinal).ToList()),
+          new PlayerStrategicIntentSnapshot(
+            player.StrategicIntent.StrategicPosture,
+            player.StrategicIntent.EconomicPosture,
+            player.StrategicIntent.MilitaryPosture,
+            player.StrategicIntent.LogisticsPosture,
+            player.StrategicIntent.DesiredReserveRatio,
+            player.StrategicIntent.AllowDelegatedCombatAutomation,
+            player.StrategicIntent.AllowDelegatedEconomicAutomation,
+            player.StrategicIntent.Notes),
+          player.Fleets.Select(fleet => new PlayerFleetSnapshot(
+            fleet.Id,
+            fleet.Label,
+            fleet.Status,
+            fleet.Role,
+            fleet.CommanderId,
+            fleet.FrontId,
+            fleet.HomeSystemId,
+            fleet.HomeStationId,
+            fleet.PolicyId,
+            fleet.AutomationPolicyId,
+            fleet.ReinforcementPolicyId,
+            fleet.AssetIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            fleet.TaskForceIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            fleet.DirectiveIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            fleet.UpdatedAtUtc)).ToList(),
+          player.TaskForces.Select(taskForce => new PlayerTaskForceSnapshot(
+            taskForce.Id,
+            taskForce.Label,
+            taskForce.Status,
+            taskForce.Role,
+            taskForce.FleetId,
+            taskForce.CommanderId,
+            taskForce.FrontId,
+            taskForce.PolicyId,
+            taskForce.AutomationPolicyId,
+            taskForce.AssetIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            taskForce.DirectiveIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            taskForce.UpdatedAtUtc)).ToList(),
+          player.StationGroups.Select(group => new PlayerStationGroupSnapshot(
+            group.Id,
+            group.Label,
+            group.Status,
+            group.Role,
+            group.EconomicRegionId,
+            group.PolicyId,
+            group.AutomationPolicyId,
+            group.StationIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            group.DirectiveIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            group.FocusItemIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            group.UpdatedAtUtc)).ToList(),
+          player.EconomicRegions.Select(region => new PlayerEconomicRegionSnapshot(
+            region.Id,
+            region.Label,
+            region.Status,
+            region.Role,
+            region.SharedEconomicRegionId,
+            region.PolicyId,
+            region.AutomationPolicyId,
+            region.SystemIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            region.StationGroupIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            region.DirectiveIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            region.UpdatedAtUtc)).ToList(),
+          player.Fronts.Select(front => new PlayerFrontSnapshot(
+            front.Id,
+            front.Label,
+            front.Status,
+            front.Priority,
+            front.Posture,
+            front.SharedFrontLineId,
+            front.TargetFactionId,
+            front.SystemIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            front.FleetIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            front.ReserveIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            front.DirectiveIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            front.UpdatedAtUtc)).ToList(),
+          player.Reserves.Select(reserve => new PlayerReserveGroupSnapshot(
+            reserve.Id,
+            reserve.Label,
+            reserve.Status,
+            reserve.ReserveKind,
+            reserve.HomeSystemId,
+            reserve.PolicyId,
+            reserve.AssetIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            reserve.FrontIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            reserve.UpdatedAtUtc)).ToList(),
+          player.Policies.Select(policy => new PlayerFactionPolicySnapshot(
+            policy.Id,
+            policy.Label,
+            policy.ScopeKind,
+            policy.ScopeId,
+            policy.PolicySetId,
+            policy.AllowDelegatedCombat,
+            policy.AllowDelegatedTrade,
+            policy.ReserveCreditsRatio,
+            policy.ReserveMilitaryRatio,
+            policy.TradeAccessPolicy,
+            policy.DockingAccessPolicy,
+            policy.ConstructionAccessPolicy,
+            policy.OperationalRangePolicy,
+            policy.CombatEngagementPolicy,
+            policy.AvoidHostileSystems,
+            policy.FleeHullRatio,
+            policy.BlacklistedSystemIds.OrderBy(id => id, StringComparer.Ordinal).ToList(),
+            policy.Notes,
+            policy.UpdatedAtUtc)).ToList(),
+          player.AutomationPolicies.Select(policy => new PlayerAutomationPolicySnapshot(
+            policy.Id,
+            policy.Label,
+            policy.ScopeKind,
+            policy.ScopeId,
+            policy.Enabled,
+            policy.BehaviorKind,
+            policy.UseOrders,
+            policy.StagingOrderKind,
+            policy.MaxSystemRange,
+            policy.KnownStationsOnly,
+            policy.Radius,
+            policy.WaitSeconds,
+            policy.PreferredItemId,
+            policy.Notes,
+            policy.RepeatOrders.Select(ToShipOrderTemplateSnapshot).ToList(),
+            policy.UpdatedAtUtc)).ToList(),
+          player.ReinforcementPolicies.Select(policy => new PlayerReinforcementPolicySnapshot(
+            policy.Id,
+            policy.Label,
+            policy.ScopeKind,
+            policy.ScopeId,
+            policy.ShipKind,
+            policy.DesiredAssetCount,
+            policy.MinimumReserveCount,
+            policy.AutoTransferReserves,
+            policy.AutoQueueProduction,
+            policy.SourceReserveId,
+            policy.TargetFrontId,
+            policy.Notes,
+            policy.UpdatedAtUtc)).ToList(),
+          player.ProductionPrograms.Select(program => new PlayerProductionProgramSnapshot(
+            program.Id,
+            program.Label,
+            program.Status,
+            program.Kind,
+            program.TargetShipKind,
+            program.TargetModuleId,
+            program.TargetItemId,
+            program.TargetCount,
+            program.CurrentCount,
+            program.StationGroupId,
+            program.ReinforcementPolicyId,
+            program.Notes,
+            program.UpdatedAtUtc)).ToList(),
+          player.Directives.Select(directive => new PlayerDirectiveSnapshot(
+            directive.Id,
+            directive.Label,
+            directive.Status,
+            directive.Kind,
+            directive.ScopeKind,
+            directive.ScopeId,
+            directive.TargetEntityId,
+            directive.TargetSystemId,
+            directive.TargetPosition is null ? null : ToDto(directive.TargetPosition.Value),
+            directive.HomeSystemId,
+            directive.HomeStationId,
+            directive.SourceStationId,
+            directive.DestinationStationId,
+            directive.BehaviorKind,
+            directive.UseOrders,
+            directive.StagingOrderKind,
+            directive.ItemId,
+            directive.PreferredAnchorId,
+            directive.PreferredConstructionSiteId,
+            directive.PreferredModuleId,
+            directive.Priority,
+            directive.Radius,
+            directive.WaitSeconds,
+            directive.MaxSystemRange,
+            directive.KnownStationsOnly,
+            directive.PatrolPoints.Select(ToDto).ToList(),
+            directive.RepeatOrders.Select(ToShipOrderTemplateSnapshot).ToList(),
+            directive.PolicyId,
+            directive.AutomationPolicyId,
+            directive.Notes,
+            directive.CreatedAtUtc,
+            directive.UpdatedAtUtc)).ToList(),
+          player.Assignments.Select(assignment => new PlayerAssignmentSnapshot(
+            assignment.Id,
+            assignment.AssetKind,
+            assignment.AssetId,
+            assignment.FleetId,
+            assignment.TaskForceId,
+            assignment.StationGroupId,
+            assignment.EconomicRegionId,
+            assignment.FrontId,
+            assignment.ReserveId,
+            assignment.DirectiveId,
+            assignment.PolicyId,
+            assignment.AutomationPolicyId,
+            assignment.Role,
+            assignment.Status,
+            assignment.UpdatedAtUtc)).ToList(),
+          player.DecisionLog.Select(entry => new PlayerDecisionLogEntrySnapshot(
+            entry.Id,
+            entry.Kind,
+            entry.Summary,
+            entry.RelatedEntityKind,
+            entry.RelatedEntityId,
+            entry.OccurredAtUtc)).ToList(),
+          player.Alerts.Select(alert => new PlayerAlertSnapshot(
+            alert.Id,
+            alert.Kind,
+            alert.Severity,
+            alert.Summary,
+            alert.AssetKind,
+            alert.AssetId,
+            alert.RelatedDirectiveId,
+            alert.Status,
+            alert.CreatedAtUtc)).ToList());
+    }
+
+    private static ShipOrderTemplateSnapshot ToShipOrderTemplateSnapshot(ShipOrderTemplateRuntime template) =>
+      new(
+        template.Kind,
+        template.Label,
+        template.TargetEntityId,
+        template.TargetSystemId,
+        template.TargetPosition is null ? null : ToDto(template.TargetPosition.Value),
+        template.SourceStationId,
+        template.DestinationStationId,
+        template.ItemId,
+        template.AnchorId,
+        template.ConstructionSiteId,
+        template.ModuleId,
+        template.WaitSeconds,
+        template.Radius,
+        template.MaxSystemRange,
+        template.KnownStationsOnly);
+
+    private static Vector3Dto ToDto(Vector3 vector) => new(vector.X, vector.Y, vector.Z);
+}

apps/backend/PlayerFaction/Simulation/PlayerStateStore.cs

@@ -0,0 +1,29 @@
+namespace SpaceGame.Api.PlayerFaction.Simulation;
+
+public sealed class PlayerStateStore : IPlayerStateStore
+{
+    private readonly Dictionary<string, PlayerFactionRuntime> _playerFactions = new(StringComparer.Ordinal);
+
+    public bool TryGetPlayerFaction(string playerId, out PlayerFactionRuntime playerFaction) =>
+      _playerFactions.TryGetValue(playerId, out playerFaction!);
+
+    public PlayerFactionRuntime GetOrAddPlayerFaction(string playerId, Func<PlayerFactionRuntime> factory)
+    {
+        if (_playerFactions.TryGetValue(playerId, out var existing))
+        {
+            return existing;
+        }
+
+        var created = factory();
+        _playerFactions[playerId] = created;
+        return created;
+    }
+
+    public IReadOnlyCollection<PlayerFactionRuntime> GetPlayerFactions() =>
+      _playerFactions.Values.ToList();
+
+    public IReadOnlyDictionary<string, PlayerFactionRuntime> GetPlayerFactionsByPlayerId() =>
+      new Dictionary<string, PlayerFactionRuntime>(_playerFactions, StringComparer.Ordinal);
+
+    public void Clear() => _playerFactions.Clear();
+}

apps/backend/Program.cs

@@ -1,30 +1,143 @@
+using System.Text;
 using FastEndpoints;
 using FastEndpoints.Swagger;
-using SpaceGame.Api.Universe.Simulation;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.IdentityModel.Tokens;
+using Npgsql;
+using SpaceGame.Api.Universe.Bootstrap;
+
+const string StartupScenarioPath = "scenarios/minimal.json";
 
 var builder = WebApplication.CreateBuilder(args);
 
 builder.Services.AddCors((options) =>
 {
-  options.AddDefaultPolicy((policy) =>
-  {
-    policy
-      .AllowAnyHeader()
-      .AllowAnyMethod()
-      .AllowAnyOrigin();
-  });
+    options.AddDefaultPolicy((policy) =>
+    {
+        policy
+        .AllowAnyHeader()
+        .AllowAnyMethod()
+        .AllowAnyOrigin();
+    });
 });
-builder.Services.Configure<WorldGenerationOptions>(builder.Configuration.GetSection("WorldGeneration"));
+builder.Services
+  .AddOptions<StaticDataOptions>()
+  .Bind(builder.Configuration.GetSection("StaticData"))
+  .Validate(options => !string.IsNullOrWhiteSpace(options.DataRoot), "StaticData:DataRoot must be configured.")
+  .PostConfigure(options =>
+  {
+      if (Path.IsPathRooted(options.DataRoot))
+      {
+          options.DataRoot = Path.GetFullPath(options.DataRoot);
+          return;
+      }
+
+      var candidatePaths = new[]
+      {
+          Path.GetFullPath(options.DataRoot),
+          Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, options.DataRoot)),
+          Path.GetFullPath(Path.Combine(builder.Environment.ContentRootPath, "..", "..", options.DataRoot)),
+      };
+
+      var resolvedPath = candidatePaths.FirstOrDefault(Directory.Exists);
+      if (resolvedPath is null)
+      {
+          throw new InvalidOperationException($"StaticData:DataRoot '{options.DataRoot}' could not be resolved to an existing directory.");
+      }
+
+      options.DataRoot = resolvedPath;
+  })
+  .ValidateOnStart();
+builder.Services.Configure<BalanceOptions>(builder.Configuration.GetSection("Balance"));
 builder.Services.Configure<OrbitalSimulationOptions>(builder.Configuration.GetSection("OrbitalSimulation"));
-builder.Services.AddFastEndpoints();
-builder.Services.SwaggerDocument();
+builder.Services
+  .AddOptions<AuthOptions>()
+  .Bind(builder.Configuration.GetSection("Auth"))
+  .Validate(options => !string.IsNullOrWhiteSpace(options.ConnectionString), "Auth:ConnectionString must be configured.")
+  .ValidateOnStart();
+builder.Services
+  .AddOptions<JwtOptions>()
+  .Bind(builder.Configuration.GetSection("Jwt"))
+  .Validate(options => !string.IsNullOrWhiteSpace(options.SigningKey), "Jwt:SigningKey must be configured.")
+  .ValidateOnStart();
+
+var jwtOptions = builder.Configuration.GetSection("Jwt").Get<JwtOptions>() ?? new JwtOptions();
+var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtOptions.SigningKey));
+builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+  .AddJwtBearer(options =>
+  {
+      options.TokenValidationParameters = new TokenValidationParameters
+      {
+          ValidateIssuer = true,
+          ValidateAudience = true,
+          ValidateIssuerSigningKey = true,
+          ValidateLifetime = true,
+          ValidIssuer = jwtOptions.Issuer,
+          ValidAudience = jwtOptions.Audience,
+          IssuerSigningKey = signingKey,
+          ClockSkew = TimeSpan.FromSeconds(30),
+      };
+  });
+builder.Services
+    .AddAuthorizationBuilder()
+    .AddPolicy(AuthPolicyNames.AdminAccess, policy =>
+    {
+        policy.RequireAuthenticatedUser();
+        policy.RequireRole(AuthRoleNames.Admin);
+    })
+    .AddPolicy(AuthPolicyNames.GmAccess, policy =>
+    {
+        policy.RequireAuthenticatedUser();
+        policy.RequireRole(AuthRoleNames.Gm);
+    });
+builder.Services.AddHttpContextAccessor();
+
+builder.Services.AddSingleton<IBalanceService, BalanceService>();
+builder.Services.AddSingleton<AppVersionService>();
+builder.Services.AddSingleton<IPlayerStateStore, PlayerStateStore>();
+builder.Services.AddSingleton<PlayerFactionProjectionService>();
+builder.Services.AddSingleton<LocalPasswordHasher>();
+builder.Services.AddSingleton<RefreshTokenFactory>();
+builder.Services.AddSingleton<ITokenService, JwtTokenService>();
+builder.Services.AddSingleton<IPasswordResetDelivery, DevPasswordResetDelivery>();
+builder.Services.AddSingleton<IPlayerIdentityResolver, HttpContextPlayerIdentityResolver>();
+builder.Services.AddSingleton((serviceProvider) =>
+{
+    var authOptions = serviceProvider.GetRequiredService<Microsoft.Extensions.Options.IOptions<AuthOptions>>();
+    return new NpgsqlDataSourceBuilder(authOptions.Value.ConnectionString).Build();
+});
+builder.Services.AddSingleton<IAuthRepository, PostgresAuthRepository>();
+builder.Services.AddSingleton<AuthService>();
+builder.Services.AddSingleton<AuthSchemaInitializer>();
+builder.Services.AddSingleton<DevAuthSeeder>();
+builder.Services.AddTransient<SystemGenerationService>();
+builder.Services.AddTransient<SpatialBuilder>();
+builder.Services.AddTransient<WorldSeedingService>();
+builder.Services.AddTransient<ScenarioValidationService>();
+builder.Services.AddTransient<ScenarioContentBuilder>();
+builder.Services.AddTransient<ScenarioLoader>();
+builder.Services.AddTransient<WorldTopologyBuilder>();
+builder.Services.AddTransient<WorldRuntimeAssembler>();
+builder.Services.AddTransient<WorldBuilder>();
+builder.Services.AddSingleton<IStaticDataProvider, StaticDataProvider>();
 builder.Services.AddSingleton<WorldService>();
 builder.Services.AddSingleton<TelemetryService>();
 builder.Services.AddHostedService<SimulationHostedService>();
 
+builder.Services.AddFastEndpoints();
+builder.Services.SwaggerDocument();
+
 var app = builder.Build();
+await app.Services.GetRequiredService<AuthSchemaInitializer>().EnsureSchemaAsync(CancellationToken.None);
+if (builder.Environment.IsDevelopment())
+{
+    await app.Services.GetRequiredService<DevAuthSeeder>().SeedAsync(CancellationToken.None);
+    app.Services.GetRequiredService<WorldService>().LoadFromScenario(StartupScenarioPath);
+}
 
 app.UseCors();
+app.UseAuthentication();
+app.UseAuthorization();
 app.UseFastEndpoints();
 app.UseSwaggerGen();
 

apps/backend/Properties/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("SpaceGame.Api.Tests")]

apps/backend/Shared/Contracts/VersionInfo.cs

@@ -0,0 +1,7 @@
+namespace SpaceGame.Api.Shared.Contracts;
+
+public sealed record VersionInfoSnapshot(
+  string Version,
+  string Environment,
+  string? CommitSha,
+  DateTimeOffset StartedAtUtc);

apps/backend/Shared/Runtime/AppVersionService.cs

@@ -0,0 +1,29 @@
+using System.Reflection;
+using Microsoft.Extensions.Hosting;
+
+namespace SpaceGame.Api.Shared.Runtime;
+
+public sealed class AppVersionService
+{
+    private readonly VersionInfoSnapshot _snapshot;
+
+    public AppVersionService(IHostEnvironment environment)
+    {
+        var assembly = Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly();
+        var informationalVersion = assembly
+            .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
+            .InformationalVersion;
+        var assemblyVersion = assembly.GetName().Version?.ToString() ?? "0.0.0";
+        var version = string.IsNullOrWhiteSpace(informationalVersion) ? assemblyVersion : informationalVersion;
+        var commitSha = Environment.GetEnvironmentVariable("SPACEGAME_COMMIT_SHA")
+          ?? Environment.GetEnvironmentVariable("GIT_COMMIT_SHA");
+
+        _snapshot = new VersionInfoSnapshot(
+          version,
+          environment.EnvironmentName,
+          string.IsNullOrWhiteSpace(commitSha) ? null : commitSha,
+          DateTimeOffset.UtcNow);
+    }
+
+    public VersionInfoSnapshot GetSnapshot() => _snapshot;
+}

apps/backend/Shared/Runtime/KnownShipTaxonomy.cs

@@ -0,0 +1,69 @@
+namespace SpaceGame.Api.Shared.Runtime;
+
+internal static class KnownShipTypes
+{
+    internal const string Resupplier = "resupplier";
+    internal const string Miner = "miner";
+    internal const string Carrier = "carrier";
+    internal const string Fighter = "fighter";
+    internal const string HeavyFighter = "heavyfighter";
+    internal const string Destroyer = "destroyer";
+    internal const string LargeMiner = "largeminer";
+    internal const string Freighter = "freighter";
+    internal const string Bomber = "bomber";
+    internal const string Scavenger = "scavenger";
+    internal const string Frigate = "frigate";
+    internal const string Transporter = "transporter";
+    internal const string Interceptor = "interceptor";
+    internal const string Scout = "scout";
+    internal const string Courier = "courier";
+    internal const string Builder = "builder";
+    internal const string Corvette = "corvette";
+    internal const string Police = "police";
+    internal const string Battleship = "battleship";
+    internal const string Gunboat = "gunboat";
+    internal const string Tug = "tug";
+    internal const string Compactor = "compactor";
+}
+
+internal static class ShipTaxonomyExtensions
+{
+    internal static string ToDataValue(this ShipPurpose purpose) =>
+      purpose switch
+      {
+          ShipPurpose.Auxiliary => "auxiliary",
+          ShipPurpose.Build => "build",
+          ShipPurpose.Fight => "fight",
+          ShipPurpose.Mine => "mine",
+          ShipPurpose.Trade => "trade",
+          _ => purpose.ToString(),
+      };
+
+    internal static string ToDataValue(this ShipType type) =>
+      type switch
+      {
+          ShipType.Resupplier => "resupplier",
+          ShipType.Miner => "miner",
+          ShipType.Carrier => "carrier",
+          ShipType.Fighter => "fighter",
+          ShipType.HeavyFighter => "heavyfighter",
+          ShipType.Destroyer => "destroyer",
+          ShipType.LargeMiner => "largeminer",
+          ShipType.Freighter => "freighter",
+          ShipType.Bomber => "bomber",
+          ShipType.Scavenger => "scavenger",
+          ShipType.Frigate => "frigate",
+          ShipType.Transporter => "transporter",
+          ShipType.Interceptor => "interceptor",
+          ShipType.Scout => "scout",
+          ShipType.Courier => "courier",
+          ShipType.Builder => "builder",
+          ShipType.Corvette => "corvette",
+          ShipType.Police => "police",
+          ShipType.Battleship => "battleship",
+          ShipType.Gunboat => "gunboat",
+          ShipType.Tug => "tug",
+          ShipType.Compactor => "compactor",
+          _ => type.ToString(),
+      };
+}

apps/backend/Shared/Runtime/ShipAutomationCatalog.cs

@@ -0,0 +1,120 @@
+namespace SpaceGame.Api.Shared.Runtime;
+
+public enum ShipAutomationSupportStatus
+{
+    Supported,
+    PartiallySupported,
+    NotSupported,
+    InternalOnly,
+}
+
+public sealed record ShipBehaviorDefinition(
+  string Id,
+  string Label,
+  string Category,
+  ShipAutomationSupportStatus SupportStatus,
+  string Notes);
+
+public sealed record ShipOrderDefinition(
+  string Id,
+  string Label,
+  string Category,
+  ShipAutomationSupportStatus SupportStatus,
+  string Notes);
+
+public static class ShipBehaviorKinds
+{
+    public const string Patrol = "patrol";
+    public const string Police = "police";
+    public const string ProtectPosition = "protect-position";
+    public const string ProtectShip = "protect-ship";
+    public const string ProtectStation = "protect-station";
+
+    public const string LocalAutoMine = "local-auto-mine";
+    public const string AdvancedAutoMine = "advanced-auto-mine";
+    public const string ExpertAutoMine = "expert-auto-mine";
+
+    public const string DockAtStation = "dock-at-station";
+    public const string Move = "move";
+    public const string FlyToObject = "fly-to-object";
+    public const string FollowShip = "follow-ship";
+    public const string HoldPosition = "hold-position";
+
+    public const string AutoSalvage = "auto-salvage";
+
+    public const string LocalAutoTrade = "local-auto-trade";
+    public const string AdvancedAutoTrade = "advanced-auto-trade";
+    public const string FillShortages = "fill-shortages";
+    public const string FindBuildTasks = "find-build-tasks";
+    public const string RevisitKnownStations = "revisit-known-stations";
+    public const string SupplyFleet = "supply-fleet";
+
+    public const string RepeatOrders = "repeat-orders";
+
+    public const string AttackTarget = "attack-target";
+    public const string ConstructStation = "construct-station";
+    public const string Idle = "idle";
+}
+
+public static class ShipAutomationCatalog
+{
+    public static readonly IReadOnlyList<ShipBehaviorDefinition> Behaviors =
+    [
+        new(ShipBehaviorKinds.Patrol, "Patrol", "Combat", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing attack or move orders from the active patrol context."),
+        new(ShipBehaviorKinds.Police, "Police", "Combat", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing attack or follow-ship inspection orders from the active policing context."),
+        new(ShipBehaviorKinds.ProtectPosition, "Protect Position", "Combat", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing attack or move orders from the defended position context."),
+        new(ShipBehaviorKinds.ProtectShip, "Protect Ship", "Combat", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing attack or follow-ship escort orders from the guarded ship context."),
+        new(ShipBehaviorKinds.ProtectStation, "Protect Station", "Combat", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing attack or move guard orders from the defended station context."),
+
+        new(ShipBehaviorKinds.LocalAutoMine, "Local AutoMine", "Mining", ShipAutomationSupportStatus.PartiallySupported, "Queue-backed for solo mining; broader order-generation model still in progress."),
+        new(ShipBehaviorKinds.AdvancedAutoMine, "Advanced AutoMine", "Mining", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing an internal mine-and-deliver run order from the current mining opportunity."),
+        new(ShipBehaviorKinds.ExpertAutoMine, "Expert AutoMine", "Mining", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing an internal mine-and-deliver run order from the current mining opportunity."),
+
+        new(ShipBehaviorKinds.DockAtStation, "Dock At Station", "Navigation", ShipAutomationSupportStatus.Supported, "Queue-backed behavior using the same building-block order as the direct order."),
+        new(ShipBehaviorKinds.Move, "Fly To Position", "Navigation", ShipAutomationSupportStatus.Supported, "Queue-backed behavior using the same building-block order as the direct order."),
+        new(ShipBehaviorKinds.FlyToObject, "Fly To Object", "Navigation", ShipAutomationSupportStatus.Supported, "Queue-backed behavior using the same building-block order as the direct order."),
+        new(ShipBehaviorKinds.FollowShip, "Follow Ship", "Navigation", ShipAutomationSupportStatus.Supported, "Queue-backed behavior using the same building-block order as the direct order."),
+        new(ShipBehaviorKinds.HoldPosition, "Hold Position", "Navigation", ShipAutomationSupportStatus.Supported, "Default baseline behavior; queue-backed behavior order is active."),
+
+        new(ShipBehaviorKinds.AutoSalvage, "AutoSalvage", "Salvage", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing an internal salvage run order for wreck recovery."),
+
+        new(ShipBehaviorKinds.LocalAutoTrade, "Local AutoTrade", "Trade", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing trade-route or dock-at-station orders from the current market context."),
+        new(ShipBehaviorKinds.AdvancedAutoTrade, "Advanced AutoTrade", "Trade", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing trade-route orders from the current market context."),
+        new(ShipBehaviorKinds.FillShortages, "Fill Shortages", "Trade", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing trade-route orders from the current market context."),
+        new(ShipBehaviorKinds.FindBuildTasks, "Find Build Tasks", "Trade", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing construction-support trade routes from the current market context."),
+        new(ShipBehaviorKinds.RevisitKnownStations, "Revisit Known Stations", "Trade", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing trade-route or dock-at-station orders from known-station context."),
+        new(ShipBehaviorKinds.SupplyFleet, "Supply Fleet", "Trade", ShipAutomationSupportStatus.Supported, "Queue-backed behavior synthesizing an internal fleet supply run order."),
+
+        new(ShipBehaviorKinds.RepeatOrders, "Repeat Orders", "Advanced", ShipAutomationSupportStatus.Supported, "Queue-backed behavior generating the current repeat-order template at the bottom of the stack."),
+
+        new(ShipBehaviorKinds.AttackTarget, "Attack Target", "Internal", ShipAutomationSupportStatus.InternalOnly, "Internal gameplay behavior used by current combat/control systems, not an X4 exposed default behavior."),
+        new(ShipBehaviorKinds.ConstructStation, "Construct Station", "Internal", ShipAutomationSupportStatus.InternalOnly, "Internal gameplay behavior used by construction ships."),
+        new(ShipBehaviorKinds.Idle, "Idle", "Internal", ShipAutomationSupportStatus.InternalOnly, "Legacy fallback/internal placeholder; not intended as an exposed player behavior."),
+    ];
+
+    public static readonly IReadOnlyList<ShipOrderDefinition> Orders =
+    [
+        new(ShipOrderKinds.DockAtStation, "Dock At Station", "Navigation", ShipAutomationSupportStatus.PartiallySupported, "Direct order supported in backend."),
+        new(ShipOrderKinds.Move, "Fly To", "Navigation", ShipAutomationSupportStatus.PartiallySupported, "Direct order completes on arrival."),
+        new(ShipOrderKinds.FlyToObject, "Fly To Object", "Navigation", ShipAutomationSupportStatus.PartiallySupported, "Direct order supported in backend."),
+        new(ShipOrderKinds.FollowShip, "Follow Ship", "Navigation", ShipAutomationSupportStatus.PartiallySupported, "Direct order supported in backend."),
+        new(ShipOrderKinds.HoldPosition, "Hold Position", "Navigation", ShipAutomationSupportStatus.Supported, "Direct order supported in backend."),
+
+        new(ShipOrderKinds.AttackTarget, "Attack Target", "Combat", ShipAutomationSupportStatus.PartiallySupported, "Direct order supported in backend."),
+
+        new(ShipOrderKinds.MineAndDeliver, "Mine Resource", "Mining", ShipAutomationSupportStatus.Supported, "Direct order mines the requested ware in the requested system until cargo is full."),
+
+        new(ShipOrderKinds.TradeRoute, "Trade Route", "Trade", ShipAutomationSupportStatus.PartiallySupported, "Direct order supported in backend."),
+
+        new(ShipOrderKinds.BuildAtSite, "Build At Site", "Construction", ShipAutomationSupportStatus.PartiallySupported, "Direct order supported in backend."),
+
+        new(ShipOrderKinds.RepeatOrders, "Repeat Orders", "Advanced", ShipAutomationSupportStatus.PartiallySupported, "Represented today as a behavior plus templates, not a normal one-shot direct order."),
+
+        new(ShipOrderKinds.MineLocal, "Mine Local", "Internal", ShipAutomationSupportStatus.InternalOnly, "Internal queue-backed behavior order for Local AutoMine."),
+        new(ShipOrderKinds.MineAndDeliverRun, "Mine And Deliver Run", "Internal", ShipAutomationSupportStatus.InternalOnly, "Internal queue-backed behavior order for Advanced/Expert AutoMine."),
+        new(ShipOrderKinds.SellMinedCargo, "Sell Mined Cargo", "Internal", ShipAutomationSupportStatus.InternalOnly, "Internal queue-backed behavior order for Local AutoMine."),
+        new(ShipOrderKinds.SupplyFleetRun, "Supply Fleet Run", "Internal", ShipAutomationSupportStatus.InternalOnly, "Internal queue-backed behavior order for Supply Fleet."),
+        new(ShipOrderKinds.SalvageRun, "Salvage Run", "Internal", ShipAutomationSupportStatus.InternalOnly, "Internal queue-backed behavior order for AutoSalvage."),
+        new(ShipOrderKinds.Flee, "Flee", "Internal", ShipAutomationSupportStatus.InternalOnly, "Internal emergency order."),
+    ];
+}

apps/backend/Shared/Runtime/SimulationKinds.cs

@@ -2,276 +2,379 @@ namespace SpaceGame.Api.Shared.Runtime;
 
 public enum SpatialNodeKind
 {
-  Star,
-  Planet,
-  Moon,
-  LagrangePoint,
+    Star,
+    Planet,
+    Moon,
+    LagrangePoint,
+    ResourceNode,
 }
 
 public enum WorkStatus
 {
-  Pending,
-  Active,
-  Blocked,
-  Completed,
-  Failed,
-  Interrupted,
+    Pending,
+    Active,
+    Blocked,
+    Completed,
+    Failed,
+    Interrupted,
 }
 
 public enum OrderStatus
 {
-  Queued,
-  Active,
-  Completed,
-  Cancelled,
-  Failed,
-  Interrupted,
+    Queued,
+    Active,
+    Completed,
+    Cancelled,
+    Failed,
+    Interrupted,
+}
+
+public enum ShipOrderSourceKind
+{
+    Player,
+    Behavior,
+    Commander,
 }
 
 public enum AiPlanStatus
 {
-  Planned,
-  Running,
-  Blocked,
-  Completed,
-  Failed,
-  Interrupted,
-}
-
-public enum AiPlanStepStatus
-{
-  Planned,
-  Running,
-  Blocked,
-  Completed,
-  Failed,
-  Interrupted,
+    Planned,
+    Running,
+    Blocked,
+    Completed,
+    Failed,
+    Interrupted,
 }
 
 public enum AiPlanSourceKind
 {
-  Rule,
-  Order,
-  DefaultBehavior,
+    Rule,
+    Order,
+    DefaultBehavior,
 }
 
 public enum ShipState
 {
-  Idle,
-  Arriving,
-  LocalFlight,
-  SpoolingWarp,
-  Warping,
-  SpoolingFtl,
-  Ftl,
-  CargoFull,
-  MiningApproach,
-  Mining,
-  NodeDepleted,
-  AwaitingDock,
-  DockingApproach,
-  Docking,
-  Docked,
-  Transferring,
-  Loading,
-  Unloading,
-  WaitingMaterials,
-  ConstructionBlocked,
-  Constructing,
-  DeliveringConstruction,
-  Blocked,
-  Undocking,
-  EngagingTarget,
-  HoldingPosition,
-  Fleeing,
+    Idle,
+    Arriving,
+    LocalFlight,
+    SpoolingWarp,
+    Warping,
+    SpoolingFtl,
+    Ftl,
+    CargoFull,
+    MiningApproach,
+    Mining,
+    NodeDepleted,
+    AwaitingDock,
+    DockingApproach,
+    Docking,
+    Docked,
+    Transferring,
+    Loading,
+    Unloading,
+    WaitingMaterials,
+    ConstructionBlocked,
+    Constructing,
+    DeliveringConstruction,
+    Blocked,
+    Undocking,
+    EngagingTarget,
+    HoldingPosition,
+    Fleeing,
 }
 
-public static class SpaceLayerKinds
+public enum SpaceLayerKind
 {
-  public const string UniverseSpace = "universe-space";
-  public const string GalaxySpace = "galaxy-space";
-  public const string SystemSpace = "system-space";
-  public const string LocalSpace = "local-space";
+    UniverseSpace,
+    GalaxySpace,
+    SystemSpace,
+    LocalSpace,
 }
 
-public static class MovementRegimeKinds
+public enum MovementRegimeKind
 {
-  public const string LocalFlight = "local-flight";
-  public const string Warp = "warp";
-  public const string StargateTransit = "stargate-transit";
-  public const string FtlTransit = "ftl-transit";
+    LocalFlight,
+    Warp,
+    StargateTransit,
+    FtlTransit,
+}
+
+public enum ModuleType
+{
+    BuildModule,
+    ConnectionModule,
+    DefenceModule,
+    DockArea,
+    Habitation,
+    Pier,
+    ProcessingModule,
+    Production,
+    Storage,
+}
+
+public enum StorageKind
+{
+    Condensate,
+    Container,
+    Liquid,
+    Solid,
 }
 
 public static class CommanderKind
 {
-  public const string Faction = "faction";
-  public const string Station = "station";
-  public const string Ship = "ship";
-  public const string Fleet = "fleet";
-  public const string Sector = "sector";
-  public const string TaskGroup = "task-group";
+    public const string Faction = "faction";
+    public const string Station = "station";
+    public const string Ship = "ship";
+    public const string Fleet = "fleet";
+    public const string Sector = "sector";
+    public const string TaskGroup = "task-group";
 }
 
 public static class ShipTaskKinds
 {
-  public const string HoldPosition = "hold-position";
-  public const string Travel = "travel";
-  public const string FollowTarget = "follow-target";
-  public const string MineNode = "mine-node";
-  public const string Dock = "dock";
-  public const string Undock = "undock";
-  public const string LoadCargo = "load-cargo";
-  public const string UnloadCargo = "unload-cargo";
-  public const string TransferCargoToShip = "transfer-cargo-to-ship";
-  public const string SalvageWreck = "salvage-wreck";
-  public const string DeliverConstruction = "deliver-construction";
-  public const string ConstructModule = "construct-module";
-  public const string BuildConstructionSite = "build-construction-site";
-  public const string AttackTarget = "attack-target";
-  public const string Flee = "flee";
-  public const string Wait = "wait";
+    public const string HoldPosition = "hold-position";
+    public const string Travel = "travel";
+    public const string FollowTarget = "follow-target";
+    public const string MineNode = "mine-node";
+    public const string Dock = "dock";
+    public const string Undock = "undock";
+    public const string LoadCargo = "load-cargo";
+    public const string UnloadCargo = "unload-cargo";
+    public const string TransferCargoToShip = "transfer-cargo-to-ship";
+    public const string SalvageWreck = "salvage-wreck";
+    public const string DeliverConstruction = "deliver-construction";
+    public const string ConstructModule = "construct-module";
+    public const string BuildConstructionSite = "build-construction-site";
+    public const string AttackTarget = "attack-target";
+    public const string Flee = "flee";
+    public const string Wait = "wait";
 }
 
 public static class ShipOrderKinds
 {
-  public const string Move = "move";
-  public const string DockAtStation = "dock-at-station";
-  public const string DockAndWait = "dock-and-wait";
-  public const string FlyAndWait = "fly-and-wait";
-  public const string FlyToObject = "fly-to-object";
-  public const string FollowShip = "follow-ship";
-  public const string TradeRoute = "trade-route";
-  public const string MineAndDeliver = "mine-and-deliver";
-  public const string BuildAtSite = "build-at-site";
-  public const string AttackTarget = "attack-target";
-  public const string HoldPosition = "hold-position";
-  public const string RepeatOrders = "repeat-orders";
-  public const string Flee = "flee";
+    public const string Move = "move";
+    public const string DockAtStation = "dock-at-station";
+    public const string FlyToObject = "fly-to-object";
+    public const string FollowShip = "follow-ship";
+    public const string TradeRoute = "trade-route";
+    public const string MineAndDeliver = "mine-and-deliver";
+    public const string BuildAtSite = "build-at-site";
+    public const string AttackTarget = "attack-target";
+    public const string HoldPosition = "hold-position";
+    public const string MineLocal = "mine-local";
+    public const string MineAndDeliverRun = "mine-and-deliver-run";
+    public const string SellMinedCargo = "sell-mined-cargo";
+    public const string SupplyFleetRun = "supply-fleet-run";
+    public const string SalvageRun = "salvage-run";
+    public const string RepeatOrders = "repeat-orders";
+    public const string Flee = "flee";
 }
 
 public static class ClaimStateKinds
 {
-  public const string Placed = "placed";
-  public const string Activating = "activating";
-  public const string Active = "active";
-  public const string Destroyed = "destroyed";
+    public const string Placed = "placed";
+    public const string Activating = "activating";
+    public const string Active = "active";
+    public const string Destroyed = "destroyed";
 }
 
 public static class ConstructionSiteStateKinds
 {
-  public const string Planned = "planned";
-  public const string Active = "active";
-  public const string Paused = "paused";
-  public const string Completed = "completed";
-  public const string Destroyed = "destroyed";
+    public const string Planned = "planned";
+    public const string Active = "active";
+    public const string Paused = "paused";
+    public const string Completed = "completed";
+    public const string Destroyed = "destroyed";
 }
 
 public static class MarketOrderKinds
 {
-  public const string Buy = "buy";
-  public const string Sell = "sell";
+    public const string Buy = "buy";
+    public const string Sell = "sell";
 }
 
 public static class MarketOrderStateKinds
 {
-  public const string Open = "open";
-  public const string PartiallyFilled = "partially-filled";
-  public const string Filled = "filled";
-  public const string Cancelled = "cancelled";
+    public const string Open = "open";
+    public const string PartiallyFilled = "partially-filled";
+    public const string Filled = "filled";
+    public const string Cancelled = "cancelled";
 }
 
 public static class SimulationEnumMappings
 {
-  public static string ToContractValue(this SpatialNodeKind kind) => kind switch
-  {
-    SpatialNodeKind.Star => "star",
-    SpatialNodeKind.Planet => "planet",
-    SpatialNodeKind.Moon => "moon",
-    SpatialNodeKind.LagrangePoint => "lagrange-point",
-    _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
-  };
+    public static string ToDataValue(this ModuleType moduleType) => moduleType switch
+    {
+        ModuleType.BuildModule => "buildmodule",
+        ModuleType.ConnectionModule => "connectionmodule",
+        ModuleType.DefenceModule => "defencemodule",
+        ModuleType.DockArea => "dockarea",
+        ModuleType.Habitation => "habitation",
+        ModuleType.Pier => "pier",
+        ModuleType.ProcessingModule => "processingmodule",
+        ModuleType.Production => "production",
+        ModuleType.Storage => "storage",
+        _ => throw new ArgumentOutOfRangeException(nameof(moduleType), moduleType, null),
+    };
 
-  public static string ToContractValue(this WorkStatus status) => status switch
-  {
-    WorkStatus.Pending => "pending",
-    WorkStatus.Active => "active",
-    WorkStatus.Blocked => "blocked",
-    WorkStatus.Completed => "completed",
-    WorkStatus.Failed => "failed",
-    WorkStatus.Interrupted => "interrupted",
-    _ => throw new ArgumentOutOfRangeException(nameof(status), status, null),
-  };
+    public static ModuleType ToModuleType(this string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            throw new ArgumentOutOfRangeException(nameof(value), value, "Module type is required.");
+        }
 
-  public static string ToContractValue(this OrderStatus status) => status switch
-  {
-    OrderStatus.Queued => "queued",
-    OrderStatus.Active => "active",
-    OrderStatus.Completed => "completed",
-    OrderStatus.Cancelled => "cancelled",
-    OrderStatus.Failed => "failed",
-    OrderStatus.Interrupted => "interrupted",
-    _ => throw new ArgumentOutOfRangeException(nameof(status), status, null),
-  };
+        return value.Trim().ToLowerInvariant() switch
+        {
+            "buildmodule" => ModuleType.BuildModule,
+            "connectionmodule" => ModuleType.ConnectionModule,
+            "defencemodule" => ModuleType.DefenceModule,
+            "dockarea" => ModuleType.DockArea,
+            "habitation" => ModuleType.Habitation,
+            "pier" => ModuleType.Pier,
+            "processingmodule" => ModuleType.ProcessingModule,
+            "production" => ModuleType.Production,
+            "storage" => ModuleType.Storage,
+            _ => throw new ArgumentOutOfRangeException(nameof(value), value, "Unsupported module type."),
+        };
+    }
 
-  public static string ToContractValue(this AiPlanStatus status) => status switch
-  {
-    AiPlanStatus.Planned => "planned",
-    AiPlanStatus.Running => "running",
-    AiPlanStatus.Blocked => "blocked",
-    AiPlanStatus.Completed => "completed",
-    AiPlanStatus.Failed => "failed",
-    AiPlanStatus.Interrupted => "interrupted",
-    _ => throw new ArgumentOutOfRangeException(nameof(status), status, null),
-  };
+    public static string ToDataValue(this StorageKind storageKind) => storageKind switch
+    {
+        StorageKind.Condensate => "condensate",
+        StorageKind.Container => "container",
+        StorageKind.Liquid => "liquid",
+        StorageKind.Solid => "solid",
+        _ => throw new ArgumentOutOfRangeException(nameof(storageKind), storageKind, null),
+    };
 
-  public static string ToContractValue(this AiPlanStepStatus status) => status switch
-  {
-    AiPlanStepStatus.Planned => "planned",
-    AiPlanStepStatus.Running => "running",
-    AiPlanStepStatus.Blocked => "blocked",
-    AiPlanStepStatus.Completed => "completed",
-    AiPlanStepStatus.Failed => "failed",
-    AiPlanStepStatus.Interrupted => "interrupted",
-    _ => throw new ArgumentOutOfRangeException(nameof(status), status, null),
-  };
+    public static StorageKind ToStorageKind(this string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            throw new ArgumentOutOfRangeException(nameof(value), value, "Storage kind is required.");
+        }
 
-  public static string ToContractValue(this AiPlanSourceKind kind) => kind switch
-  {
-    AiPlanSourceKind.Rule => "rule",
-    AiPlanSourceKind.Order => "order",
-    AiPlanSourceKind.DefaultBehavior => "default-behavior",
-    _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
-  };
+        return value.Trim().ToLowerInvariant() switch
+        {
+            "condensate" => StorageKind.Condensate,
+            "container" => StorageKind.Container,
+            "liquid" => StorageKind.Liquid,
+            "solid" => StorageKind.Solid,
+            _ => throw new ArgumentOutOfRangeException(nameof(value), value, "Unsupported storage kind."),
+        };
+    }
 
-  public static string ToContractValue(this ShipState state) => state switch
-  {
-    ShipState.Idle => "idle",
-    ShipState.Arriving => "arriving",
-    ShipState.LocalFlight => "local-flight",
-    ShipState.SpoolingWarp => "spooling-warp",
-    ShipState.Warping => "warping",
-    ShipState.SpoolingFtl => "spooling-ftl",
-    ShipState.Ftl => "ftl",
-    ShipState.CargoFull => "cargo-full",
-    ShipState.MiningApproach => "mining-approach",
-    ShipState.Mining => "mining",
-    ShipState.NodeDepleted => "node-depleted",
-    ShipState.AwaitingDock => "awaiting-dock",
-    ShipState.DockingApproach => "docking-approach",
-    ShipState.Docking => "docking",
-    ShipState.Docked => "docked",
-    ShipState.Transferring => "transferring",
-    ShipState.Loading => "loading",
-    ShipState.Unloading => "unloading",
-    ShipState.WaitingMaterials => "waiting-materials",
-    ShipState.ConstructionBlocked => "construction-blocked",
-    ShipState.Constructing => "constructing",
-    ShipState.DeliveringConstruction => "delivering-construction",
-    ShipState.Blocked => "blocked",
-    ShipState.Undocking => "undocking",
-    ShipState.EngagingTarget => "engaging-target",
-    ShipState.HoldingPosition => "holding-position",
-    ShipState.Fleeing => "fleeing",
-    _ => throw new ArgumentOutOfRangeException(nameof(state), state, null),
-  };
+    public static StorageKind? ToNullableStorageKind(this string? value) =>
+        string.IsNullOrWhiteSpace(value) ? null : value.ToStorageKind();
+
+    public static string ToContractValue(this SpatialNodeKind kind) => kind switch
+    {
+        SpatialNodeKind.Star => "star",
+        SpatialNodeKind.Planet => "planet",
+        SpatialNodeKind.Moon => "moon",
+        SpatialNodeKind.LagrangePoint => "lagrange-point",
+        SpatialNodeKind.ResourceNode => "resource-node",
+        _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
+    };
+
+    public static string ToContractValue(this WorkStatus status) => status switch
+    {
+        WorkStatus.Pending => "pending",
+        WorkStatus.Active => "active",
+        WorkStatus.Blocked => "blocked",
+        WorkStatus.Completed => "completed",
+        WorkStatus.Failed => "failed",
+        WorkStatus.Interrupted => "interrupted",
+        _ => throw new ArgumentOutOfRangeException(nameof(status), status, null),
+    };
+
+    public static string ToContractValue(this OrderStatus status) => status switch
+    {
+        OrderStatus.Queued => "queued",
+        OrderStatus.Active => "active",
+        OrderStatus.Completed => "completed",
+        OrderStatus.Cancelled => "cancelled",
+        OrderStatus.Failed => "failed",
+        OrderStatus.Interrupted => "interrupted",
+        _ => throw new ArgumentOutOfRangeException(nameof(status), status, null),
+    };
+
+    public static string ToContractValue(this AiPlanStatus status) => status switch
+    {
+        AiPlanStatus.Planned => "planned",
+        AiPlanStatus.Running => "running",
+        AiPlanStatus.Blocked => "blocked",
+        AiPlanStatus.Completed => "completed",
+        AiPlanStatus.Failed => "failed",
+        AiPlanStatus.Interrupted => "interrupted",
+        _ => throw new ArgumentOutOfRangeException(nameof(status), status, null),
+    };
+
+    public static string ToContractValue(this AiPlanSourceKind kind) => kind switch
+    {
+        AiPlanSourceKind.Rule => "rule",
+        AiPlanSourceKind.Order => "order",
+        AiPlanSourceKind.DefaultBehavior => "default-behavior",
+        _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
+    };
+
+    public static string ToContractValue(this ShipOrderSourceKind kind) => kind switch
+    {
+        ShipOrderSourceKind.Player => "player",
+        ShipOrderSourceKind.Behavior => "behavior",
+        ShipOrderSourceKind.Commander => "commander",
+        _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
+    };
+
+    public static string ToContractValue(this ShipState state) => state switch
+    {
+        ShipState.Idle => "idle",
+        ShipState.Arriving => "arriving",
+        ShipState.LocalFlight => "local-flight",
+        ShipState.SpoolingWarp => "spooling-warp",
+        ShipState.Warping => "warping",
+        ShipState.SpoolingFtl => "spooling-ftl",
+        ShipState.Ftl => "ftl",
+        ShipState.CargoFull => "cargo-full",
+        ShipState.MiningApproach => "mining-approach",
+        ShipState.Mining => "mining",
+        ShipState.NodeDepleted => "node-depleted",
+        ShipState.AwaitingDock => "awaiting-dock",
+        ShipState.DockingApproach => "docking-approach",
+        ShipState.Docking => "docking",
+        ShipState.Docked => "docked",
+        ShipState.Transferring => "transferring",
+        ShipState.Loading => "loading",
+        ShipState.Unloading => "unloading",
+        ShipState.WaitingMaterials => "waiting-materials",
+        ShipState.ConstructionBlocked => "construction-blocked",
+        ShipState.Constructing => "constructing",
+        ShipState.DeliveringConstruction => "delivering-construction",
+        ShipState.Blocked => "blocked",
+        ShipState.Undocking => "undocking",
+        ShipState.EngagingTarget => "engaging-target",
+        ShipState.HoldingPosition => "holding-position",
+        ShipState.Fleeing => "fleeing",
+        _ => throw new ArgumentOutOfRangeException(nameof(state), state, null),
+    };
+
+    public static string ToContractValue(this SpaceLayerKind kind) => kind switch
+    {
+        SpaceLayerKind.UniverseSpace => "universe-space",
+        SpaceLayerKind.GalaxySpace => "galaxy-space",
+        SpaceLayerKind.SystemSpace => "system-space",
+        SpaceLayerKind.LocalSpace => "local-space",
+        _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
+    };
+
+    public static string ToContractValue(this MovementRegimeKind kind) => kind switch
+    {
+        MovementRegimeKind.LocalFlight => "local-flight",
+        MovementRegimeKind.Warp => "warp",
+        MovementRegimeKind.StargateTransit => "stargate-transit",
+        MovementRegimeKind.FtlTransit => "ftl-transit",
+        _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
+    };
 }

apps/backend/Shared/Runtime/SimulationRuntimeSupport.cs

@@ -3,179 +3,298 @@ namespace SpaceGame.Api.Shared.Runtime;
 
 internal static class SimulationRuntimeSupport
 {
-  internal static bool HasShipCapabilities(ShipDefinition definition, params string[] capabilities) =>
-      capabilities.All(cap => definition.Capabilities.Contains(cap, StringComparer.Ordinal));
+    internal static bool CanWarp(ShipDefinition definition) =>
+        definition.Engines.Count > 0;
 
-  internal static int CountStationModules(StationRuntime station, string moduleId) =>
-      station.Modules.Count(module => string.Equals(module.ModuleId, moduleId, StringComparison.Ordinal));
+    internal static bool CanFtl(ShipDefinition definition) =>
+        definition.Engines.Count > 0;
 
-  internal static void AddStationModule(SimulationWorld world, StationRuntime station, string moduleId)
-  {
-    if (!world.ModuleDefinitions.TryGetValue(moduleId, out var definition))
+    internal static bool IsMiningShip(ShipDefinition definition) =>
+        definition.Type is ShipType.Miner or ShipType.LargeMiner;
+
+    internal static bool IsTransportShip(ShipDefinition definition) =>
+        definition.Type is ShipType.Freighter or ShipType.Transporter or ShipType.Courier or ShipType.Resupplier;
+
+    internal static bool IsConstructionShip(ShipDefinition definition) =>
+        definition.Type == ShipType.Builder;
+
+    internal static bool IsMilitaryShip(ShipDefinition definition) =>
+        definition.Type is ShipType.Fighter
+        or ShipType.HeavyFighter
+        or ShipType.Destroyer
+        or ShipType.Bomber
+        or ShipType.Frigate
+        or ShipType.Interceptor
+        or ShipType.Corvette
+        or ShipType.Battleship
+        or ShipType.Gunboat;
+
+    internal static string? GetShipCategory(ShipDefinition definition)
     {
-      return;
+        if (IsMilitaryShip(definition))
+        {
+            return "military";
+        }
+
+        if (IsConstructionShip(definition))
+        {
+            return "construction";
+        }
+
+        if (IsTransportShip(definition))
+        {
+            return "transport";
+        }
+
+        if (IsMiningShip(definition))
+        {
+            return "mining";
+        }
+
+        return null;
     }
 
-    station.Modules.Add(new StationModuleRuntime
+    internal static int CountStationModules(StationRuntime station, ModuleType moduleType) =>
+        station.Modules.Count(module => module.ModuleType == moduleType);
+
+    internal static float GetStationSupportedPopulation(
+        IReadOnlyDictionary<string, ModuleDefinition> moduleDefinitions,
+        StationRuntime station) =>
+        40f + station.Modules
+            .Select(module => moduleDefinitions.TryGetValue(module.ModuleId, out var definition) && definition is HabitationModuleDefinition habitation
+                ? habitation.SupportedPopulation
+                : 0f)
+            .Sum();
+
+    internal static float GetStationRequiredWorkforce(
+        IReadOnlyDictionary<string, ModuleDefinition> moduleDefinitions,
+        StationRuntime station) =>
+        MathF.Max(12f, station.Modules
+            .Select(module => moduleDefinitions.TryGetValue(module.ModuleId, out var definition)
+                && definition is ProductionLaneModuleDefinition productionLane
+                    ? productionLane.RequiredWorkforce
+                : 0f)
+            .Sum());
+
+    internal static float GetStationStorageCapacity(SimulationWorld world, StationRuntime station, StorageKind storageKind)
     {
-      Id = $"{station.Id}-module-{station.Modules.Count + 1}",
-      ModuleId = moduleId,
-      Health = definition.Hull,
-      MaxHealth = definition.Hull,
-    });
-    station.Radius = GetStationRadius(world, station);
-  }
-
-  internal static float GetStationRadius(SimulationWorld world, StationRuntime station)
-  {
-    var totalArea = station.Modules
-      .Select(module => world.ModuleDefinitions.TryGetValue(module.ModuleId, out var definition) ? definition.Radius * definition.Radius : 0f)
-      .Sum();
-    return MathF.Max(24f, MathF.Sqrt(MathF.Max(totalArea, 1f)));
-  }
-
-  internal static float GetStationStorageCapacity(StationRuntime station, string storageClass)
-  {
-    var baseCapacity = storageClass switch
-    {
-      "manufactured" => 400f,
-      _ => 0f,
-    };
-
-    var bulkBays = CountStationModules(station, "module_arg_stor_solid_m_01");
-    var liquidTanks = CountStationModules(station, "module_arg_stor_liquid_m_01");
-    var containerBays = CountStationModules(station, "module_arg_stor_container_m_01");
-
-    var moduleCapacity = storageClass switch
-    {
-      "solid" => bulkBays * 1000f,
-      "liquid" => liquidTanks * 500f,
-      "container" => containerBays * 800f,
-      "manufactured" => containerBays * 200f,
-      _ => 0f,
-    };
-
-    return baseCapacity + moduleCapacity;
-  }
-
-  internal static int CountModules(IEnumerable<string> modules, string moduleId) =>
-      modules.Count(candidate => string.Equals(candidate, moduleId, StringComparison.Ordinal));
-
-  internal static float GetInventoryAmount(IReadOnlyDictionary<string, float> inventory, string itemId) =>
-      inventory.TryGetValue(itemId, out var amount) ? amount : 0f;
-
-  internal static void AddInventory(IDictionary<string, float> inventory, string itemId, float amount)
-  {
-    if (amount <= 0f)
-    {
-      return;
+        SyncStorageModuleLevels(world, station, storageKind);
+        return GetStorageModules(world, station, storageKind)
+            .Sum(entry => entry.Definition.StorageCapacity);
     }
 
-    inventory[itemId] = GetInventoryAmount((IReadOnlyDictionary<string, float>)inventory, itemId) + amount;
-  }
-
-  internal static float RemoveInventory(IDictionary<string, float> inventory, string itemId, float amount)
-  {
-    var current = GetInventoryAmount((IReadOnlyDictionary<string, float>)inventory, itemId);
-    var removed = MathF.Min(current, amount);
-    var remaining = current - removed;
-    if (remaining <= 0.001f)
+    internal static bool HasStorageCapacity(SimulationWorld world, StationRuntime station, StorageKind storageKind)
     {
-      inventory.Remove(itemId);
-    }
-    else
-    {
-      inventory[itemId] = remaining;
+        SyncStorageModuleLevels(world, station, storageKind);
+        return GetStorageModules(world, station, storageKind).Any();
     }
 
-    return removed;
-  }
+    private static IEnumerable<(StorageStationModuleRuntime Module, StorageModuleDefinition Definition)> GetStorageModules(
+        SimulationWorld world,
+        StationRuntime station,
+        StorageKind storageKind) =>
+        station.Modules
+            .OfType<StorageStationModuleRuntime>()
+            .Where(module => module.StorageKind == storageKind)
+            .Select(module => world.ModuleDefinitions.TryGetValue(module.ModuleId, out var definition) && definition is StorageModuleDefinition storageDefinition
+                ? (Module: module, Definition: storageDefinition)
+                : ((StorageStationModuleRuntime Module, StorageModuleDefinition Definition)?)null)
+            .Where(entry => entry is not null && entry.Value.Definition.StorageKind == storageKind)
+            .Select(entry => entry!.Value);
 
-  internal static bool HasStationModules(StationRuntime station, params string[] modules) =>
-      modules.All(moduleId => station.Modules.Any(candidate => string.Equals(candidate.ModuleId, moduleId, StringComparison.Ordinal)));
-
-  internal static bool CanExtractNode(ShipRuntime ship, ResourceNodeRuntime node, SimulationWorld world) =>
-      HasShipCapabilities(ship.Definition, "mining")
-      && world.ItemDefinitions.TryGetValue(node.ItemId, out var item)
-      && string.Equals(item.CargoKind, ship.Definition.CargoKind, StringComparison.Ordinal);
-
-  internal static bool CanBuildClaimBeacon(ShipRuntime ship) =>
-      string.Equals(ship.Definition.Kind, "military", StringComparison.Ordinal);
-
-  internal static float ComputeWorkforceRatio(float population, float workforceRequired)
-  {
-    if (workforceRequired <= 0.01f)
+    private static void SyncStorageModuleLevels(SimulationWorld world, StationRuntime station, StorageKind storageKind)
     {
-      return 1f;
+        var storageModules = GetStorageModules(world, station, storageKind)
+            .OrderBy(entry => entry.Module.Id, StringComparer.Ordinal)
+            .ToList();
+        if (storageModules.Count == 0)
+        {
+            return;
+        }
+
+        var remaining = station.Inventory
+            .Where(entry => world.ItemDefinitions.TryGetValue(entry.Key, out var definition) && definition.CargoKind == storageKind)
+            .Sum(entry => entry.Value);
+
+        foreach (var (module, definition) in storageModules)
+        {
+            module.CurrentLevel = MathF.Min(remaining, definition.StorageCapacity);
+            remaining = MathF.Max(0f, remaining - definition.StorageCapacity);
+        }
     }
 
-    var staffedRatio = MathF.Min(1f, population / workforceRequired);
-    return 0.1f + (0.9f * staffedRatio);
-  }
-
-  internal static string? GetStorageRequirement(string storageClass) =>
-      storageClass switch
-      {
-        "solid" => "module_arg_stor_solid_m_01",
-        "liquid" => "module_arg_stor_liquid_m_01",
-        _ => null,
-      };
-
-  internal static float TryAddStationInventory(SimulationWorld world, StationRuntime station, string itemId, float amount)
-  {
-    if (amount <= 0f || !world.ItemDefinitions.TryGetValue(itemId, out var itemDefinition))
+    internal static void AddStationModule(SimulationWorld world, StationRuntime station, string moduleId)
     {
-      return 0f;
+        if (!world.ModuleDefinitions.TryGetValue(moduleId, out var definition))
+        {
+            return;
+        }
+
+        station.Modules.Add(StationModuleRuntime.Create($"{station.Id}-module-{station.Modules.Count + 1}", definition));
+        station.Radius = GetStationRadius(world, station);
     }
 
-    var storageClass = itemDefinition.CargoKind;
-    var requiredModule = GetStorageRequirement(storageClass);
-    if (requiredModule is not null && !station.InstalledModules.Contains(requiredModule, StringComparer.Ordinal))
+    internal static float GetStationRadius(SimulationWorld world, StationRuntime station)
     {
-      return 0f;
+        var totalArea = station.Modules
+          .Select(module => world.ModuleDefinitions.TryGetValue(module.ModuleId, out var definition) ? definition.Radius * definition.Radius : 0f)
+          .Sum();
+        return MathF.Max(24f, MathF.Sqrt(MathF.Max(totalArea, 1f)));
     }
 
-    var capacity = GetStationStorageCapacity(station, storageClass);
-    if (capacity <= 0.01f)
+    internal static int CountModules(IEnumerable<string> modules, string moduleId) =>
+        modules.Count(candidate => string.Equals(candidate, moduleId, StringComparison.Ordinal));
+
+    internal static float GetInventoryAmount(IReadOnlyDictionary<string, float> inventory, string itemId) =>
+        inventory.TryGetValue(itemId, out var amount) ? amount : 0f;
+
+    internal static void AddInventory(IDictionary<string, float> inventory, string itemId, float amount)
     {
-      return 0f;
+        if (amount <= 0f)
+        {
+            return;
+        }
+
+        inventory[itemId] = GetInventoryAmount((IReadOnlyDictionary<string, float>)inventory, itemId) + amount;
     }
 
-    var used = station.Inventory
-        .Where(entry => world.ItemDefinitions.TryGetValue(entry.Key, out var definition) && definition.CargoKind == storageClass)
-        .Sum(entry => entry.Value);
-    var accepted = MathF.Min(amount, MathF.Max(0f, capacity - used));
-    if (accepted <= 0.01f)
+    internal static float RemoveInventory(IDictionary<string, float> inventory, string itemId, float amount)
     {
-      return 0f;
+        var current = GetInventoryAmount((IReadOnlyDictionary<string, float>)inventory, itemId);
+        var removed = MathF.Min(current, amount);
+        var remaining = current - removed;
+        if (remaining <= 0.001f)
+        {
+            inventory.Remove(itemId);
+        }
+        else
+        {
+            inventory[itemId] = remaining;
+        }
+
+        return removed;
     }
 
-    AddInventory(station.Inventory, itemId, accepted);
-    return accepted;
-  }
+    internal static bool HasStationModules(StationRuntime station, params string[] modules) =>
+        modules.All(moduleId => station.Modules.Any(candidate => string.Equals(candidate.ModuleId, moduleId, StringComparison.Ordinal)));
 
-  internal static bool CanStartModuleConstruction(StationRuntime station, ModuleRecipeDefinition recipe) =>
-      recipe.Inputs.All(input => GetInventoryAmount(station.Inventory, input.ItemId) + 0.001f >= input.Amount);
+    internal static bool CanExtractNode(ShipRuntime ship, ResourceNodeRuntime node, SimulationWorld world) =>
+        IsMiningShip(ship.Definition)
+        && world.ItemDefinitions.TryGetValue(node.ItemId, out var item)
+        && item.CargoKind is not null
+        && ship.Definition.SupportsCargoKind(item.CargoKind.Value);
 
-  internal static ConstructionSiteRuntime? GetConstructionSiteForStation(SimulationWorld world, string stationId) =>
-      world.ConstructionSites.FirstOrDefault(site =>
-          string.Equals(site.StationId, stationId, StringComparison.Ordinal)
-          && site.State is not ConstructionSiteStateKinds.Completed and not ConstructionSiteStateKinds.Destroyed);
+    internal static bool CanBuildClaimBeacon(ShipRuntime ship) =>
+        IsMilitaryShip(ship.Definition);
 
-  internal static float GetConstructionDeliveredAmount(SimulationWorld world, ConstructionSiteRuntime site, string itemId)
-  {
-    if (site.StationId is not null
-        && world.Stations.FirstOrDefault(candidate => candidate.Id == site.StationId) is { } station)
+    internal static float ComputeWorkforceRatio(float population, float workforceRequired)
     {
-      return GetInventoryAmount(station.Inventory, itemId);
+        if (workforceRequired <= 0.01f)
+        {
+            return 1f;
+        }
+
+        var staffedRatio = MathF.Min(1f, population / workforceRequired);
+        return 0.1f + (0.9f * staffedRatio);
     }
 
-    return GetInventoryAmount(site.DeliveredItems, itemId);
-  }
+    internal static string? GetStorageRequirement(
+        IReadOnlyDictionary<string, ModuleDefinition> moduleDefinitions,
+        StorageKind? storageKind)
+    {
+        if (storageKind is not { } requiredStorageKind)
+        {
+            return null;
+        }
 
-  internal static bool IsConstructionSiteReady(SimulationWorld world, ConstructionSiteRuntime site) =>
-      site.RequiredItems.All(entry => GetConstructionDeliveredAmount(world, site, entry.Key) + 0.001f >= entry.Value);
+        return moduleDefinitions.Values
+            .OfType<StorageModuleDefinition>()
+            .Where(definition => definition.StorageKind == requiredStorageKind)
+            .OrderBy(definition => GetPreferredStorageModuleRank(definition.Id))
+            .ThenBy(definition => definition.Id, StringComparer.Ordinal)
+            .Select(definition => definition.Id)
+            .FirstOrDefault();
+    }
 
-  internal static float GetShipCargoAmount(ShipRuntime ship) =>
-    ship.Inventory.Values.Sum();
+    private static int GetPreferredStorageModuleRank(string moduleId)
+    {
+        if (moduleId.Contains("_m_", StringComparison.Ordinal))
+        {
+            return 0;
+        }
+
+        if (moduleId.Contains("_s_", StringComparison.Ordinal))
+        {
+            return 1;
+        }
+
+        if (moduleId.Contains("_l_", StringComparison.Ordinal))
+        {
+            return 2;
+        }
+
+        return 3;
+    }
+
+    internal static float TryAddStationInventory(SimulationWorld world, StationRuntime station, string itemId, float amount)
+    {
+        if (amount <= 0f || !world.ItemDefinitions.TryGetValue(itemId, out var itemDefinition))
+        {
+            return 0f;
+        }
+
+        var storageKind = itemDefinition.CargoKind;
+        if (storageKind is null)
+        {
+            return 0f;
+        }
+
+        if (!HasStorageCapacity(world, station, storageKind.Value))
+        {
+            return 0f;
+        }
+
+        var capacity = GetStationStorageCapacity(world, station, storageKind.Value);
+        if (capacity <= 0.01f)
+        {
+            return 0f;
+        }
+
+        var used = station.Inventory
+            .Where(entry => world.ItemDefinitions.TryGetValue(entry.Key, out var definition) && definition.CargoKind == storageKind)
+            .Sum(entry => entry.Value);
+        var accepted = MathF.Min(amount, MathF.Max(0f, capacity - used));
+        if (accepted <= 0.01f)
+        {
+            return 0f;
+        }
+
+        AddInventory(station.Inventory, itemId, accepted);
+        return accepted;
+    }
+
+    internal static bool CanStartModuleConstruction(StationRuntime station, ModuleRecipeDefinition recipe) =>
+        recipe.Inputs.All(input => GetInventoryAmount(station.Inventory, input.ItemId) + 0.001f >= input.Amount);
+
+    internal static ConstructionSiteRuntime? GetConstructionSiteForStation(SimulationWorld world, string stationId) =>
+        world.ConstructionSites.FirstOrDefault(site =>
+            string.Equals(site.StationId, stationId, StringComparison.Ordinal)
+            && site.State is not ConstructionSiteStateKinds.Completed and not ConstructionSiteStateKinds.Destroyed);
+
+    internal static float GetConstructionDeliveredAmount(SimulationWorld world, ConstructionSiteRuntime site, string itemId)
+    {
+        if (site.StationId is not null
+            && world.Stations.FirstOrDefault(candidate => candidate.Id == site.StationId) is { } station)
+        {
+            return GetInventoryAmount(station.Inventory, itemId);
+        }
+
+        return GetInventoryAmount(site.DeliveredItems, itemId);
+    }
+
+    internal static bool IsConstructionSiteReady(SimulationWorld world, ConstructionSiteRuntime site) =>
+        site.RequiredItems.All(entry => GetConstructionDeliveredAmount(world, site, entry.Key) + 0.001f >= entry.Value);
+
+    internal static float GetShipCargoAmount(ShipRuntime ship) =>
+      ship.Inventory.Values.Sum();
 }

apps/backend/Shared/Runtime/SimulationUnits.cs

@@ -7,6 +7,22 @@ public static class SimulationUnits
 
     public static float AuToKilometers(float au) => au * KilometersPerAu;
 
+    public static float KilometersToMeters(float kilometers) => kilometers * MetersPerKilometer;
+
+    public static float MetersToKilometers(float meters) => meters / MetersPerKilometer;
+
+    public static Vector3 KilometersToMeters(Vector3 kilometers) =>
+        new(
+            KilometersToMeters(kilometers.X),
+            KilometersToMeters(kilometers.Y),
+            KilometersToMeters(kilometers.Z));
+
+    public static Vector3 MetersToKilometers(Vector3 meters) =>
+        new(
+            MetersToKilometers(meters.X),
+            MetersToKilometers(meters.Y),
+            MetersToKilometers(meters.Z));
+
     public static float AuPerSecondToKilometersPerSecond(float auPerSecond) =>
         auPerSecond * KilometersPerAu;
 

apps/backend/Ships/AI/ShipAiService.BehaviorQueue.cs

@@ -0,0 +1,762 @@
+using static SpaceGame.Api.Shared.Runtime.SimulationRuntimeSupport;
+using static SpaceGame.Api.Shared.Runtime.ShipBehaviorKinds;
+using static SpaceGame.Api.Stations.Simulation.InfrastructureSimulationService;
+
+namespace SpaceGame.Api.Ships.AI;
+
+public sealed partial class ShipAiService
+{
+    private void SyncBehaviorOrders(SimulationWorld world, ShipRuntime ship)
+    {
+        var desiredOrder = BuildManagedBehaviorOrder(world, ship);
+        ship.OrderQueue.RemoveWhere(order =>
+            order.SourceKind == ShipOrderSourceKind.Behavior
+            && order.Id.StartsWith("behavior-", StringComparison.Ordinal)
+            && (desiredOrder is null || !string.Equals(order.Id, desiredOrder.Id, StringComparison.Ordinal)));
+
+        if (desiredOrder is null)
+        {
+            return;
+        }
+
+        var existing = ship.OrderQueue.FindById(desiredOrder.Id);
+        if (existing is null)
+        {
+            ship.OrderQueue.AddOrReplaceManagedOrder(desiredOrder);
+            return;
+        }
+
+        if (ManagedOrdersEqual(existing, desiredOrder))
+        {
+            return;
+        }
+
+        ship.OrderQueue.AddOrReplaceManagedOrder(desiredOrder);
+    }
+
+    private ShipOrderRuntime? BuildManagedBehaviorOrder(SimulationWorld world, ShipRuntime ship)
+    {
+        var assignment = ResolveAssignment(world, ship);
+        var behaviorKind = assignment?.BehaviorKind ?? ship.DefaultBehavior.Kind;
+        var systemId = assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? ship.SystemId;
+
+        if (string.Equals(behaviorKind, HoldPosition, StringComparison.Ordinal))
+        {
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-hold-position",
+                Kind = ShipOrderKinds.HoldPosition,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = "Hold position",
+                TargetSystemId = systemId,
+                TargetPosition = ship.DefaultBehavior.TargetPosition ?? ship.Position,
+                WaitSeconds = MathF.Max(2f, ship.DefaultBehavior.WaitSeconds),
+                Radius = ship.DefaultBehavior.Radius,
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, DockAtStation, StringComparison.Ordinal))
+        {
+            var station = ResolveStation(world, assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId ?? ship.DefaultBehavior.HomeStationId);
+            if (station is null)
+            {
+                ship.LastAccessFailureReason = "station-missing";
+                return null;
+            }
+
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-dock-at-station",
+                Kind = ShipOrderKinds.DockAtStation,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = $"Dock at {station.Label}",
+                TargetEntityId = station.Id,
+                TargetSystemId = station.SystemId,
+                DestinationStationId = station.Id,
+                Radius = ship.DefaultBehavior.Radius,
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, Move, StringComparison.Ordinal))
+        {
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-move",
+                Kind = ShipOrderKinds.Move,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = "Fly to position",
+                TargetSystemId = systemId,
+                TargetPosition = ship.DefaultBehavior.TargetPosition ?? ship.Position,
+                Radius = ship.DefaultBehavior.Radius,
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, FollowShip, StringComparison.Ordinal))
+        {
+            var targetShip = world.Ships.FirstOrDefault(candidate =>
+                candidate.Id == (assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId)
+                && candidate.Health > 0f);
+            if (targetShip is null)
+            {
+                ship.LastAccessFailureReason = "target-ship-missing";
+                return null;
+            }
+
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-follow-ship",
+                Kind = ShipOrderKinds.FollowShip,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = $"Follow {targetShip.Definition.Name}",
+                TargetEntityId = targetShip.Id,
+                TargetSystemId = targetShip.SystemId,
+                WaitSeconds = MathF.Max(2f, ship.DefaultBehavior.WaitSeconds),
+                Radius = MathF.Max(16f, ship.DefaultBehavior.Radius),
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, FlyToObject, StringComparison.Ordinal))
+        {
+            var targetEntityId = assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId;
+            var target = ResolveObjectTarget(world, targetEntityId);
+            if (target is null)
+            {
+                ship.LastAccessFailureReason = "target-missing";
+                return null;
+            }
+
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-fly-to-object",
+                Kind = ShipOrderKinds.FlyToObject,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = "Fly to object",
+                TargetEntityId = targetEntityId,
+                TargetSystemId = target.Value.SystemId,
+                TargetPosition = target.Value.Position,
+                WaitSeconds = MathF.Max(1f, ship.DefaultBehavior.WaitSeconds),
+                Radius = MathF.Max(8f, ship.DefaultBehavior.Radius),
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, Patrol, StringComparison.Ordinal))
+        {
+            return BuildManagedPatrolOrder(world, ship, assignment, behaviorKind);
+        }
+
+        if (string.Equals(behaviorKind, AttackTarget, StringComparison.Ordinal))
+        {
+            var targetEntityId = assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId;
+            if (string.IsNullOrWhiteSpace(targetEntityId))
+            {
+                return BuildManagedPatrolOrder(world, ship, assignment, behaviorKind);
+            }
+
+            var target = ResolveObjectTarget(world, targetEntityId);
+            ship.LastAccessFailureReason = target is null ? "target-missing" : null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-attack-target",
+                Kind = ShipOrderKinds.AttackTarget,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = "Attack target",
+                TargetEntityId = targetEntityId,
+                TargetSystemId = target?.SystemId ?? assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? ship.SystemId,
+                TargetPosition = target?.Position ?? ship.Position,
+                WaitSeconds = 0f,
+                Radius = 26f,
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, ConstructStation, StringComparison.Ordinal))
+        {
+            var site = world.ConstructionSites.FirstOrDefault(candidate => candidate.Id == (assignment?.TargetEntityId ?? ship.DefaultBehavior.PreferredConstructionSiteId))
+              ?? world.ConstructionSites
+                .Where(candidate => candidate.FactionId == ship.FactionId && candidate.State is ConstructionSiteStateKinds.Active or ConstructionSiteStateKinds.Planned)
+                .OrderBy(candidate => candidate.Id, StringComparer.Ordinal)
+                .FirstOrDefault();
+            if (site is null)
+            {
+                ship.LastAccessFailureReason = "no-construction-site";
+                return null;
+            }
+
+            if (ResolveSupportStation(world, ship, site) is null)
+            {
+                ship.LastAccessFailureReason = "support-station-missing";
+                return null;
+            }
+
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-construct-station",
+                Kind = ShipOrderKinds.BuildAtSite,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = $"Build {site.BlueprintId}",
+                TargetEntityId = site.Id,
+                TargetSystemId = site.SystemId,
+                ConstructionSiteId = site.Id,
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, AdvancedAutoMine, StringComparison.Ordinal)
+            || string.Equals(behaviorKind, ExpertAutoMine, StringComparison.Ordinal))
+        {
+            var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
+            if (homeStation is null)
+            {
+                ship.LastAccessFailureReason = "no-home-station";
+                return null;
+            }
+
+            var opportunity = SelectMiningOpportunity(world, ship, homeStation, assignment, behaviorKind);
+            if (opportunity is null)
+            {
+                ship.LastAccessFailureReason = "no-mineable-node";
+                return null;
+            }
+
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-{behaviorKind}-mine-and-deliver",
+                Kind = ShipOrderKinds.MineAndDeliverRun,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = opportunity.Summary,
+                TargetEntityId = opportunity.Node.Id,
+                TargetSystemId = opportunity.Node.SystemId,
+                DestinationStationId = opportunity.DropOffStation.Id,
+                ItemId = opportunity.Node.ItemId,
+                AnchorId = opportunity.Node.AnchorId,
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, ProtectPosition, StringComparison.Ordinal))
+        {
+            var targetSystemId = assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? ship.SystemId;
+            var targetPosition = ship.DefaultBehavior.TargetPosition ?? assignment?.TargetPosition ?? ship.Position;
+            var threat = SelectThreatTarget(world, ship, targetSystemId, targetPosition, MathF.Max(90f, ship.DefaultBehavior.Radius));
+            if (threat is not null)
+            {
+                ship.LastAccessFailureReason = null;
+                return CreateManagedAttackOrder(ship, behaviorKind, "Protect position", threat.EntityId, threat.SystemId, threat.Position);
+            }
+
+            ship.LastAccessFailureReason = null;
+            return CreateManagedMoveOrder(
+                ship,
+                behaviorKind,
+                "Protect position",
+                targetSystemId,
+                targetPosition,
+                MathF.Max(6f, ship.DefaultBehavior.Radius));
+        }
+
+        if (string.Equals(behaviorKind, ProtectShip, StringComparison.Ordinal))
+        {
+            var guardTarget = world.Ships.FirstOrDefault(candidate =>
+                candidate.Id == (assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId)
+                && candidate.Health > 0f);
+            if (guardTarget is null)
+            {
+                return BuildManagedPatrolOrder(world, ship, assignment, Patrol);
+            }
+
+            var threat = SelectThreatTarget(
+                world,
+                ship,
+                guardTarget.SystemId,
+                guardTarget.Position,
+                MathF.Max(90f, ship.DefaultBehavior.Radius),
+                excludeEntityId: guardTarget.Id);
+            if (threat is not null)
+            {
+                ship.LastAccessFailureReason = null;
+                return CreateManagedAttackOrder(ship, behaviorKind, $"Protect {guardTarget.Definition.Name}", threat.EntityId, threat.SystemId, threat.Position);
+            }
+
+            ship.LastAccessFailureReason = null;
+            return CreateManagedFollowShipOrder(
+                ship,
+                behaviorKind,
+                $"Escort {guardTarget.Definition.Name}",
+                guardTarget,
+                MathF.Max(18f, ship.DefaultBehavior.Radius * 0.5f),
+                MathF.Max(2f, ship.DefaultBehavior.WaitSeconds));
+        }
+
+        if (string.Equals(behaviorKind, ProtectStation, StringComparison.Ordinal))
+        {
+            var station = ResolveStation(world, assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId ?? assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
+            if (station is null)
+            {
+                return BuildManagedPatrolOrder(world, ship, assignment, Patrol);
+            }
+
+            var threat = SelectThreatTarget(world, ship, station.SystemId, station.Position, MathF.Max(station.Radius + 80f, ship.DefaultBehavior.Radius));
+            if (threat is not null)
+            {
+                ship.LastAccessFailureReason = null;
+                return CreateManagedAttackOrder(ship, behaviorKind, $"Protect {station.Label}", threat.EntityId, threat.SystemId, threat.Position);
+            }
+
+            ship.LastAccessFailureReason = null;
+            return CreateManagedMoveOrder(
+                ship,
+                behaviorKind,
+                $"Guard {station.Label}",
+                station.SystemId,
+                GetFormationPosition(station.Position, ship.Id, MathF.Max(station.Radius + 18f, ship.DefaultBehavior.Radius)),
+                MathF.Max(6f, ship.DefaultBehavior.Radius));
+        }
+
+        if (string.Equals(behaviorKind, Police, StringComparison.Ordinal))
+        {
+            var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
+            var policeSystemId = assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? homeStation?.SystemId ?? ship.SystemId;
+            var areaPosition = homeStation?.Position ?? ship.DefaultBehavior.TargetPosition ?? ship.Position;
+            var contact = SelectPoliceContact(world, ship, policeSystemId, areaPosition, MathF.Max(80f, ship.DefaultBehavior.Radius));
+            if (contact is null)
+            {
+                return BuildManagedPatrolOrder(world, ship, assignment, Patrol);
+            }
+
+            ship.LastAccessFailureReason = null;
+            return contact.Engage
+                ? CreateManagedAttackOrder(ship, behaviorKind, "Police engage", contact.EntityId, contact.SystemId, contact.Position)
+                : CreateManagedFollowTargetOrder(ship, behaviorKind, "Police inspect", contact.EntityId, contact.SystemId, contact.Position, MathF.Max(14f, ship.DefaultBehavior.Radius * 0.5f), MathF.Max(2f, ship.DefaultBehavior.WaitSeconds));
+        }
+
+        if (string.Equals(behaviorKind, LocalAutoTrade, StringComparison.Ordinal)
+            || string.Equals(behaviorKind, AdvancedAutoTrade, StringComparison.Ordinal)
+            || string.Equals(behaviorKind, FillShortages, StringComparison.Ordinal)
+            || string.Equals(behaviorKind, FindBuildTasks, StringComparison.Ordinal)
+            || string.Equals(behaviorKind, RevisitKnownStations, StringComparison.Ordinal))
+        {
+            var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
+            var route = SelectTradeRoute(world, ship, homeStation, behaviorKind, ship.DefaultBehavior.KnownStationsOnly);
+            if (route is not null)
+            {
+                ship.LastAccessFailureReason = null;
+                return CreateManagedTradeRouteOrder(ship, behaviorKind, route);
+            }
+
+            if (string.Equals(behaviorKind, RevisitKnownStations, StringComparison.Ordinal)
+                && SelectKnownStationVisit(world, ship, homeStation) is { } visitStation)
+            {
+                ship.LastAccessFailureReason = null;
+                return CreateManagedDockAtStationOrder(ship, behaviorKind, visitStation, $"Revisit {visitStation.Label}");
+            }
+
+            ship.LastAccessFailureReason = "no-trade-route";
+            return null;
+        }
+
+        if (string.Equals(behaviorKind, SupplyFleet, StringComparison.Ordinal))
+        {
+            var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
+            var plan = SelectFleetSupplyPlan(world, ship, homeStation);
+            if (plan is null)
+            {
+                ship.LastAccessFailureReason = "no-fleet-to-supply";
+                return null;
+            }
+
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-supply-fleet",
+                Kind = ShipOrderKinds.SupplyFleetRun,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = plan.Summary,
+                TargetEntityId = plan.TargetShip.Id,
+                TargetSystemId = plan.TargetShip.SystemId,
+                SourceStationId = plan.SourceStation.Id,
+                ItemId = plan.ItemId,
+                Radius = plan.Radius,
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, AutoSalvage, StringComparison.Ordinal))
+        {
+            var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
+            if (homeStation is null)
+            {
+                ship.LastAccessFailureReason = "no-home-station";
+                return null;
+            }
+
+            var salvage = SelectSalvageOpportunity(world, ship, homeStation);
+            if (salvage is null)
+            {
+                ship.LastAccessFailureReason = "no-salvage-target";
+                return null;
+            }
+
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-auto-salvage",
+                Kind = ShipOrderKinds.SalvageRun,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = salvage.Summary,
+                TargetEntityId = salvage.Wreck.Id,
+                TargetSystemId = salvage.Wreck.SystemId,
+                TargetPosition = salvage.Wreck.Position,
+                SourceStationId = homeStation.Id,
+                ItemId = salvage.Wreck.ItemId,
+                Radius = MathF.Max(8f, ship.DefaultBehavior.Radius * 0.25f),
+                MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        if (string.Equals(behaviorKind, RepeatOrders, StringComparison.Ordinal))
+        {
+            if (ship.DefaultBehavior.RepeatOrders.Count == 0)
+            {
+                ship.LastAccessFailureReason = "no-repeat-orders";
+                return null;
+            }
+
+            var template = ship.DefaultBehavior.RepeatOrders[ship.DefaultBehavior.RepeatIndex % ship.DefaultBehavior.RepeatOrders.Count];
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-repeat-{ship.DefaultBehavior.RepeatIndex}",
+                Kind = template.Kind,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = template.Label,
+                TargetEntityId = template.TargetEntityId,
+                TargetSystemId = template.TargetSystemId,
+                TargetPosition = template.TargetPosition,
+                SourceStationId = template.SourceStationId,
+                DestinationStationId = template.DestinationStationId,
+                ItemId = template.ItemId,
+                AnchorId = template.AnchorId,
+                ConstructionSiteId = template.ConstructionSiteId,
+                ModuleId = template.ModuleId,
+                WaitSeconds = template.WaitSeconds,
+                Radius = template.Radius,
+                MaxSystemRange = template.MaxSystemRange ?? ship.DefaultBehavior.MaxSystemRange,
+                KnownStationsOnly = template.KnownStationsOnly,
+            };
+        }
+
+        if (!string.Equals(behaviorKind, LocalAutoMine, StringComparison.Ordinal))
+        {
+            return null;
+        }
+
+        var itemId = assignment?.ItemId ?? ship.DefaultBehavior.ItemId;
+        if (string.IsNullOrWhiteSpace(itemId))
+        {
+            ship.LastAccessFailureReason = "missing-item";
+            return null;
+        }
+
+        if (GetShipCargoAmount(ship) >= ship.Definition.GetTotalCargoCapacity() - 0.01f)
+        {
+            var buyer = SelectLocalAutoMineBuyer(world, ship, systemId, itemId);
+            if (buyer is null)
+            {
+                ship.LastAccessFailureReason = "no-suitable-buyer";
+                return null;
+            }
+
+            ship.LastAccessFailureReason = null;
+            return new ShipOrderRuntime
+            {
+                Id = $"behavior-{ship.Id}-local-auto-mine-sell",
+                Kind = ShipOrderKinds.SellMinedCargo,
+                SourceKind = ShipOrderSourceKind.Behavior,
+                SourceId = behaviorKind,
+                Priority = 0,
+                InterruptCurrentPlan = false,
+                Label = $"Sell {itemId} in {systemId}",
+                TargetEntityId = buyer.Id,
+                TargetSystemId = buyer.SystemId,
+                DestinationStationId = buyer.Id,
+                ItemId = itemId,
+                WaitSeconds = 0f,
+                Radius = 0f,
+                MaxSystemRange = 0,
+                KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+            };
+        }
+
+        var node = SelectLocalMiningNode(world, ship, systemId, itemId, ship.DefaultBehavior.PreferredAnchorId);
+        if (node is null)
+        {
+            ship.LastAccessFailureReason = "no-mineable-node";
+            return null;
+        }
+
+        ship.LastAccessFailureReason = null;
+        return new ShipOrderRuntime
+        {
+            Id = $"behavior-{ship.Id}-local-auto-mine-mine",
+            Kind = ShipOrderKinds.MineLocal,
+            SourceKind = ShipOrderSourceKind.Behavior,
+            SourceId = behaviorKind,
+            Priority = 0,
+            InterruptCurrentPlan = false,
+            Label = $"Mine {itemId} in {systemId}",
+            TargetEntityId = node.Id,
+            TargetSystemId = node.SystemId,
+            AnchorId = node.AnchorId,
+            ItemId = node.ItemId,
+            WaitSeconds = 0f,
+            Radius = 0f,
+            MaxSystemRange = 0,
+            KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+        };
+    }
+
+    private static bool ManagedOrdersEqual(ShipOrderRuntime left, ShipOrderRuntime right) =>
+      string.Equals(left.Id, right.Id, StringComparison.Ordinal)
+      && string.Equals(left.Kind, right.Kind, StringComparison.Ordinal)
+      && left.SourceKind == right.SourceKind
+      && string.Equals(left.SourceId, right.SourceId, StringComparison.Ordinal)
+      && left.Priority == right.Priority
+      && left.InterruptCurrentPlan == right.InterruptCurrentPlan
+      && string.Equals(left.Label, right.Label, StringComparison.Ordinal)
+      && string.Equals(left.TargetEntityId, right.TargetEntityId, StringComparison.Ordinal)
+      && string.Equals(left.TargetSystemId, right.TargetSystemId, StringComparison.Ordinal)
+      && left.TargetPosition == right.TargetPosition
+      && string.Equals(left.DestinationStationId, right.DestinationStationId, StringComparison.Ordinal)
+      && string.Equals(left.ItemId, right.ItemId, StringComparison.Ordinal)
+      && string.Equals(left.AnchorId, right.AnchorId, StringComparison.Ordinal)
+      && left.WaitSeconds.Equals(right.WaitSeconds)
+      && left.Radius.Equals(right.Radius)
+      && left.MaxSystemRange == right.MaxSystemRange
+      && left.KnownStationsOnly == right.KnownStationsOnly;
+
+    private ShipOrderRuntime BuildManagedPatrolOrder(SimulationWorld world, ShipRuntime ship, CommanderAssignmentRuntime? assignment, string sourceKind)
+    {
+        var patrolSystemId = assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? ship.SystemId;
+        var protectPosition = ship.DefaultBehavior.TargetPosition ?? assignment?.TargetPosition ?? ship.Position;
+        var patrolThreat = SelectThreatTarget(world, ship, patrolSystemId, protectPosition, MathF.Max(60f, ship.DefaultBehavior.Radius));
+        if (patrolThreat is not null)
+        {
+            ship.LastAccessFailureReason = null;
+            return CreateManagedAttackOrder(ship, sourceKind, "Patrol intercept", patrolThreat.EntityId, patrolThreat.SystemId, patrolThreat.Position, orderIdSuffix: "patrol-attack");
+        }
+
+        Vector3 targetPosition;
+        string targetSystemId;
+        if (ship.DefaultBehavior.PatrolPoints.Count > 0)
+        {
+            var index = ship.DefaultBehavior.PatrolIndex % ship.DefaultBehavior.PatrolPoints.Count;
+            targetPosition = ship.DefaultBehavior.PatrolPoints[index];
+            ship.DefaultBehavior.PatrolIndex = (index + 1) % ship.DefaultBehavior.PatrolPoints.Count;
+            targetSystemId = ship.DefaultBehavior.AreaSystemId ?? ship.SystemId;
+        }
+        else if (ResolveStation(world, ship.DefaultBehavior.HomeStationId ?? assignment?.HomeStationId) is { } homeStation)
+        {
+            var patrolRadius = homeStation.Radius + 90f;
+            targetPosition = new Vector3(homeStation.Position.X + patrolRadius, homeStation.Position.Y, homeStation.Position.Z);
+            targetSystemId = homeStation.SystemId;
+        }
+        else
+        {
+            targetPosition = ship.Position;
+            targetSystemId = ship.SystemId;
+        }
+
+        ship.LastAccessFailureReason = null;
+        return CreateManagedMoveOrder(ship, sourceKind, "Patrol waypoint", targetSystemId, targetPosition, MathF.Max(6f, ship.DefaultBehavior.Radius), orderIdSuffix: "patrol-move");
+    }
+
+    private static ShipOrderRuntime CreateManagedAttackOrder(
+        ShipRuntime ship,
+        string behaviorKind,
+        string label,
+        string targetEntityId,
+        string targetSystemId,
+        Vector3 targetPosition,
+        string? orderIdSuffix = null) =>
+        new()
+        {
+            Id = $"behavior-{ship.Id}-{orderIdSuffix ?? behaviorKind}",
+            Kind = ShipOrderKinds.AttackTarget,
+            SourceKind = ShipOrderSourceKind.Behavior,
+            SourceId = behaviorKind,
+            Priority = 0,
+            InterruptCurrentPlan = false,
+            Label = label,
+            TargetEntityId = targetEntityId,
+            TargetSystemId = targetSystemId,
+            TargetPosition = targetPosition,
+            WaitSeconds = 0f,
+            Radius = 26f,
+            MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+            KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+        };
+
+    private static ShipOrderRuntime CreateManagedTradeRouteOrder(ShipRuntime ship, string behaviorKind, TradeRoutePlan route) =>
+        new()
+        {
+            Id = $"behavior-{ship.Id}-{behaviorKind}-trade-route",
+            Kind = ShipOrderKinds.TradeRoute,
+            SourceKind = ShipOrderSourceKind.Behavior,
+            SourceId = behaviorKind,
+            Priority = 0,
+            InterruptCurrentPlan = false,
+            Label = route.Summary,
+            SourceStationId = route.SourceStation.Id,
+            DestinationStationId = route.DestinationStation.Id,
+            ItemId = route.ItemId,
+            MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+            KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+        };
+
+    private static ShipOrderRuntime CreateManagedDockAtStationOrder(ShipRuntime ship, string behaviorKind, StationRuntime station, string label) =>
+        new()
+        {
+            Id = $"behavior-{ship.Id}-{behaviorKind}-dock-at-station",
+            Kind = ShipOrderKinds.DockAtStation,
+            SourceKind = ShipOrderSourceKind.Behavior,
+            SourceId = behaviorKind,
+            Priority = 0,
+            InterruptCurrentPlan = false,
+            Label = label,
+            TargetEntityId = station.Id,
+            TargetSystemId = station.SystemId,
+            DestinationStationId = station.Id,
+            Radius = ship.DefaultBehavior.Radius,
+            MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+            KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+        };
+
+    private static ShipOrderRuntime CreateManagedMoveOrder(
+        ShipRuntime ship,
+        string behaviorKind,
+        string label,
+        string targetSystemId,
+        Vector3 targetPosition,
+        float radius,
+        string? orderIdSuffix = null) =>
+        new()
+        {
+            Id = $"behavior-{ship.Id}-{orderIdSuffix ?? behaviorKind}",
+            Kind = ShipOrderKinds.Move,
+            SourceKind = ShipOrderSourceKind.Behavior,
+            SourceId = behaviorKind,
+            Priority = 0,
+            InterruptCurrentPlan = false,
+            Label = label,
+            TargetSystemId = targetSystemId,
+            TargetPosition = targetPosition,
+            Radius = radius,
+            MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+            KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+        };
+
+    private static ShipOrderRuntime CreateManagedFollowShipOrder(
+        ShipRuntime ship,
+        string behaviorKind,
+        string label,
+        ShipRuntime targetShip,
+        float radius,
+        float waitSeconds) =>
+        new()
+        {
+            Id = $"behavior-{ship.Id}-{behaviorKind}",
+            Kind = ShipOrderKinds.FollowShip,
+            SourceKind = ShipOrderSourceKind.Behavior,
+            SourceId = behaviorKind,
+            Priority = 0,
+            InterruptCurrentPlan = false,
+            Label = label,
+            TargetEntityId = targetShip.Id,
+            TargetSystemId = targetShip.SystemId,
+            WaitSeconds = waitSeconds,
+            Radius = radius,
+            MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+            KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+        };
+
+    private static ShipOrderRuntime CreateManagedFollowTargetOrder(
+        ShipRuntime ship,
+        string behaviorKind,
+        string label,
+        string targetEntityId,
+        string targetSystemId,
+        Vector3 targetPosition,
+        float radius,
+        float waitSeconds) =>
+        new()
+        {
+            Id = $"behavior-{ship.Id}-{behaviorKind}",
+            Kind = ShipOrderKinds.FollowShip,
+            SourceKind = ShipOrderSourceKind.Behavior,
+            SourceId = behaviorKind,
+            Priority = 0,
+            InterruptCurrentPlan = false,
+            Label = label,
+            TargetEntityId = targetEntityId,
+            TargetSystemId = targetSystemId,
+            TargetPosition = targetPosition,
+            WaitSeconds = waitSeconds,
+            Radius = radius,
+            MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
+            KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
+        };
+}

apps/backend/Ships/AI/ShipAiService.Data.cs

@@ -0,0 +1,54 @@
+namespace SpaceGame.Api.Ships.AI;
+
+public sealed partial class ShipAiService
+{
+    private enum SubTaskOutcome
+    {
+        Active,
+        Completed,
+        Failed,
+    }
+
+    private sealed record TradeRoutePlan(
+      StationRuntime SourceStation,
+      StationRuntime DestinationStation,
+      string ItemId,
+      float Score,
+      string Summary);
+
+    private sealed record MiningOpportunity(
+      ResourceNodeRuntime Node,
+      StationRuntime DropOffStation,
+      float Score,
+      string Summary);
+
+    private sealed record FleetSupplyPlan(
+      StationRuntime SourceStation,
+      ShipRuntime TargetShip,
+      string ItemId,
+      float Amount,
+      float Radius,
+      string Summary);
+
+    private sealed record LocalMiningBuyerCandidate(
+      StationRuntime Station,
+      float Score);
+
+    private sealed record ThreatTargetCandidate(
+      string EntityId,
+      string SystemId,
+      Vector3 Position,
+      float Score);
+
+    private sealed record PoliceContactCandidate(
+      string EntityId,
+      string SystemId,
+      Vector3 Position,
+      bool Engage,
+      float Score);
+
+    private sealed record SalvageOpportunity(
+      WreckRuntime Wreck,
+      float Score,
+      string Summary);
+}

apps/backend/Ships/AI/ShipAiService.Execution.cs

@@ -0,0 +1,838 @@
+using static SpaceGame.Api.Shared.Runtime.SimulationRuntimeSupport;
+using static SpaceGame.Api.Stations.Simulation.InfrastructureSimulationService;
+using static SpaceGame.Api.Stations.Simulation.StationSimulationService;
+
+namespace SpaceGame.Api.Ships.AI;
+
+public sealed partial class ShipAiService
+{
+    private SubTaskOutcome UpdateSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        return subTask.Kind switch
+        {
+            var kind when string.Equals(kind, ShipTaskKinds.Travel, StringComparison.Ordinal) => UpdateTravelSubTask(world, ship, subTask, deltaSeconds, completeOnArrival: true),
+            var kind when string.Equals(kind, ShipTaskKinds.FollowTarget, StringComparison.Ordinal) => UpdateFollowSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.Dock, StringComparison.Ordinal) => UpdateDockSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.Undock, StringComparison.Ordinal) => UpdateUndockSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.LoadCargo, StringComparison.Ordinal) => UpdateLoadCargoSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.UnloadCargo, StringComparison.Ordinal) => UpdateUnloadCargoSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.TransferCargoToShip, StringComparison.Ordinal) => UpdateTransferCargoToShipSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.MineNode, StringComparison.Ordinal) => UpdateMineSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.SalvageWreck, StringComparison.Ordinal) => UpdateSalvageSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.DeliverConstruction, StringComparison.Ordinal) => UpdateDeliverConstructionSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.BuildConstructionSite, StringComparison.Ordinal) => UpdateBuildConstructionSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.AttackTarget, StringComparison.Ordinal) => UpdateAttackSubTask(world, ship, subTask, deltaSeconds),
+            var kind when string.Equals(kind, ShipTaskKinds.HoldPosition, StringComparison.Ordinal) => UpdateHoldSubTask(ship, subTask, deltaSeconds),
+            _ => SubTaskOutcome.Failed,
+        };
+    }
+
+    private SubTaskOutcome UpdateHoldSubTask(ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        ship.State = ShipState.HoldingPosition;
+        ship.TargetPosition = subTask.TargetPosition ?? ship.Position;
+        ship.Position = ship.Position.MoveToward(ship.TargetPosition, MathF.Min(GetLocalTravelSpeed(ship) * deltaSeconds, ship.Position.DistanceTo(ship.TargetPosition)));
+        return AdvanceTimedSubTask(subTask, deltaSeconds, MathF.Max(0.1f, subTask.Amount)) ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateFollowSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        var targetShip = world.Ships.FirstOrDefault(candidate => candidate.Id == subTask.TargetEntityId && candidate.Health > 0f);
+        if (targetShip is null)
+        {
+            subTask.BlockingReason = "follow-target-missing";
+            return SubTaskOutcome.Failed;
+        }
+
+        var desiredPosition = GetFormationPosition(targetShip.Position, ship.Id, MathF.Max(subTask.Threshold, 16f));
+        subTask.TargetSystemId = targetShip.SystemId;
+        subTask.TargetPosition = desiredPosition;
+        subTask.BlockingReason = null;
+        if (ship.SystemId != targetShip.SystemId || ship.Position.DistanceTo(desiredPosition) > MathF.Max(subTask.Threshold, 12f))
+        {
+            return UpdateTravelSubTask(world, ship, subTask, deltaSeconds, completeOnArrival: false);
+        }
+
+        ship.State = ShipState.HoldingPosition;
+        ship.TargetPosition = desiredPosition;
+        ship.Position = ship.Position.MoveToward(desiredPosition, MathF.Min(GetLocalTravelSpeed(ship) * deltaSeconds, ship.Position.DistanceTo(desiredPosition)));
+        return AdvanceTimedSubTask(subTask, deltaSeconds, MathF.Max(0.5f, subTask.Amount)) ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateTravelSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds, bool completeOnArrival)
+    {
+        if (subTask.TargetPosition is null || subTask.TargetSystemId is null)
+        {
+            subTask.BlockingReason = "travel-target-missing";
+            ship.State = ShipState.Blocked;
+            return SubTaskOutcome.Failed;
+        }
+
+        var targetPosition = ResolveCurrentTargetPosition(world, subTask);
+        var targetAnchor = ResolveTravelTargetAnchor(world, subTask, targetPosition);
+        ship.TargetPosition = targetPosition;
+
+        if (ship.SystemId != subTask.TargetSystemId)
+        {
+            if (!CanFtl(ship.Definition))
+            {
+                subTask.BlockingReason = "ftl-unavailable";
+                ship.State = ShipState.Blocked;
+                return SubTaskOutcome.Failed;
+            }
+
+            var destinationEntryAnchor = ResolveSystemEntryAnchor(world, subTask.TargetSystemId) ?? targetAnchor;
+            var destinationEntryPosition = destinationEntryAnchor?.Position ?? targetPosition;
+            return UpdateFtlTransit(world, ship, subTask, deltaSeconds, subTask.TargetSystemId, destinationEntryPosition, destinationEntryAnchor, completeOnArrival, targetPosition, targetAnchor);
+        }
+
+        var currentAnchor = ResolveCurrentAnchor(world, ship);
+        if (targetAnchor is not null
+            && currentAnchor is not null
+            && !string.Equals(currentAnchor.Id, targetAnchor.Id, StringComparison.Ordinal))
+        {
+            if (!CanWarp(ship.Definition))
+            {
+                return UpdateLocalTravel(world, ship, subTask, deltaSeconds, subTask.TargetSystemId, targetPosition, currentAnchor, targetAnchor, completeOnArrival);
+            }
+
+            return UpdateWarpTransit(world, ship, subTask, deltaSeconds, targetPosition, currentAnchor, targetAnchor, completeOnArrival);
+        }
+
+        if (targetAnchor is not null
+            && currentAnchor is not null
+            && !string.Equals(currentAnchor.Id, targetAnchor.Id, StringComparison.Ordinal)
+            && CanWarp(ship.Definition))
+        {
+            return UpdateWarpTransit(world, ship, subTask, deltaSeconds, targetPosition, currentAnchor, targetAnchor, completeOnArrival);
+        }
+
+        return UpdateLocalTravel(world, ship, subTask, deltaSeconds, subTask.TargetSystemId, targetPosition, currentAnchor, targetAnchor, completeOnArrival);
+    }
+
+    private SubTaskOutcome UpdateAttackSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        var hostileShip = world.Ships.FirstOrDefault(candidate => candidate.Id == subTask.TargetEntityId && candidate.Health > 0f);
+        var hostileStation = hostileShip is null
+          ? world.Stations.FirstOrDefault(candidate => candidate.Id == subTask.TargetEntityId)
+          : null;
+        if ((hostileShip is not null && hostileShip.FactionId == ship.FactionId)
+            || (hostileStation is not null && hostileStation.FactionId == ship.FactionId))
+        {
+            subTask.BlockingReason = "friendly-target";
+            return SubTaskOutcome.Failed;
+        }
+
+        if (hostileShip is null && hostileStation is null)
+        {
+            return SubTaskOutcome.Completed;
+        }
+
+        var targetSystemId = hostileShip?.SystemId ?? hostileStation!.SystemId;
+        var targetPosition = hostileShip?.Position ?? hostileStation!.Position;
+        var attackRange = hostileShip is null ? hostileStation!.Radius + 18f : 26f;
+        subTask.TargetSystemId = targetSystemId;
+        subTask.TargetPosition = targetPosition;
+        subTask.Threshold = attackRange;
+
+        if (ship.SystemId != targetSystemId || ship.Position.DistanceTo(targetPosition) > attackRange)
+        {
+            return UpdateTravelSubTask(world, ship, subTask, deltaSeconds, completeOnArrival: false);
+        }
+
+        ship.State = ShipState.EngagingTarget;
+        ship.TargetPosition = targetPosition;
+        ship.Position = ship.Position.MoveToward(targetPosition, MathF.Min(GetLocalTravelSpeed(ship) * deltaSeconds, 8f));
+        var damage = GetShipDamagePerSecond(ship) * deltaSeconds * GetSkillFactor(ship.Skills.Combat);
+        subTask.Progress = 1f;
+
+        if (hostileShip is not null)
+        {
+            hostileShip.Health = MathF.Max(0f, hostileShip.Health - damage);
+            return hostileShip.Health <= 0f ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+        }
+
+        hostileStation!.Health = MathF.Max(0f, hostileStation.Health - (damage * 0.6f));
+        return hostileStation.Health <= 0f ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateMineSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        var node = ResolveNode(world, subTask.TargetResourceNodeId ?? subTask.TargetEntityId);
+        if (node is null || !CanExtractNode(ship, node, world))
+        {
+            subTask.BlockingReason = "node-missing";
+            ship.State = ShipState.Blocked;
+            return SubTaskOutcome.Failed;
+        }
+
+        var deposit = ResolveResourceDeposit(world, subTask.TargetResourceDepositId);
+        if (deposit is null || !string.Equals(deposit.NodeId, node.Id, StringComparison.Ordinal) || deposit.OreRemaining <= 0.01f)
+        {
+            deposit = SelectMiningDeposit(node, ship.Id);
+            subTask.TargetResourceDepositId = deposit?.Id;
+        }
+
+        if (deposit is null)
+        {
+            SyncNodeOreTotals(node);
+            return SubTaskOutcome.Completed;
+        }
+
+        var targetPosition = GetResourceHoldPosition(deposit.Position, ship.Id, 20f);
+        subTask.TargetPosition = targetPosition;
+        var approachThreshold = MathF.Max(subTask.Threshold, 8f);
+        var distanceToTarget = ship.Position.DistanceTo(targetPosition);
+        var distanceToDeposit = ship.Position.DistanceTo(deposit.Position);
+        var effectivelyAtDeposit = string.Equals(ship.SpatialState.CurrentAnchorId, node.AnchorId, StringComparison.Ordinal)
+            && distanceToDeposit <= approachThreshold;
+        ship.TargetPosition = targetPosition;
+        if (distanceToTarget > approachThreshold && !effectivelyAtDeposit)
+        {
+            ship.State = ShipState.MiningApproach;
+            ship.Position = ship.Position.MoveToward(targetPosition, GetLocalTravelSpeed(ship) * deltaSeconds);
+            return SubTaskOutcome.Active;
+        }
+
+        var cargoAmount = GetShipCargoAmount(ship);
+        if (cargoAmount >= ship.Definition.GetTotalCargoCapacity() - 0.01f)
+        {
+            return SubTaskOutcome.Completed;
+        }
+
+        ship.State = ShipState.Mining;
+        if (!AdvanceTimedSubTask(subTask, deltaSeconds, balance.MiningCycleSeconds))
+        {
+            return SubTaskOutcome.Active;
+        }
+
+        var remainingCapacity = MathF.Max(0f, ship.Definition.GetTotalCargoCapacity() - cargoAmount);
+        var mined = MathF.Min(balance.MiningRate * GetSkillFactor(ship.Skills.Mining), remainingCapacity);
+        mined = MathF.Min(mined, deposit.OreRemaining);
+        if (mined <= 0.01f)
+        {
+            return SubTaskOutcome.Completed;
+        }
+
+        AddInventory(ship.Inventory, node.ItemId, mined);
+        deposit.OreRemaining = MathF.Max(0f, deposit.OreRemaining - mined);
+        SyncNodeOreTotals(node);
+        if (GetShipCargoAmount(ship) >= ship.Definition.GetTotalCargoCapacity() - 0.01f || node.OreRemaining <= 0.01f)
+        {
+            return SubTaskOutcome.Completed;
+        }
+
+        subTask.ElapsedSeconds = 0f;
+        return SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateDockSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        var station = ResolveStation(world, subTask.TargetEntityId);
+        if (station is null)
+        {
+            subTask.BlockingReason = "dock-target-missing";
+            ship.State = ShipState.Blocked;
+            return SubTaskOutcome.Failed;
+        }
+
+        var padIndex = ship.AssignedDockingPadIndex ?? ReserveDockingPad(station, ship.Id);
+        if (padIndex is null)
+        {
+            ship.State = ShipState.AwaitingDock;
+            ship.TargetPosition = GetDockingHoldPosition(station, ship.Id);
+            if (ship.Position.DistanceTo(ship.TargetPosition) > 4f)
+            {
+                ship.Position = ship.Position.MoveToward(ship.TargetPosition, GetLocalTravelSpeed(ship) * deltaSeconds);
+            }
+
+            subTask.Status = WorkStatus.Blocked;
+            subTask.BlockingReason = "waiting-for-pad";
+            return SubTaskOutcome.Active;
+        }
+
+        subTask.Status = WorkStatus.Active;
+        subTask.BlockingReason = null;
+        ship.AssignedDockingPadIndex = padIndex;
+        var padPosition = GetDockingPadPosition(station, padIndex.Value);
+        ship.TargetPosition = padPosition;
+        if (ship.Position.DistanceTo(padPosition) > 4f)
+        {
+            ship.State = ShipState.DockingApproach;
+            ship.Position = ship.Position.MoveToward(padPosition, GetLocalTravelSpeed(ship) * deltaSeconds);
+            return SubTaskOutcome.Active;
+        }
+
+        ship.State = ShipState.Docking;
+        if (!AdvanceTimedSubTask(subTask, deltaSeconds, balance.DockingDuration))
+        {
+            return SubTaskOutcome.Active;
+        }
+
+        ship.State = ShipState.Docked;
+        ship.DockedStationId = station.Id;
+        station.DockedShipIds.Add(ship.Id);
+        ship.KnownStationIds.Add(station.Id);
+        ship.Position = padPosition;
+        ship.TargetPosition = padPosition;
+        return SubTaskOutcome.Completed;
+    }
+
+    private SubTaskOutcome UpdateUndockSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        if (ship.DockedStationId is null)
+        {
+            return SubTaskOutcome.Completed;
+        }
+
+        var station = ResolveStation(world, ship.DockedStationId);
+        if (station is null)
+        {
+            ship.DockedStationId = null;
+            ship.AssignedDockingPadIndex = null;
+            return SubTaskOutcome.Completed;
+        }
+
+        var undockTarget = GetUndockTargetPosition(station, ship.AssignedDockingPadIndex, balance.UndockDistance);
+        ship.TargetPosition = undockTarget;
+        ship.State = ShipState.Undocking;
+        if (!AdvanceTimedSubTask(subTask, deltaSeconds, balance.UndockingDuration))
+        {
+            ship.Position = GetShipDockedPosition(ship, station);
+            return SubTaskOutcome.Active;
+        }
+
+        ship.Position = ship.Position.MoveToward(undockTarget, balance.UndockDistance);
+        if (ship.Position.DistanceTo(undockTarget) > MathF.Max(subTask.Threshold, 4f))
+        {
+            return SubTaskOutcome.Active;
+        }
+
+        station.DockedShipIds.Remove(ship.Id);
+        ReleaseDockingPad(station, ship.Id);
+        ship.DockedStationId = null;
+        ship.AssignedDockingPadIndex = null;
+        return SubTaskOutcome.Completed;
+    }
+
+    private SubTaskOutcome UpdateLoadCargoSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        if (ship.DockedStationId is null)
+        {
+            subTask.BlockingReason = "not-docked";
+            return SubTaskOutcome.Failed;
+        }
+
+        var station = ResolveStation(world, ship.DockedStationId);
+        if (station is null)
+        {
+            subTask.BlockingReason = "station-missing";
+            return SubTaskOutcome.Failed;
+        }
+
+        ship.TargetPosition = GetShipDockedPosition(ship, station);
+        ship.Position = ship.TargetPosition;
+        ship.State = ShipState.Loading;
+        var itemId = subTask.ItemId;
+        if (itemId is null)
+        {
+            return SubTaskOutcome.Completed;
+        }
+
+        var desiredAmount = subTask.Amount > 0f ? subTask.Amount : ship.Definition.GetTotalCargoCapacity();
+        var availableCapacity = MathF.Max(0f, ship.Definition.GetTotalCargoCapacity() - GetShipCargoAmount(ship));
+        var transferRate = balance.TransferRate * GetSkillFactor(ship.Skills.Trade);
+        var moved = MathF.Min(transferRate * deltaSeconds, MathF.Min(availableCapacity, GetInventoryAmount(station.Inventory, itemId)));
+        if (moved > 0.01f)
+        {
+            RemoveInventory(station.Inventory, itemId, moved);
+            AddInventory(ship.Inventory, itemId, moved);
+        }
+
+        var loadedAmount = GetInventoryAmount(ship.Inventory, itemId);
+        subTask.Progress = desiredAmount <= 0.01f ? 1f : Math.Clamp(loadedAmount / desiredAmount, 0f, 1f);
+        return availableCapacity <= 0.01f || GetInventoryAmount(station.Inventory, itemId) <= 0.01f || loadedAmount >= desiredAmount - 0.01f
+          ? SubTaskOutcome.Completed
+          : SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateUnloadCargoSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        if (ship.DockedStationId is null)
+        {
+            subTask.BlockingReason = "not-docked";
+            return SubTaskOutcome.Failed;
+        }
+
+        var station = ResolveStation(world, ship.DockedStationId);
+        if (station is null)
+        {
+            subTask.BlockingReason = "station-missing";
+            return SubTaskOutcome.Failed;
+        }
+
+        ship.TargetPosition = GetShipDockedPosition(ship, station);
+        ship.Position = ship.TargetPosition;
+        ship.State = ShipState.Transferring;
+        var transferRate = balance.TransferRate * GetSkillFactor(Math.Max(ship.Skills.Trade, ship.Skills.Mining));
+
+        if (subTask.ItemId is not null)
+        {
+            var moved = MathF.Min(transferRate * deltaSeconds, GetInventoryAmount(ship.Inventory, subTask.ItemId));
+            var accepted = TryAddStationInventory(world, station, subTask.ItemId, moved);
+            RemoveInventory(ship.Inventory, subTask.ItemId, accepted);
+            subTask.Progress = subTask.Amount <= 0.01f
+              ? 1f
+              : Math.Clamp(1f - (GetInventoryAmount(ship.Inventory, subTask.ItemId) / subTask.Amount), 0f, 1f);
+            return GetInventoryAmount(ship.Inventory, subTask.ItemId) <= 0.01f ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+        }
+
+        foreach (var (itemId, amount) in ship.Inventory.ToList().OrderBy(entry => entry.Key, StringComparer.Ordinal))
+        {
+            var moved = MathF.Min(amount, transferRate * deltaSeconds);
+            var accepted = TryAddStationInventory(world, station, itemId, moved);
+            RemoveInventory(ship.Inventory, itemId, accepted);
+            if (accepted > 0.01f)
+            {
+                return GetShipCargoAmount(ship) <= 0.01f ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+            }
+        }
+
+        return GetShipCargoAmount(ship) <= 0.01f ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateTransferCargoToShipSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        var targetShip = world.Ships.FirstOrDefault(candidate => candidate.Id == subTask.TargetEntityId && candidate.Health > 0f);
+        if (targetShip is null)
+        {
+            subTask.BlockingReason = "target-ship-missing";
+            return SubTaskOutcome.Failed;
+        }
+
+        var desiredPosition = GetFormationPosition(targetShip.Position, ship.Id, MathF.Max(subTask.Threshold, 12f));
+        subTask.TargetSystemId = targetShip.SystemId;
+        subTask.TargetPosition = desiredPosition;
+        if (ship.SystemId != targetShip.SystemId || ship.Position.DistanceTo(desiredPosition) > MathF.Max(subTask.Threshold, 12f))
+        {
+            return UpdateTravelSubTask(world, ship, subTask, deltaSeconds, completeOnArrival: false);
+        }
+
+        ship.State = ShipState.Transferring;
+        ship.TargetPosition = desiredPosition;
+        ship.Position = ship.Position.MoveToward(desiredPosition, MathF.Min(GetLocalTravelSpeed(ship) * deltaSeconds, ship.Position.DistanceTo(desiredPosition)));
+        if (subTask.ItemId is null)
+        {
+            return SubTaskOutcome.Completed;
+        }
+
+        var targetCapacity = MathF.Max(0f, targetShip.Definition.GetTotalCargoCapacity() - GetShipCargoAmount(targetShip));
+        if (targetCapacity <= 0.01f)
+        {
+            subTask.BlockingReason = "target-cargo-full";
+            return SubTaskOutcome.Failed;
+        }
+
+        var transferRate = balance.TransferRate * GetSkillFactor(Math.Max(ship.Skills.Trade, ship.Skills.Navigation));
+        var desiredAmount = subTask.Amount > 0f ? subTask.Amount : GetInventoryAmount(ship.Inventory, subTask.ItemId);
+        var moved = MathF.Min(transferRate * deltaSeconds, MathF.Min(targetCapacity, GetInventoryAmount(ship.Inventory, subTask.ItemId)));
+        if (moved > 0.01f)
+        {
+            RemoveInventory(ship.Inventory, subTask.ItemId, moved);
+            AddInventory(targetShip.Inventory, subTask.ItemId, moved);
+        }
+
+        var remaining = GetInventoryAmount(ship.Inventory, subTask.ItemId);
+        subTask.Progress = desiredAmount <= 0.01f ? 1f : Math.Clamp(1f - (remaining / desiredAmount), 0f, 1f);
+        return remaining <= 0.01f || GetShipCargoAmount(targetShip) >= targetShip.Definition.GetTotalCargoCapacity() - 0.01f
+          ? SubTaskOutcome.Completed
+          : SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateSalvageSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        var wreck = world.Wrecks.FirstOrDefault(candidate => candidate.Id == subTask.TargetEntityId && candidate.RemainingAmount > 0.01f);
+        if (wreck is null)
+        {
+            return SubTaskOutcome.Completed;
+        }
+
+        var desiredPosition = subTask.TargetPosition ?? GetFormationPosition(wreck.Position, ship.Id, 8f);
+        ship.TargetPosition = desiredPosition;
+        if (ship.SystemId != wreck.SystemId || ship.Position.DistanceTo(desiredPosition) > MathF.Max(subTask.Threshold, 8f))
+        {
+            subTask.TargetSystemId = wreck.SystemId;
+            subTask.TargetPosition = desiredPosition;
+            return UpdateTravelSubTask(world, ship, subTask, deltaSeconds, completeOnArrival: false);
+        }
+
+        ship.State = ShipState.Transferring;
+        var remainingCapacity = MathF.Max(0f, ship.Definition.GetTotalCargoCapacity() - GetShipCargoAmount(ship));
+        if (remainingCapacity <= 0.01f)
+        {
+            return SubTaskOutcome.Completed;
+        }
+
+        if (!AdvanceTimedSubTask(subTask, deltaSeconds, MathF.Max(0.4f, balance.MiningCycleSeconds * 0.8f)))
+        {
+            return SubTaskOutcome.Active;
+        }
+
+        var salvageRate = balance.TransferRate * GetSkillFactor(Math.Max(ship.Skills.Mining, ship.Skills.Trade));
+        var recovered = MathF.Min(salvageRate, MathF.Min(remainingCapacity, wreck.RemainingAmount));
+        if (recovered > 0.01f)
+        {
+            AddInventory(ship.Inventory, wreck.ItemId, recovered);
+            wreck.RemainingAmount = MathF.Max(0f, wreck.RemainingAmount - recovered);
+        }
+
+        if (wreck.RemainingAmount <= 0.01f)
+        {
+            world.Wrecks.RemoveAll(candidate => candidate.Id == wreck.Id);
+        }
+
+        subTask.ElapsedSeconds = 0f;
+        return wreck.RemainingAmount <= 0.01f || GetShipCargoAmount(ship) >= ship.Definition.GetTotalCargoCapacity() - 0.01f
+          ? SubTaskOutcome.Completed
+          : SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateDeliverConstructionSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        var site = world.ConstructionSites.FirstOrDefault(candidate => candidate.Id == subTask.TargetEntityId);
+        var station = site is null ? null : ResolveSupportStation(world, ship, site);
+        if (site is null || station is null || site.State is ConstructionSiteStateKinds.Completed or ConstructionSiteStateKinds.Destroyed)
+        {
+            subTask.BlockingReason = "construction-target-missing";
+            return SubTaskOutcome.Failed;
+        }
+
+        var supportPosition = ResolveSupportPosition(ship, station, site, world);
+        if (!IsShipWithinSupportRange(ship, supportPosition, MathF.Max(12f, subTask.Threshold)))
+        {
+            ship.State = ShipState.LocalFlight;
+            ship.TargetPosition = supportPosition;
+            ship.Position = ship.Position.MoveToward(supportPosition, GetLocalTravelSpeed(ship) * deltaSeconds);
+            return SubTaskOutcome.Active;
+        }
+
+        ship.TargetPosition = supportPosition;
+        ship.Position = supportPosition;
+        ship.State = ShipState.DeliveringConstruction;
+        var transferRate = balance.TransferRate * GetSkillFactor(ship.Skills.Construction);
+        foreach (var required in site.RequiredItems.OrderBy(entry => entry.Key, StringComparer.Ordinal))
+        {
+            var delivered = GetInventoryAmount(site.DeliveredItems, required.Key);
+            var remaining = MathF.Max(0f, required.Value - delivered);
+            if (remaining <= 0.01f)
+            {
+                continue;
+            }
+
+            var available = MathF.Max(0f, GetInventoryAmount(station.Inventory, required.Key) - GetStationReserveFloor(world, station, required.Key));
+            var moved = MathF.Min(remaining, MathF.Min(available, transferRate * deltaSeconds));
+            if (moved <= 0.01f)
+            {
+                continue;
+            }
+
+            RemoveInventory(station.Inventory, required.Key, moved);
+            AddInventory(site.Inventory, required.Key, moved);
+            AddInventory(site.DeliveredItems, required.Key, moved);
+            break;
+        }
+
+        subTask.Progress = site.RequiredItems.Count == 0
+          ? 1f
+          : site.RequiredItems.Sum(required =>
+              required.Value <= 0.01f
+                ? 1f
+                : Math.Clamp(GetInventoryAmount(site.DeliveredItems, required.Key) / required.Value, 0f, 1f)) / site.RequiredItems.Count;
+        return IsConstructionSiteReady(world, site) ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateBuildConstructionSubTask(SimulationWorld world, ShipRuntime ship, ShipSubTaskRuntime subTask, float deltaSeconds)
+    {
+        var site = world.ConstructionSites.FirstOrDefault(candidate => candidate.Id == subTask.TargetEntityId);
+        var station = site is null ? null : ResolveSupportStation(world, ship, site);
+        if (site is null || station is null || site.BlueprintId is null || site.State is ConstructionSiteStateKinds.Completed or ConstructionSiteStateKinds.Destroyed)
+        {
+            subTask.BlockingReason = "construction-site-missing";
+            return SubTaskOutcome.Failed;
+        }
+
+        var supportPosition = ResolveSupportPosition(ship, station, site, world);
+        if (!IsShipWithinSupportRange(ship, supportPosition, MathF.Max(12f, subTask.Threshold)))
+        {
+            ship.State = ShipState.LocalFlight;
+            ship.TargetPosition = supportPosition;
+            ship.Position = ship.Position.MoveToward(supportPosition, GetLocalTravelSpeed(ship) * deltaSeconds);
+            return SubTaskOutcome.Active;
+        }
+
+        if (!IsConstructionSiteReady(world, site) || !world.ModuleRecipes.TryGetValue(site.BlueprintId, out var recipe))
+        {
+            ship.State = ShipState.WaitingMaterials;
+            subTask.Status = WorkStatus.Blocked;
+            subTask.BlockingReason = "waiting-materials";
+            return SubTaskOutcome.Active;
+        }
+
+        subTask.Status = WorkStatus.Active;
+        subTask.BlockingReason = null;
+        ship.TargetPosition = supportPosition;
+        ship.Position = supportPosition;
+        ship.State = ShipState.Constructing;
+        site.AssignedConstructorShipIds.Add(ship.Id);
+        site.Progress += deltaSeconds * GetSkillFactor(ship.Skills.Construction);
+        subTask.Progress = recipe.Duration <= 0.01f ? 1f : Math.Clamp(site.Progress / recipe.Duration, 0f, 1f);
+        if (site.Progress < recipe.Duration)
+        {
+            return SubTaskOutcome.Active;
+        }
+
+        if (site.StationId is null)
+        {
+            CompleteStationFoundation(world, station, site);
+        }
+        else
+        {
+            AddStationModule(world, station, site.BlueprintId);
+            PrepareNextConstructionSiteStep(world, station, site);
+        }
+
+        site.State = ConstructionSiteStateKinds.Completed;
+        return SubTaskOutcome.Completed;
+    }
+
+    private static bool AdvanceTimedSubTask(ShipSubTaskRuntime subTask, float deltaSeconds, float requiredSeconds)
+    {
+        subTask.TotalSeconds = requiredSeconds;
+        subTask.ElapsedSeconds += deltaSeconds;
+        subTask.Progress = requiredSeconds <= 0.01f ? 1f : Math.Clamp(subTask.ElapsedSeconds / requiredSeconds, 0f, 1f);
+        if (subTask.ElapsedSeconds < requiredSeconds)
+        {
+            return false;
+        }
+
+        subTask.ElapsedSeconds = 0f;
+        return true;
+    }
+
+    private SubTaskOutcome UpdateLocalTravel(
+      SimulationWorld world,
+      ShipRuntime ship,
+      ShipSubTaskRuntime subTask,
+      float deltaSeconds,
+      string targetSystemId,
+      Vector3 targetPosition,
+      AnchorRuntime? currentAnchor,
+      AnchorRuntime? targetAnchor,
+      bool completeOnArrival)
+    {
+        var distance = ship.Position.DistanceTo(targetPosition);
+        ship.SpatialState.SpaceLayer = SpaceLayerKind.LocalSpace;
+        ship.SpatialState.MovementRegime = MovementRegimeKind.LocalFlight;
+        ship.SpatialState.Transit = null;
+        ship.SpatialState.DestinationAnchorId = targetAnchor?.Id ?? currentAnchor?.Id;
+        subTask.Progress = Math.Clamp(1f - (distance / MathF.Max(distance + GetLocalTravelSpeed(ship), 1f)), 0f, 1f);
+        var localSystemOffset = SimulationUnits.MetersToKilometers(ship.Position);
+        ship.SpatialState.SystemPosition = currentAnchor is null
+          ? localSystemOffset
+          : new Vector3(
+              currentAnchor.Position.X + localSystemOffset.X,
+              currentAnchor.Position.Y + localSystemOffset.Y,
+              currentAnchor.Position.Z + localSystemOffset.Z);
+
+        if (distance <= MathF.Max(subTask.Threshold, balance.ArrivalThreshold))
+        {
+            ship.Position = targetPosition;
+            ship.TargetPosition = targetPosition;
+            ship.SystemId = targetSystemId;
+            ship.SpatialState.CurrentSystemId = targetSystemId;
+            ship.SpatialState.CurrentAnchorId = targetAnchor?.Id ?? currentAnchor?.Id;
+            var arrivalSystemOffset = SimulationUnits.MetersToKilometers(targetPosition);
+            ship.SpatialState.SystemPosition = targetAnchor is null
+              ? arrivalSystemOffset
+              : new Vector3(
+                  targetAnchor.Position.X + arrivalSystemOffset.X,
+                  targetAnchor.Position.Y + arrivalSystemOffset.Y,
+                  targetAnchor.Position.Z + arrivalSystemOffset.Z);
+            ship.State = ShipState.Arriving;
+            return completeOnArrival ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+        }
+
+        ship.State = ShipState.LocalFlight;
+        ship.SpatialState.CurrentAnchorId = currentAnchor?.Id;
+        ship.Position = ship.Position.MoveToward(targetPosition, GetLocalTravelSpeed(ship) * deltaSeconds);
+        var movedSystemOffset = SimulationUnits.MetersToKilometers(ship.Position);
+        ship.SpatialState.SystemPosition = currentAnchor is null
+          ? movedSystemOffset
+          : new Vector3(
+              currentAnchor.Position.X + movedSystemOffset.X,
+              currentAnchor.Position.Y + movedSystemOffset.Y,
+              currentAnchor.Position.Z + movedSystemOffset.Z);
+        return SubTaskOutcome.Active;
+    }
+
+    private SubTaskOutcome UpdateWarpTransit(
+      SimulationWorld world,
+      ShipRuntime ship,
+      ShipSubTaskRuntime subTask,
+      float deltaSeconds,
+      Vector3 targetPosition,
+      AnchorRuntime currentAnchor,
+      AnchorRuntime targetAnchor,
+      bool completeOnArrival)
+    {
+        var transit = ship.SpatialState.Transit;
+        if (transit is null || transit.Regime != MovementRegimeKind.Warp || transit.DestinationAnchorId != targetAnchor.Id)
+        {
+            var originAnchorPosition = currentAnchor.Position;
+            var destinationAnchorPosition = targetAnchor.Position;
+            var initialSpoolDuration = MathF.Max(0.4f, ship.Definition.SpoolTime * 0.5f);
+            var initialTravelDuration = MathF.Max(0.1f, originAnchorPosition.DistanceTo(destinationAnchorPosition) / MathF.Max(GetWarpTravelSpeed(ship), 0.001f));
+            transit = new ShipTransitRuntime
+            {
+                Regime = MovementRegimeKind.Warp,
+                OriginAnchorId = currentAnchor.Id,
+                DestinationAnchorId = targetAnchor.Id,
+                StartedAtUtc = world.GeneratedAtUtc,
+                ArrivalDueAtUtc = world.GeneratedAtUtc.AddSeconds(initialSpoolDuration + initialTravelDuration),
+            };
+            ship.SpatialState.Transit = transit;
+            subTask.ElapsedSeconds = 0f;
+        }
+
+        ship.SpatialState.SpaceLayer = SpaceLayerKind.SystemSpace;
+        ship.SpatialState.MovementRegime = MovementRegimeKind.Warp;
+        ship.SpatialState.CurrentAnchorId = null;
+        ship.SpatialState.DestinationAnchorId = targetAnchor.Id;
+
+        var spoolDurationSeconds = MathF.Max(0.4f, ship.Definition.SpoolTime * 0.5f);
+        var startedAtUtc = transit.StartedAtUtc ?? world.GeneratedAtUtc;
+        var arrivalDueAtUtc = transit.ArrivalDueAtUtc ?? world.GeneratedAtUtc;
+        var totalDuration = MathF.Max(0.1f, (float)(arrivalDueAtUtc - startedAtUtc).TotalSeconds);
+        var elapsedSeconds = Math.Clamp((float)(world.GeneratedAtUtc - startedAtUtc).TotalSeconds, 0f, totalDuration);
+        var originPosition = ResolveAnchorPosition(world, transit.OriginAnchorId, currentAnchor.Position);
+        var destinationPosition = ResolveAnchorPosition(world, transit.DestinationAnchorId, targetAnchor.Position);
+
+        if (elapsedSeconds < spoolDurationSeconds)
+        {
+            ship.State = ShipState.SpoolingWarp;
+            ship.Position = Vector3.Zero;
+            ship.TargetPosition = Vector3.Zero;
+            ship.SpatialState.SystemPosition = originPosition;
+            transit.Progress = Math.Clamp(elapsedSeconds / totalDuration, 0f, 1f);
+            subTask.Progress = transit.Progress;
+            return SubTaskOutcome.Active;
+        }
+
+        ship.State = ShipState.Warping;
+        var warpTravelDuration = MathF.Max(0.001f, totalDuration - spoolDurationSeconds);
+        var travelElapsed = Math.Clamp(elapsedSeconds - spoolDurationSeconds, 0f, warpTravelDuration);
+        var travelProgress = Math.Clamp(travelElapsed / warpTravelDuration, 0f, 1f);
+        var travelDelta = destinationPosition.Subtract(originPosition);
+        ship.Position = Vector3.Zero;
+        ship.TargetPosition = Vector3.Zero;
+        ship.SpatialState.SystemPosition = new Vector3(
+            originPosition.X + (travelDelta.X * travelProgress),
+            originPosition.Y + (travelDelta.Y * travelProgress),
+            originPosition.Z + (travelDelta.Z * travelProgress));
+        transit.Progress = Math.Clamp(elapsedSeconds / totalDuration, 0f, 1f);
+        subTask.Progress = transit.Progress;
+        if (elapsedSeconds < totalDuration - 0.001f)
+        {
+            return SubTaskOutcome.Active;
+        }
+
+        return CompleteTransitArrival(ship, subTask.TargetSystemId ?? ship.SystemId, targetPosition, targetAnchor, completeOnArrival);
+    }
+
+    private SubTaskOutcome UpdateFtlTransit(
+      SimulationWorld world,
+      ShipRuntime ship,
+      ShipSubTaskRuntime subTask,
+      float deltaSeconds,
+      string targetSystemId,
+      Vector3 entryPosition,
+      AnchorRuntime? entryAnchor,
+      bool completeOnArrival,
+      Vector3 finalTargetPosition,
+      AnchorRuntime? finalTargetAnchor)
+    {
+        var destinationAnchorId = entryAnchor?.Id;
+        var transit = ship.SpatialState.Transit;
+        if (transit is null || transit.Regime != MovementRegimeKind.FtlTransit || transit.DestinationAnchorId != destinationAnchorId)
+        {
+            var initialTravelDuration = MathF.Max(0.1f, ResolveSystemGalaxyPosition(world, ship.SystemId).DistanceTo(ResolveSystemGalaxyPosition(world, targetSystemId)) / MathF.Max(ship.Definition.FtlSpeed * GetSkillFactor(ship.Skills.Navigation), 0.001f));
+            var initialSpoolDuration = MathF.Max(ship.Definition.SpoolTime, 0.1f);
+            transit = new ShipTransitRuntime
+            {
+                Regime = MovementRegimeKind.FtlTransit,
+                OriginAnchorId = ship.SpatialState.CurrentAnchorId,
+                DestinationAnchorId = destinationAnchorId,
+                StartedAtUtc = world.GeneratedAtUtc,
+                ArrivalDueAtUtc = world.GeneratedAtUtc.AddSeconds(initialSpoolDuration + initialTravelDuration),
+            };
+            ship.SpatialState.Transit = transit;
+            subTask.ElapsedSeconds = 0f;
+        }
+
+        ship.SpatialState.SpaceLayer = SpaceLayerKind.GalaxySpace;
+        ship.SpatialState.MovementRegime = MovementRegimeKind.FtlTransit;
+        ship.SpatialState.CurrentAnchorId = null;
+        ship.SpatialState.DestinationAnchorId = destinationAnchorId;
+
+        var spoolDurationSeconds = MathF.Max(ship.Definition.SpoolTime, 0.1f);
+        var startedAtUtc = transit.StartedAtUtc ?? world.GeneratedAtUtc;
+        var arrivalDueAtUtc = transit.ArrivalDueAtUtc ?? world.GeneratedAtUtc;
+        var totalDuration = MathF.Max(0.1f, (float)(arrivalDueAtUtc - startedAtUtc).TotalSeconds);
+        var elapsedSeconds = Math.Clamp((float)(world.GeneratedAtUtc - startedAtUtc).TotalSeconds, 0f, totalDuration);
+        ship.State = elapsedSeconds < spoolDurationSeconds ? ShipState.SpoolingFtl : ShipState.Ftl;
+        transit.Progress = Math.Clamp(elapsedSeconds / totalDuration, 0f, 1f);
+        subTask.Progress = transit.Progress;
+        if (elapsedSeconds < totalDuration - 0.001f)
+        {
+            return SubTaskOutcome.Active;
+        }
+
+        ship.Position = Vector3.Zero;
+        ship.TargetPosition = finalTargetPosition;
+        ship.SystemId = targetSystemId;
+        ship.SpatialState.CurrentSystemId = targetSystemId;
+        ship.SpatialState.Transit = null;
+        ship.SpatialState.SpaceLayer = SpaceLayerKind.LocalSpace;
+        ship.SpatialState.MovementRegime = MovementRegimeKind.LocalFlight;
+        ship.SpatialState.CurrentAnchorId = entryAnchor?.Id;
+        ship.SpatialState.DestinationAnchorId = finalTargetAnchor?.Id ?? entryAnchor?.Id;
+        ship.SpatialState.SystemPosition = entryPosition;
+        ship.State = ShipState.Arriving;
+
+        // Cross-system travel is only complete once the ship finishes the
+        // destination-system local leg to the actual target.
+        return SubTaskOutcome.Active;
+    }
+
+    private static SubTaskOutcome CompleteTransitArrival(ShipRuntime ship, string targetSystemId, Vector3 targetPosition, AnchorRuntime? targetAnchor, bool completeOnArrival)
+    {
+        ship.Position = targetPosition;
+        ship.TargetPosition = targetPosition;
+        ship.SystemId = targetSystemId;
+        ship.SpatialState.CurrentSystemId = targetSystemId;
+        ship.SpatialState.Transit = null;
+        ship.SpatialState.SpaceLayer = SpaceLayerKind.LocalSpace;
+        ship.SpatialState.MovementRegime = MovementRegimeKind.LocalFlight;
+        ship.SpatialState.CurrentAnchorId = targetAnchor?.Id;
+        ship.SpatialState.DestinationAnchorId = targetAnchor?.Id;
+        var arrivalSystemOffset = SimulationUnits.MetersToKilometers(targetPosition);
+        ship.SpatialState.SystemPosition = targetAnchor is null
+          ? arrivalSystemOffset
+          : new Vector3(
+              targetAnchor.Position.X + arrivalSystemOffset.X,
+              targetAnchor.Position.Y + arrivalSystemOffset.Y,
+              targetAnchor.Position.Z + arrivalSystemOffset.Z);
+        ship.State = ShipState.Arriving;
+        return completeOnArrival ? SubTaskOutcome.Completed : SubTaskOutcome.Active;
+    }
+}

apps/backend/Ships/AI/ShipAiService.Planning.Behaviors.cs

@@ -0,0 +1,179 @@
+using static SpaceGame.Api.Shared.Runtime.SimulationRuntimeSupport;
+using static SpaceGame.Api.Stations.Simulation.InfrastructureSimulationService;
+
+namespace SpaceGame.Api.Ships.AI;
+
+public sealed partial class ShipAiService
+{
+    private static bool IsBehaviorBlockingFailure(string behaviorKind, string? failureReason) => failureReason switch
+    {
+        "missing-item" => true,
+        "no-suitable-buyer" => true,
+        "no-mineable-node" when string.Equals(behaviorKind, ShipBehaviorKinds.LocalAutoMine, StringComparison.Ordinal) => true,
+        _ => false,
+    };
+
+    private static (string BehaviorKind, string SourceId) ResolveBehaviorSource(SimulationWorld world, ShipRuntime ship)
+    {
+        var assignment = ResolveAssignment(world, ship);
+        return assignment is null
+          ? (ship.DefaultBehavior.Kind, ship.DefaultBehavior.Kind)
+          : (assignment.BehaviorKind, assignment.ObjectiveId);
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime> BuildTradeSubTasks(ShipRuntime ship, TradeRoutePlan route)
+    {
+        return
+        [
+            CreateSubTask("sub-acquire-travel", ShipTaskKinds.Travel, $"Travel to {route.SourceStation.Label}", route.SourceStation.SystemId, route.SourceStation.Position, route.SourceStation.Id, MathF.Max(route.SourceStation.Radius + 12f, 12f), 0f),
+            CreateSubTask("sub-acquire-dock", ShipTaskKinds.Dock, $"Dock at {route.SourceStation.Label}", route.SourceStation.SystemId, route.SourceStation.Position, route.SourceStation.Id, 4f, 0f),
+            CreateSubTask("sub-acquire-load", ShipTaskKinds.LoadCargo, $"Load {route.ItemId}", route.SourceStation.SystemId, route.SourceStation.Position, route.SourceStation.Id, 0f, ship.Definition.GetTotalCargoCapacity(), itemId: route.ItemId),
+            CreateSubTask("sub-acquire-undock", ShipTaskKinds.Undock, $"Undock from {route.SourceStation.Label}", route.SourceStation.SystemId, route.SourceStation.Position, route.SourceStation.Id, MathF.Max(4f, 12f), 0f),
+            CreateSubTask("sub-route-travel", ShipTaskKinds.Travel, $"Travel to {route.DestinationStation.Label}", route.DestinationStation.SystemId, route.DestinationStation.Position, route.DestinationStation.Id, MathF.Max(route.DestinationStation.Radius + 12f, 12f), 0f),
+            CreateSubTask("sub-route-dock", ShipTaskKinds.Dock, $"Dock at {route.DestinationStation.Label}", route.DestinationStation.SystemId, route.DestinationStation.Position, route.DestinationStation.Id, 4f, 0f),
+            CreateSubTask("sub-route-unload", ShipTaskKinds.UnloadCargo, $"Unload {route.ItemId}", route.DestinationStation.SystemId, route.DestinationStation.Position, route.DestinationStation.Id, 0f, ship.Definition.GetTotalCargoCapacity(), itemId: route.ItemId),
+            CreateSubTask("sub-route-undock", ShipTaskKinds.Undock, $"Undock from {route.DestinationStation.Label}", route.DestinationStation.SystemId, route.DestinationStation.Position, route.DestinationStation.Id, MathF.Max(4f, 12f), 0f),
+        ];
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime> BuildFleetSupplySubTasks(FleetSupplyPlan plan)
+    {
+        return
+        [
+            CreateSubTask("sub-fleet-source-travel", ShipTaskKinds.Travel, $"Travel to {plan.SourceStation.Label}", plan.SourceStation.SystemId, plan.SourceStation.Position, plan.SourceStation.Id, MathF.Max(plan.SourceStation.Radius + 12f, 12f), 0f),
+            CreateSubTask("sub-fleet-source-dock", ShipTaskKinds.Dock, $"Dock at {plan.SourceStation.Label}", plan.SourceStation.SystemId, plan.SourceStation.Position, plan.SourceStation.Id, 4f, 0f),
+            CreateSubTask("sub-fleet-source-load", ShipTaskKinds.LoadCargo, $"Load {plan.ItemId}", plan.SourceStation.SystemId, plan.SourceStation.Position, plan.SourceStation.Id, 0f, plan.Amount, itemId: plan.ItemId),
+            CreateSubTask("sub-fleet-source-undock", ShipTaskKinds.Undock, $"Undock from {plan.SourceStation.Label}", plan.SourceStation.SystemId, plan.SourceStation.Position, plan.SourceStation.Id, 12f, 0f),
+            CreateSubTask("sub-fleet-follow", ShipTaskKinds.FollowTarget, $"Rendezvous with {plan.TargetShip.Definition.Name}", plan.TargetShip.SystemId, plan.TargetShip.Position, plan.TargetShip.Id, plan.Radius, 6f),
+            CreateSubTask("sub-fleet-transfer", ShipTaskKinds.TransferCargoToShip, $"Transfer {plan.ItemId}", plan.TargetShip.SystemId, plan.TargetShip.Position, plan.TargetShip.Id, plan.Radius, plan.Amount, itemId: plan.ItemId),
+        ];
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime> BuildConstructionSubTasks(ConstructionSiteRuntime site, StationRuntime supportStation)
+    {
+        var targetPosition = supportStation.Position;
+        return
+        [
+            CreateSubTask("sub-construction-travel", ShipTaskKinds.Travel, $"Travel to support station {supportStation.Label}", supportStation.SystemId, targetPosition, supportStation.Id, MathF.Max(supportStation.Radius + 18f, 18f), 0f),
+            CreateSubTask("sub-construction-deliver", ShipTaskKinds.DeliverConstruction, $"Deliver materials to {site.Id}", site.SystemId, supportStation.Position, site.Id, 12f, 0f),
+            CreateSubTask("sub-construction-build", ShipTaskKinds.BuildConstructionSite, $"Build {site.Id}", site.SystemId, supportStation.Position, site.Id, 12f, 0f),
+        ];
+    }
+
+    private static IReadOnlyList<ShipSubTaskRuntime> BuildAttackSubTasks(string targetEntityId, string? targetSystemId, string summary)
+    {
+        return
+        [
+            CreateSubTask("sub-attack", ShipTaskKinds.AttackTarget, summary, targetSystemId ?? string.Empty, Vector3.Zero, targetEntityId, 26f, 0f),
+        ];
+    }
+
+    private static IReadOnlyList<ShipSubTaskRuntime> BuildFlyToObjectSubTasks(string targetSystemId, Vector3 targetPosition, string targetEntityId, string summary)
+    {
+        return
+        [
+            CreateSubTask("sub-fly-object-travel", ShipTaskKinds.Travel, summary, targetSystemId, targetPosition, targetEntityId, 8f, 0f),
+        ];
+    }
+
+    private static IReadOnlyList<ShipSubTaskRuntime> BuildFollowShipSubTasks(ShipRuntime targetShip, float radius, float durationSeconds, string summary) =>
+      BuildFollowSubTasks(targetShip.Id, targetShip.SystemId, targetShip.Position, radius, durationSeconds, summary);
+
+    private static IReadOnlyList<ShipSubTaskRuntime> BuildFollowSubTasks(string targetEntityId, string targetSystemId, Vector3 targetPosition, float radius, float durationSeconds, string summary)
+    {
+        return
+        [
+            CreateSubTask("sub-follow", ShipTaskKinds.FollowTarget, summary, targetSystemId, targetPosition, targetEntityId, radius, durationSeconds),
+        ];
+    }
+
+    private static IReadOnlyList<ShipSubTaskRuntime> BuildHoldSubTasks(ShipRuntime ship, ShipOrderRuntime order)
+    {
+        return
+        [
+            CreateSubTask("sub-hold", ShipTaskKinds.HoldPosition, order.Label ?? "Hold position", order.TargetSystemId ?? ship.SystemId, order.TargetPosition ?? ship.Position, order.TargetEntityId, 0f, 3f),
+        ];
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime> BuildMiningSubTasks(ShipRuntime ship, ResourceNodeRuntime node, StationRuntime homeStation)
+    {
+        var deposit = SelectMiningDeposit(node, ship.Id);
+        var extractionPosition = GetResourceHoldPosition(deposit?.Position ?? Vector3.Zero, ship.Id, 20f);
+        return
+        [
+            CreateSubTask("sub-mine-travel", ShipTaskKinds.Travel, $"Travel to {node.ItemId} field", node.SystemId, Vector3.Zero, node.AnchorId, 8f, 0f, targetAnchorId: node.AnchorId),
+            CreateSubTask("sub-mine", ShipTaskKinds.MineNode, $"Mine {node.ItemId}", node.SystemId, extractionPosition, node.Id, 8f, ship.Definition.GetTotalCargoCapacity(), itemId: node.ItemId, targetAnchorId: node.AnchorId, targetResourceNodeId: node.Id, targetResourceDepositId: deposit?.Id),
+            CreateSubTask("sub-deliver-travel", ShipTaskKinds.Travel, $"Travel to {homeStation.Label}", homeStation.SystemId, homeStation.Position, homeStation.Id, MathF.Max(homeStation.Radius + 12f, 12f), 0f),
+            CreateSubTask("sub-deliver-dock", ShipTaskKinds.Dock, $"Dock at {homeStation.Label}", homeStation.SystemId, homeStation.Position, homeStation.Id, 4f, 0f),
+            CreateSubTask("sub-deliver-unload", ShipTaskKinds.UnloadCargo, $"Unload at {homeStation.Label}", homeStation.SystemId, homeStation.Position, homeStation.Id, 0f, ship.Definition.GetTotalCargoCapacity()),
+            CreateSubTask("sub-deliver-undock", ShipTaskKinds.Undock, $"Undock from {homeStation.Label}", homeStation.SystemId, homeStation.Position, homeStation.Id, MathF.Max(4f, 12f), 0f),
+        ];
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime> BuildLocalMiningSubTasks(ShipRuntime ship, ResourceNodeRuntime node)
+    {
+        var deposit = SelectMiningDeposit(node, ship.Id);
+        var extractionPosition = GetResourceHoldPosition(deposit?.Position ?? Vector3.Zero, ship.Id, 20f);
+        return
+        [
+            CreateSubTask("sub-mine-travel", ShipTaskKinds.Travel, $"Travel to {node.ItemId} field", node.SystemId, Vector3.Zero, node.AnchorId, 8f, 0f, targetAnchorId: node.AnchorId),
+            CreateSubTask("sub-mine", ShipTaskKinds.MineNode, $"Mine {node.ItemId}", node.SystemId, extractionPosition, node.Id, 8f, ship.Definition.GetTotalCargoCapacity(), itemId: node.ItemId, targetAnchorId: node.AnchorId, targetResourceNodeId: node.Id, targetResourceDepositId: deposit?.Id),
+        ];
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime> BuildLocalMiningDeliverySubTasks(ShipRuntime ship, StationRuntime buyer, string itemId)
+    {
+        var amount = MathF.Max(1f, GetInventoryAmount(ship.Inventory, itemId));
+        return
+        [
+            CreateSubTask("sub-deliver-travel", ShipTaskKinds.Travel, $"Travel to {buyer.Label}", buyer.SystemId, buyer.Position, buyer.Id, MathF.Max(buyer.Radius + 12f, 12f), 0f),
+            CreateSubTask("sub-deliver-dock", ShipTaskKinds.Dock, $"Dock at {buyer.Label}", buyer.SystemId, buyer.Position, buyer.Id, 4f, 0f),
+            CreateSubTask("sub-deliver-unload", ShipTaskKinds.UnloadCargo, $"Unload {itemId} at {buyer.Label}", buyer.SystemId, buyer.Position, buyer.Id, 0f, amount, itemId: itemId),
+            CreateSubTask("sub-deliver-undock", ShipTaskKinds.Undock, $"Undock from {buyer.Label}", buyer.SystemId, buyer.Position, buyer.Id, MathF.Max(4f, 12f), 0f),
+        ];
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime> BuildSalvageSubTasks(ShipRuntime ship, WreckRuntime wreck, StationRuntime homeStation, Vector3 approach)
+    {
+        return
+        [
+            CreateSubTask("sub-salvage-travel", ShipTaskKinds.Travel, $"Travel to wreck {wreck.Id}", wreck.SystemId, approach, wreck.Id, 8f, 0f),
+            CreateSubTask("sub-salvage-work", ShipTaskKinds.SalvageWreck, $"Salvage {wreck.ItemId}", wreck.SystemId, approach, wreck.Id, 8f, ship.Definition.GetTotalCargoCapacity(), itemId: wreck.ItemId),
+            CreateSubTask("sub-salvage-deliver-travel", ShipTaskKinds.Travel, $"Travel to {homeStation.Label}", homeStation.SystemId, homeStation.Position, homeStation.Id, MathF.Max(homeStation.Radius + 12f, 12f), 0f),
+            CreateSubTask("sub-salvage-deliver-dock", ShipTaskKinds.Dock, $"Dock at {homeStation.Label}", homeStation.SystemId, homeStation.Position, homeStation.Id, 4f, 0f),
+            CreateSubTask("sub-salvage-deliver-unload", ShipTaskKinds.UnloadCargo, $"Unload salvage at {homeStation.Label}", homeStation.SystemId, homeStation.Position, homeStation.Id, 0f, ship.Definition.GetTotalCargoCapacity(), itemId: wreck.ItemId),
+            CreateSubTask("sub-salvage-deliver-undock", ShipTaskKinds.Undock, $"Undock from {homeStation.Label}", homeStation.SystemId, homeStation.Position, homeStation.Id, 12f, 0f),
+        ];
+    }
+
+    private static ShipSubTaskRuntime CreateSubTask(
+        string id,
+        string kind,
+        string summary,
+        string targetSystemId,
+        Vector3 targetPosition,
+        string? targetEntityId,
+        float threshold,
+        float amount,
+        string? itemId = null,
+        string? moduleId = null,
+        string? targetAnchorId = null,
+        string? targetResourceNodeId = null,
+        string? targetResourceDepositId = null) =>
+        new()
+        {
+            Id = id,
+            Kind = kind,
+            Summary = summary,
+            TargetSystemId = targetSystemId,
+            TargetPosition = targetPosition,
+            TargetEntityId = targetEntityId,
+            TargetAnchorId = targetAnchorId,
+            TargetResourceNodeId = targetResourceNodeId,
+            TargetResourceDepositId = targetResourceDepositId,
+            ItemId = itemId,
+            ModuleId = moduleId,
+            Threshold = threshold,
+            Amount = amount,
+        };
+}

apps/backend/Ships/AI/ShipAiService.Planning.Orders.cs

@@ -0,0 +1,328 @@
+using static SpaceGame.Api.Shared.Runtime.SimulationRuntimeSupport;
+using static SpaceGame.Api.Stations.Simulation.InfrastructureSimulationService;
+using static SpaceGame.Api.Stations.Simulation.StationSimulationService;
+
+namespace SpaceGame.Api.Ships.AI;
+
+public sealed partial class ShipAiService
+{
+    private ShipOrderRuntime? BuildEmergencyOrder(SimulationWorld world, ShipRuntime ship)
+    {
+        var policy = ResolvePolicy(world, ship.PolicySetId);
+        if (policy is null)
+        {
+            return null;
+        }
+
+        var hullRatio = ship.Definition.Hull <= 0.01f ? 1f : ship.Health / ship.Definition.Hull;
+        if (hullRatio > policy.FleeHullRatio)
+        {
+            return null;
+        }
+
+        var hostileNearby = world.Ships.Any(candidate =>
+          candidate.Health > 0f &&
+          candidate.FactionId != ship.FactionId &&
+          candidate.SystemId == ship.SystemId &&
+          candidate.Position.DistanceTo(ship.Position) <= 200f);
+        if (!hostileNearby)
+        {
+            return null;
+        }
+
+        var safeStation = world.Stations
+          .Where(station => station.FactionId == ship.FactionId)
+          .OrderByDescending(station => station.SystemId == ship.SystemId ? 1 : 0)
+          .ThenBy(station => station.Position.DistanceTo(ship.Position))
+          .FirstOrDefault();
+
+        return new ShipOrderRuntime
+        {
+            Id = $"rule-{ship.Id}-flee",
+            Kind = ShipOrderKinds.Flee,
+            SourceKind = ShipOrderSourceKind.Behavior,
+            SourceId = ShipOrderKinds.Flee,
+            Priority = 1000,
+            InterruptCurrentPlan = true,
+            Label = "Emergency retreat",
+            TargetEntityId = safeStation?.Id,
+            TargetSystemId = safeStation?.SystemId ?? ship.SystemId,
+            TargetPosition = safeStation?.Position ?? ship.Position,
+            DestinationStationId = safeStation?.Id,
+            Radius = safeStation is null ? 0f : MathF.Max(balance.ArrivalThreshold, safeStation.Radius + 12f),
+        };
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        return order.Kind switch
+        {
+            var kind when string.Equals(kind, ShipOrderKinds.Flee, StringComparison.Ordinal) => BuildFleeSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.Move, StringComparison.Ordinal) => BuildMoveSubTasks(ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.DockAtStation, StringComparison.Ordinal) => BuildDockOrderSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.FlyToObject, StringComparison.Ordinal) => BuildFlyToObjectOrderSubTasks(world, order),
+            var kind when string.Equals(kind, ShipOrderKinds.FollowShip, StringComparison.Ordinal) => BuildFollowShipOrderSubTasks(world, order),
+            var kind when string.Equals(kind, ShipOrderKinds.TradeRoute, StringComparison.Ordinal) => BuildTradeOrderSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.MineAndDeliver, StringComparison.Ordinal) => BuildMineOrderSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.MineLocal, StringComparison.Ordinal) => BuildMineLocalOrderSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.MineAndDeliverRun, StringComparison.Ordinal) => BuildMineAndDeliverRunOrderSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.SellMinedCargo, StringComparison.Ordinal) => BuildSellMinedCargoOrderSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.SupplyFleetRun, StringComparison.Ordinal) => BuildSupplyFleetOrderSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.SalvageRun, StringComparison.Ordinal) => BuildAutoSalvageOrderSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.BuildAtSite, StringComparison.Ordinal) => BuildBuildOrderSubTasks(world, ship, order),
+            var kind when string.Equals(kind, ShipOrderKinds.AttackTarget, StringComparison.Ordinal) => BuildAttackOrderSubTasks(order),
+            var kind when string.Equals(kind, ShipOrderKinds.HoldPosition, StringComparison.Ordinal) => BuildHoldSubTasks(ship, order),
+            _ => null,
+        };
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime> BuildFleeSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var safeStation = ResolveStation(world, order.TargetEntityId ?? order.DestinationStationId);
+        if (safeStation is null)
+        {
+            return
+            [
+                CreateSubTask("sub-flee-hold", ShipTaskKinds.HoldPosition, "Hold safe position", ship.SystemId, ship.Position, null, 0f, 3f),
+            ];
+        }
+
+        return
+        [
+            CreateSubTask("sub-flee-travel", ShipTaskKinds.Travel, $"Travel to {safeStation.Label}", safeStation.SystemId, safeStation.Position, safeStation.Id, MathF.Max(balance.ArrivalThreshold, safeStation.Radius + 12f), 0f),
+            CreateSubTask("sub-flee-dock", ShipTaskKinds.Dock, $"Dock at {safeStation.Label}", safeStation.SystemId, safeStation.Position, safeStation.Id, 4f, 0f),
+        ];
+    }
+
+    private static IReadOnlyList<ShipSubTaskRuntime> BuildMoveSubTasks(ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var targetSystemId = order.TargetSystemId ?? ship.SystemId;
+        var targetPosition = order.TargetPosition ?? ship.Position;
+        return
+        [
+            CreateSubTask("sub-move-travel", ShipTaskKinds.Travel, order.Label ?? "Travel", targetSystemId, targetPosition, order.TargetEntityId, MathF.Max(0f, order.Radius), 0f),
+        ];
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildDockOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var station = ResolveStation(world, order.TargetEntityId ?? order.DestinationStationId);
+        if (station is null)
+        {
+            order.FailureReason = "station-missing";
+            return null;
+        }
+
+        return
+        [
+            CreateSubTask("sub-dock-travel", ShipTaskKinds.Travel, $"Travel to {station.Label}", station.SystemId, station.Position, station.Id, MathF.Max(balance.ArrivalThreshold, station.Radius + 12f), 0f),
+            CreateSubTask("sub-dock", ShipTaskKinds.Dock, $"Dock at {station.Label}", station.SystemId, station.Position, station.Id, 4f, 0f),
+        ];
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildTradeOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        if (order.SourceStationId is null || order.DestinationStationId is null || order.ItemId is null)
+        {
+            order.FailureReason = "trade-order-incomplete";
+            return null;
+        }
+
+        var route = ResolveTradeRoute(world, order.ItemId, order.SourceStationId, order.DestinationStationId);
+        if (route is null)
+        {
+            order.FailureReason = "trade-route-missing";
+            return null;
+        }
+
+        return BuildTradeSubTasks(ship, route);
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildMineOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var systemId = order.TargetSystemId ?? ship.SystemId;
+        var itemId = order.ItemId;
+        if (string.IsNullOrWhiteSpace(itemId))
+        {
+            order.FailureReason = "mine-order-item-missing";
+            return null;
+        }
+
+        var anchor = ResolveMiningAnchor(world, order.AnchorId, order.TargetEntityId);
+        var node = ResolveNode(world, order.TargetEntityId);
+        if (node is not null)
+        {
+            if (!string.Equals(node.SystemId, systemId, StringComparison.Ordinal))
+            {
+                order.FailureReason = "mine-order-node-system-mismatch";
+                return null;
+            }
+
+            if (!string.Equals(node.ItemId, itemId, StringComparison.Ordinal))
+            {
+                order.FailureReason = "mine-order-node-item-mismatch";
+                return null;
+            }
+        }
+        else
+        {
+            node = SelectLocalMiningNode(world, ship, systemId, itemId, anchor?.Id);
+        }
+
+        if (node is null)
+        {
+            order.FailureReason = "mine-order-node-missing";
+            return null;
+        }
+
+        return BuildLocalMiningSubTasks(ship, node);
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildMineLocalOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var anchor = ResolveMiningAnchor(world, order.AnchorId, order.TargetEntityId);
+        var node = ResolveNode(world, order.TargetEntityId)
+          ?? SelectLocalMiningNode(world, ship, order.TargetSystemId ?? ship.SystemId, order.ItemId ?? ship.DefaultBehavior.ItemId ?? string.Empty, anchor?.Id);
+        if (node is null)
+        {
+            order.FailureReason = "mine-order-incomplete";
+            return null;
+        }
+
+        return BuildLocalMiningSubTasks(ship, node);
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildMineAndDeliverRunOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var anchor = ResolveMiningAnchor(world, order.AnchorId, order.TargetEntityId);
+        var node = ResolveNode(world, order.TargetEntityId)
+          ?? (string.IsNullOrWhiteSpace(order.ItemId)
+            ? null
+            : SelectLocalMiningNode(world, ship, order.TargetSystemId ?? ship.SystemId, order.ItemId, anchor?.Id));
+        var buyer = ResolveStation(world, order.DestinationStationId);
+        if (node is null || buyer is null)
+        {
+            order.FailureReason = "mine-and-deliver-order-incomplete";
+            return null;
+        }
+
+        return BuildMiningSubTasks(ship, node, buyer);
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildSellMinedCargoOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var buyer = ResolveStation(world, order.DestinationStationId ?? order.TargetEntityId);
+        if (buyer is null || string.IsNullOrWhiteSpace(order.ItemId))
+        {
+            order.FailureReason = "sell-order-incomplete";
+            return null;
+        }
+
+        return BuildLocalMiningDeliverySubTasks(ship, buyer, order.ItemId);
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildAutoSalvageOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var homeStation = ResolveStation(world, order.SourceStationId ?? ship.DefaultBehavior.HomeStationId);
+        var wreck = world.Wrecks.FirstOrDefault(candidate => candidate.Id == order.TargetEntityId && candidate.RemainingAmount > 0.01f);
+        if (homeStation is null || wreck is null)
+        {
+            order.FailureReason = "salvage-order-incomplete";
+            return null;
+        }
+
+        var approach = GetFormationPosition(wreck.Position, ship.Id, MathF.Max(8f, order.Radius > 0f ? order.Radius : ship.DefaultBehavior.Radius * 0.25f));
+        return BuildSalvageSubTasks(ship, wreck, homeStation, approach);
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildSupplyFleetOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var sourceStation = ResolveStation(world, order.SourceStationId);
+        var targetShip = world.Ships.FirstOrDefault(candidate => candidate.Id == order.TargetEntityId && candidate.Health > 0f);
+        if (sourceStation is null || targetShip is null || string.IsNullOrWhiteSpace(order.ItemId))
+        {
+            order.FailureReason = "supply-fleet-order-incomplete";
+            return null;
+        }
+
+        var amount = MathF.Min(
+            MathF.Max(10f, ship.Definition.GetTotalCargoCapacity() * 0.5f),
+            GetInventoryAmount(sourceStation.Inventory, order.ItemId));
+        if (amount <= 0.01f)
+        {
+            order.FailureReason = "supply-item-unavailable";
+            return null;
+        }
+
+        var plan = new FleetSupplyPlan(
+            sourceStation,
+            targetShip,
+            order.ItemId,
+            amount,
+            MathF.Max(16f, order.Radius),
+            order.Label ?? $"Supply {targetShip.Definition.Name} with {order.ItemId}");
+        return BuildFleetSupplySubTasks(plan);
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildBuildOrderSubTasks(SimulationWorld world, ShipRuntime ship, ShipOrderRuntime order)
+    {
+        var site = world.ConstructionSites.FirstOrDefault(candidate => candidate.Id == (order.ConstructionSiteId ?? order.TargetEntityId));
+        if (site is null)
+        {
+            order.FailureReason = "construction-site-missing";
+            return null;
+        }
+
+        var supportStation = ResolveSupportStation(world, ship, site);
+        if (supportStation is null)
+        {
+            order.FailureReason = "support-station-missing";
+            return null;
+        }
+
+        return BuildConstructionSubTasks(site, supportStation);
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildAttackOrderSubTasks(ShipOrderRuntime order)
+    {
+        var targetId = order.TargetEntityId;
+        if (targetId is null)
+        {
+            order.FailureReason = "attack-target-missing";
+            return null;
+        }
+
+        return BuildAttackSubTasks(targetId, order.TargetSystemId, order.Label ?? "Attack target");
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildFlyToObjectOrderSubTasks(SimulationWorld world, ShipOrderRuntime order)
+    {
+        var targetEntityId = order.TargetEntityId;
+        if (targetEntityId is null)
+        {
+            order.FailureReason = "target-missing";
+            return null;
+        }
+
+        var objectTarget = ResolveObjectTarget(world, targetEntityId);
+        if (objectTarget is null)
+        {
+            order.FailureReason = "target-missing";
+            return null;
+        }
+
+        return BuildFlyToObjectSubTasks(objectTarget.Value.SystemId, objectTarget.Value.Position, targetEntityId, order.Label ?? $"Fly to {targetEntityId}");
+    }
+
+    private IReadOnlyList<ShipSubTaskRuntime>? BuildFollowShipOrderSubTasks(SimulationWorld world, ShipOrderRuntime order)
+    {
+        var targetShip = world.Ships.FirstOrDefault(candidate => candidate.Id == order.TargetEntityId && candidate.Health > 0f);
+        if (targetShip is null)
+        {
+            order.FailureReason = "target-ship-missing";
+            return null;
+        }
+
+        return BuildFollowShipSubTasks(targetShip, MathF.Max(order.Radius, 18f), MathF.Max(2f, order.WaitSeconds), order.Label ?? $"Follow {targetShip.Definition.Name}");
+    }
+}

apps/backend/Ships/AI/ShipAiService.cs

@@ -0,0 +1,220 @@
+using static SpaceGame.Api.Shared.Runtime.SimulationRuntimeSupport;
+using static SpaceGame.Api.Shared.Runtime.ShipBehaviorKinds;
+
+namespace SpaceGame.Api.Ships.AI;
+
+public sealed partial class ShipAiService
+{
+    private const float WarpEngageDistanceKilometers = 250_000f;
+    private const float FrigateDps = 7f;
+    private const float DestroyerDps = 12f;
+    private const float CruiserDps = 18f;
+    private const float CapitalDps = 26f;
+
+    private readonly IBalanceService balance;
+
+    public ShipAiService(IBalanceService balance)
+    {
+        this.balance = balance;
+    }
+
+    internal void UpdateShip(SimulationWorld world, ShipRuntime ship, float deltaSeconds, ICollection<SimulationEventRecord> events)
+    {
+        if (ship.ReplanCooldownSeconds > 0f)
+        {
+            ship.ReplanCooldownSeconds = MathF.Max(0f, ship.ReplanCooldownSeconds - deltaSeconds);
+        }
+
+        var previousState = ship.State;
+        var previousOrderId = ship.ActiveOrderId;
+        var previousTaskId = GetCurrentSubTask(ship)?.Id;
+
+        SyncEmergencyOrders(world, ship);
+        SyncBehaviorOrders(world, ship);
+        EnsureOrderExecution(world, ship, events);
+        ExecuteOrder(world, ship, deltaSeconds, events);
+        TrackHistory(ship);
+        EmitStateEvents(ship, previousState, previousOrderId, previousTaskId, events);
+    }
+
+    private void EnsureOrderExecution(SimulationWorld world, ShipRuntime ship, ICollection<SimulationEventRecord> events)
+    {
+        var currentOrder = ship.OrderQueue.GetCurrentOrder();
+        if (currentOrder is null)
+        {
+            ClearActiveOrder(ship);
+            ApplyIdleOrBlockedState(world, ship);
+            return;
+        }
+
+        if (currentOrder.Status == OrderStatus.Queued)
+        {
+            currentOrder.Status = OrderStatus.Active;
+        }
+
+        if (!ship.NeedsReplan
+            && string.Equals(ship.ActiveOrderId, currentOrder.Id, StringComparison.Ordinal)
+            && ship.ActiveSubTaskIndex < ship.ActiveSubTasks.Count)
+        {
+            return;
+        }
+
+        if (ship.ReplanCooldownSeconds > 0f && !string.Equals(ship.ActiveOrderId, currentOrder.Id, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        var subTasks = BuildOrderSubTasks(world, ship, currentOrder);
+        if (subTasks is null || subTasks.Count == 0)
+        {
+            FailOrder(ship, currentOrder, currentOrder.FailureReason ?? "order-unavailable");
+            ClearActiveOrder(ship);
+            ship.NeedsReplan = true;
+            ship.ReplanCooldownSeconds = 0.1f;
+            ship.LastReplanReason = currentOrder.FailureReason ?? "order-unavailable";
+            events.Add(new SimulationEventRecord("ship", ship.Id, "order-failed", $"{ship.Definition.Name} failed {currentOrder.Label ?? currentOrder.Kind}.", DateTimeOffset.UtcNow));
+            ApplyIdleOrBlockedState(world, ship);
+            return;
+        }
+
+        BeginOrderExecution(ship, currentOrder, subTasks);
+        events.Add(new SimulationEventRecord("ship", ship.Id, "order-started", $"{ship.Definition.Name} started {currentOrder.Label ?? currentOrder.Kind}.", DateTimeOffset.UtcNow));
+    }
+
+    private void ExecuteOrder(SimulationWorld world, ShipRuntime ship, float deltaSeconds, ICollection<SimulationEventRecord> events)
+    {
+        var order = ship.ActiveOrderId is null ? null : ship.OrderQueue.FindById(ship.ActiveOrderId);
+        if (order is null)
+        {
+            ClearActiveOrder(ship);
+            ApplyIdleOrBlockedState(world, ship);
+            return;
+        }
+
+        if (ship.ActiveSubTaskIndex >= ship.ActiveSubTasks.Count)
+        {
+            CompleteOrderExecution(ship, order, events);
+            return;
+        }
+
+        var subTask = ship.ActiveSubTasks[ship.ActiveSubTaskIndex];
+        if (subTask.Status == WorkStatus.Pending)
+        {
+            subTask.Status = WorkStatus.Active;
+        }
+        else if (subTask.Status == WorkStatus.Blocked)
+        {
+            ship.State = ShipState.Blocked;
+            ship.TargetPosition = subTask.TargetPosition ?? ship.Position;
+            return;
+        }
+
+        var outcome = UpdateSubTask(world, ship, subTask, deltaSeconds);
+        switch (outcome)
+        {
+            case SubTaskOutcome.Active:
+                return;
+            case SubTaskOutcome.Completed:
+                subTask.Status = WorkStatus.Completed;
+                subTask.Progress = 1f;
+                ship.ActiveSubTaskIndex += 1;
+                if (ship.ActiveSubTaskIndex >= ship.ActiveSubTasks.Count)
+                {
+                    CompleteOrderExecution(ship, order, events);
+                }
+
+                return;
+            case SubTaskOutcome.Failed:
+                subTask.Status = WorkStatus.Failed;
+                FailOrderExecution(ship, order, subTask.BlockingReason ?? "subtask-failed", events);
+                return;
+        }
+    }
+
+    private static void BeginOrderExecution(ShipRuntime ship, ShipOrderRuntime order, IReadOnlyList<ShipSubTaskRuntime> subTasks)
+    {
+        ship.ActiveOrderId = order.Id;
+        ship.ActiveSubTaskIndex = 0;
+        ship.ActiveSubTasks.Clear();
+        ship.ActiveSubTasks.AddRange(subTasks);
+        ship.NeedsReplan = false;
+        ship.ReplanCooldownSeconds = 0f;
+        ship.LastReplanReason = "order-execution-started";
+        ship.LastDeltaSignature = string.Empty;
+    }
+
+    private static void ClearActiveOrder(ShipRuntime ship)
+    {
+        ship.ActiveOrderId = null;
+        ship.ActiveSubTaskIndex = 0;
+        ship.ActiveSubTasks.Clear();
+    }
+
+    private void CompleteOrderExecution(ShipRuntime ship, ShipOrderRuntime order, ICollection<SimulationEventRecord> events)
+    {
+        ship.OrderQueue.TryCompleteOrder(order.Id);
+        if (order.SourceKind == ShipOrderSourceKind.Behavior
+            && string.Equals(order.SourceId, RepeatOrders, StringComparison.Ordinal)
+            && ship.DefaultBehavior.RepeatOrders.Count > 0)
+        {
+            ship.DefaultBehavior.RepeatIndex = (ship.DefaultBehavior.RepeatIndex + 1) % ship.DefaultBehavior.RepeatOrders.Count;
+        }
+
+        ClearActiveOrder(ship);
+        ship.NeedsReplan = true;
+        ship.ReplanCooldownSeconds = 0.25f;
+        ship.LastReplanReason = "order-completed";
+        ship.LastDeltaSignature = string.Empty;
+        events.Add(new SimulationEventRecord("ship", ship.Id, "order-completed", $"{ship.Definition.Name} completed {order.Label ?? order.Kind}.", DateTimeOffset.UtcNow));
+    }
+
+    private void FailOrderExecution(ShipRuntime ship, ShipOrderRuntime order, string failureReason, ICollection<SimulationEventRecord> events)
+    {
+        FailOrder(ship, order, failureReason);
+        ClearActiveOrder(ship);
+        ship.NeedsReplan = true;
+        ship.ReplanCooldownSeconds = 0.5f;
+        ship.LastReplanReason = failureReason;
+        ship.LastDeltaSignature = string.Empty;
+        events.Add(new SimulationEventRecord("ship", ship.Id, "order-failed", $"{ship.Definition.Name} failed {order.Label ?? order.Kind}.", DateTimeOffset.UtcNow));
+    }
+
+    private static void FailOrder(ShipRuntime ship, ShipOrderRuntime order, string failureReason)
+    {
+        ship.OrderQueue.TryFailOrder(order.Id, failureReason);
+        ship.LastDeltaSignature = string.Empty;
+    }
+
+    private static ShipSubTaskRuntime? GetCurrentSubTask(ShipRuntime ship) =>
+      ship.ActiveSubTaskIndex >= ship.ActiveSubTasks.Count ? null : ship.ActiveSubTasks[ship.ActiveSubTaskIndex];
+
+    private void ApplyIdleOrBlockedState(SimulationWorld world, ShipRuntime ship)
+    {
+        var (behaviorKind, _) = ResolveBehaviorSource(world, ship);
+        if (IsBehaviorBlockingFailure(behaviorKind, ship.LastAccessFailureReason))
+        {
+            ship.State = ShipState.Blocked;
+            ship.TargetPosition = ship.Position;
+            return;
+        }
+
+        ship.State = ShipState.Idle;
+        ship.TargetPosition = ship.Position;
+    }
+
+    private void SyncEmergencyOrders(SimulationWorld world, ShipRuntime ship)
+    {
+        var desiredOrder = BuildEmergencyOrder(world, ship);
+        ship.OrderQueue.RemoveWhere(order =>
+            order.SourceKind == ShipOrderSourceKind.Behavior
+            && string.Equals(order.SourceId, ShipOrderKinds.Flee, StringComparison.Ordinal)
+            && (desiredOrder is null || !string.Equals(order.Id, desiredOrder.Id, StringComparison.Ordinal)));
+
+        if (desiredOrder is null)
+        {
+            return;
+        }
+
+        ship.OrderQueue.AddOrReplaceManagedOrderAtFront(desiredOrder);
+    }
+}

apps/backend/Ships/AI/ShipBootstrapPolicy.cs

@@ -0,0 +1,31 @@
+using static SpaceGame.Api.Shared.Runtime.SimulationRuntimeSupport;
+
+namespace SpaceGame.Api.Ships.AI;
+
+internal static class ShipBootstrapPolicy
+{
+    internal static ShipSkillProfileRuntime CreateSkills(ShipDefinition definition)
+    {
+        if (IsTransportShip(definition))
+        {
+            return new ShipSkillProfileRuntime { Navigation = 3, Trade = 4, Mining = 1, Combat = 1, Construction = 1 };
+        }
+
+        if (IsConstructionShip(definition))
+        {
+            return new ShipSkillProfileRuntime { Navigation = 3, Trade = 1, Mining = 1, Combat = 1, Construction = 4 };
+        }
+
+        if (IsMilitaryShip(definition))
+        {
+            return new ShipSkillProfileRuntime { Navigation = 4, Trade = 1, Mining = 1, Combat = 4, Construction = 1 };
+        }
+
+        if (IsMiningShip(definition))
+        {
+            return new ShipSkillProfileRuntime { Navigation = 3, Trade = 1, Mining = 4, Combat = 1, Construction = 1 };
+        }
+
+        return new ShipSkillProfileRuntime { Navigation = 3, Trade = 2, Mining = 1, Combat = 1, Construction = 1 };
+    }
+}

apps/backend/Ships/Api/EnqueueShipOrderHandler.cs

@@ -4,36 +4,35 @@ namespace SpaceGame.Api.Ships.Api;
 
 public sealed class EnqueueShipOrderHandler(WorldService worldService) : Endpoint<ShipOrderCommandRequest, ShipSnapshot>
 {
-  public override void Configure()
-  {
-    Post("/api/ships/{shipId}/orders");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(ShipOrderCommandRequest request, CancellationToken cancellationToken)
-  {
-    var shipId = Route<string>("shipId");
-    if (string.IsNullOrWhiteSpace(shipId))
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Post("/api/ships/{shipId}/orders");
     }
 
-    try
+    public override async Task HandleAsync(ShipOrderCommandRequest request, CancellationToken cancellationToken)
     {
-      var snapshot = worldService.EnqueueShipOrder(shipId, request);
-      if (snapshot is null)
-      {
-        await SendNotFoundAsync(cancellationToken);
-        return;
-      }
+        var shipId = Route<string>("shipId");
+        if (string.IsNullOrWhiteSpace(shipId))
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
 
-      await SendOkAsync(snapshot, cancellationToken);
+        try
+        {
+            var snapshot = worldService.EnqueueShipOrder(shipId, request);
+            if (snapshot is null)
+            {
+                await SendNotFoundAsync(cancellationToken);
+                return;
+            }
+
+            await SendOkAsync(snapshot, cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
     }
-    catch (InvalidOperationException ex)
-    {
-      AddError(ex.Message);
-      await SendErrorsAsync(cancellation: cancellationToken);
-    }
-  }
 }

apps/backend/Ships/Api/GetShipAutomationCatalogHandler.cs

@@ -0,0 +1,35 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Ships.Api;
+
+public sealed class GetShipAutomationCatalogHandler : EndpointWithoutRequest<ShipAutomationCatalogSnapshot>
+{
+    public override void Configure()
+    {
+        Get("/api/ships/catalog");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken cancellationToken)
+    {
+        var snapshot = new ShipAutomationCatalogSnapshot(
+          ShipAutomationCatalog.Behaviors
+            .Select(definition => new ShipBehaviorDefinitionSnapshot(
+              definition.Id,
+              definition.Label,
+              definition.Category,
+              definition.SupportStatus.ToString(),
+              definition.Notes))
+            .ToList(),
+          ShipAutomationCatalog.Orders
+            .Select(definition => new ShipOrderDefinitionSnapshot(
+              definition.Id,
+              definition.Label,
+              definition.Category,
+              definition.SupportStatus.ToString(),
+              definition.Notes))
+            .ToList());
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
+}

apps/backend/Ships/Api/RemoveShipOrderHandler.cs

@@ -4,27 +4,26 @@ namespace SpaceGame.Api.Ships.Api;
 
 public sealed class RemoveShipOrderRequest
 {
-  public string ShipId { get; set; } = string.Empty;
-  public string OrderId { get; set; } = string.Empty;
+    public string ShipId { get; set; } = string.Empty;
+    public string OrderId { get; set; } = string.Empty;
 }
 
 public sealed class RemoveShipOrderHandler(WorldService worldService) : Endpoint<RemoveShipOrderRequest, ShipSnapshot>
 {
-  public override void Configure()
-  {
-    Delete("/api/ships/{shipId}/orders/{orderId}");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(RemoveShipOrderRequest request, CancellationToken cancellationToken)
-  {
-    var snapshot = worldService.RemoveShipOrder(request.ShipId, request.OrderId);
-    if (snapshot is null)
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Delete("/api/ships/{shipId}/orders/{orderId}");
     }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+    public override async Task HandleAsync(RemoveShipOrderRequest request, CancellationToken cancellationToken)
+    {
+        var snapshot = worldService.RemoveShipOrder(request.ShipId, request.OrderId);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/Ships/Api/ReorderShipOrderHandler.cs

@@ -0,0 +1,31 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Ships.Api;
+
+public sealed class ReorderShipOrderHandler(WorldService worldService) : Endpoint<ShipOrderReorderRequest, ShipSnapshot>
+{
+    public override void Configure()
+    {
+        Put("/api/ships/{shipId}/orders/{orderId}/position");
+    }
+
+    public override async Task HandleAsync(ShipOrderReorderRequest request, CancellationToken cancellationToken)
+    {
+        var shipId = Route<string>("shipId");
+        var orderId = Route<string>("orderId");
+        if (string.IsNullOrWhiteSpace(shipId) || string.IsNullOrWhiteSpace(orderId))
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        var snapshot = worldService.ReorderShipOrder(shipId, orderId, request);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
+}

apps/backend/Ships/Api/UpdateShipDefaultBehaviorHandler.cs

@@ -4,28 +4,27 @@ namespace SpaceGame.Api.Ships.Api;
 
 public sealed class UpdateShipDefaultBehaviorHandler(WorldService worldService) : Endpoint<ShipDefaultBehaviorCommandRequest, ShipSnapshot>
 {
-  public override void Configure()
-  {
-    Put("/api/ships/{shipId}/default-behavior");
-    AllowAnonymous();
-  }
-
-  public override async Task HandleAsync(ShipDefaultBehaviorCommandRequest request, CancellationToken cancellationToken)
-  {
-    var shipId = Route<string>("shipId");
-    if (string.IsNullOrWhiteSpace(shipId))
+    public override void Configure()
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
+        Put("/api/ships/{shipId}/default-behavior");
     }
 
-    var snapshot = worldService.UpdateShipDefaultBehavior(shipId, request);
-    if (snapshot is null)
+    public override async Task HandleAsync(ShipDefaultBehaviorCommandRequest request, CancellationToken cancellationToken)
     {
-      await SendNotFoundAsync(cancellationToken);
-      return;
-    }
+        var shipId = Route<string>("shipId");
+        if (string.IsNullOrWhiteSpace(shipId))
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
 
-    await SendOkAsync(snapshot, cancellationToken);
-  }
+        var snapshot = worldService.UpdateShipDefaultBehavior(shipId, request);
+        if (snapshot is null)
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        await SendOkAsync(snapshot, cancellationToken);
+    }
 }

apps/backend/Ships/Api/UpdateShipOrderHandler.cs

@@ -0,0 +1,39 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Ships.Api;
+
+public sealed class UpdateShipOrderHandler(WorldService worldService) : Endpoint<ShipOrderUpdateCommandRequest, ShipSnapshot>
+{
+    public override void Configure()
+    {
+        Put("/api/ships/{shipId}/orders/{orderId}");
+    }
+
+    public override async Task HandleAsync(ShipOrderUpdateCommandRequest request, CancellationToken cancellationToken)
+    {
+        var shipId = Route<string>("shipId");
+        var orderId = Route<string>("orderId");
+        if (string.IsNullOrWhiteSpace(shipId) || string.IsNullOrWhiteSpace(orderId))
+        {
+            await SendNotFoundAsync(cancellationToken);
+            return;
+        }
+
+        try
+        {
+            var snapshot = worldService.UpdateShipOrder(shipId, orderId, request);
+            if (snapshot is null)
+            {
+                await SendNotFoundAsync(cancellationToken);
+                return;
+            }
+
+            await SendOkAsync(snapshot, cancellationToken);
+        }
+        catch (InvalidOperationException ex)
+        {
+            AddError(ex.Message);
+            await SendErrorsAsync(cancellation: cancellationToken);
+        }
+    }
+}

apps/backend/Ships/Contracts/ShipAutomation.cs

@@ -0,0 +1,19 @@
+namespace SpaceGame.Api.Ships.Contracts;
+
+public sealed record ShipBehaviorDefinitionSnapshot(
+  string Id,
+  string Label,
+  string Category,
+  string SupportStatus,
+  string Notes);
+
+public sealed record ShipOrderDefinitionSnapshot(
+  string Id,
+  string Label,
+  string Category,
+  string SupportStatus,
+  string Notes);
+
+public sealed record ShipAutomationCatalogSnapshot(
+  IReadOnlyList<ShipBehaviorDefinitionSnapshot> Behaviors,
+  IReadOnlyList<ShipOrderDefinitionSnapshot> Orders);

apps/backend/Ships/Contracts/ShipCommands.cs

@@ -11,7 +11,7 @@ public sealed record ShipOrderCommandRequest(
   string? SourceStationId,
   string? DestinationStationId,
   string? ItemId,
-  string? NodeId,
+  string? AnchorId,
   string? ConstructionSiteId,
   string? ModuleId,
   float? WaitSeconds,
@@ -19,6 +19,28 @@ public sealed record ShipOrderCommandRequest(
   int? MaxSystemRange,
   bool? KnownStationsOnly);
 
+public sealed record ShipOrderUpdateCommandRequest(
+  string Kind,
+  int Priority,
+  bool InterruptCurrentPlan,
+  string? Label,
+  string? TargetEntityId,
+  string? TargetSystemId,
+  Vector3Dto? TargetPosition,
+  string? SourceStationId,
+  string? DestinationStationId,
+  string? ItemId,
+  string? AnchorId,
+  string? ConstructionSiteId,
+  string? ModuleId,
+  float? WaitSeconds,
+  float? Radius,
+  int? MaxSystemRange,
+  bool? KnownStationsOnly);
+
+public sealed record ShipOrderReorderRequest(
+  int TargetIndex);
+
 public sealed record ShipOrderTemplateCommandRequest(
   string Kind,
   string? Label,
@@ -28,7 +50,7 @@ public sealed record ShipOrderTemplateCommandRequest(
   string? SourceStationId,
   string? DestinationStationId,
   string? ItemId,
-  string? NodeId,
+  string? AnchorId,
   string? ConstructionSiteId,
   string? ModuleId,
   float? WaitSeconds,
@@ -42,8 +64,8 @@ public sealed record ShipDefaultBehaviorCommandRequest(
   string? HomeStationId,
   string? AreaSystemId,
   string? TargetEntityId,
-  string? PreferredItemId,
-  string? PreferredNodeId,
+  string? ItemId,
+  string? PreferredAnchorId,
   string? PreferredConstructionSiteId,
   string? PreferredModuleId,
   Vector3Dto? TargetPosition,

apps/backend/Ships/Contracts/Ships.cs

@@ -10,6 +10,8 @@ public sealed record ShipSkillProfileSnapshot(
 public sealed record ShipOrderSnapshot(
   string Id,
   string Kind,
+  string SourceKind,
+  string SourceId,
   string Status,
   int Priority,
   bool InterruptCurrentPlan,
@@ -21,7 +23,7 @@ public sealed record ShipOrderSnapshot(
   string? SourceStationId,
   string? DestinationStationId,
   string? ItemId,
-  string? NodeId,
+  string? AnchorId,
   string? ConstructionSiteId,
   string? ModuleId,
   float WaitSeconds,
@@ -39,7 +41,7 @@ public sealed record ShipOrderTemplateSnapshot(
   string? SourceStationId,
   string? DestinationStationId,
   string? ItemId,
-  string? NodeId,
+  string? AnchorId,
   string? ConstructionSiteId,
   string? ModuleId,
   float WaitSeconds,
@@ -53,8 +55,8 @@ public sealed record DefaultBehaviorSnapshot(
   string? HomeStationId,
   string? AreaSystemId,
   string? TargetEntityId,
-  string? PreferredItemId,
-  string? PreferredNodeId,
+  string? ItemId,
+  string? PreferredAnchorId,
   string? PreferredConstructionSiteId,
   string? PreferredModuleId,
   Vector3Dto? TargetPosition,
@@ -93,7 +95,9 @@ public sealed record ShipSubTaskSnapshot(
   string Summary,
   string? TargetEntityId,
   string? TargetSystemId,
-  string? TargetNodeId,
+  string? TargetAnchorId,
+  string? TargetResourceNodeId,
+  string? TargetResourceDepositId,
   Vector3Dto? TargetPosition,
   string? ItemId,
   string? ModuleId,
@@ -104,35 +108,13 @@ public sealed record ShipSubTaskSnapshot(
   float TotalSeconds,
   string? BlockingReason);
 
-public sealed record ShipPlanStepSnapshot(
-  string Id,
-  string Kind,
-  string Status,
-  string Summary,
-  string? BlockingReason,
-  int CurrentSubTaskIndex,
-  IReadOnlyList<ShipSubTaskSnapshot> SubTasks);
-
-public sealed record ShipPlanSnapshot(
-  string Id,
-  string SourceKind,
-  string SourceId,
-  string Kind,
-  string Status,
-  string Summary,
-  int CurrentStepIndex,
-  DateTimeOffset CreatedAtUtc,
-  DateTimeOffset UpdatedAtUtc,
-  string? InterruptReason,
-  string? FailureReason,
-  IReadOnlyList<ShipPlanStepSnapshot> Steps);
-
 public sealed record ShipSnapshot(
   string Id,
-  string Label,
-  string Kind,
-  string Class,
+  string Name,
+  string Purpose,
+  string Type,
   string SystemId,
+  string? AnchorId,
   Vector3Dto LocalPosition,
   Vector3Dto LocalVelocity,
   Vector3Dto TargetLocalPosition,
@@ -141,19 +123,17 @@ public sealed record ShipSnapshot(
   DefaultBehaviorSnapshot DefaultBehavior,
   ShipAssignmentSnapshot? Assignment,
   ShipSkillProfileSnapshot Skills,
-  ShipPlanSnapshot? ActivePlan,
-  string? CurrentStepId,
   IReadOnlyList<ShipSubTaskSnapshot> ActiveSubTasks,
   string ControlSourceKind,
   string? ControlSourceId,
   string? ControlReason,
   string? LastReplanReason,
   string? LastAccessFailureReason,
-  string? CelestialId,
   string? DockedStationId,
   string? CommanderId,
   string? PolicySetId,
   float CargoCapacity,
+  IReadOnlyList<string> CargoTypes,
   float TravelSpeed,
   string TravelSpeedUnit,
   IReadOnlyList<InventoryEntry> Inventory,
@@ -164,10 +144,11 @@ public sealed record ShipSnapshot(
 
 public sealed record ShipDelta(
   string Id,
-  string Label,
-  string Kind,
-  string Class,
+  string Name,
+  string Purpose,
+  string Type,
   string SystemId,
+  string? AnchorId,
   Vector3Dto LocalPosition,
   Vector3Dto LocalVelocity,
   Vector3Dto TargetLocalPosition,
@@ -176,19 +157,17 @@ public sealed record ShipDelta(
   DefaultBehaviorSnapshot DefaultBehavior,
   ShipAssignmentSnapshot? Assignment,
   ShipSkillProfileSnapshot Skills,
-  ShipPlanSnapshot? ActivePlan,
-  string? CurrentStepId,
   IReadOnlyList<ShipSubTaskSnapshot> ActiveSubTasks,
   string ControlSourceKind,
   string? ControlSourceId,
   string? ControlReason,
   string? LastReplanReason,
   string? LastAccessFailureReason,
-  string? CelestialId,
   string? DockedStationId,
   string? CommanderId,
   string? PolicySetId,
   float CargoCapacity,
+  IReadOnlyList<string> CargoTypes,
   float TravelSpeed,
   string TravelSpeedUnit,
   IReadOnlyList<InventoryEntry> Inventory,
@@ -200,17 +179,17 @@ public sealed record ShipDelta(
 public sealed record ShipSpatialStateSnapshot(
   string SpaceLayer,
   string CurrentSystemId,
-  string? CurrentCelestialId,
+  string? CurrentAnchorId,
   Vector3Dto? LocalPosition,
   Vector3Dto? SystemPosition,
   string MovementRegime,
-  string? DestinationNodeId,
+  string? DestinationAnchorId,
   ShipTransitSnapshot? Transit);
 
 public sealed record ShipTransitSnapshot(
   string Regime,
-  string? OriginNodeId,
-  string? DestinationNodeId,
+  string? OriginAnchorId,
+  string? DestinationAnchorId,
   DateTimeOffset? StartedAtUtc,
   DateTimeOffset? ArrivalDueAtUtc,
   float Progress);

apps/backend/Ships/Runtime/ShipRuntimeModels.cs

@@ -2,156 +2,312 @@ namespace SpaceGame.Api.Ships.Runtime;
 
 public sealed class ShipRuntime
 {
-  public required string Id { get; init; }
-  public required string SystemId { get; set; }
-  public required ShipDefinition Definition { get; init; }
-  public required string FactionId { get; init; }
-  public required Vector3 Position { get; set; }
-  public required Vector3 TargetPosition { get; set; }
-  public required ShipSpatialStateRuntime SpatialState { get; set; }
-  public Vector3 Velocity { get; set; } = Vector3.Zero;
-  public ShipState State { get; set; } = ShipState.Idle;
-  public required DefaultBehaviorRuntime DefaultBehavior { get; set; }
-  public List<ShipOrderRuntime> OrderQueue { get; } = [];
-  public ShipPlanRuntime? ActivePlan { get; set; }
-  public required ShipSkillProfileRuntime Skills { get; set; }
-  public bool NeedsReplan { get; set; } = true;
-  public float ReplanCooldownSeconds { get; set; }
-  public Dictionary<string, float> Inventory { get; } = new(StringComparer.Ordinal);
-  public string? DockedStationId { get; set; }
-  public int? AssignedDockingPadIndex { get; set; }
-  public string? CommanderId { get; set; }
-  public string? PolicySetId { get; set; }
-  public string ControlSourceKind { get; set; } = "unassigned";
-  public string? ControlSourceId { get; set; }
-  public string? ControlReason { get; set; }
-  public string? LastReplanReason { get; set; }
-  public string? LastAccessFailureReason { get; set; }
-  public float Health { get; set; }
-  public HashSet<string> KnownStationIds { get; } = new(StringComparer.Ordinal);
-  public List<string> History { get; } = [];
-  public string LastSignature { get; set; } = string.Empty;
-  public string LastDeltaSignature { get; set; } = string.Empty;
+    public required string Id { get; init; }
+    public required string SystemId { get; set; }
+    public required ShipDefinition Definition { get; init; }
+    public required string FactionId { get; init; }
+    public required Vector3 Position { get; set; }
+    public required Vector3 TargetPosition { get; set; }
+    public required ShipSpatialStateRuntime SpatialState { get; set; }
+    public Vector3 Velocity { get; set; } = Vector3.Zero;
+    public ShipState State { get; set; } = ShipState.Idle;
+    public required DefaultBehaviorRuntime DefaultBehavior { get; set; }
+    public ShipOrderQueue OrderQueue { get; } = new();
+    public required ShipSkillProfileRuntime Skills { get; set; }
+    public bool NeedsReplan { get; set; } = true;
+    public float ReplanCooldownSeconds { get; set; }
+    public Dictionary<string, float> Inventory { get; } = new(StringComparer.Ordinal);
+    public string? DockedStationId { get; set; }
+    public int? AssignedDockingPadIndex { get; set; }
+    public string? CommanderId { get; set; }
+    public string? PolicySetId { get; set; }
+    public string ControlSourceKind { get; set; } = "unassigned";
+    public string? ControlSourceId { get; set; }
+    public string? ControlReason { get; set; }
+    public string? LastReplanReason { get; set; }
+    public string? LastAccessFailureReason { get; set; }
+    public float Health { get; set; }
+    public HashSet<string> KnownStationIds { get; } = new(StringComparer.Ordinal);
+    public List<string> History { get; } = [];
+    public string? ActiveOrderId { get; set; }
+    public int ActiveSubTaskIndex { get; set; }
+    public List<ShipSubTaskRuntime> ActiveSubTasks { get; } = [];
+    public string LastSignature { get; set; } = string.Empty;
+    public string LastDeltaSignature { get; set; } = string.Empty;
+}
+
+public sealed class ShipOrderQueue : IReadOnlyList<ShipOrderRuntime>
+{
+    public const int MaxOrders = 8;
+
+    private readonly List<ShipOrderRuntime> _orders = [];
+
+    public int Count => _orders.Count;
+
+    public ShipOrderRuntime this[int index] => _orders[index];
+
+    public IEnumerator<ShipOrderRuntime> GetEnumerator() => _orders.GetEnumerator();
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+    public void Enqueue(ShipOrderRuntime order)
+    {
+        if (_orders.Count >= MaxOrders)
+        {
+            throw new InvalidOperationException("Order queue is full.");
+        }
+
+        _orders.Add(order);
+    }
+
+    public void EnqueuePlayerOrder(ShipOrderRuntime order)
+    {
+        if (order.SourceKind != ShipOrderSourceKind.Player)
+        {
+            throw new InvalidOperationException("Player segment only accepts player orders.");
+        }
+
+        EnsureCapacityForNewOrder(order.Id);
+        _orders.Insert(GetManagedInsertionIndex(), order);
+    }
+
+    public void EnqueueManagedOrder(ShipOrderRuntime order)
+    {
+        EnsureCapacityForNewOrder(order.Id);
+        _orders.Add(order);
+    }
+
+    public void AddOrReplaceManagedOrder(ShipOrderRuntime order)
+      => AddOrReplaceManagedOrder(order, insertAtFront: false);
+
+    public void AddOrReplaceManagedOrderAtFront(ShipOrderRuntime order)
+      => AddOrReplaceManagedOrder(order, insertAtFront: true);
+
+    private void AddOrReplaceManagedOrder(ShipOrderRuntime order, bool insertAtFront)
+    {
+        var existingIndex = _orders.FindIndex(candidate => string.Equals(candidate.Id, order.Id, StringComparison.Ordinal));
+        if (existingIndex >= 0)
+        {
+            _orders[existingIndex] = order;
+            return;
+        }
+
+        EnsureCapacityForNewOrder(order.Id);
+        if (insertAtFront)
+        {
+            _orders.Insert(GetManagedInsertionIndex(), order);
+            return;
+        }
+
+        _orders.Add(order);
+    }
+
+    public bool Remove(ShipOrderRuntime order) => RemoveById(order.Id);
+
+    public bool RemoveById(string orderId) => _orders.RemoveAll(order => string.Equals(order.Id, orderId, StringComparison.Ordinal)) > 0;
+
+    public int RemoveWhere(Predicate<ShipOrderRuntime> predicate) => _orders.RemoveAll(predicate);
+
+    public ShipOrderRuntime? FindById(string orderId) => _orders.FirstOrDefault(order => string.Equals(order.Id, orderId, StringComparison.Ordinal));
+
+    public ShipOrderRuntime? FindLeadingOrderForSource(ShipOrderSourceKind sourceKind) =>
+      _orders.FirstOrDefault(order => order.SourceKind == sourceKind);
+
+    public string? GetLeadingOrderLabelForSource(ShipOrderSourceKind sourceKind) =>
+      FindLeadingOrderForSource(sourceKind) is { } order
+        ? order.Label ?? order.Kind
+        : null;
+
+    public bool HasOrdersFromSource(ShipOrderSourceKind sourceKind) => _orders.Any(order => order.SourceKind == sourceKind);
+
+    public ShipOrderRuntime? GetCurrentOrder() =>
+      _orders.FirstOrDefault(order => order.Status is OrderStatus.Queued or OrderStatus.Active);
+
+    public bool TryMovePlayerOrder(string orderId, int targetIndex)
+    {
+        var currentIndex = _orders.FindIndex(order => string.Equals(order.Id, orderId, StringComparison.Ordinal));
+        if (currentIndex < 0)
+        {
+            return false;
+        }
+
+        var order = _orders[currentIndex];
+        if (order.SourceKind != ShipOrderSourceKind.Player)
+        {
+            return false;
+        }
+
+        var playerOrderIds = _orders
+          .Select((candidate, index) => (candidate, index))
+          .Where(entry => entry.candidate.SourceKind == ShipOrderSourceKind.Player)
+          .Select(entry => entry.index)
+          .ToList();
+        if (playerOrderIds.Count <= 1)
+        {
+            return true;
+        }
+
+        var clampedPlayerIndex = Math.Clamp(targetIndex, 0, playerOrderIds.Count - 1);
+        var destinationIndex = playerOrderIds[clampedPlayerIndex];
+        if (currentIndex == destinationIndex)
+        {
+            return true;
+        }
+
+        _orders.RemoveAt(currentIndex);
+        if (currentIndex < destinationIndex)
+        {
+            destinationIndex -= 1;
+        }
+
+        _orders.Insert(destinationIndex, order);
+        return true;
+    }
+
+    public bool TryCompleteOrder(string orderId) => TryTransitionOrder(orderId, OrderStatus.Completed);
+
+    public bool TryFailOrder(string orderId, string? failureReason = null)
+    {
+        var order = FindById(orderId);
+        if (order is null)
+        {
+            return false;
+        }
+
+        order.FailureReason = failureReason ?? order.FailureReason;
+        if (order.SourceKind == ShipOrderSourceKind.Player)
+        {
+            order.Status = OrderStatus.Failed;
+            return true;
+        }
+
+        return TryTransitionOrder(orderId, OrderStatus.Failed);
+    }
+
+    public bool TryTransitionOrder(string orderId, OrderStatus terminalStatus)
+    {
+        var order = FindById(orderId);
+        if (order is null)
+        {
+            return false;
+        }
+
+        order.Status = terminalStatus;
+        return RemoveById(orderId);
+    }
+
+    private int GetManagedInsertionIndex() =>
+      _orders.TakeWhile(order => order.SourceKind == ShipOrderSourceKind.Player).Count();
+
+    private void EnsureCapacityForNewOrder(string orderId)
+    {
+        if (FindById(orderId) is not null)
+        {
+            return;
+        }
+
+        if (_orders.Count >= MaxOrders)
+        {
+            throw new InvalidOperationException("Order queue is full.");
+        }
+    }
 }
 
 public sealed class ShipSkillProfileRuntime
 {
-  public int Navigation { get; set; }
-  public int Trade { get; set; }
-  public int Mining { get; set; }
-  public int Combat { get; set; }
-  public int Construction { get; set; }
+    public int Navigation { get; set; }
+    public int Trade { get; set; }
+    public int Mining { get; set; }
+    public int Combat { get; set; }
+    public int Construction { get; set; }
 }
 
 public sealed class ShipOrderRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; init; }
-  public OrderStatus Status { get; set; } = OrderStatus.Queued;
-  public int Priority { get; set; }
-  public bool InterruptCurrentPlan { get; set; } = true;
-  public DateTimeOffset CreatedAtUtc { get; init; } = DateTimeOffset.UtcNow;
-  public string? Label { get; set; }
-  public string? TargetEntityId { get; set; }
-  public string? TargetSystemId { get; set; }
-  public Vector3? TargetPosition { get; set; }
-  public string? SourceStationId { get; set; }
-  public string? DestinationStationId { get; set; }
-  public string? ItemId { get; set; }
-  public string? NodeId { get; set; }
-  public string? ConstructionSiteId { get; set; }
-  public string? ModuleId { get; set; }
-  public float WaitSeconds { get; set; }
-  public float Radius { get; set; }
-  public int? MaxSystemRange { get; set; }
-  public bool KnownStationsOnly { get; set; }
-  public string? FailureReason { get; set; }
+    public required string Id { get; init; }
+    public required string Kind { get; init; }
+    public required ShipOrderSourceKind SourceKind { get; init; }
+    public required string SourceId { get; init; }
+    public OrderStatus Status { get; set; } = OrderStatus.Queued;
+    public int Priority { get; set; }
+    public bool InterruptCurrentPlan { get; set; } = true;
+    public DateTimeOffset CreatedAtUtc { get; init; } = DateTimeOffset.UtcNow;
+    public string? Label { get; set; }
+    public string? TargetEntityId { get; set; }
+    public string? TargetSystemId { get; set; }
+    public Vector3? TargetPosition { get; set; }
+    public string? SourceStationId { get; set; }
+    public string? DestinationStationId { get; set; }
+    public string? ItemId { get; set; }
+    public string? AnchorId { get; set; }
+    public string? ConstructionSiteId { get; set; }
+    public string? ModuleId { get; set; }
+    public float WaitSeconds { get; set; }
+    public float Radius { get; set; }
+    public int? MaxSystemRange { get; set; }
+    public bool KnownStationsOnly { get; set; }
+    public string? FailureReason { get; set; }
 }
 
 public sealed class DefaultBehaviorRuntime
 {
-  public required string Kind { get; set; }
-  public string? HomeSystemId { get; set; }
-  public string? HomeStationId { get; set; }
-  public string? AreaSystemId { get; set; }
-  public string? TargetEntityId { get; set; }
-  public string? PreferredItemId { get; set; }
-  public string? PreferredNodeId { get; set; }
-  public string? PreferredConstructionSiteId { get; set; }
-  public string? PreferredModuleId { get; set; }
-  public Vector3? TargetPosition { get; set; }
-  public float WaitSeconds { get; set; } = 3f;
-  public float Radius { get; set; } = 24f;
-  public int MaxSystemRange { get; set; }
-  public bool KnownStationsOnly { get; set; }
-  public List<Vector3> PatrolPoints { get; set; } = [];
-  public int PatrolIndex { get; set; }
-  public List<ShipOrderTemplateRuntime> RepeatOrders { get; set; } = [];
-  public int RepeatIndex { get; set; }
+    public required string Kind { get; set; }
+    public string? HomeSystemId { get; set; }
+    public string? HomeStationId { get; set; }
+    public string? AreaSystemId { get; set; }
+    public string? TargetEntityId { get; set; }
+    public string? ItemId { get; set; }
+    public string? PreferredAnchorId { get; set; }
+    public string? PreferredConstructionSiteId { get; set; }
+    public string? PreferredModuleId { get; set; }
+    public Vector3? TargetPosition { get; set; }
+    public float WaitSeconds { get; set; } = 3f;
+    public float Radius { get; set; } = 24f;
+    public int MaxSystemRange { get; set; }
+    public bool KnownStationsOnly { get; set; }
+    public List<Vector3> PatrolPoints { get; set; } = [];
+    public int PatrolIndex { get; set; }
+    public List<ShipOrderTemplateRuntime> RepeatOrders { get; set; } = [];
+    public int RepeatIndex { get; set; }
 }
 
 public sealed class ShipOrderTemplateRuntime
 {
-  public required string Kind { get; init; }
-  public string? Label { get; set; }
-  public string? TargetEntityId { get; set; }
-  public string? TargetSystemId { get; set; }
-  public Vector3? TargetPosition { get; set; }
-  public string? SourceStationId { get; set; }
-  public string? DestinationStationId { get; set; }
-  public string? ItemId { get; set; }
-  public string? NodeId { get; set; }
-  public string? ConstructionSiteId { get; set; }
-  public string? ModuleId { get; set; }
-  public float WaitSeconds { get; set; }
-  public float Radius { get; set; }
-  public int? MaxSystemRange { get; set; }
-  public bool KnownStationsOnly { get; set; }
-}
-
-public sealed class ShipPlanRuntime
-{
-  public required string Id { get; init; }
-  public required AiPlanSourceKind SourceKind { get; init; }
-  public required string SourceId { get; init; }
-  public required string Kind { get; init; }
-  public required string Summary { get; set; }
-  public AiPlanStatus Status { get; set; } = AiPlanStatus.Planned;
-  public int CurrentStepIndex { get; set; }
-  public DateTimeOffset CreatedAtUtc { get; init; } = DateTimeOffset.UtcNow;
-  public DateTimeOffset UpdatedAtUtc { get; set; } = DateTimeOffset.UtcNow;
-  public string? InterruptReason { get; set; }
-  public string? FailureReason { get; set; }
-  public List<ShipPlanStepRuntime> Steps { get; } = [];
-}
-
-public sealed class ShipPlanStepRuntime
-{
-  public required string Id { get; init; }
-  public required string Kind { get; init; }
-  public required string Summary { get; set; }
-  public AiPlanStepStatus Status { get; set; } = AiPlanStepStatus.Planned;
-  public int CurrentSubTaskIndex { get; set; }
-  public string? BlockingReason { get; set; }
-  public List<ShipSubTaskRuntime> SubTasks { get; } = [];
+    public required string Kind { get; init; }
+    public string? Label { get; set; }
+    public string? TargetEntityId { get; set; }
+    public string? TargetSystemId { get; set; }
+    public Vector3? TargetPosition { get; set; }
+    public string? SourceStationId { get; set; }
+    public string? DestinationStationId { get; set; }
+    public string? ItemId { get; set; }
+    public string? AnchorId { get; set; }
+    public string? ConstructionSiteId { get; set; }
+    public string? ModuleId { get; set; }
+    public float WaitSeconds { get; set; }
+    public float Radius { get; set; }
+    public int? MaxSystemRange { get; set; }
+    public bool KnownStationsOnly { get; set; }
 }
 
 public sealed class ShipSubTaskRuntime
 {
-  public required string Id { get; init; }
-  public required string Kind { get; init; }
-  public required string Summary { get; set; }
-  public WorkStatus Status { get; set; } = WorkStatus.Pending;
-  public string? TargetEntityId { get; set; }
-  public string? TargetSystemId { get; set; }
-  public string? TargetNodeId { get; set; }
-  public Vector3? TargetPosition { get; set; }
-  public string? ItemId { get; set; }
-  public string? ModuleId { get; set; }
-  public float Threshold { get; set; }
-  public float Amount { get; set; }
-  public float ElapsedSeconds { get; set; }
-  public float TotalSeconds { get; set; }
-  public float Progress { get; set; }
-  public string? BlockingReason { get; set; }
+    public required string Id { get; init; }
+    public required string Kind { get; init; }
+    public required string Summary { get; set; }
+    public WorkStatus Status { get; set; } = WorkStatus.Pending;
+    public string? TargetEntityId { get; set; }
+    public string? TargetSystemId { get; set; }
+    public string? TargetAnchorId { get; set; }
+    public string? TargetResourceNodeId { get; set; }
+    public string? TargetResourceDepositId { get; set; }
+    public Vector3? TargetPosition { get; set; }
+    public string? ItemId { get; set; }
+    public string? ModuleId { get; set; }
+    public float Threshold { get; set; }
+    public float Amount { get; set; }
+    public float ElapsedSeconds { get; set; }
+    public float TotalSeconds { get; set; }
+    public float Progress { get; set; }
+    public string? BlockingReason { get; set; }
 }

apps/backend/Simulation/Core/SimulationEngine.cs

@@ -1,148 +1,151 @@
-
 namespace SpaceGame.Api.Simulation.Core;
 
-public sealed class SimulationEngine
+internal sealed class SimulationEngine
 {
-  private readonly OrbitalSimulationOptions _orbitalSimulation;
-  private readonly OrbitalStateUpdater _orbitalStateUpdater;
-  private readonly InfrastructureSimulationService _infrastructureSimulation;
-  private readonly GeopoliticalSimulationService _geopolitics;
-  private readonly CommanderPlanningService _commanderPlanning;
-  private readonly PlayerFactionService _playerFaction;
-  private readonly StationSimulationService _stationSimulation;
-  private readonly StationLifecycleService _stationLifecycle;
-  private readonly ShipAiService _shipAi;
-  private readonly SimulationProjectionService _projection;
+    private readonly IBalanceService _balance;
+    private readonly IPlayerStateStore _playerStateStore;
+    private readonly OrbitalSimulationOptions _orbitalSimulation;
+    private readonly OrbitalStateUpdater _orbitalStateUpdater;
+    private readonly InfrastructureSimulationService _infrastructureSimulation;
+    private readonly GeopoliticalSimulationService _geopolitics;
+    private readonly CommanderPlanningService _commanderPlanning;
+    private readonly PlayerFactionService _playerFaction;
+    private readonly StationSimulationService _stationSimulation;
+    private readonly StationLifecycleService _stationLifecycle;
+    private readonly ShipAiService _shipAi;
+    private readonly SimulationProjectionService _projection;
 
-  public SimulationEngine(OrbitalSimulationOptions? orbitalSimulation = null)
-  {
-    _orbitalSimulation = orbitalSimulation ?? new OrbitalSimulationOptions();
-    _orbitalStateUpdater = new OrbitalStateUpdater(_orbitalSimulation);
-    _infrastructureSimulation = new InfrastructureSimulationService();
-    _geopolitics = new GeopoliticalSimulationService();
-    _commanderPlanning = new CommanderPlanningService();
-    _playerFaction = new PlayerFactionService();
-    _stationSimulation = new StationSimulationService();
-    _stationLifecycle = new StationLifecycleService(_stationSimulation);
-    _shipAi = new ShipAiService();
-    _projection = new SimulationProjectionService(_orbitalSimulation);
-  }
-
-  public WorldDelta Tick(SimulationWorld world, float deltaSeconds, long sequence)
-  {
-    var nowUtc = DateTimeOffset.UtcNow;
-    var events = new List<SimulationEventRecord>();
-    var simulationDeltaSeconds = deltaSeconds * MathF.Max(world.Balance.SimulationSpeedMultiplier, 0.01f);
-    world.GeneratedAtUtc = nowUtc;
-
-    world.OrbitalTimeSeconds += simulationDeltaSeconds * _orbitalSimulation.SimulatedSecondsPerRealSecond;
-
-    _orbitalStateUpdater.Update(world);
-    _infrastructureSimulation.UpdateClaims(world, events);
-    _infrastructureSimulation.UpdateConstructionSites(world, events);
-    _geopolitics.Update(world, simulationDeltaSeconds, events);
-    _commanderPlanning.UpdateCommanders(world, simulationDeltaSeconds, events);
-    _playerFaction.Update(world, simulationDeltaSeconds, events);
-    _stationLifecycle.UpdateStations(world, simulationDeltaSeconds, events);
-
-    foreach (var ship in world.Ships.ToList())
+    internal SimulationEngine(OrbitalSimulationOptions orbitalSimulation, IBalanceService balance, IPlayerStateStore playerStateStore)
     {
-      if (ship.Health <= 0f)
-      {
-        continue;
-      }
-
-      var previousPosition = ship.Position;
-      _shipAi.UpdateShip(world, ship, simulationDeltaSeconds, events);
-      ship.Velocity = ship.Position.Subtract(previousPosition).Divide(simulationDeltaSeconds);
+        _balance = balance;
+        _playerStateStore = playerStateStore;
+        _orbitalSimulation = orbitalSimulation;
+        _orbitalStateUpdater = new OrbitalStateUpdater(_orbitalSimulation);
+        _infrastructureSimulation = new InfrastructureSimulationService();
+        _geopolitics = new GeopoliticalSimulationService();
+        _commanderPlanning = new CommanderPlanningService();
+        _playerFaction = new PlayerFactionService();
+        _stationSimulation = new StationSimulationService();
+        _stationLifecycle = new StationLifecycleService(_stationSimulation);
+        _shipAi = new ShipAiService(balance);
+        _projection = new SimulationProjectionService(_orbitalSimulation);
     }
 
-    _orbitalStateUpdater.SyncSpatialState(world);
-    CleanupDestroyedEntities(world, events);
-    return _projection.BuildDelta(world, sequence, events);
-  }
-
-  public WorldSnapshot BuildSnapshot(SimulationWorld world, long sequence) =>
-    _projection.BuildSnapshot(world, sequence);
-
-  public void PrimeDeltaBaseline(SimulationWorld world) =>
-    _projection.PrimeDeltaBaseline(world);
-
-  internal static float GetShipCargoAmount(ShipRuntime ship) =>
-    SimulationRuntimeSupport.GetShipCargoAmount(ship);
-
-  private static void CleanupDestroyedEntities(SimulationWorld world, ICollection<SimulationEventRecord> events)
-  {
-    foreach (var ship in world.Ships.Where(candidate => candidate.Health <= 0f).ToList())
+    public WorldDelta Tick(SimulationWorld world, float deltaSeconds, long sequence)
     {
-      CreateWreck(world, "ship", ship.Id, ship.SystemId, ship.Position, ship.Definition.CargoCapacity + (ship.Definition.MaxHealth * 0.08f));
-      world.Ships.Remove(ship);
-      if (ship.DockedStationId is not null && world.Stations.FirstOrDefault(station => station.Id == ship.DockedStationId) is { } dockedStation)
-      {
-        dockedStation.DockedShipIds.Remove(ship.Id);
-        dockedStation.DockingPadAssignments.Remove(ship.AssignedDockingPadIndex ?? -1);
-      }
+        var nowUtc = DateTimeOffset.UtcNow;
+        var events = new List<SimulationEventRecord>();
+        var simulationDeltaSeconds = deltaSeconds * MathF.Max(_balance.SimulationSpeedMultiplier, 0.01f);
+        world.GeneratedAtUtc = nowUtc;
 
-      if (world.Factions.FirstOrDefault(candidate => candidate.Id == ship.FactionId) is { } faction)
-      {
-        faction.ShipsLost += 1;
-      }
+        world.OrbitalTimeSeconds += simulationDeltaSeconds * _orbitalSimulation.SimulatedSecondsPerRealSecond;
 
-      if (ship.CommanderId is not null && world.Commanders.FirstOrDefault(candidate => candidate.Id == ship.CommanderId) is { } commander)
-      {
-        commander.IsAlive = false;
-      }
+        _orbitalStateUpdater.Update(world);
+        _infrastructureSimulation.UpdateClaims(world, events);
+        _infrastructureSimulation.UpdateConstructionSites(world, events);
+        _geopolitics.Update(world, simulationDeltaSeconds, events);
+        _commanderPlanning.UpdateCommanders(world, _playerStateStore, simulationDeltaSeconds, events);
+        _playerFaction.Update(world, _playerStateStore, simulationDeltaSeconds, events);
+        _stationLifecycle.UpdateStations(world, simulationDeltaSeconds, events);
 
-      events.Add(new SimulationEventRecord("ship", ship.Id, "destroyed", $"{ship.Definition.Label} was destroyed.", DateTimeOffset.UtcNow));
+        foreach (var ship in world.Ships.ToList())
+        {
+            if (ship.Health <= 0f)
+            {
+                continue;
+            }
+
+            var previousPosition = ship.Position;
+            _shipAi.UpdateShip(world, ship, simulationDeltaSeconds, events);
+            ship.Velocity = ship.Position.Subtract(previousPosition).Divide(simulationDeltaSeconds);
+        }
+
+        _orbitalStateUpdater.SyncSpatialState(world);
+        CleanupDestroyedEntities(world, events);
+        return _projection.BuildDelta(world, sequence, events);
     }
 
-    foreach (var station in world.Stations.Where(candidate => candidate.Health <= 0f).ToList())
+    public WorldSnapshot BuildSnapshot(SimulationWorld world, long sequence) =>
+      _projection.BuildSnapshot(world, sequence);
+
+    public void PrimeDeltaBaseline(SimulationWorld world) =>
+      _projection.PrimeDeltaBaseline(world);
+
+    internal static float GetShipCargoAmount(ShipRuntime ship) =>
+      SimulationRuntimeSupport.GetShipCargoAmount(ship);
+
+    private static void CleanupDestroyedEntities(SimulationWorld world, ICollection<SimulationEventRecord> events)
     {
-      CreateWreck(world, "station", station.Id, station.SystemId, station.Position, station.MaxHealth * 0.12f);
-      world.Stations.Remove(station);
+        foreach (var ship in world.Ships.Where(candidate => candidate.Health <= 0f).ToList())
+        {
+            CreateWreck(world, "ship", ship.Id, ship.SystemId, ship.Position, ship.Definition.GetTotalCargoCapacity() + (ship.Definition.Hull * 0.08f));
+            world.Ships.Remove(ship);
+            if (ship.DockedStationId is not null && world.Stations.FirstOrDefault(station => station.Id == ship.DockedStationId) is { } dockedStation)
+            {
+                dockedStation.DockedShipIds.Remove(ship.Id);
+                dockedStation.DockingPadAssignments.Remove(ship.AssignedDockingPadIndex ?? -1);
+            }
 
-      if (station.CelestialId is not null && world.Celestials.FirstOrDefault(candidate => candidate.Id == station.CelestialId) is { } celestial)
-      {
-        celestial.OccupyingStructureId = null;
-      }
+            if (world.Factions.FirstOrDefault(candidate => candidate.Id == ship.FactionId) is { } faction)
+            {
+                faction.ShipsLost += 1;
+            }
 
-      foreach (var claim in world.Claims.Where(candidate => candidate.CelestialId == station.CelestialId))
-      {
-        claim.Health = 0f;
-        claim.State = ClaimStateKinds.Destroyed;
-      }
+            if (ship.CommanderId is not null && world.Commanders.FirstOrDefault(candidate => candidate.Id == ship.CommanderId) is { } commander)
+            {
+                commander.IsAlive = false;
+            }
 
-      foreach (var site in world.ConstructionSites.Where(candidate => candidate.StationId == station.Id))
-      {
-        site.State = ConstructionSiteStateKinds.Destroyed;
-      }
+            events.Add(new SimulationEventRecord("ship", ship.Id, "destroyed", $"{ship.Definition.Name} was destroyed.", DateTimeOffset.UtcNow));
+        }
 
-      events.Add(new SimulationEventRecord("station", station.Id, "destroyed", $"{station.Label} was destroyed.", DateTimeOffset.UtcNow));
-    }
-  }
+        foreach (var station in world.Stations.Where(candidate => candidate.Health <= 0f).ToList())
+        {
+            CreateWreck(world, "station", station.Id, station.SystemId, station.Position, station.MaxHealth * 0.12f);
+            world.Stations.Remove(station);
 
-  private static void CreateWreck(SimulationWorld world, string sourceKind, string sourceEntityId, string systemId, Vector3 position, float amount)
-  {
-    var itemId = world.ItemDefinitions.ContainsKey("scrapmetal")
-      ? "scrapmetal"
-      : world.ItemDefinitions.ContainsKey("rawscrap")
-        ? "rawscrap"
-        : world.ItemDefinitions.Keys.OrderBy(id => id, StringComparer.Ordinal).FirstOrDefault();
-    if (itemId is null || amount <= 0.01f)
-    {
-      return;
+            if (station.AnchorId is not null && world.Anchors.FirstOrDefault(candidate => candidate.Id == station.AnchorId) is { } anchor)
+            {
+                anchor.OccupyingStructureId = null;
+            }
+
+            foreach (var claim in world.Claims.Where(candidate => candidate.AnchorId == station.AnchorId))
+            {
+                claim.Health = 0f;
+                claim.State = ClaimStateKinds.Destroyed;
+            }
+
+            foreach (var site in world.ConstructionSites.Where(candidate => candidate.StationId == station.Id))
+            {
+                site.State = ConstructionSiteStateKinds.Destroyed;
+            }
+
+            events.Add(new SimulationEventRecord("station", station.Id, "destroyed", $"{station.Label} was destroyed.", DateTimeOffset.UtcNow));
+        }
     }
 
-    world.Wrecks.Add(new WreckRuntime
+    private static void CreateWreck(SimulationWorld world, string sourceKind, string sourceEntityId, string systemId, Vector3 position, float amount)
     {
-      Id = $"wreck-{sourceKind}-{sourceEntityId}",
-      SourceKind = sourceKind,
-      SourceEntityId = sourceEntityId,
-      SystemId = systemId,
-      Position = position,
-      ItemId = itemId,
-      RemainingAmount = amount,
-      MaxAmount = amount,
-    });
-  }
+        var itemId = world.ItemDefinitions.ContainsKey("scrapmetal")
+          ? "scrapmetal"
+          : world.ItemDefinitions.ContainsKey("rawscrap")
+            ? "rawscrap"
+            : world.ItemDefinitions.Keys.OrderBy(id => id, StringComparer.Ordinal).FirstOrDefault();
+        if (itemId is null || amount <= 0.01f)
+        {
+            return;
+        }
+
+        world.Wrecks.Add(new WreckRuntime
+        {
+            Id = $"wreck-{sourceKind}-{sourceEntityId}",
+            SourceKind = sourceKind,
+            SourceEntityId = sourceEntityId,
+            SystemId = systemId,
+            Position = position,
+            ItemId = itemId,
+            RemainingAmount = amount,
+            MaxAmount = amount,
+        });
+    }
 }

apps/backend/SpaceGame.Api.csproj

@@ -9,6 +9,8 @@
   <ItemGroup>
     <PackageReference Include="FastEndpoints" Version="6.*" />
     <PackageReference Include="FastEndpoints.Swagger" Version="6.*" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.0-preview.7.25380.108" />
+    <PackageReference Include="Npgsql" Version="9.0.3" />
   </ItemGroup>
 
 </Project>