diff --git a/src/client/BuildSettingsModal.ts b/src/client/BuildSettingsModal.ts
index f01cf67d2..ef7ad6ac6 100644
--- a/src/client/BuildSettingsModal.ts
+++ b/src/client/BuildSettingsModal.ts
@@ -38,7 +38,7 @@ export class BuildSettingsModal extends LitElement {
       return {
         id,
         name: id,
-        icon: unitIconMap[id] || "",
+        icon: unitIconMap[id] ?? "",
       };
     });
     const persisted = this._loadPersisted();
diff --git a/src/client/Transport.ts b/src/client/Transport.ts
index 9b80c1093..8cb9b3800 100644
--- a/src/client/Transport.ts
+++ b/src/client/Transport.ts
@@ -423,6 +423,12 @@ export class Transport {
         console.error("socket is null");
         return;
       }
+      // Notify the client code that we are connected (mirrors local behavior)
+      try {
+        this.onconnect?.();
+      } catch (err) {
+        console.error("Error in onconnect handler:", err);
+      }
       while (this.buffer.length > 0) {
         console.log("sending dropped message");
         const msg = this.buffer.pop();
diff --git a/src/client/Utils.ts b/src/client/Utils.ts
index c99f80939..14697d7e2 100644
--- a/src/client/Utils.ts
+++ b/src/client/Utils.ts
@@ -165,6 +165,7 @@ export function getMessageTypeClasses(type: MessageType): string {
   switch (type) {
     case MessageType.SAM_HIT:
     case MessageType.CAPTURED_ENEMY_UNIT:
+    case MessageType.TRADE_SHIP_CAPTURED_ENEMY:
     case MessageType.RECEIVED_GOLD_FROM_TRADE:
     case MessageType.CONQUERED_PLAYER:
     case MessageType.INSURANCE_REFUND:
@@ -174,6 +175,8 @@ export function getMessageTypeClasses(type: MessageType): string {
     case MessageType.ALLIANCE_BROKEN:
     case MessageType.UNIT_CAPTURED_BY_ENEMY:
     case MessageType.UNIT_DESTROYED:
+    case MessageType.TRADE_SHIP_CAPTURED:
+    case MessageType.TRADE_SHIP_SUNK:
       return severityColors["fail"];
     case MessageType.ATTACK_CANCELLED:
     case MessageType.ATTACK_REQUEST:
@@ -192,6 +195,7 @@ export function getMessageTypeClasses(type: MessageType): string {
     case MessageType.PARATROOPER_INBOUND:
     case MessageType.WARN:
     case MessageType.PEACE_TIMER_BLOCKED:
+    case MessageType.TRADE_SHIP_TURNED_AROUND:
       return severityColors["warn"];
     case MessageType.WAR_DECLARED:
       return severityColors["warn"]; // war start: highlight prominently
diff --git a/src/client/graphics/GameRenderer.ts b/src/client/graphics/GameRenderer.ts
index 0fe4b3ec3..a21e89695 100644
--- a/src/client/graphics/GameRenderer.ts
+++ b/src/client/graphics/GameRenderer.ts
@@ -22,6 +22,7 @@ import { NameLayer } from "./layers/NameLayer";
 import { OptionsMenu } from "./layers/OptionsMenu";
 import { PlayerInfoOverlay } from "./layers/PlayerInfoOverlay";
 import { PlayerPanel } from "./layers/PlayerPanel";
+import { PointerCoordsLayer } from "./layers/PointerCoordsLayer";
 import { RadialMenu } from "./layers/RadialMenu";
 import { RangeOverlayLayer } from "./layers/RangeOverlayLayer";
 import { ReplayPanel } from "./layers/ReplayPanel";
@@ -38,6 +39,9 @@ import { UILayer } from "./layers/UILayer";
 import { UnitLayer } from "./layers/UnitLayer";
 import { WinModal } from "./layers/WinModal";
 
+// Debug flags (keep off for normal gameplay)
+const DEBUG_SHOW_POINTER_COORDS = false;
+
 export function createRenderer(
   canvas: HTMLCanvasElement,
   game: GameView,
@@ -246,6 +250,10 @@ export function createRenderer(
     new NameLayer(game, transformHandler, eventBus),
     // UI layer comes after world-space drawing to minimize save/restore
     new UILayer(game, eventBus, transformHandler),
+    // Pointer coordinates (screen-space, debug only)
+    ...(DEBUG_SHOW_POINTER_COORDS
+      ? [new PointerCoordsLayer(game, eventBus, transformHandler)]
+      : []),
     eventsDisplay,
     chatDisplay,
     new RadialMenu(
diff --git a/src/client/graphics/layers/ControlPanel2.ts b/src/client/graphics/layers/ControlPanel2.ts
index 774bb2e42..4e06e6937 100644
--- a/src/client/graphics/layers/ControlPanel2.ts
+++ b/src/client/graphics/layers/ControlPanel2.ts
@@ -10,7 +10,7 @@ import {
   UnitType,
   UpgradeType,
 } from "../../../core/game/Game";
-import { GameView, PlayerView } from "../../../core/game/GameView";
+import { GameView, PlayerView, UnitView } from "../../../core/game/GameView";
 import { getTechMeta, RESEARCH_TECH_IDS } from "../../../core/tech/TechEffects";
 // Ensure modal custom elements register at runtime
 import "../../BuildSettingsModal";
@@ -87,7 +87,8 @@ export class ControlPanel2 extends LitElement implements Layer {
   private init_: boolean = false;
 
   @state()
-  private activeTab: "Build" | "Attack" | "Economy" | "Bombers" = "Build";
+  private activeTab: "Build" | "Attack" | "Economy" | "Bombers" | "Trade" =
+    "Build";
 
   @state()
   private _lastAirfieldCount: number = 0;
@@ -237,6 +238,11 @@ export class ControlPanel2 extends LitElement implements Layer {
     super.disconnectedCallback();
   }
 
+  // Restore disabled shadow DOM so legacy global CSS and querySelector usage continue working
+  protected createRenderRoot(): HTMLElement | DocumentFragment {
+    return this; // Render into light DOM
+  }
+
   init() {
     this.attackRatio = Number(
       localStorage.getItem("settings.attackRatio") ?? "0.3",
@@ -883,7 +889,7 @@ export class ControlPanel2 extends LitElement implements Layer {
 
   private _openBuildSettings() {
     const modal =
-      (document.querySelector("build-settings-modal") as any) ||
+      (document.querySelector("build-settings-modal") as any) ??
       this._ensureBuildSettingsModal();
     if (!modal) {
       console.warn("BuildSettingsModal element not found or failed to create");
@@ -950,7 +956,9 @@ export class ControlPanel2 extends LitElement implements Layer {
     return el;
   }
 
-  private _changeTab(tab: "Build" | "Attack" | "Economy" | "Bombers") {
+  private _changeTab(
+    tab: "Build" | "Attack" | "Economy" | "Bombers" | "Trade",
+  ) {
     this.activeTab = tab;
     if (this.uiState.pendingBuildUnitType) {
       this.uiState.pendingBuildUnitType = null;
@@ -1170,6 +1178,15 @@ export class ControlPanel2 extends LitElement implements Layer {
           >
             Economy
           </button>
+          <button
+            class="py-2 px-4 text-center font-ocr uppercase cp2-tab ${this
+              .activeTab === "Trade"
+              ? "active"
+              : ""}"
+            @click=${() => this._changeTab("Trade")}
+          >
+            Trade
+          </button>
           ${this._hasAirfields
             ? html`
                 <button
@@ -1834,13 +1851,199 @@ export class ControlPanel2 extends LitElement implements Layer {
                 </div>
               `
             : ""}
+          ${this.activeTab === "Trade" ? this._renderTradeTab() : ""}
         </div>
       </div>
     `;
   }
 
-  createRenderRoot() {
-    return this; // Disable shadow DOM to allow Tailwind styles
+  private _renderTradeTab() {
+    const me = this.game.myPlayer();
+    if (!me) return html``;
+    const ships = me.units(UnitType.TradeShip).filter((u) => u.isActive());
+    const ports = me.units(UnitType.Port).filter((p) => p.isActive());
+    const ticks = this.game.ticks();
+    const delay = this.game.config().tradeShipReplacementDelayTicks();
+    // Multi-build: gather all pending construction due ticks across ports
+    const pendingEntries: Array<{ port: UnitView; due: number }> = [];
+    for (const p of ports) {
+      const arr: number[] = (p as any).pendingTradeShipDueTicks?.() ?? [];
+      for (const due of arr) {
+        if (due > ticks) pendingEntries.push({ port: p, due });
+      }
+    }
+    pendingEntries.sort((a, b) => a.due - b.due);
+    const pendingRows = pendingEntries.map(({ port, due }, idx) => {
+      const remaining = due - ticks;
+      const pct = Math.min(
+        100,
+        Math.max(0, Math.round(((delay - remaining) / delay) * 100)),
+      );
+      return html`<div
+        class="py-1 px-2 border-b"
+        style="border-color: var(--ui-panel-border)"
+      >
+        <div class="mb-1 text-gray-300">
+          Trade Ship #${idx + 1} (Port #${port.id()}) constructing…
+        </div>
+        <div class="progress-track" style="height:6px;">
+          <div class="progress-fill" style="width:${pct}%;"></div>
+        </div>
+      </div>`;
+    });
+
+    const mapHeight = this.game.height();
+    const rows = ships.map((ship) => {
+      const tile = ship.tile();
+      const x = this.game.x(tile);
+      const topOriginY = this.game.y(tile);
+      const y = mapHeight - 1 - topOriginY; // display with bottom-left origin
+      const status = this._computeTradeShipStatus(ship);
+      return html`
+        <div
+          class="flex items-center justify-between py-1 px-2 border-b"
+          style="border-color: var(--ui-panel-border)"
+        >
+          <div class="truncate">
+            <span class="text-blue-200">Ship #${ship.id()}</span>
+            <span class="text-gray-400 ml-2">${status}</span>
+          </div>
+          <div class="text-gray-300 font-mono">(${x}, ${y})</div>
+        </div>
+      `;
+    });
+
+    // Compute demand indicator (global: all trade ships, not just mine)
+    const allTradeShips = this.game
+      .units(UnitType.TradeShip)
+      .filter((u) => u.isActive());
+    const totalShips = allTradeShips.length;
+    const availableShips = allTradeShips.filter((s) => {
+      const isReturning = s.returning();
+      const phase = s.tradePhase();
+      const hasTarget = s.targetUnitId() !== undefined;
+      const dockOwner = s.dockedAtPortOwner();
+      return !isReturning && phase === null && !hasTarget && dockOwner !== null;
+    }).length;
+    const queueLen = me.tradeDemandQueueLength();
+    const denom = Math.max(1, totalShips);
+    const queuedPct = queueLen / denom;
+    const availablePct = availableShips / denom;
+    let demandLabel = "Medium";
+    let demandColor = "var(--ui-text-default)";
+    if (queuedPct > 0.5) {
+      demandLabel = "Very High";
+      demandColor = "var(--ui-alert)";
+    } else if (queuedPct > 0.25) {
+      demandLabel = "High";
+      demandColor = "var(--ui-warning)";
+    } else if (availablePct > 0.5) {
+      demandLabel = "Very Low";
+      demandColor = "var(--ui-info)";
+    } else if (availablePct > 0.25) {
+      demandLabel = "Low";
+      demandColor = "var(--ui-success)";
+    } else {
+      demandLabel = "Medium";
+      demandColor = "var(--ui-text-default)";
+    }
+
+    return html`
+      <div class="w-full">
+        <div class="flex items-center justify-between mb-2">
+          <h3 class="military-heading">Trade Ships</h3>
+          <div
+            class="text-sm"
+            title="Demand is based on queued routes vs total ships and available ships"
+          >
+            <span
+              class="px-2 py-0.5 rounded-full border"
+              style="border-color: var(--ui-panel-border); color: ${demandColor};"
+            >
+              Trade Demand: ${demandLabel}
+            </span>
+          </div>
+        </div>
+        ${pendingRows.length > 0
+          ? html`<div class="mb-2">
+              <h4 class="text-gray-200 text-sm mb-1">Under Construction</h4>
+              <style>
+                /* Reuse research progress bar styling */
+                .progress-track {
+                  width: 100%;
+                  background: color-mix(
+                    in srgb,
+                    var(--ui-secondary) 25%,
+                    transparent
+                  );
+                  border: 1px solid
+                    color-mix(in srgb, var(--ui-secondary) 35%, transparent);
+                  border-radius: 6px;
+                  overflow: hidden;
+                  margin: 0;
+                }
+                .progress-fill {
+                  height: 100%;
+                  background: linear-gradient(
+                    90deg,
+                    color-mix(in srgb, var(--ui-info) 90%, transparent) 0%,
+                    color-mix(in srgb, var(--ui-info) 70%, transparent) 100%
+                  );
+                  box-shadow:
+                    0 0 10px color-mix(in srgb, var(--ui-info) 55%, transparent),
+                    0 0 16px color-mix(in srgb, var(--ui-info) 35%, transparent),
+                    inset 0 0 4px
+                      color-mix(in srgb, var(--ui-text-light) 10%, transparent);
+                }
+              </style>
+              <div class="divide-y">${pendingRows}</div>
+            </div>`
+          : ""}
+        ${ships.length > 0
+          ? html`<div class="divide-y">${rows}</div>`
+          : ships.length === 0 && pendingRows.length === 0
+            ? html`<div class="text-gray-400">No active trade ships.</div>`
+            : ""}
+      </div>
+    `;
+  }
+
+  private _computeTradeShipStatus(ship: UnitView): string {
+    // Debug ship status logging removed
+    const ownerName = (pv: PlayerView | null) => pv?.displayName() ?? "Unknown";
+    const dockOwner = ship.dockedAtPortOwner();
+    const startOwner = ship.tradeRouteStartOwner();
+    const endOwner = ship.tradeRouteEndOwner();
+    const targetId = ship.targetUnitId();
+    const targetUnit =
+      targetId !== undefined ? this.game.unit(targetId) : undefined;
+
+    if (dockOwner && !ship.returning() && targetId === undefined) {
+      return `in port owned by ${ownerName(dockOwner)}`;
+    }
+
+    if (ship.returning()) {
+      if (targetUnit && targetUnit.type() === UnitType.Port) {
+        return `returning to port owned by ${ownerName(targetUnit.owner())}`;
+      }
+      return "returning to port";
+    }
+
+    const phase = ship.tradePhase();
+
+    if (phase === "toStart") {
+      return `traveling to start port owned by ${ownerName(startOwner)}`;
+    }
+    if (phase === "toEnd") {
+      if (startOwner || endOwner) {
+        return `trading between ${ownerName(startOwner)} and ${ownerName(endOwner)}`;
+      }
+      if (targetUnit && targetUnit.type() === UnitType.Port) {
+        return `traveling to port owned by ${ownerName(targetUnit.owner())}`;
+      }
+    }
+
+    return "at sea";
   }
 }
 
diff --git a/src/client/graphics/layers/PointerCoordsLayer.ts b/src/client/graphics/layers/PointerCoordsLayer.ts
new file mode 100644
index 000000000..2fa131d80
--- /dev/null
+++ b/src/client/graphics/layers/PointerCoordsLayer.ts
@@ -0,0 +1,93 @@
+import { EventBus } from "../../../core/EventBus";
+import { GameView } from "../../../core/game/GameView";
+import { MouseMoveEvent } from "../../InputHandler";
+import { TransformHandler } from "../TransformHandler";
+import { Layer } from "./Layer";
+
+/**
+ * PointerCoordsLayer
+ * Renders the world tile coordinates next to the mouse pointer.
+ * Y is displayed using a bottom-left origin: y' = (H - 1) - y.
+ * Drawn in screen-space (no transform) so it sticks to the pointer.
+ */
+export class PointerCoordsLayer implements Layer {
+  private lastScreenX: number | null = null;
+  private lastScreenY: number | null = null;
+
+  constructor(
+    private game: GameView,
+    private eventBus: EventBus,
+    private transform: TransformHandler,
+  ) {}
+
+  shouldTransform(): boolean {
+    return false; // screen-space overlay
+  }
+
+  init() {
+    this.eventBus.on(MouseMoveEvent, (e: MouseMoveEvent) => {
+      this.lastScreenX = e.x;
+      this.lastScreenY = e.y;
+    });
+  }
+
+  renderLayer(ctx: CanvasRenderingContext2D) {
+    if (this.lastScreenX === null || this.lastScreenY === null) return;
+
+    const world = this.transform.screenToWorldCoordinates(
+      this.lastScreenX,
+      this.lastScreenY,
+    );
+    if (!this.game.isValidCoord(world.x, world.y)) return;
+
+    const x = world.x;
+    const yBL = this.game.height() - 1 - world.y; // bottom-left origin
+
+    const label = `(${x}, ${yBL})`;
+
+    // Position slightly offset from the pointer
+    const px = this.lastScreenX + 12;
+    const py = this.lastScreenY + 18;
+
+    // Draw background pill for readability
+    ctx.save();
+    ctx.font = "12px Inter, system-ui, -apple-system, Segoe UI, Roboto";
+    ctx.textBaseline = "top";
+    const paddingX = 6;
+    const paddingY = 3;
+    const metrics = ctx.measureText(label);
+    const w = Math.ceil(metrics.width) + paddingX * 2;
+    const h = 16 + paddingY * 2;
+
+    ctx.fillStyle = "rgba(20, 20, 24, 0.8)";
+    ctx.strokeStyle = "rgba(255, 255, 255, 0.15)";
+    ctx.lineWidth = 1;
+    ctx.beginPath();
+    const r = 6;
+    this.roundRect(ctx, px - 2, py - 2, w + 4, h + 4, r);
+    ctx.fill();
+    ctx.stroke();
+
+    // Draw text
+    ctx.fillStyle = "#E5E7EB"; // light gray for contrast
+    ctx.fillText(label, px + paddingX, py + paddingY);
+    ctx.restore();
+  }
+
+  private roundRect(
+    ctx: CanvasRenderingContext2D,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    radius: number,
+  ) {
+    const r = Math.min(radius, width / 2, height / 2);
+    ctx.moveTo(x + r, y);
+    ctx.arcTo(x + width, y, x + width, y + height, r);
+    ctx.arcTo(x + width, y + height, x, y + height, r);
+    ctx.arcTo(x, y + height, x, y, r);
+    ctx.arcTo(x, y, x + width, y, r);
+    ctx.closePath();
+  }
+}
diff --git a/src/client/index.html b/src/client/index.html
index 833cbdc0b..19ffe7bb6 100644
--- a/src/client/index.html
+++ b/src/client/index.html
@@ -68,7 +68,6 @@
         left: 0;
         width: 100%;
         height: 100%;
-        filter: blur(0px);
         z-index: -1;
       }
 
diff --git a/src/client/styles/modal/lobby-team.css b/src/client/styles/modal/lobby-team.css
index 0fd02f710..3a3125c83 100644
--- a/src/client/styles/modal/lobby-team.css
+++ b/src/client/styles/modal/lobby-team.css
@@ -95,7 +95,9 @@
   background: var(--ui-alert);
   color: var(--ui-button-text);
   border-radius: 50%;
-  font-size: 0.6875em;
+  font-size: 14px; /* Larger glyph, same button size */
+  font-weight: 700; /* Thicker X for readability */
+  line-height: 1;
   cursor: pointer;
   display: inline-flex;
   align-items: center;
diff --git a/src/core/GameRunner.ts b/src/core/GameRunner.ts
index f68119c2d..ae6688e55 100644
--- a/src/core/GameRunner.ts
+++ b/src/core/GameRunner.ts
@@ -1,7 +1,9 @@
 import { placeName } from "../client/graphics/NameBoxCalculator";
 import { getConfig } from "./configuration/ConfigLoader";
 import { AllianceExpireCheckExecution } from "./execution/alliance/AllianceExpireCheckExecution";
+import { CapitalRecalculationExecution } from "./execution/CapitalRecalculationExecution";
 import { Executor } from "./execution/ExecutionManager";
+import { TradeManagerExecution } from "./execution/TradeManagerExecution";
 import { WinCheckExecution } from "./execution/WinCheckExecution";
 import { AllianceImpl } from "./game/AllianceImpl";
 import {
@@ -241,6 +243,10 @@ export class GameRunner {
     }
     this.game.addExecution(new WinCheckExecution());
     this.game.addExecution(new AllianceExpireCheckExecution());
+    // Background: periodically compute player capitals (geographic centers)
+    this.game.addExecution(new CapitalRecalculationExecution());
+    // Trade rework: central trade manager for demand/supply/assignment
+    this.game.addExecution(new TradeManagerExecution());
   }
 
   public addTurn(turn: Turn): void {
diff --git a/src/core/configuration/Config.ts b/src/core/configuration/Config.ts
index 60687124f..176257698 100644
--- a/src/core/configuration/Config.ts
+++ b/src/core/configuration/Config.ts
@@ -125,6 +125,8 @@ export interface Config {
   proximityBonusPortsNb(totalPorts: number): number;
   proximityBonusAirfieldsNumber(totalAirfields: number): number;
   maxPopulation(player: Player | PlayerView): number;
+  // Multiplier used to compute a player's GDP as: gdpFactor * maxPopulation(player)
+  gdpFactor(): number;
   cityPopulationIncrease(): number;
   boatAttackAmount(attacker: Player, defender: Player | TerraNullius): number;
   shellLifetime(): number;
@@ -150,6 +152,12 @@ export interface Config {
   upgradeInfo(type: UpgradeType): UpgradeInfo;
   tradeShipGold(dist: number): Gold;
   tradeShipSpawnRate(numberOfPorts: number): number;
+  // Trade rework: gravity-based demand and port-supplied ships
+  tradeGravityK(): number; // Coefficient K in K * gdp_i * gdp_j / distance / world_gdp
+  tradeDemandTickInterval(): number; // Ticks between gravity accumulation (default 10)
+  tradeShipPerPortSupply(): number; // Number of trade ships each port supplies (default 1)
+  tradeIncomeFixed(): Gold; // Fixed income per completed trade (default 10k)
+  tradeShipReplacementDelayTicks(): number; // Ticks to generate a new/replacement trade ship (default 600 ~= 60s)
   cargoTruckSpawnRate(numberOfStructures: number): number;
   cargoTruckGold(distance: number): Gold;
   roadUpdatesPerTick(): number;
diff --git a/src/core/configuration/DefaultConfig.ts b/src/core/configuration/DefaultConfig.ts
index 5e2f717f1..d1268852c 100644
--- a/src/core/configuration/DefaultConfig.ts
+++ b/src/core/configuration/DefaultConfig.ts
@@ -352,6 +352,24 @@ export class DefaultConfig implements Config {
   tradeShipSpawnRate(numberOfPorts: number): number {
     return Math.round(10 * Math.pow(numberOfPorts, 0.37));
   }
+  // Trade rework parameters
+  tradeGravityK(): number {
+    // Tunable coefficient for gravity model demand accumulation
+    return 3e-6; // conservative default to avoid flooding the queue
+  }
+  tradeDemandTickInterval(): number {
+    return 10;
+  }
+  tradeShipPerPortSupply(): number {
+    return 1;
+  }
+  tradeIncomeFixed(): Gold {
+    return BigInt(10_000);
+  }
+  tradeShipReplacementDelayTicks(): number {
+    // Assume ~10 ticks/sec => 600 ticks ~= 60s
+    return 600;
+  }
 
   // Roads and Cargo Trucks
 
@@ -1118,6 +1136,11 @@ export class DefaultConfig implements Config {
     }
   }
 
+  // Multiplier for computing GDP relative to max population
+  gdpFactor(): number {
+    return 1.0;
+  }
+
   populationIncreaseRate(player: Player): number {
     const max = this.maxPopulation(player);
     //population grows proportional to current population with growth decreasing as it approaches max
diff --git a/src/core/execution/CapitalRecalculationExecution.ts b/src/core/execution/CapitalRecalculationExecution.ts
new file mode 100644
index 000000000..fbd8ac907
--- /dev/null
+++ b/src/core/execution/CapitalRecalculationExecution.ts
@@ -0,0 +1,106 @@
+import { Cell, Execution, Game, Player, Tick } from "../game/Game";
+import { PlayerImpl } from "../game/PlayerImpl";
+import { PseudoRandom } from "../PseudoRandom";
+import { simpleHash } from "../Util";
+
+/**
+ * Periodically recomputes each player's capital (geographic center of owned tiles).
+ * - Recomputes at most once every 30 seconds per player
+ * - Spreads computations across 10 ticks by bucketing players by smallID % 10
+ * - Uses up to 100 randomly sampled tiles (deterministic sampling per interval)
+ */
+export class CapitalRecalculationExecution implements Execution {
+  private mg!: Game;
+  private active = true;
+
+  // Track last tick each player's capital was recalculated
+  private lastRecalc: Map<string, Tick> = new Map();
+
+  // Precomputed interval in ticks (30 seconds)
+  private intervalTicks = 0;
+
+  isActive(): boolean {
+    return this.active;
+  }
+
+  activeDuringSpawnPhase(): boolean {
+    // Harmless during spawn; enables early UI if needed
+    return true;
+  }
+
+  init(mg: Game, _ticks: number): void {
+    this.mg = mg;
+    const turnMs = this.mg.config().serverConfig().turnIntervalMs();
+    this.intervalTicks = Math.max(1, Math.ceil(30_000 / turnMs));
+    // Compute capitals immediately at game start for all players
+    for (const p of this.mg.players()) {
+      this.recomputeCapital(p, _ticks);
+    }
+  }
+
+  tick(ticks: number): void {
+    const bucket = ticks % 10;
+    const players = this.mg.players();
+
+    for (const p of players) {
+      // Spread across 10 ticks based on smallID bucket
+      if (p.smallID() % 10 !== bucket) continue;
+
+      const last = this.lastRecalc.get(p.id()) ?? -Infinity;
+      if (ticks - last < this.intervalTicks) continue;
+
+      this.recomputeCapital(p, ticks);
+    }
+  }
+
+  private recomputeCapital(player: Player, ticks: Tick): void {
+    const tiles = Array.from(player.tiles());
+    let capital: Cell | null = null;
+
+    if (tiles.length > 0) {
+      const sampleSize = Math.min(100, tiles.length);
+      const intervalIndex = Math.floor(ticks / Math.max(1, this.intervalTicks));
+      const prng = new PseudoRandom(
+        simpleHash(`${player.id()}::${intervalIndex}`),
+      );
+      // Deterministic reservoir sampling of up to 100 tiles
+      const sample: number[] = [];
+      for (let i = 0; i < tiles.length; i++) {
+        if (i < sampleSize) {
+          sample[i] = tiles[i];
+        } else {
+          const j = prng.nextInt(0, i + 1);
+          if (j < sampleSize) sample[j] = tiles[i];
+        }
+      }
+
+      // Compute centroid
+      let sumX = 0;
+      let sumY = 0;
+      for (const t of sample) {
+        sumX += this.mg.x(t as any);
+        sumY += this.mg.y(t as any);
+      }
+      const cx = sumX / sample.length;
+      const cy = sumY / sample.length;
+
+      // Snap to the nearest sampled owned tile to keep it on-land and owned
+      let best = sample[0];
+      let bestD2 = Infinity;
+      for (const t of sample) {
+        const dx = this.mg.x(t as any) - cx;
+        const dy = this.mg.y(t as any) - cy;
+        const d2 = dx * dx + dy * dy;
+        if (d2 < bestD2) {
+          best = t;
+          bestD2 = d2;
+        }
+      }
+
+      capital = new Cell(this.mg.x(best as any), this.mg.y(best as any));
+    }
+
+    (player as PlayerImpl)._setCapital(capital);
+    this.lastRecalc.set(player.id(), this.mg.ticks());
+  }
+}
diff --git a/src/core/execution/PortExecution.ts b/src/core/execution/PortExecution.ts
index bb9207a3d..89591b96f 100644
--- a/src/core/execution/PortExecution.ts
+++ b/src/core/execution/PortExecution.ts
@@ -1,7 +1,6 @@
 import { Execution, Game, Player, Unit, UnitType } from "../game/Game";
 import { TileRef } from "../game/GameMap";
 import { PseudoRandom } from "../PseudoRandom";
-import { TradeShipExecution } from "./TradeShipExecution";
 
 export class PortExecution implements Execution {
   private active = true;
@@ -56,26 +55,10 @@ export class PortExecution implements Execution {
       return;
     }
 
-    const totalEffectivePorts = this.mg
-      .players()
-      .reduce((sum, p) => sum + p.effectiveUnits(UnitType.Port), 0);
-
-    if (
-      !this.random.chance(
-        this.mg.config().tradeShipSpawnRate(totalEffectivePorts),
-      )
-    ) {
-      return;
-    }
-
-    const ports = this.player.tradingPorts(this.port);
-
-    if (ports.length === 0) {
-      return;
-    }
-
-    const port = this.random.randElement(ports);
-    this.mg.addExecution(new TradeShipExecution(this.player, this.port, port));
+    // Trade rework: trade ships are assigned by TradeManager; ports no longer
+    // spawn spontaneous trade routes here. Keep this execution responsible for
+    // ensuring the port exists and remains active.
+    return;
   }
 
   isActive(): boolean {
diff --git a/src/core/execution/SubmarineExecution.ts b/src/core/execution/SubmarineExecution.ts
index dc8377463..f95e767e3 100644
--- a/src/core/execution/SubmarineExecution.ts
+++ b/src/core/execution/SubmarineExecution.ts
@@ -127,15 +127,9 @@ export class SubmarineExecution implements Execution {
         continue;
       }
       if (unit.type() === UnitType.TradeShip) {
-        if (
-          !hasPort ||
-          unit.isSafeFromPirates() ||
-          unit.targetUnit()?.owner() === this.submarine.owner() || // trade ship is coming to my port
-          unit
-            .targetUnit()
-            ?.owner()
-            .isFriendly(this.submarine.owner() as any) // trade ship is coming to my ally
-        ) {
+        if (!hasPort || unit.isSafeFromPirates()) {
+          // Submarines only engage enemy trade ships when at war, but still
+          // respect basic protections like safe-from-pirates and owner having a port.
           continue;
         }
         if (
diff --git a/src/core/execution/TradeManagerExecution.ts b/src/core/execution/TradeManagerExecution.ts
new file mode 100644
index 000000000..a3d7b921c
--- /dev/null
+++ b/src/core/execution/TradeManagerExecution.ts
@@ -0,0 +1,1203 @@
+import {
+  Cell,
+  Execution,
+  Game,
+  MessageType,
+  Player,
+  PlayerType,
+  Tick,
+  Unit,
+  UnitType,
+} from "../game/Game";
+import { TileRef } from "../game/GameMap";
+import { PathFindResultType } from "../pathfinding/AStar";
+import { PathFinder } from "../pathfinding/PathFinding";
+import { PseudoRandom } from "../PseudoRandom";
+
+type PairKey = string; // `${fromId}->${toId}`
+
+interface DemandRoute {
+  from: Player;
+  to: Player;
+}
+
+/**
+ * Centralized trade system:
+ * - Accumulates bilateral demand via gravity model every N ticks
+ * - Maintains a FIFO demand queue; when demand >= 1, enqueues route
+ * - Each port supplies X trade ships (default 1) available for assignment
+ * - Assigns routes to available ships, moving them to start port then to end port
+ * - On completion, awards fixed income split between both traders and the ship owner
+ * - Handles replacement timers for new/lost trade ships per port
+ */
+export class TradeManagerExecution implements Execution {
+  private mg!: Game;
+  private active = true;
+  private lastDemandTick: Tick = -1;
+  private demand: Map<PairKey, number> = new Map();
+  private queue: DemandRoute[] = [];
+  private rand!: PseudoRandom; // Global PRNG for trade decisions
+  // Periodic logger for queue length
+  private queueLogIntervalId: any;
+  // Port -> list of replacement due ticks (supports multiple concurrent builds per port level)
+  private replacementDueAt: Map<number /*portUnitID*/, Tick[]> = new Map();
+  // Track last-known owner for each port to detect captures
+  private portOwnerById: Map<number /*portUnitID*/, Player> = new Map();
+  // Track last-known level for each port to detect upgrades
+  private portLevelById: Map<number /*portUnitID*/, number> = new Map();
+  // Track trade ships to detect losses (capture/deletion) and their home ports
+  private shipOwnerById: Map<number, Player> = new Map();
+  private shipHomePortById: Map<number, number /*portUnitID*/> = new Map();
+  private knownPortIds: Set<number> = new Set();
+
+  // --- Debug helpers (human owners only) ---
+  // Logging removed per request; retain no-op stubs to avoid refactor churn
+  private log(_msg: string): void {}
+  private logShip(_ship: Unit, _msg: string): void {}
+
+  init(mg: Game, _ticks: number): void {
+    this.mg = mg;
+    // Seed with a constant to satisfy request; deterministic across peers
+    this.rand = new PseudoRandom(123);
+  }
+
+  public randomNext(): number {
+    return this.rand.next();
+  }
+  public randomNextInt(min: number, max: number): number {
+    return this.rand.nextInt(min, max);
+  }
+
+  isActive(): boolean {
+    return this.active;
+  }
+
+  activeDuringSpawnPhase(): boolean {
+    return false;
+  }
+
+  tick(ticks: number): void {
+    if (!this.active) return;
+
+    // Capture whether there was carry-over demand before new accumulation this tick
+    const hadCarryOverAtStart = this.queue.length > 0;
+
+    // 1) Periodic gravity-based demand accumulation
+    const interval = this.mg.config().tradeDemandTickInterval();
+    if (this.lastDemandTick === -1) this.lastDemandTick = ticks;
+    let didAccumulateThisTick = false;
+    if (ticks - this.lastDemandTick >= interval) {
+      this.lastDemandTick = ticks;
+      this.accumulateDemand();
+      didAccumulateThisTick = true;
+    }
+
+    // 2) Maintain per-port replacement timers and spawn replacements when due
+    this.processPortSupply(ticks);
+
+    // 3) Drop any queued routes that are now embargoed
+    this.pruneEmbargoedRoutes();
+
+    // 4) Assign ships to queued routes when available
+    const preAssignQueueLen = this.queue.length;
+    this.assignRoutes(hadCarryOverAtStart, ticks);
+
+    // 5) Expose current queue length to the game for UI indicators (post-assignment)
+    (this.mg as any).setTradeDemandQueueLength?.(this.queue.length);
+
+    // 6) Periodic demand logging removed per user request; UI now derives state from queue length alone.
+  }
+
+  private playersForTrade(): Player[] {
+    // Consider all non-bot players who currently have at least one port,
+    // regardless of territory (alive()). This aligns with spec: exclude bots.
+    return this.mg
+      .players()
+      .filter(
+        (p) => p.type() !== PlayerType.Bot && p.units(UnitType.Port).length > 0,
+      );
+  }
+
+  private pruneEmbargoedRoutes(): void {
+    const before = this.queue.length;
+    if (before === 0) return;
+    this.queue = this.queue.filter(({ from, to }) => {
+      // Remove routes where either side embargoes the other
+      return !(from.hasEmbargoAgainst(to) || to.hasEmbargoAgainst(from));
+    });
+  }
+
+  private key(from: Player, to: Player): PairKey {
+    return `${from.id()}->${to.id()}`;
+  }
+
+  private accumulateDemand(): void {
+    const K = this.mg.config().tradeGravityK();
+    // World GDP = sum of all alive players' GDPs (bots and humans)
+    const worldGDP = this.mg
+      .players()
+      .filter((p) => p.isAlive())
+      .reduce((sum, p) => sum + p.gdp(), 0);
+    const players = this.playersForTrade();
+    for (let i = 0; i < players.length; i++) {
+      for (let j = 0; j < players.length; j++) {
+        if (i === j) continue;
+        const a = players[i];
+        const b = players[j];
+        // If either side has an embargo against the other, demand is zero
+        if (a.hasEmbargoAgainst(b) || b.hasEmbargoAgainst(a)) {
+          // Keep fractional demand at 0 for this pair
+          this.demand.set(this.key(a, b), 0);
+          continue;
+        }
+        const capA = a.capital();
+        const capB = b.capital();
+        if (capA === null || capB === null) continue;
+
+        const dist = this.capitalDistance(capA, capB);
+        if (dist <= 0) continue;
+        // New gravity model scaling:
+        // demand += K * gdp_i * gdp_j / distance / world_gdp
+        // Safeguard zero world GDP
+        const demandDelta =
+          worldGDP > 0 ? (K * a.gdp() * b.gdp()) / dist / worldGDP : 0;
+        const k = this.key(a, b);
+        // Initialize with a uniform random fractional remainder in [0,1) once per pair
+        let prev = this.demand.get(k);
+        prev ??= 0.8 + this.rand.next() * 0.2;
+        const next = (prev as number) + demandDelta;
+        // Enqueue integer demand, keep fractional remainder
+        if (next >= 1) {
+          const count = Math.floor(next);
+          for (let c = 0; c < count; c++) {
+            this.queue.push({ from: a, to: b });
+          }
+          this.demand.set(k, next - count);
+        } else {
+          this.demand.set(k, next);
+        }
+      }
+    }
+  }
+
+  private capitalDistance(a: Cell, b: Cell): number {
+    const refA = this.mg.ref(a.x, a.y);
+    const refB = this.mg.ref(b.x, b.y);
+    return Math.sqrt(this.mg.euclideanDistSquared(refA, refB));
+  }
+
+  // (removed) nearestOceanWithin helper was unused after direct undocking implementation
+
+  private processPortSupply(ticks: Tick): void {
+    const basePerPort = this.mg.config().tradeShipPerPortSupply();
+    const delay = this.mg.config().tradeShipReplacementDelayTicks();
+    const targetSupplyFor = (port: Unit) => basePerPort * port.level();
+
+    // 1) Update current home-port assignments and track current owners
+    const currentShipIds = new Set<number>();
+    const shipsSnapshot = [...this.mg.units(UnitType.TradeShip)];
+    for (const ship of shipsSnapshot) {
+      // Remove trade ships owned by eliminated players
+      if (!ship.owner().isAlive()) {
+        // Delete without messages; considered a consequence of elimination
+        ship.delete(false);
+        this.logShip(ship, `deleted (owner eliminated)`);
+        // Clean up tracking
+        const sid = ship.id();
+        this.shipOwnerById.delete(sid);
+        this.shipHomePortById.delete(sid);
+        continue;
+      }
+      if (!ship.isActive()) continue;
+      const sid = ship.id();
+      currentShipIds.add(sid);
+      const prevOwner = this.shipOwnerById.get(sid);
+      const currOwner = ship.owner();
+      if (prevOwner && prevOwner !== currOwner) {
+        // Captured by another nation -> schedule replacement for its last known home port
+        const shipLabel = `Trade Ship #${sid}`;
+        // Notify previous owner they lost their ship to capture
+        this.mg.displayMessage(
+          `${shipLabel} was captured by ${currOwner.displayName()}`,
+          MessageType.TRADE_SHIP_CAPTURED,
+          prevOwner.id(),
+        );
+        // Notify new owner of successful capture
+        this.mg.displayMessage(
+          `You captured ${shipLabel} from ${prevOwner.displayName()}`,
+          MessageType.TRADE_SHIP_CAPTURED_ENEMY,
+          currOwner.id(),
+        );
+        const homePortId = this.shipHomePortById.get(sid);
+        if (homePortId !== undefined) {
+          const port = this.mg
+            .units(UnitType.Port)
+            .find((p) => p.id() === homePortId && p.isActive());
+          if (
+            port &&
+            this.activeHomeSupplyCount(port) < targetSupplyFor(port)
+          ) {
+            const list = this.replacementDueAt.get(homePortId) ?? [];
+            const target = targetSupplyFor(port);
+            const active = this.activeHomeSupplyCount(port);
+            const pending = list.length;
+            const missing = Math.max(0, target - (active + pending));
+            if (missing > 0) {
+              const newList = [...list];
+              for (let i = 0; i < missing; i++) newList.push(ticks + delay);
+              this.replacementDueAt.set(homePortId, newList);
+              const homePortObj = this.mg
+                .units(UnitType.Port)
+                .find((p) => p.id() === homePortId && p.isActive());
+              if (homePortObj)
+                (homePortObj as any).setPendingTradeShipDueTicks(newList);
+              this.log(
+                `t=${ticks} schedule replacement after capture homePort=${homePortId} add=${missing} due=${ticks + delay}`,
+              );
+            }
+          }
+        }
+        // Clear home assignment after capture
+        this.shipHomePortById.delete(sid);
+        this.logShip(ship, `captured by '${currOwner.displayName()}'`);
+      }
+      this.shipOwnerById.set(sid, currOwner);
+
+      // If idle and docked at own port (on the port tile), assign/update home port
+      if (ship.targetUnit() === undefined) {
+        const dockPort = this.mg
+          .unitsAt(ship.tile())
+          .find(
+            (u) => u.type() === UnitType.Port && u.owner() === currOwner,
+          ) as Unit | undefined;
+        if (dockPort) this.shipHomePortById.set(sid, dockPort.id());
+      }
+    }
+    // Detect deletions (sunk etc.) -> schedule replacement at last known home port
+    for (const [sid, prevOwner] of Array.from(this.shipOwnerById.entries())) {
+      if (!currentShipIds.has(sid)) {
+        // Ship was destroyed/lost (sunk). Notify previous owner.
+        const shipLabel = `Trade Ship #${sid}`;
+        this.mg.displayMessage(
+          `${shipLabel} was sunk at sea`,
+          MessageType.TRADE_SHIP_SUNK,
+          prevOwner.id(),
+        );
+        const homePortId = this.shipHomePortById.get(sid);
+        if (homePortId !== undefined) {
+          const port = this.mg
+            .units(UnitType.Port)
+            .find((p) => p.id() === homePortId && p.isActive());
+          if (
+            port &&
+            this.activeHomeSupplyCount(port) < targetSupplyFor(port)
+          ) {
+            const list = this.replacementDueAt.get(homePortId) ?? [];
+            const target = targetSupplyFor(port);
+            const active = this.activeHomeSupplyCount(port);
+            const pending = list.length;
+            const missing = Math.max(0, target - (active + pending));
+            if (missing > 0) {
+              const newList = [...list];
+              for (let i = 0; i < missing; i++) newList.push(ticks + delay);
+              this.replacementDueAt.set(homePortId, newList);
+              const homePortObj2 = this.mg
+                .units(UnitType.Port)
+                .find((p) => p.id() === homePortId && p.isActive());
+              if (homePortObj2)
+                (homePortObj2 as any).setPendingTradeShipDueTicks(newList);
+              this.log(
+                `t=${ticks} schedule replacement (ship lost) homePort=${homePortId} add=${missing} due=${ticks + delay}`,
+              );
+            }
+          }
+        }
+        this.shipOwnerById.delete(sid);
+        this.shipHomePortById.delete(sid);
+      }
+    }
+
+    // 2) Handle new ports: schedule initial supply if needed
+    const currentPortIds = new Set<number>();
+    for (const port of this.mg.units(UnitType.Port)) {
+      if (!port.isActive()) continue;
+      currentPortIds.add(port.id());
+      // Detect ownership change of an existing port
+      const prevOwner = this.portOwnerById.get(port.id());
+      const currentLevel = port.level();
+      const prevLevel = this.portLevelById.get(port.id());
+      if (prevOwner && prevOwner !== port.owner()) {
+        // Port captured: ensure new owner can reach level-scaled supply target
+        if (this.activeHomeSupplyCount(port) < targetSupplyFor(port)) {
+          const list = this.replacementDueAt.get(port.id()) ?? [];
+          const target = targetSupplyFor(port);
+          const active = this.activeHomeSupplyCount(port);
+          const pending = list.length;
+          const missing = Math.max(0, target - (active + pending));
+          if (missing > 0) {
+            const newList = [...list];
+            for (let i = 0; i < missing; i++) newList.push(ticks + delay);
+            this.replacementDueAt.set(port.id(), newList);
+            (port as any).setPendingTradeShipDueTicks(newList);
+            this.log(
+              `t=${ticks} portCapture port=${port.id()} level=${currentLevel} add=${missing} due=${ticks + delay}`,
+            );
+          }
+        }
+      }
+      // Detect level upgrade
+      if (prevLevel !== undefined && currentLevel > prevLevel) {
+        if (this.activeHomeSupplyCount(port) < targetSupplyFor(port)) {
+          const list = this.replacementDueAt.get(port.id()) ?? [];
+          const target = targetSupplyFor(port);
+          const active = this.activeHomeSupplyCount(port);
+          const pending = list.length;
+          const missing = Math.max(0, target - (active + pending));
+          if (missing > 0) {
+            const newList = [...list];
+            for (let i = 0; i < missing; i++) newList.push(ticks + delay);
+            this.replacementDueAt.set(port.id(), newList);
+            (port as any).setPendingTradeShipDueTicks(newList);
+            this.log(
+              `t=${ticks} portUpgrade port=${port.id()} oldLevel=${prevLevel} newLevel=${currentLevel} add=${missing} due=${ticks + delay}`,
+            );
+          }
+        }
+      }
+      // Track current owner
+      this.portOwnerById.set(port.id(), port.owner());
+      // Track current level
+      this.portLevelById.set(port.id(), currentLevel);
+      if (!this.knownPortIds.has(port.id())) {
+        // New port detected
+        if (this.activeHomeSupplyCount(port) < targetSupplyFor(port)) {
+          const list = this.replacementDueAt.get(port.id()) ?? [];
+          const target = targetSupplyFor(port);
+          const active = this.activeHomeSupplyCount(port);
+          const pending = list.length;
+          const missing = Math.max(0, target - (active + pending));
+          if (missing > 0) {
+            const newList = [...list];
+            for (let i = 0; i < missing; i++) newList.push(ticks + delay);
+            this.replacementDueAt.set(port.id(), newList);
+            (port as any).setPendingTradeShipDueTicks(newList);
+          }
+        }
+        this.knownPortIds.add(port.id());
+      }
+    }
+    // Clear ports that no longer exist
+    for (const pid of Array.from(this.knownPortIds)) {
+      if (!currentPortIds.has(pid)) {
+        this.knownPortIds.delete(pid);
+        this.portOwnerById.delete(pid);
+      }
+    }
+
+    // 3) Spawn replacements that are due (but only if still below target supply)
+    for (const [portID, dueList] of Array.from(
+      this.replacementDueAt.entries(),
+    )) {
+      const port = this.mg
+        .units(UnitType.Port)
+        .find((p) => p.id() === portID && p.isActive());
+      if (!port) {
+        this.replacementDueAt.delete(portID);
+        continue;
+      }
+      // Spawn all whose due tick has arrived
+      let remaining = dueList.filter((d) => d > ticks);
+      const ready = dueList.filter((d) => d <= ticks);
+      for (const dueTick of ready) {
+        if (this.activeHomeSupplyCount(port) >= targetSupplyFor(port)) {
+          remaining = [];
+          break;
+        }
+        const owner = port.owner();
+        const requested = port.tile();
+        const spawn = owner.canBuild(UnitType.TradeShip, requested);
+        if (spawn !== false) {
+          const hasPortAtSpawn = this.mg
+            .unitsAt(requested)
+            .some((u) => u.type() === UnitType.Port);
+          if (hasPortAtSpawn) {
+            const newShip = owner.buildUnit(
+              UnitType.TradeShip,
+              requested,
+              {} as any,
+            );
+            this.shipOwnerById.set(newShip.id(), newShip.owner());
+            this.shipHomePortById.set(newShip.id(), portID);
+            this.logShip(
+              newShip,
+              `spawned replacement port=${portID} owner='${owner.displayName()}' due=${dueTick}`,
+            );
+          }
+        }
+      }
+      // After spawns, schedule additional if still missing
+      const target = targetSupplyFor(port);
+      const active = this.activeHomeSupplyCount(port);
+      const pending = remaining.length;
+      const missing = Math.max(0, target - (active + pending));
+      if (missing > 0) {
+        for (let i = 0; i < missing; i++) remaining.push(ticks + delay);
+      }
+      if (remaining.length === 0) {
+        this.replacementDueAt.delete(portID);
+        (port as any).setPendingTradeShipDueTicks([]);
+      } else {
+        remaining.sort((a, b) => a - b);
+        this.replacementDueAt.set(portID, remaining);
+        (port as any).setPendingTradeShipDueTicks(remaining);
+      }
+    }
+  }
+
+  private selectRandomPort(player: Player): Unit | null {
+    const ports = player.units(UnitType.Port).filter((p) => p.isActive());
+    if (ports.length === 0) return null;
+    const idx = this.rand.nextInt(0, ports.length);
+    return ports[idx];
+  }
+
+  private availableShips(): Unit[] {
+    const ships: Unit[] = [];
+    for (const ship of this.mg.units(UnitType.TradeShip)) {
+      if (!ship.isActive()) continue;
+      // Do not consider ships that are flagged as returning
+      if (ship.returning()) continue;
+      // Exclude ships already on a trade assignment this tick (phase set)
+      if (ship.tradePhase && ship.tradePhase() !== null) continue;
+      // Idle and docked: considered available
+      if (ship.targetUnit() !== undefined) continue;
+      // Consider available if docked at ANY port tile (regardless of owner)
+      const isDockedAtAnyPort = this.mg
+        .unitsAt(ship.tile())
+        .some((u) => u.type() === UnitType.Port);
+      if (!isDockedAtAnyPort) continue;
+      ships.push(ship);
+    }
+    return ships;
+  }
+
+  private availableShipsFor(owner: Player): Unit[] {
+    return this.availableShips().filter((s) => s.owner() === owner);
+  }
+
+  private activeHomeSupplyCount(port: Unit): number {
+    let count = 0;
+    const pid = port.id();
+    for (const ship of this.mg.units(UnitType.TradeShip)) {
+      if (!ship.isActive()) continue;
+      if (ship.owner() !== port.owner()) continue;
+      if (this.shipHomePortById.get(ship.id()) === pid) count++;
+    }
+    return count;
+  }
+
+  private assignRoutes(carryOverMode: boolean, ticks: Tick): void {
+    if (this.queue.length === 0) return;
+    const available = this.availableShips();
+    if (available.length === 0) return;
+
+    // When there was carry-over demand, each available ship gets a weighted draw over all routes.
+    if (carryOverMode) {
+      // Iterate over ships; for each, select a route weighted by inverse distance to its closest start port
+      for (
+        let sIdx = 0;
+        sIdx < available.length && this.queue.length > 0;
+        sIdx++
+      ) {
+        const ship = available[sIdx];
+        const shipX = this.mg.x(ship.tile());
+        const shipY = this.mg.y(ship.tile());
+
+        // Build candidate list: each route with at least one active start & end port
+        const candidates: Array<{
+          routeIndex: number;
+          startPort: Unit;
+          endPorts: Unit[];
+          weight: number;
+        }> = [];
+        let totalWeight = 0;
+        for (let rIdx = 0; rIdx < this.queue.length; rIdx++) {
+          const route = this.queue[rIdx];
+          const startPorts = route.from
+            .units(UnitType.Port)
+            .filter((p) => p.isActive());
+          const endPorts = route.to
+            .units(UnitType.Port)
+            .filter((p) => p.isActive());
+          if (startPorts.length === 0 || endPorts.length === 0) continue; // unassignable this tick
+          // Find closest start port to this ship (Manhattan)
+          let bestPort: Unit = startPorts[0];
+          let bestDist =
+            Math.abs(this.mg.x(bestPort.tile()) - shipX) +
+            Math.abs(this.mg.y(bestPort.tile()) - shipY);
+          for (let k = 1; k < startPorts.length; k++) {
+            const sp = startPorts[k];
+            const d =
+              Math.abs(this.mg.x(sp.tile()) - shipX) +
+              Math.abs(this.mg.y(sp.tile()) - shipY);
+            if (d < bestDist) {
+              bestDist = d;
+              bestPort = sp;
+            }
+          }
+          const weight = 1 / (bestDist + 1); // inverse distance weighting
+          candidates.push({
+            routeIndex: rIdx,
+            startPort: bestPort,
+            endPorts,
+            weight,
+          });
+          totalWeight += weight;
+        }
+        if (candidates.length === 0) break; // nothing can be assigned
+
+        // Weighted selection via global PRNG
+        let r = this.rand.next() * totalWeight;
+        let chosen = candidates[0];
+        for (const c of candidates) {
+          if (r <= c.weight) {
+            chosen = c;
+            break;
+          }
+          r -= c.weight;
+        }
+
+        // Remove selected route from queue
+        const [route] = this.queue.splice(chosen.routeIndex, 1);
+        // Pick end port randomly (uniform among active end ports)
+        const endPort =
+          chosen.endPorts[this.rand.nextInt(0, chosen.endPorts.length)];
+
+        this.mg.addExecution(
+          new AssignedTradeRouteExecution(
+            this,
+            ship,
+            chosen.startPort,
+            endPort,
+          ),
+        );
+        this.logShip(
+          ship,
+          `assigned (carryOver) route startPort=${chosen.startPort.id()} startOwner='${chosen.startPort
+            .owner()
+            .displayName()}' endPort=${endPort.id()} endOwner='${endPort
+            .owner()
+            .displayName()}' queueRemaining=${this.queue.length}`,
+        );
+      }
+      // Optionally prune any remaining routes that are unassignable (no ports)
+      this.queue = this.queue.filter(
+        (r) =>
+          r.from.units(UnitType.Port).some((p) => p.isActive()) &&
+          r.to.units(UnitType.Port).some((p) => p.isActive()),
+      );
+      return;
+    }
+
+    // Assign as many routes as possible this tick while ships and routes are available
+    while (this.queue.length > 0 && available.length > 0) {
+      // Peek next route; if endpoints invalid, skip it (drop) to avoid blocking
+      const next = this.queue[0];
+      const startPort = this.selectRandomPort(next.from);
+      const endPort = this.selectRandomPort(next.to);
+      if (!startPort || !endPort) {
+        // Can't satisfy this route right now (no ports); drop it
+        this.queue.shift();
+        continue;
+      }
+
+      // Pick an available ship weighted by inverse Manhattan distance to start port (closer ships favored)
+      const sx = this.mg.x(startPort.tile());
+      const sy = this.mg.y(startPort.tile());
+      let totalWeight = 0;
+      const weights: number[] = new Array(available.length);
+      for (let i = 0; i < available.length; i++) {
+        const ship = available[i];
+        const dx = Math.abs(this.mg.x(ship.tile()) - sx);
+        const dy = Math.abs(this.mg.y(ship.tile()) - sy);
+        const dist = dx + dy;
+        const w = 1 / (dist + 1); // distance 0 -> weight 1, dist 1 -> 0.5, etc.
+        weights[i] = w;
+        totalWeight += w;
+      }
+      const r = this.rand.next() * totalWeight;
+      let acc = 0;
+      let chosenIndex = 0;
+      for (let i = 0; i < weights.length; i++) {
+        acc += weights[i];
+        if (r <= acc) {
+          chosenIndex = i;
+          break;
+        }
+      }
+      const [ship] = available.splice(chosenIndex, 1);
+
+      // Assign: set target to start port if not already there; execution will handle moves
+      this.queue.shift();
+      this.mg.addExecution(
+        new AssignedTradeRouteExecution(this, ship, startPort, endPort),
+      );
+      this.logShip(
+        ship,
+        `assigned route startPort=${startPort.id()} startOwner='${startPort
+          .owner()
+          .displayName()}' endPort=${endPort.id()} endOwner='${endPort
+          .owner()
+          .displayName()}' queueRemaining=${this.queue.length}`,
+      );
+    }
+  }
+
+  // Requeue a route demand back into FIFO queue (called by executions on abort)
+  public requeueRoute(from: Player, to: Player): void {
+    this.queue.push({ from, to });
+  }
+}
+
+export class AssignedTradeRouteExecution implements Execution {
+  private mg!: Game;
+  private path!: PathFinder;
+  private active = true;
+  private phase: "toStart" | "toEnd" = "toStart";
+  private lastMoveTick = 0;
+  private lastPort: Unit | null = null;
+
+  constructor(
+    private manager: TradeManagerExecution,
+    private ship: Unit,
+    private startPort: Unit,
+    private endPort: Unit,
+  ) {}
+
+  init(mg: Game, ticks: number): void {
+    this.mg = mg;
+    this.path = PathFinder.Mini(mg, 30000, true, 100);
+    this.lastMoveTick = ticks;
+    // Ensure ship is not in a stale 'returning' state from a prior turnaround
+    this.ship.setReturning(false);
+    // Mark phase as heading to start when assignment begins
+    this.setPhaseWithLog("toStart", "init_toStart");
+    // Store route owners on the ship for warship logic
+    this.ship.setTradeRouteOwners(this.startPort.owner(), this.endPort.owner());
+    // Load cargo equal to the route's fixed income; used if captured and returned
+    this.ship.setCargoGold(this.mg.config().tradeIncomeFixed());
+    // Record last port visited at assignment time (only if currently on a port tile)
+    const dockPort = this.mg
+      .unitsAt(this.ship.tile())
+      .find((u) => u.type() === UnitType.Port) as Unit | undefined;
+    this.lastPort = dockPort ?? null;
+    this.log(
+      `init route ship=${this.ship.id()} owner='${this.ship
+        .owner()
+        .displayName()}' startPort=${this.startPort.id()} endPort=${this.endPort.id()} startPhase=toStart`,
+    );
+
+    // (removed) assignment-time debug logs
+  }
+  isActive(): boolean {
+    return this.active;
+  }
+
+  activeDuringSpawnPhase(): boolean {
+    return false;
+  }
+
+  tick(ticks: number): void {
+    if (!this.active) return;
+    if (!this.ship.isActive()) {
+      // Keep current phase value even if destroyed (avoid null)
+      this.setPhaseWithLog(this.phase, "destroyed_mid_route");
+      this.active = false;
+      this.log(`destroyed mid-route ship=${this.ship.id()}`);
+      return;
+    }
+    // Determine where this ship should be heading this tick
+    let expectedTargetUnit =
+      this.phase === "toStart" ? this.startPort : this.endPort;
+    if (this.ship.returning()) {
+      // Keep current trade phase while returning (avoid null)
+      this.ship.setTradePhase(this.phase);
+      // Prefer lastPort only if it still exists; otherwise choose a domestic fallback
+      if (this.lastPort && this.lastPort.isActive()) {
+        expectedTargetUnit = this.lastPort;
+      } else {
+        // No valid last port: pick a domestic fallback or scuttle
+        const domesticFallback = this.selectRandomDomesticPort(
+          this.ship.owner(),
+        );
+        if (domesticFallback) {
+          expectedTargetUnit = domesticFallback;
+          // Treat chosen fallback as the new lastPort to avoid redirect loops
+          this.lastPort = domesticFallback;
+        } else {
+          // Nowhere sensible to return to -> scuttle the ship and end.
+          this.ship.delete(false);
+          this.active = false;
+          this.log(`scuttled ship=${this.ship.id()} reason=noFallbackReturn`);
+          return;
+        }
+      }
+    }
+    // If the DESTINATION (expected target) was destroyed, try to substitute another port of the same owner.
+    if (!expectedTargetUnit.isActive()) {
+      let substituted = false;
+      if (!this.ship.returning()) {
+        if (this.phase === "toEnd") {
+          // Replace endPort with nearest active port owned by the original end owner
+          const endOwner =
+            this.ship.tradeRouteEndOwner?.() ?? this.endPort.owner();
+          const replacement = endOwner
+            ? this.selectNearestPort(endOwner)
+            : null;
+          if (replacement) {
+            this.endPort = replacement;
+            expectedTargetUnit = replacement;
+            this.ship.setTargetUnit(expectedTargetUnit);
+            substituted = true;
+          }
+        } else {
+          // phase === "toStart": replace startPort similarly
+          const startOwner =
+            this.ship.tradeRouteStartOwner?.() ?? this.startPort.owner();
+          const replacement = startOwner
+            ? this.selectNearestPort(startOwner)
+            : null;
+          if (replacement) {
+            this.startPort = replacement;
+            expectedTargetUnit = replacement;
+            this.ship.setTargetUnit(expectedTargetUnit);
+            substituted = true;
+          }
+        }
+      }
+      if (!substituted) {
+        // Fall back to previous returning/scuttle behavior
+        const domesticFallback = this.selectRandomDomesticPort(
+          this.ship.owner(),
+        );
+        if (!this.ship.returning()) {
+          const fallback =
+            this.lastPort && this.lastPort.isActive()
+              ? this.lastPort
+              : domesticFallback;
+          if (fallback) {
+            this.ship.setReturning(true);
+            this.setPhaseWithLog(
+              this.phase,
+              "dest_lost_set_returning_clear_phase",
+            );
+            // Notify the ship owner that this ship was turned around (likely blockade/destination lost)
+            try {
+              const shipLabel = `Trade Ship #${this.ship.id()}`;
+              const otherOwner =
+                this.phase === "toEnd"
+                  ? (this.ship.tradeRouteEndOwner?.() ?? this.endPort.owner())
+                  : (this.ship.tradeRouteStartOwner?.() ??
+                    this.startPort.owner());
+              const otherName = otherOwner?.displayName();
+              const msg = otherName
+                ? `${shipLabel} was turned around due to blockade by ${otherName}`
+                : `${shipLabel} was turned around due to blockade`;
+              this.mg.displayMessage(
+                msg,
+                MessageType.TRADE_SHIP_TURNED_AROUND,
+                this.ship.owner().id(),
+              );
+            } catch (_e) {
+              // no-op: best-effort message emission
+            }
+            this.ship.setTargetUnit(fallback);
+            this.log(
+              `returning ship=${this.ship.id()} reason=destinationLost fallbackPort=${fallback.id()}`,
+            );
+          } else {
+            // Nowhere sensible to return to -> scuttle the ship
+            this.setPhaseWithLog(
+              this.phase,
+              "dest_lost_no_fallback_clear_phase",
+            );
+            this.ship.delete(false);
+            this.active = false;
+            this.log(
+              `scuttled ship=${this.ship.id()} reason=destinationLostNoFallback`,
+            );
+          }
+        } else {
+          if (domesticFallback) {
+            this.ship.setTargetUnit(domesticFallback);
+            // Pin fallback as lastPort so subsequent ticks keep a stable target
+            this.lastPort = domesticFallback;
+            this.log(
+              `redirectReturn ship=${this.ship.id()} newPort=${domesticFallback.id()} reason=destinationLostWhileReturning`,
+            );
+          } else {
+            // Already returning but no valid fallback -> scuttle the ship
+            this.setPhaseWithLog(
+              this.phase,
+              "returning_dest_lost_no_fallback_clear_phase",
+            );
+            this.ship.delete(false);
+            this.active = false;
+            this.log(
+              `scuttled ship=${this.ship.id()} reason=returningDestinationLostNoFallback`,
+            );
+          }
+        }
+        return;
+      }
+      // If substituted, fall through and continue navigation to the new target.
+    }
+    // If some external order changed the target while not returning, stop this assignment
+    // Allow initial assignment where target is still undefined; we'll set it below.
+    if (
+      !this.ship.returning() &&
+      this.ship.targetUnit() !== undefined &&
+      this.ship.targetUnit() !== expectedTargetUnit
+    ) {
+      // External retargeting cancels the assignment; clear trade phase so this ship is no longer considered in-route
+      this.setPhaseWithLog(null, "external_retarget_cancel_clear_phase");
+      // Propagate cleared phase immediately
+      this.ship.touch();
+      this.active = false;
+      this.log(
+        `externalRetargetCancel ship=${this.ship.id()} oldTargetUnit=${this.ship
+          .targetUnit()
+          ?.id?.()} expectedTarget=${expectedTargetUnit.id()}`,
+      );
+      return;
+    }
+    // Ensure the ship's target matches the expected target we will navigate to
+    if (this.ship.targetUnit() !== expectedTargetUnit) {
+      this.ship.setTargetUnit(expectedTargetUnit);
+    }
+
+    // Move at default cadence (every tick)
+    if (ticks - this.lastMoveTick < 1) return;
+    this.lastMoveTick = ticks;
+
+    const targetTile: TileRef = expectedTargetUnit.tile();
+
+    // If adjacent to expected target port, dock onto the port tile and handle arrival
+    if (this.mg.manhattanDist(this.ship.tile(), targetTile) === 1) {
+      this.ship.move(targetTile);
+      // Update lastPort upon docking
+      const portHere = this.mg
+        .unitsAt(targetTile)
+        .find((u) => u.type() === UnitType.Port) as Unit | undefined;
+      if (portHere) this.lastPort = portHere;
+      // (removed) arrival logs for human-owned trade ships
+      if (this.ship.returning()) {
+        // Clear returning state upon successful return dock; keep phase
+        this.ship.setReturning(false);
+        // Clear trade phase so ship becomes idle/assignable
+        this.setPhaseWithLog(null, "returned_clear_phase");
+        // Cancel route on return to last port
+        this.ship.setTargetUnit(undefined);
+        this.ship.setTradeRouteOwners(null, null);
+        this.ship.setCargoGold(0n);
+        // Force an immediate update so targetId and trade metadata clear client-side
+        this.ship.touch();
+        this.active = false;
+        this.log(
+          `returned ship=${this.ship.id()} port=${this.lastPort?.id()} cargoGoldCleared`,
+        );
+        return;
+      }
+      if (this.phase === "toStart") {
+        // Arrived at start; proceed to end
+        this.phase = "toEnd";
+        this.setPhaseWithLog("toEnd", "arrived_start_toEnd");
+        this.ship.setTargetUnit(this.endPort);
+        this.log(
+          `arrivedStart ship=${this.ship.id()} startPort=${this.startPort.id()} switchingPhase=toEnd`,
+        );
+        return;
+      }
+      // Arrived at end
+      this.complete();
+      return;
+    }
+
+    // Compute a navigable water target near the destination port
+    const navTarget = this.navTargetForPort(targetTile);
+    if (navTarget === null) {
+      // Cannot navigate to this port (no adjacent ocean). End assignment.
+      // Extra instrumentation: report ocean-adjacent count and coordinates.
+      const neighbors = this.mg.neighbors(targetTile);
+      const oceanAdj = neighbors.filter((t) => this.mg.isOcean(t));
+      this.active = false;
+      this.log(
+        `abort ship=${this.ship.id()} reason=noNavTarget destPort=${expectedTargetUnit.id()} portTile=(${this.mg.x(
+          targetTile,
+        )},${this.mg.y(targetTile)}) oceanAdjCount=${oceanAdj.length}`,
+      );
+      return;
+    }
+
+    // If on land (port tile), leave port directly onto ocean: prefer adjacent ocean; otherwise jump to nearest ocean within a small radius.
+    if (!this.mg.isOcean(this.ship.tile())) {
+      const here = this.ship.tile();
+      // Must be docked at a port to undock
+      const dockPort = this.mg
+        .unitsAt(here)
+        .find((u) => u.type() === UnitType.Port) as Unit | undefined;
+      if (!dockPort) {
+        // On land without a port; do not move. End assignment.
+        this.active = false;
+        this.log(
+          `abort ship=${this.ship.id()} reason=onLandNotPort tile=(${this.mg.x(
+            here,
+          )},${this.mg.y(here)})`,
+        );
+        return;
+      }
+      // Try an adjacent ocean step first
+      const adjOcean = this.mg
+        .neighbors(here)
+        .filter((t) => this.mg.isOcean(t))
+        .sort(
+          (a, b) =>
+            this.mg.manhattanDist(a, navTarget) -
+            this.mg.manhattanDist(b, navTarget),
+        );
+      if (adjOcean.length > 0) {
+        this.ship.move(adjOcean[0]);
+        this.log(
+          `undock ship=${this.ship.id()} stepToOcean=(${this.mg.x(
+            adjOcean[0],
+          )},${this.mg.y(adjOcean[0])}) phase=${this.phase}`,
+        );
+        return;
+      }
+      // No adjacent ocean: do not jump; end assignment
+      this.active = false;
+      this.log(
+        `abort ship=${this.ship.id()} reason=noAdjacentOcean port=${dockPort?.id()}`,
+      );
+      return;
+    }
+
+    if (this.ship.tile() === targetTile) {
+      // Ensure lastPort is set if we're already on the port tile
+      if (!this.lastPort) {
+        const portHere = this.mg
+          .unitsAt(targetTile)
+          .find((u) => u.type() === UnitType.Port) as Unit | undefined;
+        if (portHere) this.lastPort = portHere;
+      }
+      // (removed) arrival logs when already on port tile
+      if (this.ship.returning()) {
+        // Clear returning state upon successful return dock; keep phase
+        this.ship.setReturning(false);
+        // Clear trade phase so ship becomes idle/assignable
+        this.setPhaseWithLog(null, "returned_on_port_clear_phase");
+        this.ship.setTargetUnit(undefined);
+        // Ensure UI receives cleared target immediately
+        this.ship.touch();
+        this.active = false;
+        this.log(
+          `returned ship=${this.ship.id()} (alreadyOnPortTile) port=${this.lastPort?.id()} cargoCleared`,
+        );
+        return;
+      }
+      if (this.phase === "toStart") {
+        this.phase = "toEnd";
+        this.setPhaseWithLog("toEnd", "arrived_start_on_port_toEnd");
+        this.ship.setTargetUnit(this.endPort);
+        this.log(
+          `arrivedStart ship=${this.ship.id()} (alreadyOnPortTile) startPort=${this.startPort.id()} switchingPhase=toEnd`,
+        );
+        return;
+      }
+      this.complete();
+      return;
+    }
+
+    const res = this.path.nextTile(this.ship.tile(), navTarget);
+    switch (res.type) {
+      case PathFindResultType.Completed:
+        this.ship.move(navTarget); // silent per-tick
+        break;
+      case PathFindResultType.Pending:
+        this.ship.move(this.ship.tile()); // no movement
+        break;
+      case PathFindResultType.NextTile:
+        this.ship.move(res.node); // silent step
+        break;
+      case PathFindResultType.PathNotFound:
+        // Path cannot be found; try another port of the same owner before giving up
+        if (!this.ship.returning()) {
+          if (this.phase === "toEnd") {
+            const owner = this.endPort.owner();
+            const alt = this.selectAlternatePort(owner, this.endPort.id());
+            if (alt) {
+              this.endPort = alt;
+              this.ship.setTargetUnit(alt);
+              return;
+            }
+          } else {
+            const owner = this.startPort.owner();
+            const alt = this.selectAlternatePort(owner, this.startPort.id());
+            if (alt) {
+              this.startPort = alt;
+              this.ship.setTargetUnit(alt);
+              return;
+            }
+          }
+        }
+        // No alternative available -> end assignment
+        // Instrumentation: log distance and target tile for diagnostics.
+        const failDist = this.mg.manhattanDist(this.ship.tile(), targetTile);
+        this.log(
+          `pathFail ship=${this.ship.id()} phase=${this.phase} targetPort=${expectedTargetUnit.id()} targetTile=(${this.mg.x(
+            targetTile,
+          )},${this.mg.y(targetTile)}) manhattanDist=${failDist} iterationsBudget=2500`,
+        );
+        // Reset ship to idle-at-port state and clear trade metadata
+        this.ship.setReturning(false);
+        // Clear trade phase since this assignment is aborted
+        this.setPhaseWithLog(null, "path_not_found_clear_phase");
+        this.ship.setTargetUnit(undefined);
+        this.ship.setTradeRouteOwners(null, null);
+        this.ship.setCargoGold(0n);
+        // Immediately propagate cleared state to the client
+        this.ship.touch();
+        // Return the demanded route to the queue for future assignment (only if not in 'returning')
+        if (!this.ship.returning()) {
+          this.manager.requeueRoute(
+            this.startPort.owner(),
+            this.endPort.owner(),
+          );
+        }
+        this.active = false;
+        this.log(
+          `abort ship=${this.ship.id()} reason=pathNotFound phase=${this.phase} requeuedRoute=(${this.startPort.owner().smallID()}->${this.endPort
+            .owner()
+            .smallID()})`,
+        );
+        break;
+    }
+  }
+
+  private complete(): void {
+    // Award fixed income split between traders and ship owner
+    const total = this.mg.config().tradeIncomeFixed();
+    const third = total / 3n;
+    const remainder = total - third * 3n;
+    const owner = this.ship.owner();
+    const a = this.startPort.owner();
+    const b = this.endPort.owner();
+    a.addGold(third);
+    b.addGold(third);
+    owner.addGold(third + remainder);
+
+    // Clear trade phase upon successful completion so the ship is eligible for reassignment
+    this.setPhaseWithLog(null, "complete_clear_phase");
+    this.ship.setTargetUnit(undefined);
+    this.ship.setTradeRouteOwners(null, null);
+    this.ship.setCargoGold(0n);
+    // Force an update so the cleared targetId reflects this tick
+    this.ship.touch();
+    this.active = false;
+    this.log(
+      `completed ship=${this.ship.id()} startPort=${this.startPort.id()} endPort=${this.endPort.id()} income=${total} ownerShare=${third + remainder}`,
+    );
+  }
+
+  // Wrapper to set trade phase and log for human-owned ships with a reason tag
+  private setPhaseWithLog(
+    phase: "toStart" | "toEnd" | null,
+    reason: string,
+  ): void {
+    this.ship.setTradePhase(phase);
+    const owner = this.ship.owner();
+    // Trade phase transition logging removed
+  }
+
+  // Pick an ocean tile adjacent to the port (targetTile) as navigation target
+  private navTargetForPort(portTile: TileRef): TileRef | null {
+    if (this.mg.isOcean(portTile)) return portTile;
+    const candidates = this.mg
+      .neighbors(portTile)
+      .filter((t) => this.mg.isOcean(t));
+    if (candidates.length === 0) return null;
+    candidates.sort(
+      (a, b) =>
+        this.mg.manhattanDist(this.ship.tile(), a) -
+        this.mg.manhattanDist(this.ship.tile(), b),
+    );
+    return candidates[0];
+  }
+
+  // Removed unused shoreline stepping helpers
+
+  // Pick any active port owned by the given owner
+  private selectRandomDomesticPort(owner: Player): Unit | null {
+    const ports = this.mg
+      .units(UnitType.Port)
+      .filter((p) => p.isActive() && p.owner() === owner);
+    if (ports.length === 0) return null;
+    const idx = this.manager.randomNextInt(0, ports.length);
+    return ports[idx];
+  }
+
+  // Pick the nearest active port owned by the given owner (to the ship's current position)
+  private selectNearestPort(owner: Player): Unit | null {
+    const ports = this.mg
+      .units(UnitType.Port)
+      .filter((p) => p.isActive() && p.owner() === owner);
+    if (ports.length === 0) return null;
+    let best: Unit | null = null;
+    let bestDist = Number.POSITIVE_INFINITY;
+    const here = this.ship.tile();
+    for (const p of ports) {
+      const d = this.mg.euclideanDistSquared(here, p.tile());
+      if (d < bestDist) {
+        bestDist = d;
+        best = p;
+      }
+    }
+    return best;
+  }
+
+  // Pick the nearest alternative active port owned by the owner, excluding a specific port ID,
+  // and prefer ports with at least one adjacent ocean tile (dockable)
+  private selectAlternatePort(
+    owner: Player,
+    excludePortId: number,
+  ): Unit | null {
+    const candidates = this.mg
+      .units(UnitType.Port)
+      .filter(
+        (p) => p.isActive() && p.owner() === owner && p.id() !== excludePortId,
+      );
+    if (candidates.length === 0) return null;
+    const dockable: Unit[] = [];
+    const here = this.ship.tile();
+    for (const p of candidates) {
+      const neighbors = this.mg.neighbors(p.tile());
+      if (neighbors.some((t) => this.mg.isOcean(t))) {
+        dockable.push(p);
+      }
+    }
+    const list = dockable.length > 0 ? dockable : candidates;
+    list.sort(
+      (a, b) =>
+        this.mg.euclideanDistSquared(here, a.tile()) -
+        this.mg.euclideanDistSquared(here, b.tile()),
+    );
+    return list[0] ?? null;
+  }
+
+  // --- Logging helpers (human owners only) ---
+  private log(msg: string): void {
+    const owner = this.ship.owner();
+    // Per-request: trade logging removed
+  }
+  // Per-tile movement logging removed per user request.
+}
diff --git a/src/core/execution/WarshipExecution.ts b/src/core/execution/WarshipExecution.ts
index ec678d778..ad3b56d8f 100644
--- a/src/core/execution/WarshipExecution.ts
+++ b/src/core/execution/WarshipExecution.ts
@@ -3,6 +3,7 @@ import {
   Game,
   isUnit,
   OwnerComp,
+  Player,
   Unit,
   UnitParams,
   UnitType,
@@ -111,19 +112,40 @@ export class WarshipExecution implements Execution {
       ) {
         continue;
       }
-      // Only engage if at war with the target's owner
-      if (!this.warship.owner().isAtWarWith(unit.owner())) {
-        continue;
+      // Decide engagement rules per unit type
+      if (unit.type() === UnitType.TradeShip) {
+        const shipOwner = unit.owner();
+        const myOwner = this.warship.owner();
+        const startOwner = unit.tradeRouteStartOwner();
+        const endOwner = unit.tradeRouteEndOwner();
+        const atWarWithAnyEndpoint = [startOwner, endOwner]
+          .filter((p): p is Player => !!p)
+          .some((p) => myOwner.isAtWarWith(p));
+
+        const embargoAgainstAnyEndpoint = [startOwner, endOwner]
+          .filter((p): p is Player => !!p)
+          .some(
+            (p) => myOwner.hasEmbargoAgainst(p) || p.hasEmbargoAgainst(myOwner),
+          );
+
+        const canTargetTrade =
+          myOwner.isAtWarWith(shipOwner) ||
+          ((atWarWithAnyEndpoint || embargoAgainstAnyEndpoint) &&
+            !myOwner.isFriendly(shipOwner));
+        if (!canTargetTrade) {
+          continue;
+        }
+      } else {
+        // Non-trade ships: only target if at war with owner
+        if (!this.warship.owner().isAtWarWith(unit.owner())) {
+          continue;
+        }
       }
       if (unit.type() === UnitType.TradeShip) {
-        if (
-          !hasPort ||
-          unit.isSafeFromPirates() ||
-          unit.targetUnit()?.owner() === this.warship.owner() || // trade ship is coming to my port
-          unit.targetUnit()?.owner().isFriendly(this.warship.owner()) // trade ship is coming to my ally
-        ) {
+        if (!hasPort || unit.isSafeFromPirates()) {
           continue;
         }
+        // Keep patrol range constraint for trade ships
         if (
           this.mg.euclideanDistSquared(
             this.warship.patrolTile()!,
@@ -241,11 +263,49 @@ export class WarshipExecution implements Execution {
         5,
       );
       switch (result.type) {
-        case PathFindResultType.Completed:
-          this.warship.owner().captureUnit(this.warship.targetUnit()!);
+        case PathFindResultType.Completed: {
+          const targetShip = this.warship.targetUnit()!;
+          const myOwner = this.warship.owner();
+          const shipOwner = targetShip.owner();
+          if (myOwner.isAtWarWith(shipOwner)) {
+            // Enemy trade ship -> capture
+            this.warship.owner().captureUnit(targetShip);
+            // Clear any trade route metadata on the captured ship
+            targetShip.setTradeRouteOwners(null, null);
+            // Send captured ship back to a home port of the new owner; cargo will be awarded on arrival
+            this.mg.addExecution(
+              new CapturedTradeShipReturnExecution(targetShip),
+            );
+            this.warship.setTargetUnit(undefined);
+            this.warship.move(this.warship.tile());
+            return;
+          }
+          // Neutral trade ship headed to/from my enemy -> turn around upon contact
+          const startOwner = targetShip.tradeRouteStartOwner();
+          const endOwner = targetShip.tradeRouteEndOwner();
+          const atWarWithAnyEndpoint = [startOwner, endOwner]
+            .filter((p): p is Player => !!p)
+            .some((p) => myOwner.isAtWarWith(p));
+          const embargoAgainstAnyEndpoint = [startOwner, endOwner]
+            .filter((p): p is Player => !!p)
+            .some(
+              (p) =>
+                myOwner.hasEmbargoAgainst(p) || p.hasEmbargoAgainst(myOwner),
+            );
+          if (
+            (atWarWithAnyEndpoint || embargoAgainstAnyEndpoint) &&
+            !myOwner.isFriendly(shipOwner)
+          ) {
+            targetShip.setReturning(true);
+            this.warship.setTargetUnit(undefined);
+            this.warship.move(this.warship.tile());
+            return;
+          }
+          // Otherwise, disengage
           this.warship.setTargetUnit(undefined);
           this.warship.move(this.warship.tile());
           return;
+        }
         case PathFindResultType.NextTile:
           this.warship.move(result.node);
           break;
@@ -420,3 +480,146 @@ export class WarshipExecution implements Execution {
     }
   }
 }
+
+class CapturedTradeShipReturnExecution implements Execution {
+  private mg!: Game;
+  private pathfinder!: PathFinder;
+  private active = true;
+  private lastMoveTick = 0;
+  private destPort: Unit | null = null;
+
+  constructor(private ship: Unit) {}
+
+  init(mg: Game, ticks: number): void {
+    this.mg = mg;
+    this.pathfinder = PathFinder.Mini(mg, 2500);
+    this.lastMoveTick = ticks;
+    // Pick nearest active port owned by the ship's owner
+    this.destPort = this.selectNearestPort(this.ship.owner());
+    if (this.destPort) {
+      this.ship.setTargetUnit(this.destPort);
+    } else {
+      // No port to return to; cancel
+      this.active = false;
+    }
+  }
+
+  isActive(): boolean {
+    return this.active;
+  }
+
+  activeDuringSpawnPhase(): boolean {
+    return false;
+  }
+
+  tick(ticks: number): void {
+    if (!this.active) return;
+    if (!this.ship.isActive()) {
+      this.active = false;
+      return;
+    }
+    if (!this.destPort || !this.destPort.isActive()) {
+      // Destination no longer valid; try to pick another
+      this.destPort = this.selectNearestPort(this.ship.owner());
+      if (!this.destPort) {
+        this.active = false;
+        return;
+      }
+      this.ship.setTargetUnit(this.destPort);
+    }
+
+    if (ticks - this.lastMoveTick < 1) return;
+    this.lastMoveTick = ticks;
+
+    const targetTile = this.destPort.tile();
+    if (this.mg.manhattanDist(this.ship.tile(), targetTile) === 1) {
+      // Dock
+      this.ship.move(targetTile);
+      const cargo = this.ship.cargoGold();
+      if (cargo > 0n) {
+        this.ship.owner().addGold(cargo);
+        this.ship.setCargoGold(0n);
+      }
+      this.ship.setTargetUnit(undefined);
+      this.active = false;
+      return;
+    }
+
+    const navTarget = this.navTargetForPort(targetTile);
+    if (navTarget === null) {
+      this.active = false;
+      return;
+    }
+
+    // If on land (port tile), step into adjacent ocean first
+    if (!this.mg.isOcean(this.ship.tile())) {
+      const step = this.stepIntoOceanTowards(navTarget);
+      if (step !== null) {
+        this.ship.move(step);
+        return;
+      }
+      this.active = false;
+      return;
+    }
+
+    const res = this.pathfinder.nextTile(this.ship.tile(), navTarget);
+    switch (res.type) {
+      case PathFindResultType.Completed:
+        this.ship.move(navTarget);
+        break;
+      case PathFindResultType.NextTile:
+        this.ship.move(res.node);
+        break;
+      case PathFindResultType.Pending:
+        this.ship.touch();
+        break;
+      case PathFindResultType.PathNotFound:
+        this.active = false;
+        break;
+    }
+  }
+
+  private selectNearestPort(owner: Player): Unit | null {
+    const ports = this.mg
+      .units(UnitType.Port)
+      .filter((p) => p.owner() === owner && p.isActive());
+    if (ports.length === 0) return null;
+    let best: Unit | null = null;
+    let bestDist = Number.POSITIVE_INFINITY;
+    for (const p of ports) {
+      const d = this.mg.euclideanDistSquared(this.ship.tile(), p.tile());
+      if (d < bestDist) {
+        bestDist = d;
+        best = p;
+      }
+    }
+    return best;
+  }
+
+  private navTargetForPort(portTile: TileRef): TileRef | null {
+    if (this.mg.isOcean(portTile)) return portTile;
+    const candidates = this.mg
+      .neighbors(portTile)
+      .filter((t) => this.mg.isOcean(t));
+    if (candidates.length === 0) return null;
+    candidates.sort(
+      (a, b) =>
+        this.mg.manhattanDist(this.ship.tile(), a) -
+        this.mg.manhattanDist(this.ship.tile(), b),
+    );
+    return candidates[0];
+  }
+
+  private stepIntoOceanTowards(navTarget: TileRef): TileRef | null {
+    const oceanNeighbors = this.mg
+      .neighbors(this.ship.tile())
+      .filter((t) => this.mg.isOcean(t));
+    if (oceanNeighbors.length === 0) return null;
+    oceanNeighbors.sort(
+      (a, b) =>
+        this.mg.manhattanDist(a, navTarget) -
+        this.mg.manhattanDist(b, navTarget),
+    );
+    return oceanNeighbors[0];
+  }
+}
diff --git a/src/core/game/Game.ts b/src/core/game/Game.ts
index 1aec97136..57832d173 100644
--- a/src/core/game/Game.ts
+++ b/src/core/game/Game.ts
@@ -514,6 +514,18 @@ export interface Unit {
   setSafeFromPirates(): void; // Only for trade ships
   isSafeFromPirates(): boolean; // Only for trade ships
 
+  // Trade route metadata (used primarily by trade ships)
+  setTradeRouteOwners(startOwner: Player | null, endOwner: Player | null): void;
+  tradeRouteStartOwner(): Player | null;
+  tradeRouteEndOwner(): Player | null;
+  // Trade navigation phase (null when idle/returning or no active assignment)
+  setTradePhase(phase: "toStart" | "toEnd" | null): void;
+  tradePhase(): "toStart" | "toEnd" | null;
+
+  // Trade ship cargo (gold carried during a route; awarded on capture return)
+  setCargoGold(amount: Gold): void;
+  cargoGold(): Gold;
+
   // Construction
   constructionType(): UnitType | null;
   setConstructionType(type: UnitType): void;
@@ -568,6 +580,9 @@ export interface Player {
 
   lastTileChange(): Tick;
 
+  // Capital (geographic center) of the player's territory, if any
+  capital(): Cell | null;
+
   isDisconnected(): boolean;
   markDisconnected(isDisconnected: boolean): void;
 
@@ -595,6 +610,8 @@ export interface Player {
   removeProductivity(amount: number): void;
   investmentRate(): number; // Returns the investment rate (0 to 1)
   setInvestmentRate(rate: number): void;
+  // Economic: Gross Domestic Product proxy
+  gdp(): number; // Computed as config.gdpFactor() * maxPopulation(this)
   // Roads: investment ratio (0..1) of per-tick income allocated to roads
   roadInvestmentRate(): number;
   setRoadInvestmentRate(rate: number): void;
@@ -898,6 +915,11 @@ export enum MessageType {
   ALLIANCE_EXPIRED,
   WAR_DECLARED,
   PEACE_MADE,
+  // Trade ship lifecycle events (new)
+  TRADE_SHIP_CAPTURED,
+  TRADE_SHIP_SUNK,
+  TRADE_SHIP_TURNED_AROUND,
+  TRADE_SHIP_CAPTURED_ENEMY,
   SENT_GOLD_TO_PLAYER,
   RECEIVED_GOLD_FROM_PLAYER,
   RECEIVED_GOLD_FROM_TRADE,
@@ -943,6 +965,10 @@ export const MESSAGE_TYPE_CATEGORIES: Record<MessageType, MessageCategory> = {
   [MessageType.PEACE_MADE]: MessageCategory.ALLIANCE,
   [MessageType.WARN]: MessageCategory.ALLIANCE,
   [MessageType.PEACE_TIMER_BLOCKED]: MessageCategory.ATTACK,
+  [MessageType.TRADE_SHIP_CAPTURED]: MessageCategory.ATTACK,
+  [MessageType.TRADE_SHIP_SUNK]: MessageCategory.ATTACK,
+  [MessageType.TRADE_SHIP_TURNED_AROUND]: MessageCategory.TRADE,
+  [MessageType.TRADE_SHIP_CAPTURED_ENEMY]: MessageCategory.ATTACK,
   [MessageType.SENT_GOLD_TO_PLAYER]: MessageCategory.TRADE,
   [MessageType.RECEIVED_GOLD_FROM_PLAYER]: MessageCategory.TRADE,
   [MessageType.RECEIVED_GOLD_FROM_TRADE]: MessageCategory.TRADE,
diff --git a/src/core/game/GameImpl.ts b/src/core/game/GameImpl.ts
index 41bf1443d..4ee73d5b3 100644
--- a/src/core/game/GameImpl.ts
+++ b/src/core/game/GameImpl.ts
@@ -81,6 +81,8 @@ export class GameImpl implements Game {
   private roadManager: RoadManager;
   private _roads = new Map<number, Road>();
   private cargoManager: CargoManager;
+  // Trade: global demand queue length, updated by TradeManagerExecution each tick
+  private _tradeDemandQueueLength: number = 0;
 
   private playerTeams: Team[];
   private botTeam: Team = ColoredTeams.Bot;
@@ -468,6 +470,15 @@ export class GameImpl implements Game {
     return this.updates;
   }
 
+  // Trade demand queue length accessors (used by PlayerImpl.toUpdate and UI)
+  public setTradeDemandQueueLength(n: number): void {
+    // Clamp to non-negative integer
+    this._tradeDemandQueueLength = n < 0 ? 0 : Math.floor(n);
+  }
+  public tradeDemandQueueLength(): number {
+    return this._tradeDemandQueueLength;
+  }
+
   private hash(): number {
     let hash = 1;
     this._players.forEach((p) => {
diff --git a/src/core/game/GameUpdates.ts b/src/core/game/GameUpdates.ts
index a09886972..42b701235 100644
--- a/src/core/game/GameUpdates.ts
+++ b/src/core/game/GameUpdates.ts
@@ -3,6 +3,7 @@ import {
   EmojiMessage,
   GameUpdates,
   Gold,
+  MapPos,
   MessageType,
   NameViewData,
   PlayerID,
@@ -139,6 +140,15 @@ export interface UnitUpdate {
   ghostExpiresAt?: Tick;
   // Structure upgrade level (>=1). Cities increase level by 1 per upgrade.
   level?: number;
+  // Trade-ship specific, for precise UI without heuristics
+  tradeRouteStartOwnerID?: number; // smallID of start port owner
+  tradeRouteEndOwnerID?: number; // smallID of end port owner
+  tradePhase?: "toStart" | "toEnd"; // current navigation phase (returning is provided separately)
+  dockedAtPortOwnerID?: number; // smallID of the owner of the port the ship is currently docked at (if any)
+  // Port-specific: when a trade ship is scheduled from this port, its construction completion tick
+  pendingTradeShipDueTick?: Tick;
+  // Port-specific: support multiple concurrent trade ship constructions
+  pendingTradeShipDueTicks?: Tick[];
 }
 
 export interface AttackUpdate {
@@ -162,8 +172,12 @@ export interface PlayerUpdate {
   playerType: PlayerType;
   isAlive: boolean;
   isDisconnected: boolean;
+  // Geographic capital (center) of player's territory
+  capital?: MapPos;
   tilesOwned: number;
   gold: Gold;
+  // Economic: GDP proxy = config.gdpFactor() * maxPopulation(player)
+  gdp: number;
   population: number;
   totalPopulation: number;
   hospitalReturns: number;
@@ -171,6 +185,8 @@ export interface PlayerUpdate {
   productivity: number;
   productivityGrowthPerMinute: number;
   investmentRate: number;
+  // Trade: current global demand queue length (for UI indicators)
+  tradeDemandQueueLength?: number;
   // Road KPIs (percent values 0..100)
   roadNetworkQuality?: number;
   roadNetworkCompletion?: number;
diff --git a/src/core/game/GameView.ts b/src/core/game/GameView.ts
index ea0f820ac..39d202b1f 100644
--- a/src/core/game/GameView.ts
+++ b/src/core/game/GameView.ts
@@ -161,10 +161,47 @@ export class UnitView {
     return this.data.targetedBySAM ?? false;
   }
 
+  // Trade metadata (optional)
+  tradeRouteStartOwner(): PlayerView | null {
+    const id = (this.data as any).tradeRouteStartOwnerID as number | undefined;
+    return id !== undefined
+      ? (this.gameView.playerBySmallID(id) as PlayerView)
+      : null;
+  }
+  tradeRouteEndOwner(): PlayerView | null {
+    const id = (this.data as any).tradeRouteEndOwnerID as number | undefined;
+    return id !== undefined
+      ? (this.gameView.playerBySmallID(id) as PlayerView)
+      : null;
+  }
+  tradePhase(): "toStart" | "toEnd" | null {
+    const v = (this.data as any).tradePhase as "toStart" | "toEnd" | undefined;
+    return v ?? null;
+  }
+  dockedAtPortOwner(): PlayerView | null {
+    const id = (this.data as any).dockedAtPortOwnerID as number | undefined;
+    return id !== undefined
+      ? (this.gameView.playerBySmallID(id) as PlayerView)
+      : null;
+  }
+
   // Structure upgrade level (>=1). Defaults to 1 when undefined in updates.
   level(): number {
     return (this.data as any).level ?? 1;
   }
+
+  // Port-specific: pending trade ship construction due tick (or null if none scheduled)
+  pendingTradeShipDueTick(): Tick | null {
+    const v = (this.data as any).pendingTradeShipDueTick as Tick | undefined;
+    return v ?? null;
+  }
+  // Port-specific: multiple pending trade ship construction due ticks
+  pendingTradeShipDueTicks(): Tick[] {
+    const arr = (this.data as any).pendingTradeShipDueTicks as
+      | Tick[]
+      | undefined;
+    return Array.isArray(arr) ? [...arr] : [];
+  }
 }
 
 export class PlayerView {
@@ -329,6 +366,9 @@ export class PlayerView {
   gold(): Gold {
     return this.data.gold;
   }
+  gdp(): number {
+    return this.data.gdp;
+  }
   population(): number {
     return this.data.population;
   }
@@ -427,6 +467,10 @@ export class PlayerView {
   isDisconnected(): boolean {
     return this.data.isDisconnected;
   }
+  // Trade: global demand queue length (server-provided; default 0)
+  tradeDemandQueueLength(): number {
+    return (this.data as any).tradeDemandQueueLength ?? 0;
+  }
 }
 
 export class GameView implements GameMap {
diff --git a/src/core/game/PlayerImpl.ts b/src/core/game/PlayerImpl.ts
index 6212c4a52..46d3b3c74 100644
--- a/src/core/game/PlayerImpl.ts
+++ b/src/core/game/PlayerImpl.ts
@@ -23,6 +23,7 @@ import {
   AllPlayers,
   Attack,
   BuildableUnit,
+  Cell,
   ColoredTeams,
   Embargo,
   EmojiMessage,
@@ -133,6 +134,9 @@ export class PlayerImpl implements Player {
   private _autoBombingEnabled: boolean = false;
   public bombersOnTarget = new Map<TileRef, number>();
 
+  // Cached capital (geographic center) of player's territory
+  private _capital: Cell | null = null;
+
   constructor(
     private mg: GameImpl,
     private _smallID: number,
@@ -168,8 +172,13 @@ export class PlayerImpl implements Player {
       playerType: this.type(),
       isAlive: this.isAlive(),
       isDisconnected: this.isDisconnected(),
+      capital:
+        this._capital !== null
+          ? { x: this._capital.x, y: this._capital.y }
+          : undefined,
       tilesOwned: this.numTilesOwned(),
       gold: this._gold,
+      gdp: this.gdp(),
       population: this.population(),
       totalPopulation: this.totalPopulation(),
       hospitalReturns: this.hospitalReturns(),
@@ -179,6 +188,8 @@ export class PlayerImpl implements Player {
       roadNetworkCompletion: this.roadNetworkCompletion(),
       roadNetworkLength: this.mg.getRoadLengthForPlayer(this.id()),
       roadNetPixelsPerSecond: this.mg.getRoadNetPixelsPerSecond(this.id()),
+      // Trade: expose current global demand queue length
+      tradeDemandQueueLength: (this.mg as any).tradeDemandQueueLength?.() ?? 0,
       troops: this.troops(),
       attackingTroops: this.attackingTroops(),
       targetTroopRatio: this.targetTroopRatio(),
@@ -263,6 +274,16 @@ export class PlayerImpl implements Player {
     return this.playerInfo.playerType;
   }
 
+  // Economic: GDP proxy as parameter * max population
+  gdp(): number {
+    const factor = this.mg.config().gdpFactor();
+    const maxPop = this.mg.config().maxPopulation(this);
+    const g = factor * maxPop;
+    // Ensure finite, non-negative number
+    if (!Number.isFinite(g) || g < 0) return 0;
+    return Math.floor(g);
+  }
+
   clan(): string | null {
     return this.playerInfo.clan;
   }
@@ -1440,6 +1461,15 @@ export class PlayerImpl implements Player {
     return this._lastTileChange;
   }
 
+  capital(): Cell | null {
+    return this._capital;
+  }
+
+  /** Internal setter used by background executions */
+  public _setCapital(capital: Cell | null): void {
+    this._capital = capital;
+  }
+
   isDisconnected(): boolean {
     return this._isDisconnected;
   }
diff --git a/src/core/game/RoadManager.ts b/src/core/game/RoadManager.ts
index 84c5c2fdc..08844549c 100644
--- a/src/core/game/RoadManager.ts
+++ b/src/core/game/RoadManager.ts
@@ -574,9 +574,7 @@ export class RoadManager {
       else this.nodesByOwner.set(pid, [node]);
     }
 
-    // Process pathfinding queue in chunks for better performance
-    const startTime = performance.now();
-    const MAX_PROCESSING_TIME = 16; // Max 16ms per frame to prevent stuttering
+    // Process pathfinding queue in deterministic chunks per tick
     const isBulkOperation = this.pathfindingQueue.length > 100;
 
     // Sort queue to process priority connections first in bulk operations
@@ -607,11 +605,6 @@ export class RoadManager {
 
       const canonicalSegment = this.getCanonicalSegment(from, to);
 
-      // Check processing time limit
-      if (performance.now() - startTime > MAX_PROCESSING_TIME) {
-        break; // Continue next frame if we're taking too long
-      }
-
       processedThisTick++;
       this.pathfindingQueue.shift(); // Only remove if we're actually processing it
 
diff --git a/src/core/game/UnitImpl.ts b/src/core/game/UnitImpl.ts
index 6ada6de7a..6bd8b0f0d 100644
--- a/src/core/game/UnitImpl.ts
+++ b/src/core/game/UnitImpl.ts
@@ -57,6 +57,16 @@ export class UnitImpl implements Unit {
   private _trajectoryIndex: number = 0;
   private _trajectory: TrajectoryTile[];
 
+  // Trade-ship specific: route owners for warship consideration
+  private _tradeRouteStartOwner: PlayerImpl | null = null;
+  private _tradeRouteEndOwner: PlayerImpl | null = null;
+  // Trade-ship specific: cargo carried (gold)
+  private _cargoGold: bigint = 0n;
+  private _tradePhase: "toStart" | "toEnd" | null = null;
+  // Port-specific: pending trade ship construction due tick (legacy single) and multiple concurrent builds
+  private _pendingTradeShipDueTick: Tick | null = null; // deprecated after multi-build
+  private _pendingTradeShipDueTicks: Tick[] = [];
+
   constructor(
     private _type: UnitType,
     private mg: GameImpl,
@@ -167,6 +177,31 @@ export class UnitImpl implements Unit {
       returning: this.returning(),
       isAttacking: this.isAttacking,
       isDetectedByNavalUnit: this.isDetectedByNavalUnit,
+      // Trade metadata
+      tradeRouteStartOwnerID: this._tradeRouteStartOwner
+        ? this._tradeRouteStartOwner.smallID()
+        : undefined,
+      tradeRouteEndOwnerID: this._tradeRouteEndOwner
+        ? this._tradeRouteEndOwner.smallID()
+        : undefined,
+      tradePhase: this._tradePhase ?? undefined,
+      dockedAtPortOwnerID: (() => {
+        if (this._type !== UnitType.TradeShip) return undefined;
+        const here = this._tile;
+        const portHere = this.mg
+          .unitsAt(here)
+          .find((u) => u.type() === UnitType.Port) as UnitImpl | undefined;
+        return portHere ? portHere.owner().smallID() : undefined;
+      })(),
+      pendingTradeShipDueTick:
+        this._type === UnitType.Port && this._pendingTradeShipDueTick !== null
+          ? this._pendingTradeShipDueTick
+          : undefined,
+      pendingTradeShipDueTicks:
+        this._type === UnitType.Port &&
+        this._pendingTradeShipDueTicks.length > 0
+          ? [...this._pendingTradeShipDueTicks]
+          : undefined,
     };
   }
 
@@ -223,6 +258,34 @@ export class UnitImpl implements Unit {
     return this._level;
   }
 
+  // Port-specific accessor/mutator for scheduled trade ship construction (single legacy)
+  setPendingTradeShipDueTick(due: Tick | null): void {
+    if (this._pendingTradeShipDueTick !== due) {
+      this._pendingTradeShipDueTick = due;
+      // Only emit update for ports
+      if (this._type === UnitType.Port) {
+        this.mg.addUpdate(this.toUpdate());
+      }
+    }
+  }
+  pendingTradeShipDueTick(): Tick | null {
+    return this._pendingTradeShipDueTick;
+  }
+  // Multi-build: replace entire set
+  setPendingTradeShipDueTicks(dueTicks: Tick[]): void {
+    // Normalize & sort ascending for UI consistency
+    const normalized = [...dueTicks].sort((a, b) => a - b);
+    const changed =
+      normalized.length !== this._pendingTradeShipDueTicks.length ||
+      normalized.some((v, i) => v !== this._pendingTradeShipDueTicks[i]);
+    if (!changed) return;
+    this._pendingTradeShipDueTicks = normalized;
+    if (this._type === UnitType.Port) this.mg.addUpdate(this.toUpdate());
+  }
+  pendingTradeShipDueTicks(): Tick[] {
+    return [...this._pendingTradeShipDueTicks];
+  }
+
   /**
    * Generic structure upgrade entrypoint.
    * Supports City and Port upgrades: +1 level, +1000 max HP, heal 1000 (capped), invalidate caches, emit update.
@@ -649,4 +712,33 @@ export class UnitImpl implements Unit {
       this.mg.config().safeFromPiratesCooldownMax()
     );
   }
+
+  // Trade route metadata API
+  setTradeRouteOwners(
+    startOwner: PlayerImpl | null,
+    endOwner: PlayerImpl | null,
+  ): void {
+    this._tradeRouteStartOwner = startOwner;
+    this._tradeRouteEndOwner = endOwner;
+  }
+  tradeRouteStartOwner(): PlayerImpl | null {
+    return this._tradeRouteStartOwner;
+  }
+  tradeRouteEndOwner(): PlayerImpl | null {
+    return this._tradeRouteEndOwner;
+  }
+
+  setTradePhase(phase: "toStart" | "toEnd" | null): void {
+    this._tradePhase = phase;
+  }
+  tradePhase(): "toStart" | "toEnd" | null {
+    return this._tradePhase;
+  }
+
+  setCargoGold(amount: bigint): void {
+    this._cargoGold = amount;
+  }
+  cargoGold(): bigint {
+    return this._cargoGold;
+  }
 }
diff --git a/src/core/pathfinding/MiniAStar.ts b/src/core/pathfinding/MiniAStar.ts
index 9e69ccfea..fc11691bd 100644
--- a/src/core/pathfinding/MiniAStar.ts
+++ b/src/core/pathfinding/MiniAStar.ts
@@ -67,6 +67,7 @@ export class MiniAStar implements AStar<TileRef> {
   }
 
   reconstructPath(): TileRef[] {
+    // Build start and destination cells at full resolution
     let cellSrc: Cell | undefined;
     if (!Array.isArray(this.src)) {
       cellSrc = new Cell(this.gameMap.x(this.src), this.gameMap.y(this.src));
@@ -75,16 +76,104 @@ export class MiniAStar implements AStar<TileRef> {
       this.gameMap.x(this.dst),
       this.gameMap.y(this.dst),
     );
-    const upscaled = fixExtremes(
-      upscalePath(
-        this.aStar
-          .reconstructPath()
-          .map((tr) => new Cell(this.miniMap.x(tr), this.miniMap.y(tr))),
-      ),
-      cellDst,
-      cellSrc,
+
+    // Get path in mini-map coords, upscale to full grid coordinates
+    const coarseCells = this.aStar
+      .reconstructPath()
+      .map((tr) => new Cell(this.miniMap.x(tr), this.miniMap.y(tr)));
+    const upscaled = fixExtremes(upscalePath(coarseCells), cellDst, cellSrc);
+
+    // Convert to an orthogonal, water-preferred path on the full grid
+    const waterOrthogonal: Cell[] = [];
+    if (upscaled.length > 0) {
+      let curr = upscaled[0];
+      waterOrthogonal.push(curr);
+      for (let i = 1; i < upscaled.length; i++) {
+        const target = upscaled[i];
+        while (curr.x !== target.x || curr.y !== target.y) {
+          const stepX = Math.sign(target.x - curr.x);
+          const stepY = Math.sign(target.y - curr.y);
+          const candidates: Cell[] = [];
+          if (stepX !== 0) candidates.push(new Cell(curr.x + stepX, curr.y));
+          if (stepY !== 0) candidates.push(new Cell(curr.x, curr.y + stepY));
+
+          // Prefer candidates that are water and reduce manhattan distance
+          let best: Cell | null = null;
+          let bestScore = Number.POSITIVE_INFINITY;
+          for (const cand of candidates) {
+            const ref = this.gameMap.ref(cand.x, cand.y);
+            const isWater = this.gameMap.isWater(ref);
+            const dist =
+              Math.abs(target.x - cand.x) + Math.abs(target.y - cand.y);
+            const score = (isWater ? 0 : 1000) + dist; // strong preference for water
+            if (score < bestScore) {
+              best = cand;
+              bestScore = score;
+            }
+          }
+          // If no candidates (shouldn't happen), break to avoid infinite loop
+          if (best === null) break;
+          curr = best;
+          waterOrthogonal.push(curr);
+        }
+      }
+    }
+
+    // Remove any residual non-water cells if present (belt-and-suspenders)
+    let finalCells = waterOrthogonal.filter((c) =>
+      this.gameMap.isWater(this.gameMap.ref(c.x, c.y)),
     );
-    return upscaled.map((c) => this.gameMap.ref(c.x, c.y));
+
+    // Robustness: ensure path includes src and dst and has at least 2 cells
+    const srcCell = cellSrc ?? (upscaled.length > 0 ? upscaled[0] : undefined);
+    if (finalCells.length === 0) {
+      // Fallback to upscaled (pre-orthogonal) if filtering removed everything
+      finalCells = [...upscaled];
+    }
+    if (srcCell) {
+      const first = finalCells[0];
+      if (!first || first.x !== srcCell.x || first.y !== srcCell.y) {
+        finalCells.unshift(srcCell);
+      }
+    }
+    const last = finalCells[finalCells.length - 1];
+    if (!last || last.x !== cellDst.x || last.y !== cellDst.y) {
+      finalCells.push(cellDst);
+    }
+    if (finalCells.length < 2) {
+      // Create a single orthogonal step toward dst
+      const start = finalCells[0];
+      if (!start) {
+        finalCells = [cellDst];
+      } else if (start.x !== cellDst.x || start.y !== cellDst.y) {
+        const stepX = Math.sign(cellDst.x - start.x);
+        const stepY = Math.sign(cellDst.y - start.y);
+        const candidates: Cell[] = [];
+        if (stepX !== 0) candidates.push(new Cell(start.x + stepX, start.y));
+        if (stepY !== 0) candidates.push(new Cell(start.x, start.y + stepY));
+        let best: Cell | null = null;
+        let bestScore = Number.POSITIVE_INFINITY;
+        for (const cand of candidates) {
+          const ref = this.gameMap.ref(cand.x, cand.y);
+          const isWater = this.gameMap.isWater(ref);
+          const dist =
+            Math.abs(cellDst.x - cand.x) + Math.abs(cellDst.y - cand.y);
+          const score = (isWater ? 0 : 1000) + dist;
+          if (score < bestScore) {
+            best = cand;
+            bestScore = score;
+          }
+        }
+        if (best) finalCells.push(best);
+      }
+      if (finalCells.length < 2) {
+        // As a final guard, ensure there are at least two cells
+        finalCells.push(cellDst);
+      }
+    }
+
+    // Map to tile refs
+    return finalCells.map((c) => this.gameMap.ref(c.x, c.y));
   }
 }
 
diff --git a/src/core/pathfinding/PathFinding.ts b/src/core/pathfinding/PathFinding.ts
index 236afc13e..898ba84ea 100644
--- a/src/core/pathfinding/PathFinding.ts
+++ b/src/core/pathfinding/PathFinding.ts
@@ -200,7 +200,17 @@ export class PathFinder {
       } else {
         const tile = this.path?.shift();
         if (tile === undefined) {
-          throw new Error("missing tile");
+          // Path exhausted unexpectedly. If already within step distance, report completion.
+          if (this.game.manhattanDist(curr, dst) < dist) {
+            return { type: PathFindResultType.Completed, node: curr };
+          }
+          // Otherwise, recompute a fresh path from current position.
+          this.curr = curr;
+          this.dst = dst;
+          this.path = null;
+          this.aStar = this.newAStar(curr, dst);
+          this.computeFinished = false;
+          return this.nextTile(curr, dst);
         }
         return { type: PathFindResultType.NextTile, node: tile };
       }
@@ -212,7 +222,14 @@ export class PathFinder {
         this.path = this.aStar.reconstructPath();
         // Remove the start tile
         this.path.shift();
-
+        // If the reconstructed path is empty, fall back to completion or path-not-found handling.
+        if (!this.path || this.path.length === 0) {
+          if (this.game.manhattanDist(curr, dst) < dist) {
+            return { type: PathFindResultType.Completed, node: curr };
+          } else {
+            return { type: PathFindResultType.PathNotFound };
+          }
+        }
         return this.nextTile(curr, dst);
       case PathFindResultType.Pending:
         return { type: PathFindResultType.Pending };
diff --git a/src/server/GameServer.ts b/src/server/GameServer.ts
index a4e9522c3..6d813464a 100644
--- a/src/server/GameServer.ts
+++ b/src/server/GameServer.ts
@@ -129,6 +129,15 @@ export class GameServer {
   }
 
   public addClient(client: Client, lastTurn: number) {
+    // If this is a private lobby and no creator is set, assign the first joiner as creator
+    if (!this.isPublic() && this.LobbyCreatorID === undefined) {
+      this.LobbyCreatorID = client.clientID;
+      this.log.info("Assigned lobby creator to first joiner", {
+        gameID: this.id,
+        creatorID: this.LobbyCreatorID,
+      });
+    }
+
     // Authorization check
     if (this._hasStarted) {
       const isOriginalPlayer =
@@ -148,13 +157,17 @@ export class GameServer {
       }
     }
 
-    this.websockets.add(client.ws);
     if (this.kickedClients.has(client.clientID)) {
       this.log.warn(`cannot add client, already kicked`, {
         clientID: client.clientID,
       });
+      // Ensure the connection is closed so the client does not linger
+      if (client.ws.readyState === WebSocket.OPEN) {
+        client.ws.close(1008, "Kicked from lobby");
+      }
       return;
     }
+    this.websockets.add(client.ws);
     // Log when lobby creator joins private game
     if (client.clientID === this.LobbyCreatorID) {
       this.log.info("Lobby creator joined", {
@@ -774,7 +787,7 @@ export class GameServer {
 
     const lastHashTurn = this.turns.length - 10;
 
-    const { mostCommonHash, outOfSyncClients } =
+    const { mostCommonHash, outOfSyncClients, numClientsWithMostCommonHash } =
       this.findOutOfSyncClients(lastHashTurn);
 
     if (outOfSyncClients.length === 0) {
@@ -786,8 +799,7 @@ export class GameServer {
       type: "desync",
       turn: lastHashTurn,
       correctHash: mostCommonHash,
-      clientsWithCorrectHash:
-        this.activeClients.length - outOfSyncClients.length,
+      clientsWithCorrectHash: numClientsWithMostCommonHash,
       totalActiveClients: this.activeClients.length,
     });
     if (!serverDesync.success) {
@@ -817,6 +829,7 @@ export class GameServer {
   findOutOfSyncClients(turnNumber: number): {
     mostCommonHash: number | null;
     outOfSyncClients: Client[];
+    numClientsWithMostCommonHash: number;
   } {
     const counts = new Map<number, number>();
 
@@ -851,7 +864,8 @@ export class GameServer {
       }
     }
 
-    // If half clients out of sync assume all are out of sync.
+    // If half clients out of sync assume all are out of sync for remediation,
+    // but keep the true count of clients with most-common hash for reporting.
     if (outOfSyncClients.length >= Math.floor(this.activeClients.length / 2)) {
       outOfSyncClients = this.activeClients;
     }
@@ -859,6 +873,7 @@ export class GameServer {
     return {
       mostCommonHash,
       outOfSyncClients,
+      numClientsWithMostCommonHash: maxCount,
     };
   }
 }
diff --git a/tests/Warship.test.ts b/tests/Warship.test.ts
index 330e0fd25..5a2db707a 100644
--- a/tests/Warship.test.ts
+++ b/tests/Warship.test.ts
@@ -125,7 +125,8 @@ describe("Warship", () => {
       UnitType.TradeShip,
       game.ref(coastX + 1, 11),
       {
-        targetUnit: player1.buildUnit(UnitType.Port, game.ref(coastX, 11), {}),
+        // Destination should NOT grant the warship owner a port; keep player1 without ports
+        targetUnit: player2.buildUnit(UnitType.Port, game.ref(coastX, 11), {}),
       },
     );
 
diff --git a/tests/core/execution/TradeManagerExecution.test.ts b/tests/core/execution/TradeManagerExecution.test.ts
new file mode 100644
index 000000000..a0b089fb8
--- /dev/null
+++ b/tests/core/execution/TradeManagerExecution.test.ts
@@ -0,0 +1,120 @@
+import {
+  AssignedTradeRouteExecution,
+  TradeManagerExecution,
+} from "../../../src/core/execution/TradeManagerExecution";
+import {
+  Game,
+  Player,
+  PlayerInfo,
+  PlayerType,
+  Unit,
+  UnitType,
+} from "../../../src/core/game/Game";
+import { setup } from "../../util/Setup";
+import { executeTicks } from "../../util/utils";
+
+// We reuse the shoreline used by other naval tests on the half_land_half_ocean map
+const coastX = 7;
+
+describe("TradeManagerExecution", () => {
+  let game: Game;
+  let p1: Player;
+  let p2: Player;
+  let p1Port: Unit;
+  let p2Port: Unit;
+
+  beforeEach(() => {
+    // Prevent background setInterval logs from outliving tests
+    jest.useFakeTimers();
+    jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  beforeEach(async () => {
+    game = await setup(
+      "half_land_half_ocean",
+      { infiniteGold: true, instantBuild: true, startingGold: 0 },
+      [
+        new PlayerInfo("us", "P1", PlayerType.Human, null, "p1_id"),
+        new PlayerInfo("us", "P2", PlayerType.Human, null, "p2_id"),
+      ],
+    );
+
+    // Exit spawn phase to start normal ticks
+    while (game.inSpawnPhase()) game.executeNextTick();
+
+    p1 = game.player("p1_id");
+    p2 = game.player("p2_id");
+
+    // Place two ports on adjacent shoreline tiles; their adjacent ocean tiles are connected
+    p1Port = p1.buildUnit(UnitType.Port, game.ref(coastX, 10), {} as any);
+    p2Port = p2.buildUnit(UnitType.Port, game.ref(coastX, 11), {} as any);
+
+    // Ensure players are considered alive (TradeManager deletes ships of eliminated players)
+    game.conquer(p1, p1Port.tile());
+    game.conquer(p2, p2Port.tile());
+    // Demand accumulation path is bypassed; no need to mock randomness/GDP/intervals
+
+    // Freeze per-tick income so gold deltas come only from trade
+    jest.spyOn(game.config(), "grossGoldAdditionRate").mockReturnValue(0);
+    // Keep per-tick net gold isolated to trade; gross rate mocked above is sufficient
+
+    // Make trade income deterministic and small
+    jest.spyOn(game.config(), "tradeIncomeFixed").mockReturnValue(1000n);
+  });
+
+  test("assigns a route when demand accumulates and a ship is available", () => {
+    // Create an idle trade ship docked at p1's port (idle = no targetUnit)
+    const ship = p1.buildUnit(UnitType.TradeShip, p1Port.tile(), {} as any);
+
+    // Sanity: ship is on a port tile and idle
+    expect(game.unitsAt(p1Port.tile()).some((u) => u.id() === ship.id())).toBe(
+      true,
+    );
+    expect(ship.targetUnit()).toBeUndefined();
+
+    const addExecSpy = jest.spyOn(game, "addExecution");
+    const mgr = new TradeManagerExecution();
+    game.addExecution(mgr);
+    // Directly enqueue a route to avoid relying on gravity demand randomness
+    mgr.requeueRoute(p1, p2);
+
+    // Advance several ticks to allow demand -> queue -> assignment
+    executeTicks(game, 10);
+
+    // A trade route execution should have been scheduled for the ship
+    expect(addExecSpy).toHaveBeenCalledWith(
+      expect.any(AssignedTradeRouteExecution),
+    );
+  });
+
+  test("completes a trade and awards income to both traders and ship owner", () => {
+    // Build one idle ship at p1's port
+    const ship = p1.buildUnit(UnitType.TradeShip, p1Port.tile(), {} as any);
+
+    const goldBeforeP1 = p1.gold();
+    const goldBeforeP2 = p2.gold();
+
+    const mgr = new TradeManagerExecution();
+    game.addExecution(mgr);
+    // Directly enqueue a route to avoid relying on gravity demand randomness
+    mgr.requeueRoute(p1, p2);
+
+    // Run enough ticks for assignment and completion
+    executeTicks(game, 200);
+
+    // Income split: total=1000, each trader gets 333, ship owner gets 334 (remainder)
+    const p1Delta = p1.gold() - goldBeforeP1;
+    const p2Delta = p2.gold() - goldBeforeP2;
+
+    // p1 is both a trader (start owner) and ship owner -> 333 + 334 = 667
+    expect(p1Delta).toBe(667n);
+    // p2 is the other trader -> 333
+    expect(p2Delta).toBe(333n);
+  });
+});
diff --git a/tests/util/TestServerConfig.ts b/tests/util/TestServerConfig.ts
index 4c1f76eb4..639cb9d1e 100644
--- a/tests/util/TestServerConfig.ts
+++ b/tests/util/TestServerConfig.ts
@@ -29,7 +29,8 @@ export class TestServerConfig implements ServerConfig {
     return "test";
   }
   turnIntervalMs(): number {
-    throw new Error("Method not implemented.");
+    // Keep tests fast; ~10 ticks/second
+    return 100;
   }
   gameCreationRate(): number {
     throw new Error("Method not implemented.");