Publish Gradio console bundle

space-bundle/README.md

@@ -0,0 +1,32 @@
+---
+title: Omnichannel Fulfillment and Returns Control Tower
+emoji: 📦
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 5.50.0
+app_file: app.py
+pinned: false
+license: mit
+tags:
+- operations-research
+- supply-chain
+- inventory-allocation
+- order-fulfillment
+- reverse-logistics
+- network-flow
+- gradio
+---
+
+# Omnichannel Fulfillment and Returns Control Tower
+
+Joint order allocation across stores, distribution centers, regional
+warehouses, cross-docks, and suppliers — with dynamic admission control,
+adaptive large-neighborhood reoptimization, assortment substitution, and
+rule-based reverse logistics for returns.
+
+Run five network scenarios (peak-season surge, regional stockout,
+high-return category wave, DC capacity outage, green-logistics push),
+inspect network KPIs and the Adaptive Large Neighborhood Search
+improvement curve, and compare Fast vs. Economical vs. Green delivery
+options for the same order.

space-bundle/app.py

@@ -0,0 +1,142 @@
+"""Gradio console for the Omnichannel Fulfillment and Returns Control Tower."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT / "src"))
+
+import gradio as gr
+
+from omnitower.generator import SCENARIOS, list_scenarios
+from omnitower.pipeline import run_scenario, run_delivery_options_for_order
+from omnitower.visualization import kpi_bar, cost_history_plot, returns_disposition_pie, delivery_options_plot, inventory_impact_table
+
+SCENARIO_CHOICES = [(v, k) for k, v in SCENARIOS.items()]
+
+
+def run_demo(scenario_key: str, delivery_option: str, n_orders: int, lns_iterations: int, seed: int, use_admission: bool):
+    result = run_scenario(
+        scenario_key,
+        seed=int(seed),
+        n_orders=int(n_orders),
+        delivery_option=delivery_option,
+        lns_iterations=int(lns_iterations),
+        use_admission_control=bool(use_admission),
+    )
+    metrics = result.metrics.to_dict()
+    event_md = "\n".join(f"- {e.description}" for e in result.network.events)
+    kpi_md = "\n".join(f"- **{k.replace('_', ' ').title()}**: {v}" for k, v in metrics.items())
+    admission_md = f"Orders deferred to backorder by dynamic admission control: **{result.admission_rejections}**"
+    returns_md = (
+        f"Returns generated: **{result.return_summary['n_returns']}** · "
+        f"Resell rate: **{result.return_summary['resell_rate']:.0%}** · "
+        f"Handling cost: **${result.return_summary['total_handling_cost_usd']:,.2f}** · "
+        f"Recovered value: **${result.return_summary['total_recovered_value_usd']:,.2f}**"
+    )
+
+    kpi_fig = kpi_bar(metrics)
+    cost_fig = cost_history_plot(result.cost_history)
+    returns_fig = returns_disposition_pie(result.return_summary["by_disposition"])
+
+    return (
+        f"### Scenario Event\n{event_md}\n\n### Network KPIs\n{kpi_md}\n\n{admission_md}",
+        returns_md,
+        kpi_fig,
+        cost_fig,
+        returns_fig,
+    )
+
+
+def run_options(scenario_key: str, order_index: int, seed: int):
+    network, results = run_delivery_options_for_order(scenario_key, order_index=int(order_index), seed=int(seed))
+    fig = delivery_options_plot(results)
+    table = [[r.option, r.total_cost_usd, r.total_lead_time_hours, r.total_carbon_kg, ", ".join(r.report["nodes_used"])] for r in results]
+    impact_table = inventory_impact_table(results)
+    return fig, table, impact_table
+
+
+with gr.Blocks(title="Omnichannel Fulfillment and Returns Control Tower", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "# Omnichannel Fulfillment and Returns Control Tower\n"
+        "Joint order allocation across stores, distribution centers, cross-docks, "
+        "and suppliers, with dynamic admission control, adaptive large-neighborhood "
+        "reoptimization, and rule-based reverse logistics for returns."
+    )
+
+    with gr.Tab("Fulfillment Network Run"):
+        with gr.Row():
+            scenario = gr.Dropdown(choices=SCENARIO_CHOICES, value=list_scenarios()[0], label="Network scenario")
+            option = gr.Radio(choices=[("Fast", "fast"), ("Economical", "economical"), ("Green", "green")], value="economical", label="Delivery objective")
+        with gr.Row():
+            n_orders = gr.Slider(60, 400, value=200, step=20, label="Orders in the horizon")
+            iterations = gr.Slider(5, 60, value=25, step=5, label="ALNS iterations")
+        with gr.Row():
+            seed = gr.Slider(1, 100, value=42, step=1, label="Random seed")
+            admission = gr.Checkbox(value=True, label="Enable dynamic admission control")
+        run_btn = gr.Button("Run Network", variant="primary")
+
+        with gr.Row():
+            kpi_out = gr.Markdown()
+            returns_out = gr.Markdown()
+        with gr.Row():
+            kpi_plot_out = gr.Plot(label="Network KPIs")
+            cost_plot_out = gr.Plot(label="ALNS Cost Improvement")
+        returns_plot_out = gr.Plot(label="Return Disposition Mix")
+
+        run_btn.click(
+            run_demo,
+            inputs=[scenario, option, n_orders, iterations, seed, admission],
+            outputs=[kpi_out, returns_out, kpi_plot_out, cost_plot_out, returns_plot_out],
+        )
+
+    with gr.Tab("Fast vs. Economical vs. Green"):
+        gr.Markdown(
+            "For a single order, compares the three delivery options requested in the "
+            "brief and shows the effect each choice has on downstream inventory and "
+            "picking-capacity availability."
+        )
+        with gr.Row():
+            o_scenario = gr.Dropdown(choices=SCENARIO_CHOICES, value="green_logistics_push", label="Network scenario")
+            o_index = gr.Slider(0, 50, value=0, step=1, label="Order index")
+            o_seed = gr.Slider(1, 100, value=42, step=1, label="Random seed")
+        options_btn = gr.Button("Compare Delivery Options", variant="primary")
+        options_plot = gr.Plot(label="Cost / Lead Time / Carbon by Option")
+        options_table = gr.Dataframe(
+            headers=["Option", "Cost (USD)", "Lead Time (hours)", "Carbon (kg)", "Nodes Used"],
+            label="Option Summary",
+        )
+        impact_table = gr.Dataframe(
+            headers=["Option", "Node", "SKU", "Qty Consumed", "Inventory Before", "Inventory After"],
+            label="Inventory and Capacity Impact",
+        )
+        options_btn.click(run_options, inputs=[o_scenario, o_index, o_seed], outputs=[options_plot, options_table, impact_table])
+
+    with gr.Tab("About"):
+        gr.Markdown(
+            """
+### Decisions modeled
+- Which fulfillment node serves each order line (DC, regional warehouse, cross-dock, or ship-from-store)
+- Whether an order is split across multiple sources
+- Whether a substitute SKU is offered when the requested SKU is unavailable
+- Standard vs. express (and a carbon-weighted "green") shipping mode
+- Whether an incoming order is admitted immediately or deferred to backorder under scarce inventory
+- Where a returned unit is routed: restock at the store, restock at the DC, repair, recycle, or dispose
+- Whether a returned unit is resold or scrapped
+
+### Models
+- **Order allocation**: Greedy Marginal Cost heuristic ranking every candidate source by weighted transport, picking, lead-time, and carbon cost
+- **Allocation improvement**: Adaptive Large Neighborhood Search — destroy a batch of orders, reinsert by priority, keep only if network cost improves
+- **Dynamic admission control**: bid-price-style scarcity scoring that defers low-priority orders competing for scarce stock
+- **Assortment substitution**: substitute-group lookup triggered on stockout
+- **Reverse logistics**: rule-based return disposition and resell/scrap decisioning
+
+### Stack
+NetworkX · Plotly · Gradio 5.x · Static explorer
+"""
+        )
+
+if __name__ == "__main__":
+    demo.launch()

space-bundle/requirements.txt

@@ -0,0 +1,5 @@
+networkx>=3.2
+numpy>=1.26
+pandas>=2.0
+plotly>=5.18
+gradio>=5.50

space-bundle/src/omnitower/__init__.py

@@ -0,0 +1,3 @@
+"""Omnichannel Fulfillment and Returns Control Tower — core optimization engine."""
+
+__version__ = "1.0.0"

space-bundle/src/omnitower/admission.py

@@ -0,0 +1,62 @@
+"""Dynamic admission control.
+
+Approximates a bid-price control policy: rather than a static allocation
+rule, each incoming order is scored against the *current* scarcity of the
+SKUs it requests (remaining pooled inventory vs. remaining forecast demand
+for the rest of the horizon). Orders that would consume disproportionately
+scarce stock for a low-margin / low-priority order are queued as
+backorders instead of being admitted immediately, protecting inventory for
+higher-value demand still expected to arrive.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .models import Network, Order
+from .allocation import AllocationState
+from .constants import DEFAULT_MARGIN_RATE, BACKORDER_PENALTY_USD
+
+PRIORITY_WEIGHT = {"vip": 1.6, "premium": 1.25, "standard": 1.0}
+
+
+@dataclass
+class AdmissionDecision:
+    order_id: str
+    admitted: bool
+    reason: str
+    scarcity_score: float
+
+
+def _scarcity_score(network: Network, state: AllocationState, order: Order, remaining_demand_factor: float) -> float:
+    scores = []
+    for line in order.lines:
+        total_remaining = sum(qty for (node, sku), qty in state.inventory.items() if sku == line.sku_id)
+        forecast_need = max(1.0, total_remaining * 0.0 + remaining_demand_factor * line.qty_requested * 6.0)
+        if total_remaining <= 0:
+            scores.append(1.0)
+        else:
+            scores.append(min(1.0, forecast_need / (total_remaining + forecast_need)))
+    return sum(scores) / max(1, len(scores))
+
+
+def evaluate_admission(
+    network: Network,
+    state: AllocationState,
+    order: Order,
+    remaining_demand_factor: float = 0.5,
+    scarcity_threshold: float = 0.82,
+) -> AdmissionDecision:
+    scarcity = _scarcity_score(network, state, order, remaining_demand_factor)
+    priority_weight = PRIORITY_WEIGHT.get(order.priority_class, 1.0)
+    effective_threshold = scarcity_threshold * priority_weight
+    order_value = sum(network.skus[l.sku_id].unit_price * l.qty_requested for l in order.lines if l.sku_id in network.skus)
+    margin_value = order_value * DEFAULT_MARGIN_RATE
+
+    if scarcity < effective_threshold or margin_value > BACKORDER_PENALTY_USD * 20:
+        return AdmissionDecision(order.order_id, True, "accepted: inventory scarcity within threshold for priority class", round(scarcity, 3))
+    return AdmissionDecision(order.order_id, False, "deferred to backorder: scarce stock reserved for expected higher-value demand", round(scarcity, 3))
+
+
+def evaluate_all(network: Network, state: AllocationState, remaining_demand_factor: float = 0.5) -> list[AdmissionDecision]:
+    return [evaluate_admission(network, state, order, remaining_demand_factor) for order in network.orders]

space-bundle/src/omnitower/allocation.py

@@ -0,0 +1,156 @@
+"""Order allocation optimizer: Inventory Allocation + Order Fulfillment.
+
+Implements the "Greedy Marginal Cost" scalable heuristic referenced in the
+project brief: for every order line, candidate fulfillment nodes are ranked
+by the marginal cost of serving that unit from that node (transport +
+picking + packing, weighted by the chosen delivery objective), subject to
+live inventory and daily picking-capacity pools that are decremented as the
+order stream is processed. Split shipments and ship-from-store are native
+outcomes of the ranking rather than a separate rule.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .models import Network, Order, OrderLine
+from .network import build_graph, distance_km, transport_cost, carbon_kg, candidate_sources
+from .constants import (
+    COST_PER_PICK_USD,
+    COST_PER_PACK_USD,
+    COST_PER_SPLIT_SHIPMENT_USD,
+    LEAD_TIME_HOURS_PER_100KM_STANDARD,
+    LEAD_TIME_HOURS_PER_100KM_EXPRESS,
+    LEAD_TIME_HOURS_PER_100KM_GREEN,
+)
+
+OBJECTIVE_WEIGHTS = {
+    # (cost_weight, time_weight, carbon_weight)
+    "fast": (0.15, 0.75, 0.10),
+    "economical": (0.75, 0.10, 0.15),
+    "green": (0.15, 0.10, 0.75),
+}
+
+
+@dataclass
+class AllocationState:
+    inventory: dict[tuple[str, str], float]
+    capacity: dict[str, float]
+
+
+def build_state(network: Network) -> AllocationState:
+    inv = {}
+    for rec in network.inventory:
+        inv[(rec.node_id, rec.sku_id)] = rec.on_hand_qty * rec.accuracy
+    cap = {n.node_id: float(n.daily_pick_capacity) for n in network.nodes.values()}
+    return AllocationState(inventory=inv, capacity=cap)
+
+
+def _mode_for_option(option: str) -> str:
+    return {"fast": "express", "economical": "standard", "green": "green"}[option]
+
+
+def _lead_time_hours(distance: float, mode: str) -> float:
+    rate = {
+        "express": LEAD_TIME_HOURS_PER_100KM_EXPRESS,
+        "green": LEAD_TIME_HOURS_PER_100KM_GREEN,
+    }.get(mode, LEAD_TIME_HOURS_PER_100KM_STANDARD)
+    return 2.0 + (distance / 100.0) * rate
+
+
+def _score_source(graph, node, sku_id, demand_node_id, node_meta, option, state: AllocationState) -> tuple[float, dict]:
+    dist = distance_km(graph, node, demand_node_id)
+    if dist == float("inf"):
+        return float("inf"), {}
+    mode = _mode_for_option(option)
+    link_mode = "express" if mode == "express" else "standard"
+    t_cost = transport_cost(dist, link_mode)
+    pick_cost = COST_PER_PICK_USD * node_meta.picking_cost_multiplier
+    pack_cost = COST_PER_PACK_USD
+    lead_hours = _lead_time_hours(dist, mode)
+    carbon = carbon_kg(dist, mode)
+    cw, tw, cbw = OBJECTIVE_WEIGHTS[option]
+    # normalize roughly to comparable scales before weighting
+    score = cw * (t_cost + pick_cost + pack_cost) + tw * lead_hours + cbw * (carbon * 0.5)
+    breakdown = {
+        "distance_km": round(dist, 1),
+        "transport_cost_usd": round(t_cost, 2),
+        "pick_cost_usd": round(pick_cost, 2),
+        "pack_cost_usd": round(pack_cost, 2),
+        "lead_time_hours": round(lead_hours, 1),
+        "carbon_kg": round(carbon, 2),
+        "ship_mode": mode,
+    }
+    return score, breakdown
+
+
+def _find_substitute(network: Network, sku_id: str, state: AllocationState, source_pool: list[str]) -> str | None:
+    sku = network.skus[sku_id]
+    for other in network.skus.values():
+        if other.sku_id == sku_id or other.substitute_group != sku.substitute_group:
+            continue
+        if any(state.inventory.get((n, other.sku_id), 0) >= 1 for n in source_pool):
+            return other.sku_id
+    return None
+
+
+def allocate_order(network: Network, order: Order, option: str, state: AllocationState, graph=None) -> dict:
+    graph = graph or build_graph(network)
+    sources = candidate_sources(network, order.demand_node_id)
+    used_nodes: set[str] = set()
+    line_reports = []
+
+    for line in order.lines:
+        remaining = line.qty_requested
+        line.qty_fulfilled = 0
+        while remaining > 0:
+            ranked = []
+            for node_id in sources:
+                node_meta = network.nodes[node_id]
+                avail = state.inventory.get((node_id, line.sku_id), 0)
+                cap = state.capacity.get(node_id, 0)
+                if avail < 1 or cap < 1:
+                    continue
+                score, breakdown = _score_source(graph, node_id, line.sku_id, order.demand_node_id, node_meta, option, state)
+                if score == float("inf"):
+                    continue
+                ranked.append((score, node_id, breakdown))
+            if not ranked:
+                substitute = _find_substitute(network, line.sku_id, state, sources)
+                if substitute and line.substituted_sku_id is None:
+                    line.substituted_sku_id = substitute
+                    line.sku_id = substitute
+                    continue
+                break
+            ranked.sort(key=lambda x: x[0])
+            score, node_id, breakdown = ranked[0]
+            take = min(remaining, state.inventory[(node_id, line.sku_id)], state.capacity[node_id])
+            take = max(1, int(take))
+            state.inventory[(node_id, line.sku_id)] -= take
+            state.capacity[node_id] -= take
+            line.qty_fulfilled += take
+            line.source_node_id = node_id
+            used_nodes.add(node_id)
+            remaining -= take
+            line_reports.append({"sku_id": line.sku_id, "node_id": node_id, "qty": take, **breakdown})
+        line.backordered_qty = remaining
+
+    order.split_shipment = len(used_nodes) > 1
+    order.chosen_delivery_option = option
+    total_backorder = sum(l.backordered_qty for l in order.lines)
+    order.accepted = total_backorder < sum(l.qty_requested for l in order.lines)
+    return {
+        "order_id": order.order_id,
+        "delivery_option": option,
+        "split_shipment": order.split_shipment,
+        "nodes_used": sorted(used_nodes),
+        "line_reports": line_reports,
+        "total_backordered_qty": total_backorder,
+    }
+
+
+def allocate_all(network: Network, option: str = "economical") -> tuple[AllocationState, list[dict]]:
+    state = build_state(network)
+    graph = build_graph(network)
+    reports = [allocate_order(network, order, option, state, graph) for order in network.orders]
+    return state, reports

space-bundle/src/omnitower/constants.py

@@ -0,0 +1,59 @@
+"""Shared constants and cost coefficients for the control tower."""
+
+from __future__ import annotations
+
+NODE_TYPES = [
+    "store",
+    "central_dc",
+    "regional_wh",
+    "supplier",
+    "cross_dock",
+    "return_center",
+    "repair_center",
+    "recycle_center",
+]
+
+SHIP_MODE_STANDARD = "standard"
+SHIP_MODE_EXPRESS = "express"
+
+DELIVERY_OPTIONS = ["fast", "economical", "green"]
+
+# Approximate cost / emission coefficients used across the demo scenarios.
+COST_PER_KM_STANDARD_USD = 0.055
+COST_PER_KM_EXPRESS_USD = 0.145
+COST_PER_PICK_USD = 1.35
+COST_PER_PACK_USD = 0.85
+COST_PER_SPLIT_SHIPMENT_USD = 3.20
+CARBON_KG_PER_KM_STANDARD = 0.18
+CARBON_KG_PER_KM_EXPRESS = 0.34
+CARBON_KG_PER_KM_GREEN = 0.07  # consolidated / low-carbon linehaul
+
+LEAD_TIME_HOURS_PER_100KM_STANDARD = 2.4
+LEAD_TIME_HOURS_PER_100KM_EXPRESS = 0.9
+LEAD_TIME_HOURS_PER_100KM_GREEN = 3.6
+
+RETURN_HANDLING_COST_USD = {
+    "restock_store": 1.10,
+    "restock_dc": 1.60,
+    "repair": 6.50,
+    "recycle": 2.20,
+    "dispose": 3.00,
+}
+
+RETURN_RECOVERY_VALUE_FACTOR = {
+    "restock_store": 0.92,
+    "restock_dc": 0.88,
+    "repair": 0.55,
+    "recycle": 0.06,
+    "dispose": 0.0,
+}
+
+DEFAULT_MARGIN_RATE = 0.34
+BACKORDER_PENALTY_USD = 4.50
+CANCELLATION_PENALTY_USD = 9.00
+WORKING_CAPITAL_DAYS_HELD = {
+    "central_dc": 21,
+    "regional_wh": 14,
+    "store": 9,
+    "cross_dock": 2,
+}

space-bundle/src/omnitower/generator.py

@@ -0,0 +1,214 @@
+"""Synthetic omnichannel network and demand scenario generator.
+
+Builds a reproducible multi-echelon network (central DC, regional warehouses,
+stores, suppliers, cross-dock, return/repair/recycle centers), a SKU
+catalog with substitute groups, noisy inventory, and a day's worth of
+multi-line orders, then applies one of the demo scenario archetypes.
+"""
+
+from __future__ import annotations
+
+import random
+from math import radians, sin, cos, asin, sqrt
+
+from .models import Node, SKU, InventoryRecord, TransportLink, Order, OrderLine, ScenarioEvent, Network
+
+CATEGORIES = ["apparel", "footwear", "electronics_accessory", "home_goods", "beauty"]
+SUBSTITUTE_GROUPS = {
+    "apparel": ["APP-A", "APP-B"],
+    "footwear": ["SHOE-A"],
+    "electronics_accessory": ["ELEC-A"],
+    "home_goods": ["HOME-A", "HOME-B"],
+    "beauty": ["BEAUTY-A"],
+}
+BASE_RETURN_RATE = {
+    "apparel": 0.22,
+    "footwear": 0.17,
+    "electronics_accessory": 0.06,
+    "home_goods": 0.05,
+    "beauty": 0.03,
+}
+
+SCENARIOS = {
+    "peak_season_surge": "Peak-season demand surge with tight picking capacity",
+    "regional_stockout": "Regional warehouse stockout forcing ship-from-store",
+    "high_return_category_wave": "Apparel high-return wave stressing reverse logistics",
+    "capacity_constrained_dc": "Central DC capacity outage shifting flow to regional network",
+    "green_logistics_push": "Corporate mandate to minimize carbon emissions this week",
+}
+
+
+def _haversine_km(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    r = 6371.0
+    dlat, dlon = radians(lat2 - lat1), radians(lon2 - lon1)
+    a = sin(dlat / 2) ** 2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlon / 2) ** 2
+    return 2 * r * asin(sqrt(a))
+
+
+def _make_nodes(rng: random.Random, n_stores: int) -> dict[str, Node]:
+    nodes: dict[str, Node] = {}
+    nodes["DC1"] = Node("DC1", "central_dc", "Central Distribution Center", 39.10, -94.58, daily_pick_capacity=6000, picking_cost_multiplier=0.85)
+    nodes["RWH-E"] = Node("RWH-E", "regional_wh", "Regional Warehouse East", 40.71, -74.01, daily_pick_capacity=2600, picking_cost_multiplier=0.95)
+    nodes["RWH-W"] = Node("RWH-W", "regional_wh", "Regional Warehouse West", 34.05, -118.24, daily_pick_capacity=2600, picking_cost_multiplier=0.95)
+    nodes["SUP1"] = Node("SUP1", "supplier", "Primary Supplier Hub", 41.88, -87.63, daily_pick_capacity=4000, picking_cost_multiplier=1.10)
+    nodes["XDOCK1"] = Node("XDOCK1", "cross_dock", "Regional Cross-Dock", 38.63, -90.20, daily_pick_capacity=3200, picking_cost_multiplier=0.70)
+    nodes["RET1"] = Node("RET1", "return_center", "Returns Processing Center", 39.77, -86.16, daily_pick_capacity=1800, picking_cost_multiplier=1.0)
+    nodes["REPAIR1"] = Node("REPAIR1", "repair_center", "Repair & Refurbishment Center", 39.77, -86.20, daily_pick_capacity=600, picking_cost_multiplier=1.0)
+    nodes["RECY1"] = Node("RECY1", "recycle_center", "Recycling & Recovery Center", 39.80, -86.10, daily_pick_capacity=900, picking_cost_multiplier=1.0)
+
+    for i in range(n_stores):
+        lat = 30.0 + rng.uniform(0, 15.0)
+        lon = -122.0 + rng.uniform(0, 45.0)
+        sid = f"ST{i:03d}"
+        nodes[sid] = Node(sid, "store", f"Store {i:03d}", round(lat, 3), round(lon, 3), daily_pick_capacity=rng.randint(120, 320), picking_cost_multiplier=1.25)
+    return nodes
+
+
+def _make_skus(rng: random.Random, n_skus: int) -> dict[str, SKU]:
+    skus: dict[str, SKU] = {}
+    for i in range(n_skus):
+        cat = CATEGORIES[i % len(CATEGORIES)]
+        group = SUBSTITUTE_GROUPS[cat][i % len(SUBSTITUTE_GROUPS[cat])]
+        cost = round(rng.uniform(8, 90), 2)
+        skus[f"SKU{i:04d}"] = SKU(
+            sku_id=f"SKU{i:04d}",
+            category=cat,
+            unit_price=round(cost * rng.uniform(1.5, 2.6), 2),
+            unit_cost=cost,
+            weight_kg=round(rng.uniform(0.2, 4.5), 2),
+            substitute_group=group,
+            return_rate=round(BASE_RETURN_RATE[cat] * rng.uniform(0.7, 1.3), 3),
+        )
+    return skus
+
+
+def _make_inventory(rng: random.Random, nodes: dict[str, Node], skus: dict[str, SKU]) -> list[InventoryRecord]:
+    inv = []
+    fulfillment_nodes = [n for n in nodes.values() if n.node_type in ("central_dc", "regional_wh", "store", "cross_dock", "supplier")]
+    for node in fulfillment_nodes:
+        base_qty = {"central_dc": 800, "regional_wh": 300, "cross_dock": 150, "supplier": 5000, "store": 25}[node.node_type]
+        for sku in skus.values():
+            qty = max(0, int(rng.gauss(base_qty, base_qty * 0.35)))
+            accuracy = round(rng.uniform(0.88, 0.99), 3)
+            inv.append(InventoryRecord(node.node_id, sku.sku_id, qty, accuracy))
+    return inv
+
+
+def _make_links(nodes: dict[str, Node]) -> list[TransportLink]:
+    links = []
+    sources = [n for n in nodes.values() if n.node_type in ("central_dc", "regional_wh", "cross_dock", "supplier", "store")]
+    dests = [n for n in nodes.values() if n.node_type in ("store", "regional_wh", "cross_dock", "return_center")]
+    for o in sources:
+        for d in dests:
+            if o.node_id == d.node_id:
+                continue
+            dist = round(_haversine_km(o.lat, o.lon, d.lat, d.lon), 1)
+            links.append(TransportLink(o.node_id, d.node_id, dist, "standard"))
+            links.append(TransportLink(o.node_id, d.node_id, dist, "express"))
+    return links
+
+
+def _make_orders(rng: random.Random, nodes: dict[str, Node], skus: dict[str, SKU], n_orders: int, demand_multiplier: float) -> list[Order]:
+    stores = [n for n in nodes.values() if n.node_type == "store"]
+    sku_ids = list(skus.keys())
+    orders = []
+    n_orders = max(1, int(n_orders * demand_multiplier))
+    for i in range(n_orders):
+        demand_node = rng.choice(stores)
+        channel = rng.choice(["online"] * 7 + ["store"] * 3)
+        priority = rng.choice(["standard"] * 6 + ["premium"] * 3 + ["vip"] * 1)
+        n_lines = rng.randint(1, 3)
+        lines = []
+        for _ in range(n_lines):
+            sku_id = rng.choice(sku_ids)
+            lines.append(OrderLine(sku_id=sku_id, qty_requested=rng.randint(1, 3)))
+        orders.append(
+            Order(
+                order_id=f"ORD{i:05d}",
+                demand_node_id=demand_node.node_id,
+                channel=channel,
+                priority_class=priority,
+                lines=lines,
+                placed_at_hour=rng.randint(0, 23),
+            )
+        )
+    return orders
+
+
+def _apply_scenario(rng: random.Random, scenario_key: str, network: Network) -> ScenarioEvent:
+    if scenario_key == "peak_season_surge":
+        event = ScenarioEvent(
+            "peak_season_surge",
+            "Demand spikes 65% while picking capacity stays flat across all fulfillment nodes",
+            affected_node_ids=list(network.nodes.keys()),
+            capacity_factor=1.0,
+            demand_multiplier=1.65,
+        )
+        network.orders = _make_orders(rng, network.nodes, network.skus, len(network.orders), 1.65)
+    elif scenario_key == "regional_stockout":
+        affected = "RWH-E"
+        for rec in network.inventory:
+            if rec.node_id == affected:
+                rec.on_hand_qty = int(rec.on_hand_qty * 0.08)
+        event = ScenarioEvent(
+            "regional_stockout",
+            f"{network.nodes[affected].name} inventory collapses to 8% of nominal, forcing ship-from-store",
+            affected_node_ids=[affected],
+            capacity_factor=1.0,
+        )
+    elif scenario_key == "high_return_category_wave":
+        for sku in network.skus.values():
+            if sku.category == "apparel":
+                sku.return_rate = round(min(0.55, sku.return_rate * 2.1), 3)
+        event = ScenarioEvent(
+            "high_return_category_wave",
+            "Apparel return rate more than doubles after a sizing-related quality issue",
+            affected_node_ids=["RET1", "REPAIR1"],
+        )
+    elif scenario_key == "capacity_constrained_dc":
+        network.nodes["DC1"].daily_pick_capacity = int(network.nodes["DC1"].daily_pick_capacity * 0.35)
+        event = ScenarioEvent(
+            "capacity_constrained_dc",
+            "Central DC picking capacity cut to 35% after a conveyor outage",
+            affected_node_ids=["DC1"],
+            capacity_factor=0.35,
+        )
+    elif scenario_key == "green_logistics_push":
+        event = ScenarioEvent(
+            "green_logistics_push",
+            "Corporate mandate to weight the carbon objective heavily in this week's allocation",
+            affected_node_ids=list(network.nodes.keys()),
+        )
+    else:
+        raise ValueError(f"Unknown scenario key: {scenario_key}")
+    return event
+
+
+def generate_network(scenario_key: str, seed: int = 42, n_stores: int = 24, n_skus: int = 60, n_orders: int = 260) -> Network:
+    if scenario_key not in SCENARIOS:
+        raise ValueError(f"Unknown scenario '{scenario_key}'. Options: {list(SCENARIOS)}")
+    rng = random.Random(seed)
+    nodes = _make_nodes(rng, n_stores)
+    skus = _make_skus(rng, n_skus)
+    inventory = _make_inventory(rng, nodes, skus)
+    links = _make_links(nodes)
+    orders = _make_orders(rng, nodes, skus, n_orders, 1.0)
+
+    network = Network(
+        scenario_id=f"{scenario_key}_seed{seed}",
+        scenario_name=SCENARIOS[scenario_key],
+        description=SCENARIOS[scenario_key],
+        nodes=nodes,
+        skus=skus,
+        inventory=inventory,
+        links=links,
+        orders=orders,
+        events=[],
+    )
+    event = _apply_scenario(rng, scenario_key, network)
+    network.events.append(event)
+    return network
+
+
+def list_scenarios() -> list[str]:
+    return list(SCENARIOS.keys())

space-bundle/src/omnitower/lns_solver.py

@@ -0,0 +1,80 @@
+"""Adaptive Large Neighborhood Search improvement over the greedy allocation.
+
+The greedy marginal-cost allocator (`allocation.py`) is fast and scalable
+but processes orders in a fixed sequence, so early orders can lock in
+sources that would have been better reserved for later, higher-value
+orders. This module repeatedly (a) destroys a random subset of already
+allocated orders, releasing their inventory/capacity back into the pool,
+and (b) re-inserts them in an order driven by priority and margin, keeping
+the change only if total network cost improves — a lightweight ALNS loop
+sized for interactive demo latency rather than production scale.
+"""
+
+from __future__ import annotations
+
+import random
+import copy
+
+from .models import Network
+from .allocation import AllocationState, build_state, allocate_order
+from .network import build_graph
+
+
+def _network_cost(network: Network, reports: dict[str, dict]) -> float:
+    total = 0.0
+    for report in reports.values():
+        for lr in report["line_reports"]:
+            total += lr.get("transport_cost_usd", 0) + lr.get("pick_cost_usd", 0) + lr.get("pack_cost_usd", 0)
+        if report["split_shipment"]:
+            total += 3.20
+        total += report["total_backordered_qty"] * 4.5
+    return total
+
+
+def improve_allocation(network: Network, option: str = "economical", iterations: int = 25, destroy_fraction: float = 0.15, seed: int = 3) -> tuple[AllocationState, dict[str, dict], list[float]]:
+    rng = random.Random(seed)
+    graph = build_graph(network)
+    state = build_state(network)
+    reports = {}
+    order_by_id = {o.order_id: o for o in network.orders}
+
+    ordered = sorted(network.orders, key=lambda o: (-{"vip": 3, "premium": 2, "standard": 1}[o.priority_class], o.placed_at_hour))
+    for order in ordered:
+        reports[order.order_id] = allocate_order(network, order, option, state, graph)
+
+    history = [_network_cost(network, reports)]
+    order_ids = list(order_by_id.keys())
+
+    for _ in range(iterations):
+        k = max(1, int(len(order_ids) * destroy_fraction))
+        destroyed_ids = rng.sample(order_ids, k)
+
+        trial_state = AllocationState(inventory=dict(state.inventory), capacity=dict(state.capacity))
+        trial_reports = dict(reports)
+        trial_orders = {oid: copy.deepcopy(order_by_id[oid]) for oid in destroyed_ids}
+
+        for oid in destroyed_ids:
+            old_report = reports[oid]
+            for lr in old_report["line_reports"]:
+                trial_state.inventory[(lr["node_id"], lr["sku_id"])] = trial_state.inventory.get((lr["node_id"], lr["sku_id"]), 0) + lr["qty"]
+                trial_state.capacity[lr["node_id"]] = trial_state.capacity.get(lr["node_id"], 0) + lr["qty"]
+
+        reinsert_order_of_ids = sorted(
+            destroyed_ids,
+            key=lambda oid: -{"vip": 3, "premium": 2, "standard": 1}[order_by_id[oid].priority_class],
+        )
+        for oid in reinsert_order_of_ids:
+            trial_reports[oid] = allocate_order(network, trial_orders[oid], option, trial_state, graph)
+
+        new_cost = _network_cost(network, trial_reports)
+        if new_cost <= history[-1]:
+            state = trial_state
+            reports = trial_reports
+            for oid in destroyed_ids:
+                order_by_id[oid] = trial_orders[oid]
+            history.append(new_cost)
+        else:
+            history.append(history[-1])
+
+    network.orders = list(order_by_id.values())
+    return state, reports, history

space-bundle/src/omnitower/metrics.py

@@ -0,0 +1,94 @@
+"""Network-level KPI computation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+
+from .models import Network
+from .constants import DEFAULT_MARGIN_RATE, BACKORDER_PENALTY_USD, CANCELLATION_PENALTY_USD, WORKING_CAPITAL_DAYS_HELD
+
+
+@dataclass
+class NetworkMetrics:
+    gross_margin_usd: float
+    fill_rate: float
+    on_time_sla_rate: float
+    n_split_shipments: int
+    split_shipment_rate: float
+    picking_workload_units: int
+    return_handling_cost_usd: float
+    total_carbon_kg: float
+    working_capital_usd: float
+    n_orders: int
+    n_backordered_orders: int
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def compute_metrics(network: Network, reports: dict[str, dict], return_summary: dict | None = None, sla_hours: float = 48.0) -> NetworkMetrics:
+    gross_margin = 0.0
+    total_requested = 0
+    total_fulfilled = 0
+    n_split = 0
+    picking_units = 0
+    total_carbon = 0.0
+    on_time = 0
+    n_orders_with_lines = 0
+    n_backordered_orders = 0
+
+    order_by_id = {o.order_id: o for o in network.orders}
+
+    for order_id, report in reports.items():
+        order = order_by_id.get(order_id)
+        if order is None:
+            continue
+        n_orders_with_lines += 1
+        if report["split_shipment"]:
+            n_split += 1
+        max_lead = 0.0
+        for lr in report["line_reports"]:
+            sku = network.skus.get(lr["sku_id"])
+            unit_price = sku.unit_price if sku else 0.0
+            unit_cost = sku.unit_cost if sku else unit_price * (1 - DEFAULT_MARGIN_RATE)
+            gross_margin += (unit_price - unit_cost) * lr["qty"]
+            gross_margin -= lr.get("transport_cost_usd", 0) + lr.get("pick_cost_usd", 0) + lr.get("pack_cost_usd", 0)
+            picking_units += lr["qty"]
+            total_carbon += lr.get("carbon_kg", 0.0)
+            max_lead = max(max_lead, lr.get("lead_time_hours", 0.0))
+        if max_lead and max_lead <= sla_hours:
+            on_time += 1
+        if report["total_backordered_qty"] > 0:
+            gross_margin -= report["total_backordered_qty"] * BACKORDER_PENALTY_USD
+            n_backordered_orders += 1
+        total_requested += sum(l.qty_requested for l in order.lines)
+        total_fulfilled += sum(l.qty_fulfilled for l in order.lines)
+
+    return_cost = return_summary["total_handling_cost_usd"] if return_summary else 0.0
+    if return_summary:
+        gross_margin -= return_cost
+        gross_margin += return_summary.get("total_recovered_value_usd", 0.0)
+
+    working_capital = 0.0
+    for rec in network.inventory:
+        node = network.nodes.get(rec.node_id)
+        sku = network.skus.get(rec.sku_id)
+        if not node or not sku:
+            continue
+        days_held = WORKING_CAPITAL_DAYS_HELD.get(node.node_type, 10)
+        working_capital += rec.on_hand_qty * sku.unit_cost * (days_held / 365.0) * 12
+
+    n_orders = max(1, n_orders_with_lines)
+    return NetworkMetrics(
+        gross_margin_usd=round(gross_margin, 2),
+        fill_rate=round(total_fulfilled / total_requested, 4) if total_requested else 1.0,
+        on_time_sla_rate=round(on_time / n_orders, 4),
+        n_split_shipments=n_split,
+        split_shipment_rate=round(n_split / n_orders, 4),
+        picking_workload_units=picking_units,
+        return_handling_cost_usd=round(return_cost, 2),
+        total_carbon_kg=round(total_carbon, 2),
+        working_capital_usd=round(working_capital, 2),
+        n_orders=n_orders_with_lines,
+        n_backordered_orders=n_backordered_orders,
+    )

space-bundle/src/omnitower/models.py

@@ -0,0 +1,118 @@
+"""Domain model for the omnichannel fulfillment and returns network."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, asdict
+from typing import Optional
+
+
+@dataclass
+class Node:
+    node_id: str
+    node_type: str
+    name: str
+    lat: float
+    lon: float
+    daily_pick_capacity: int = 800
+    picking_cost_multiplier: float = 1.0
+
+
+@dataclass
+class SKU:
+    sku_id: str
+    category: str
+    unit_price: float
+    unit_cost: float
+    weight_kg: float
+    substitute_group: str
+    return_rate: float
+    resalable: bool = True
+
+
+@dataclass
+class InventoryRecord:
+    node_id: str
+    sku_id: str
+    on_hand_qty: int
+    accuracy: float = 0.94  # fraction of on_hand_qty that is actually pickable
+
+
+@dataclass
+class TransportLink:
+    origin_id: str
+    dest_id: str
+    distance_km: float
+    ship_mode: str = "standard"
+
+
+@dataclass
+class OrderLine:
+    sku_id: str
+    qty_requested: int
+    qty_fulfilled: int = 0
+    substituted_sku_id: Optional[str] = None
+    source_node_id: Optional[str] = None
+    backordered_qty: int = 0
+    cancelled_qty: int = 0
+
+
+@dataclass
+class Order:
+    order_id: str
+    demand_node_id: str
+    channel: str  # "online" or "store"
+    priority_class: str
+    lines: list[OrderLine]
+    placed_at_hour: int
+    accepted: bool = True
+    split_shipment: bool = False
+    chosen_delivery_option: str = "economical"
+
+
+@dataclass
+class ReturnItem:
+    return_id: str
+    order_id: str
+    sku_id: str
+    qty: int
+    quality_score: float
+    origin_node_id: str
+    disposition: str = ""  # restock_store, restock_dc, repair, recycle, dispose
+    resold: bool = False
+
+
+@dataclass
+class ScenarioEvent:
+    event_type: str
+    description: str
+    affected_node_ids: list[str] = field(default_factory=list)
+    capacity_factor: float = 1.0
+    demand_multiplier: float = 1.0
+
+
+@dataclass
+class Network:
+    scenario_id: str
+    scenario_name: str
+    description: str
+    nodes: dict[str, Node]
+    skus: dict[str, SKU]
+    inventory: list[InventoryRecord]
+    links: list[TransportLink]
+    orders: list[Order]
+    events: list[ScenarioEvent]
+
+    def to_dict(self) -> dict:
+        return {
+            "scenario_id": self.scenario_id,
+            "scenario_name": self.scenario_name,
+            "description": self.description,
+            "nodes": {k: asdict(v) for k, v in self.nodes.items()},
+            "skus": {k: asdict(v) for k, v in self.skus.items()},
+            "inventory": [asdict(i) for i in self.inventory],
+            "links": [asdict(l) for l in self.links],
+            "orders": [
+                {**asdict(o), "lines": [asdict(ln) for ln in o.lines]} for o in self.orders
+            ],
+            "events": [asdict(e) for e in self.events],
+        }

space-bundle/src/omnitower/network.py

@@ -0,0 +1,68 @@
+"""Graph utilities: distance lookup and candidate-source ranking.
+
+A lightweight NetworkX directed graph indexes transport links so the
+allocation and routing modules can query distance / mode without
+re-scanning the flat link list on every call.
+"""
+
+from __future__ import annotations
+
+import networkx as nx
+
+from .models import Network
+from .constants import (
+    COST_PER_KM_STANDARD_USD,
+    COST_PER_KM_EXPRESS_USD,
+    CARBON_KG_PER_KM_STANDARD,
+    CARBON_KG_PER_KM_EXPRESS,
+    CARBON_KG_PER_KM_GREEN,
+)
+
+FULFILLMENT_NODE_TYPES = ("central_dc", "regional_wh", "cross_dock", "supplier", "store")
+
+
+def build_graph(network: Network) -> nx.DiGraph:
+    graph = nx.DiGraph()
+    for node in network.nodes.values():
+        graph.add_node(node.node_id, node_type=node.node_type, capacity=node.daily_pick_capacity)
+    for link in network.links:
+        graph.add_edge(
+            link.origin_id,
+            link.dest_id,
+            **{f"distance_km_{link.ship_mode}": link.distance_km},
+        )
+    return graph
+
+
+def distance_km(graph: nx.DiGraph, origin_id: str, dest_id: str) -> float:
+    if origin_id == dest_id:
+        return 0.0
+    data = graph.get_edge_data(origin_id, dest_id, default=None)
+    if data is None:
+        return float("inf")
+    for key, value in data.items():
+        if key.startswith("distance_km_"):
+            return value
+    return float("inf")
+
+
+def transport_cost(distance: float, mode: str) -> float:
+    if distance == 0:
+        return 0.0
+    rate = COST_PER_KM_EXPRESS_USD if mode == "express" else COST_PER_KM_STANDARD_USD
+    return distance * rate
+
+
+def carbon_kg(distance: float, mode: str) -> float:
+    if distance == 0:
+        return 0.0
+    factor = {
+        "express": CARBON_KG_PER_KM_EXPRESS,
+        "green": CARBON_KG_PER_KM_GREEN,
+    }.get(mode, CARBON_KG_PER_KM_STANDARD)
+    return distance * factor
+
+
+def candidate_sources(network: Network, demand_node_id: str) -> list[str]:
+    """All nodes that can physically fulfill an order for a given demand node."""
+    return [n.node_id for n in network.nodes.values() if n.node_type in FULFILLMENT_NODE_TYPES]

space-bundle/src/omnitower/omnitower/__init__.py

@@ -0,0 +1,3 @@
+"""Omnichannel Fulfillment and Returns Control Tower — core optimization engine."""
+
+__version__ = "1.0.0"

space-bundle/src/omnitower/omnitower/admission.py

@@ -0,0 +1,62 @@
+"""Dynamic admission control.
+
+Approximates a bid-price control policy: rather than a static allocation
+rule, each incoming order is scored against the *current* scarcity of the
+SKUs it requests (remaining pooled inventory vs. remaining forecast demand
+for the rest of the horizon). Orders that would consume disproportionately
+scarce stock for a low-margin / low-priority order are queued as
+backorders instead of being admitted immediately, protecting inventory for
+higher-value demand still expected to arrive.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .models import Network, Order
+from .allocation import AllocationState
+from .constants import DEFAULT_MARGIN_RATE, BACKORDER_PENALTY_USD
+
+PRIORITY_WEIGHT = {"vip": 1.6, "premium": 1.25, "standard": 1.0}
+
+
+@dataclass
+class AdmissionDecision:
+    order_id: str
+    admitted: bool
+    reason: str
+    scarcity_score: float
+
+
+def _scarcity_score(network: Network, state: AllocationState, order: Order, remaining_demand_factor: float) -> float:
+    scores = []
+    for line in order.lines:
+        total_remaining = sum(qty for (node, sku), qty in state.inventory.items() if sku == line.sku_id)
+        forecast_need = max(1.0, total_remaining * 0.0 + remaining_demand_factor * line.qty_requested * 6.0)
+        if total_remaining <= 0:
+            scores.append(1.0)
+        else:
+            scores.append(min(1.0, forecast_need / (total_remaining + forecast_need)))
+    return sum(scores) / max(1, len(scores))
+
+
+def evaluate_admission(
+    network: Network,
+    state: AllocationState,
+    order: Order,
+    remaining_demand_factor: float = 0.5,
+    scarcity_threshold: float = 0.82,
+) -> AdmissionDecision:
+    scarcity = _scarcity_score(network, state, order, remaining_demand_factor)
+    priority_weight = PRIORITY_WEIGHT.get(order.priority_class, 1.0)
+    effective_threshold = scarcity_threshold * priority_weight
+    order_value = sum(network.skus[l.sku_id].unit_price * l.qty_requested for l in order.lines if l.sku_id in network.skus)
+    margin_value = order_value * DEFAULT_MARGIN_RATE
+
+    if scarcity < effective_threshold or margin_value > BACKORDER_PENALTY_USD * 20:
+        return AdmissionDecision(order.order_id, True, "accepted: inventory scarcity within threshold for priority class", round(scarcity, 3))
+    return AdmissionDecision(order.order_id, False, "deferred to backorder: scarce stock reserved for expected higher-value demand", round(scarcity, 3))
+
+
+def evaluate_all(network: Network, state: AllocationState, remaining_demand_factor: float = 0.5) -> list[AdmissionDecision]:
+    return [evaluate_admission(network, state, order, remaining_demand_factor) for order in network.orders]

space-bundle/src/omnitower/omnitower/allocation.py

@@ -0,0 +1,156 @@
+"""Order allocation optimizer: Inventory Allocation + Order Fulfillment.
+
+Implements the "Greedy Marginal Cost" scalable heuristic referenced in the
+project brief: for every order line, candidate fulfillment nodes are ranked
+by the marginal cost of serving that unit from that node (transport +
+picking + packing, weighted by the chosen delivery objective), subject to
+live inventory and daily picking-capacity pools that are decremented as the
+order stream is processed. Split shipments and ship-from-store are native
+outcomes of the ranking rather than a separate rule.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .models import Network, Order, OrderLine
+from .network import build_graph, distance_km, transport_cost, carbon_kg, candidate_sources
+from .constants import (
+    COST_PER_PICK_USD,
+    COST_PER_PACK_USD,
+    COST_PER_SPLIT_SHIPMENT_USD,
+    LEAD_TIME_HOURS_PER_100KM_STANDARD,
+    LEAD_TIME_HOURS_PER_100KM_EXPRESS,
+    LEAD_TIME_HOURS_PER_100KM_GREEN,
+)
+
+OBJECTIVE_WEIGHTS = {
+    # (cost_weight, time_weight, carbon_weight)
+    "fast": (0.15, 0.75, 0.10),
+    "economical": (0.75, 0.10, 0.15),
+    "green": (0.15, 0.10, 0.75),
+}
+
+
+@dataclass
+class AllocationState:
+    inventory: dict[tuple[str, str], float]
+    capacity: dict[str, float]
+
+
+def build_state(network: Network) -> AllocationState:
+    inv = {}
+    for rec in network.inventory:
+        inv[(rec.node_id, rec.sku_id)] = rec.on_hand_qty * rec.accuracy
+    cap = {n.node_id: float(n.daily_pick_capacity) for n in network.nodes.values()}
+    return AllocationState(inventory=inv, capacity=cap)
+
+
+def _mode_for_option(option: str) -> str:
+    return {"fast": "express", "economical": "standard", "green": "green"}[option]
+
+
+def _lead_time_hours(distance: float, mode: str) -> float:
+    rate = {
+        "express": LEAD_TIME_HOURS_PER_100KM_EXPRESS,
+        "green": LEAD_TIME_HOURS_PER_100KM_GREEN,
+    }.get(mode, LEAD_TIME_HOURS_PER_100KM_STANDARD)
+    return 2.0 + (distance / 100.0) * rate
+
+
+def _score_source(graph, node, sku_id, demand_node_id, node_meta, option, state: AllocationState) -> tuple[float, dict]:
+    dist = distance_km(graph, node, demand_node_id)
+    if dist == float("inf"):
+        return float("inf"), {}
+    mode = _mode_for_option(option)
+    link_mode = "express" if mode == "express" else "standard"
+    t_cost = transport_cost(dist, link_mode)
+    pick_cost = COST_PER_PICK_USD * node_meta.picking_cost_multiplier
+    pack_cost = COST_PER_PACK_USD
+    lead_hours = _lead_time_hours(dist, mode)
+    carbon = carbon_kg(dist, mode)
+    cw, tw, cbw = OBJECTIVE_WEIGHTS[option]
+    # normalize roughly to comparable scales before weighting
+    score = cw * (t_cost + pick_cost + pack_cost) + tw * lead_hours + cbw * (carbon * 0.5)
+    breakdown = {
+        "distance_km": round(dist, 1),
+        "transport_cost_usd": round(t_cost, 2),
+        "pick_cost_usd": round(pick_cost, 2),
+        "pack_cost_usd": round(pack_cost, 2),
+        "lead_time_hours": round(lead_hours, 1),
+        "carbon_kg": round(carbon, 2),
+        "ship_mode": mode,
+    }
+    return score, breakdown
+
+
+def _find_substitute(network: Network, sku_id: str, state: AllocationState, source_pool: list[str]) -> str | None:
+    sku = network.skus[sku_id]
+    for other in network.skus.values():
+        if other.sku_id == sku_id or other.substitute_group != sku.substitute_group:
+            continue
+        if any(state.inventory.get((n, other.sku_id), 0) >= 1 for n in source_pool):
+            return other.sku_id
+    return None
+
+
+def allocate_order(network: Network, order: Order, option: str, state: AllocationState, graph=None) -> dict:
+    graph = graph or build_graph(network)
+    sources = candidate_sources(network, order.demand_node_id, exclude_demand_node=(order.channel == "online"))
+    used_nodes: set[str] = set()
+    line_reports = []
+
+    for line in order.lines:
+        remaining = line.qty_requested
+        line.qty_fulfilled = 0
+        while remaining > 0:
+            ranked = []
+            for node_id in sources:
+                node_meta = network.nodes[node_id]
+                avail = state.inventory.get((node_id, line.sku_id), 0)
+                cap = state.capacity.get(node_id, 0)
+                if avail < 1 or cap < 1:
+                    continue
+                score, breakdown = _score_source(graph, node_id, line.sku_id, order.demand_node_id, node_meta, option, state)
+                if score == float("inf"):
+                    continue
+                ranked.append((score, node_id, breakdown))
+            if not ranked:
+                substitute = _find_substitute(network, line.sku_id, state, sources)
+                if substitute and line.substituted_sku_id is None:
+                    line.substituted_sku_id = substitute
+                    line.sku_id = substitute
+                    continue
+                break
+            ranked.sort(key=lambda x: x[0])
+            score, node_id, breakdown = ranked[0]
+            take = min(remaining, state.inventory[(node_id, line.sku_id)], state.capacity[node_id])
+            take = max(1, int(take))
+            state.inventory[(node_id, line.sku_id)] -= take
+            state.capacity[node_id] -= take
+            line.qty_fulfilled += take
+            line.source_node_id = node_id
+            used_nodes.add(node_id)
+            remaining -= take
+            line_reports.append({"sku_id": line.sku_id, "node_id": node_id, "qty": take, **breakdown})
+        line.backordered_qty = remaining
+
+    order.split_shipment = len(used_nodes) > 1
+    order.chosen_delivery_option = option
+    total_backorder = sum(l.backordered_qty for l in order.lines)
+    order.accepted = total_backorder < sum(l.qty_requested for l in order.lines)
+    return {
+        "order_id": order.order_id,
+        "delivery_option": option,
+        "split_shipment": order.split_shipment,
+        "nodes_used": sorted(used_nodes),
+        "line_reports": line_reports,
+        "total_backordered_qty": total_backorder,
+    }
+
+
+def allocate_all(network: Network, option: str = "economical") -> tuple[AllocationState, list[dict]]:
+    state = build_state(network)
+    graph = build_graph(network)
+    reports = [allocate_order(network, order, option, state, graph) for order in network.orders]
+    return state, reports

space-bundle/src/omnitower/omnitower/constants.py

@@ -0,0 +1,59 @@
+"""Shared constants and cost coefficients for the control tower."""
+
+from __future__ import annotations
+
+NODE_TYPES = [
+    "store",
+    "central_dc",
+    "regional_wh",
+    "supplier",
+    "cross_dock",
+    "return_center",
+    "repair_center",
+    "recycle_center",
+]
+
+SHIP_MODE_STANDARD = "standard"
+SHIP_MODE_EXPRESS = "express"
+
+DELIVERY_OPTIONS = ["fast", "economical", "green"]
+
+# Approximate cost / emission coefficients used across the demo scenarios.
+COST_PER_KM_STANDARD_USD = 0.055
+COST_PER_KM_EXPRESS_USD = 0.145
+COST_PER_PICK_USD = 1.35
+COST_PER_PACK_USD = 0.85
+COST_PER_SPLIT_SHIPMENT_USD = 3.20
+CARBON_KG_PER_KM_STANDARD = 0.18
+CARBON_KG_PER_KM_EXPRESS = 0.34
+CARBON_KG_PER_KM_GREEN = 0.07  # consolidated / low-carbon linehaul
+
+LEAD_TIME_HOURS_PER_100KM_STANDARD = 2.4
+LEAD_TIME_HOURS_PER_100KM_EXPRESS = 0.9
+LEAD_TIME_HOURS_PER_100KM_GREEN = 3.6
+
+RETURN_HANDLING_COST_USD = {
+    "restock_store": 1.10,
+    "restock_dc": 1.60,
+    "repair": 6.50,
+    "recycle": 2.20,
+    "dispose": 3.00,
+}
+
+RETURN_RECOVERY_VALUE_FACTOR = {
+    "restock_store": 0.92,
+    "restock_dc": 0.88,
+    "repair": 0.55,
+    "recycle": 0.06,
+    "dispose": 0.0,
+}
+
+DEFAULT_MARGIN_RATE = 0.34
+BACKORDER_PENALTY_USD = 4.50
+CANCELLATION_PENALTY_USD = 9.00
+WORKING_CAPITAL_DAYS_HELD = {
+    "central_dc": 21,
+    "regional_wh": 14,
+    "store": 9,
+    "cross_dock": 2,
+}

space-bundle/src/omnitower/omnitower/generator.py

@@ -0,0 +1,214 @@
+"""Synthetic omnichannel network and demand scenario generator.
+
+Builds a reproducible multi-echelon network (central DC, regional warehouses,
+stores, suppliers, cross-dock, return/repair/recycle centers), a SKU
+catalog with substitute groups, noisy inventory, and a day's worth of
+multi-line orders, then applies one of the demo scenario archetypes.
+"""
+
+from __future__ import annotations
+
+import random
+from math import radians, sin, cos, asin, sqrt
+
+from .models import Node, SKU, InventoryRecord, TransportLink, Order, OrderLine, ScenarioEvent, Network
+
+CATEGORIES = ["apparel", "footwear", "electronics_accessory", "home_goods", "beauty"]
+SUBSTITUTE_GROUPS = {
+    "apparel": ["APP-A", "APP-B"],
+    "footwear": ["SHOE-A"],
+    "electronics_accessory": ["ELEC-A"],
+    "home_goods": ["HOME-A", "HOME-B"],
+    "beauty": ["BEAUTY-A"],
+}
+BASE_RETURN_RATE = {
+    "apparel": 0.22,
+    "footwear": 0.17,
+    "electronics_accessory": 0.06,
+    "home_goods": 0.05,
+    "beauty": 0.03,
+}
+
+SCENARIOS = {
+    "peak_season_surge": "Peak-season demand surge with tight picking capacity",
+    "regional_stockout": "Regional warehouse stockout forcing ship-from-store",
+    "high_return_category_wave": "Apparel high-return wave stressing reverse logistics",
+    "capacity_constrained_dc": "Central DC capacity outage shifting flow to regional network",
+    "green_logistics_push": "Corporate mandate to minimize carbon emissions this week",
+}
+
+
+def _haversine_km(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    r = 6371.0
+    dlat, dlon = radians(lat2 - lat1), radians(lon2 - lon1)
+    a = sin(dlat / 2) ** 2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlon / 2) ** 2
+    return 2 * r * asin(sqrt(a))
+
+
+def _make_nodes(rng: random.Random, n_stores: int) -> dict[str, Node]:
+    nodes: dict[str, Node] = {}
+    nodes["DC1"] = Node("DC1", "central_dc", "Central Distribution Center", 39.10, -94.58, daily_pick_capacity=6000, picking_cost_multiplier=0.85)
+    nodes["RWH-E"] = Node("RWH-E", "regional_wh", "Regional Warehouse East", 40.71, -74.01, daily_pick_capacity=2600, picking_cost_multiplier=0.95)
+    nodes["RWH-W"] = Node("RWH-W", "regional_wh", "Regional Warehouse West", 34.05, -118.24, daily_pick_capacity=2600, picking_cost_multiplier=0.95)
+    nodes["SUP1"] = Node("SUP1", "supplier", "Primary Supplier Hub", 41.88, -87.63, daily_pick_capacity=4000, picking_cost_multiplier=1.10)
+    nodes["XDOCK1"] = Node("XDOCK1", "cross_dock", "Regional Cross-Dock", 38.63, -90.20, daily_pick_capacity=3200, picking_cost_multiplier=0.70)
+    nodes["RET1"] = Node("RET1", "return_center", "Returns Processing Center", 39.77, -86.16, daily_pick_capacity=1800, picking_cost_multiplier=1.0)
+    nodes["REPAIR1"] = Node("REPAIR1", "repair_center", "Repair & Refurbishment Center", 39.77, -86.20, daily_pick_capacity=600, picking_cost_multiplier=1.0)
+    nodes["RECY1"] = Node("RECY1", "recycle_center", "Recycling & Recovery Center", 39.80, -86.10, daily_pick_capacity=900, picking_cost_multiplier=1.0)
+
+    for i in range(n_stores):
+        lat = 30.0 + rng.uniform(0, 15.0)
+        lon = -122.0 + rng.uniform(0, 45.0)
+        sid = f"ST{i:03d}"
+        nodes[sid] = Node(sid, "store", f"Store {i:03d}", round(lat, 3), round(lon, 3), daily_pick_capacity=rng.randint(120, 320), picking_cost_multiplier=1.25)
+    return nodes
+
+
+def _make_skus(rng: random.Random, n_skus: int) -> dict[str, SKU]:
+    skus: dict[str, SKU] = {}
+    for i in range(n_skus):
+        cat = CATEGORIES[i % len(CATEGORIES)]
+        group = SUBSTITUTE_GROUPS[cat][i % len(SUBSTITUTE_GROUPS[cat])]
+        cost = round(rng.uniform(8, 90), 2)
+        skus[f"SKU{i:04d}"] = SKU(
+            sku_id=f"SKU{i:04d}",
+            category=cat,
+            unit_price=round(cost * rng.uniform(1.5, 2.6), 2),
+            unit_cost=cost,
+            weight_kg=round(rng.uniform(0.2, 4.5), 2),
+            substitute_group=group,
+            return_rate=round(BASE_RETURN_RATE[cat] * rng.uniform(0.7, 1.3), 3),
+        )
+    return skus
+
+
+def _make_inventory(rng: random.Random, nodes: dict[str, Node], skus: dict[str, SKU]) -> list[InventoryRecord]:
+    inv = []
+    fulfillment_nodes = [n for n in nodes.values() if n.node_type in ("central_dc", "regional_wh", "store", "cross_dock", "supplier")]
+    for node in fulfillment_nodes:
+        base_qty = {"central_dc": 800, "regional_wh": 300, "cross_dock": 150, "supplier": 5000, "store": 25}[node.node_type]
+        for sku in skus.values():
+            qty = max(0, int(rng.gauss(base_qty, base_qty * 0.35)))
+            accuracy = round(rng.uniform(0.88, 0.99), 3)
+            inv.append(InventoryRecord(node.node_id, sku.sku_id, qty, accuracy))
+    return inv
+
+
+def _make_links(nodes: dict[str, Node]) -> list[TransportLink]:
+    links = []
+    sources = [n for n in nodes.values() if n.node_type in ("central_dc", "regional_wh", "cross_dock", "supplier", "store")]
+    dests = [n for n in nodes.values() if n.node_type in ("store", "regional_wh", "cross_dock", "return_center")]
+    for o in sources:
+        for d in dests:
+            if o.node_id == d.node_id:
+                continue
+            dist = round(_haversine_km(o.lat, o.lon, d.lat, d.lon), 1)
+            links.append(TransportLink(o.node_id, d.node_id, dist, "standard"))
+            links.append(TransportLink(o.node_id, d.node_id, dist, "express"))
+    return links
+
+
+def _make_orders(rng: random.Random, nodes: dict[str, Node], skus: dict[str, SKU], n_orders: int, demand_multiplier: float) -> list[Order]:
+    stores = [n for n in nodes.values() if n.node_type == "store"]
+    sku_ids = list(skus.keys())
+    orders = []
+    n_orders = max(1, int(n_orders * demand_multiplier))
+    for i in range(n_orders):
+        demand_node = rng.choice(stores)
+        channel = rng.choice(["online"] * 7 + ["store"] * 3)
+        priority = rng.choice(["standard"] * 6 + ["premium"] * 3 + ["vip"] * 1)
+        n_lines = rng.randint(1, 3)
+        lines = []
+        for _ in range(n_lines):
+            sku_id = rng.choice(sku_ids)
+            lines.append(OrderLine(sku_id=sku_id, qty_requested=rng.randint(1, 3)))
+        orders.append(
+            Order(
+                order_id=f"ORD{i:05d}",
+                demand_node_id=demand_node.node_id,
+                channel=channel,
+                priority_class=priority,
+                lines=lines,
+                placed_at_hour=rng.randint(0, 23),
+            )
+        )
+    return orders
+
+
+def _apply_scenario(rng: random.Random, scenario_key: str, network: Network) -> ScenarioEvent:
+    if scenario_key == "peak_season_surge":
+        event = ScenarioEvent(
+            "peak_season_surge",
+            "Demand spikes 65% while picking capacity stays flat across all fulfillment nodes",
+            affected_node_ids=list(network.nodes.keys()),
+            capacity_factor=1.0,
+            demand_multiplier=1.65,
+        )
+        network.orders = _make_orders(rng, network.nodes, network.skus, len(network.orders), 1.65)
+    elif scenario_key == "regional_stockout":
+        affected = "RWH-E"
+        for rec in network.inventory:
+            if rec.node_id == affected:
+                rec.on_hand_qty = int(rec.on_hand_qty * 0.08)
+        event = ScenarioEvent(
+            "regional_stockout",
+            f"{network.nodes[affected].name} inventory collapses to 8% of nominal, forcing ship-from-store",
+            affected_node_ids=[affected],
+            capacity_factor=1.0,
+        )
+    elif scenario_key == "high_return_category_wave":
+        for sku in network.skus.values():
+            if sku.category == "apparel":
+                sku.return_rate = round(min(0.55, sku.return_rate * 2.1), 3)
+        event = ScenarioEvent(
+            "high_return_category_wave",
+            "Apparel return rate more than doubles after a sizing-related quality issue",
+            affected_node_ids=["RET1", "REPAIR1"],
+        )
+    elif scenario_key == "capacity_constrained_dc":
+        network.nodes["DC1"].daily_pick_capacity = int(network.nodes["DC1"].daily_pick_capacity * 0.35)
+        event = ScenarioEvent(
+            "capacity_constrained_dc",
+            "Central DC picking capacity cut to 35% after a conveyor outage",
+            affected_node_ids=["DC1"],
+            capacity_factor=0.35,
+        )
+    elif scenario_key == "green_logistics_push":
+        event = ScenarioEvent(
+            "green_logistics_push",
+            "Corporate mandate to weight the carbon objective heavily in this week's allocation",
+            affected_node_ids=list(network.nodes.keys()),
+        )
+    else:
+        raise ValueError(f"Unknown scenario key: {scenario_key}")
+    return event
+
+
+def generate_network(scenario_key: str, seed: int = 42, n_stores: int = 24, n_skus: int = 60, n_orders: int = 260) -> Network:
+    if scenario_key not in SCENARIOS:
+        raise ValueError(f"Unknown scenario '{scenario_key}'. Options: {list(SCENARIOS)}")
+    rng = random.Random(seed)
+    nodes = _make_nodes(rng, n_stores)
+    skus = _make_skus(rng, n_skus)
+    inventory = _make_inventory(rng, nodes, skus)
+    links = _make_links(nodes)
+    orders = _make_orders(rng, nodes, skus, n_orders, 1.0)
+
+    network = Network(
+        scenario_id=f"{scenario_key}_seed{seed}",
+        scenario_name=SCENARIOS[scenario_key],
+        description=SCENARIOS[scenario_key],
+        nodes=nodes,
+        skus=skus,
+        inventory=inventory,
+        links=links,
+        orders=orders,
+        events=[],
+    )
+    event = _apply_scenario(rng, scenario_key, network)
+    network.events.append(event)
+    return network
+
+
+def list_scenarios() -> list[str]:
+    return list(SCENARIOS.keys())

space-bundle/src/omnitower/omnitower/lns_solver.py

@@ -0,0 +1,80 @@
+"""Adaptive Large Neighborhood Search improvement over the greedy allocation.
+
+The greedy marginal-cost allocator (`allocation.py`) is fast and scalable
+but processes orders in a fixed sequence, so early orders can lock in
+sources that would have been better reserved for later, higher-value
+orders. This module repeatedly (a) destroys a random subset of already
+allocated orders, releasing their inventory/capacity back into the pool,
+and (b) re-inserts them in an order driven by priority and margin, keeping
+the change only if total network cost improves — a lightweight ALNS loop
+sized for interactive demo latency rather than production scale.
+"""
+
+from __future__ import annotations
+
+import random
+import copy
+
+from .models import Network
+from .allocation import AllocationState, build_state, allocate_order
+from .network import build_graph
+
+
+def _network_cost(network: Network, reports: dict[str, dict]) -> float:
+    total = 0.0
+    for report in reports.values():
+        for lr in report["line_reports"]:
+            total += lr.get("transport_cost_usd", 0) + lr.get("pick_cost_usd", 0) + lr.get("pack_cost_usd", 0)
+        if report["split_shipment"]:
+            total += 3.20
+        total += report["total_backordered_qty"] * 4.5
+    return total
+
+
+def improve_allocation(network: Network, option: str = "economical", iterations: int = 25, destroy_fraction: float = 0.15, seed: int = 3) -> tuple[AllocationState, dict[str, dict], list[float]]:
+    rng = random.Random(seed)
+    graph = build_graph(network)
+    state = build_state(network)
+    reports = {}
+    order_by_id = {o.order_id: o for o in network.orders}
+
+    ordered = sorted(network.orders, key=lambda o: (-{"vip": 3, "premium": 2, "standard": 1}[o.priority_class], o.placed_at_hour))
+    for order in ordered:
+        reports[order.order_id] = allocate_order(network, order, option, state, graph)
+
+    history = [_network_cost(network, reports)]
+    order_ids = list(order_by_id.keys())
+
+    for _ in range(iterations):
+        k = max(1, int(len(order_ids) * destroy_fraction))
+        destroyed_ids = rng.sample(order_ids, k)
+
+        trial_state = AllocationState(inventory=dict(state.inventory), capacity=dict(state.capacity))
+        trial_reports = dict(reports)
+        trial_orders = {oid: copy.deepcopy(order_by_id[oid]) for oid in destroyed_ids}
+
+        for oid in destroyed_ids:
+            old_report = reports[oid]
+            for lr in old_report["line_reports"]:
+                trial_state.inventory[(lr["node_id"], lr["sku_id"])] = trial_state.inventory.get((lr["node_id"], lr["sku_id"]), 0) + lr["qty"]
+                trial_state.capacity[lr["node_id"]] = trial_state.capacity.get(lr["node_id"], 0) + lr["qty"]
+
+        reinsert_order_of_ids = sorted(
+            destroyed_ids,
+            key=lambda oid: -{"vip": 3, "premium": 2, "standard": 1}[order_by_id[oid].priority_class],
+        )
+        for oid in reinsert_order_of_ids:
+            trial_reports[oid] = allocate_order(network, trial_orders[oid], option, trial_state, graph)
+
+        new_cost = _network_cost(network, trial_reports)
+        if new_cost <= history[-1]:
+            state = trial_state
+            reports = trial_reports
+            for oid in destroyed_ids:
+                order_by_id[oid] = trial_orders[oid]
+            history.append(new_cost)
+        else:
+            history.append(history[-1])
+
+    network.orders = list(order_by_id.values())
+    return state, reports, history

space-bundle/src/omnitower/omnitower/metrics.py

@@ -0,0 +1,96 @@
+"""Network-level KPI computation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+
+from .models import Network
+from .constants import DEFAULT_MARGIN_RATE, BACKORDER_PENALTY_USD, CANCELLATION_PENALTY_USD, WORKING_CAPITAL_DAYS_HELD
+
+
+@dataclass
+class NetworkMetrics:
+    gross_margin_usd: float
+    fill_rate: float
+    on_time_sla_rate: float
+    n_split_shipments: int
+    split_shipment_rate: float
+    picking_workload_units: int
+    return_handling_cost_usd: float
+    total_carbon_kg: float
+    working_capital_usd: float
+    n_orders: int
+    n_backordered_orders: int
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def compute_metrics(network: Network, reports: dict[str, dict] | list[dict], return_summary: dict | None = None, sla_hours: float = 48.0) -> NetworkMetrics:
+    if isinstance(reports, list):
+        reports = {r["order_id"]: r for r in reports}
+    gross_margin = 0.0
+    total_requested = 0
+    total_fulfilled = 0
+    n_split = 0
+    picking_units = 0
+    total_carbon = 0.0
+    on_time = 0
+    n_orders_with_lines = 0
+    n_backordered_orders = 0
+
+    order_by_id = {o.order_id: o for o in network.orders}
+
+    for order_id, report in reports.items():
+        order = order_by_id.get(order_id)
+        if order is None:
+            continue
+        n_orders_with_lines += 1
+        if report["split_shipment"]:
+            n_split += 1
+        max_lead = 0.0
+        for lr in report["line_reports"]:
+            sku = network.skus.get(lr["sku_id"])
+            unit_price = sku.unit_price if sku else 0.0
+            unit_cost = sku.unit_cost if sku else unit_price * (1 - DEFAULT_MARGIN_RATE)
+            gross_margin += (unit_price - unit_cost) * lr["qty"]
+            gross_margin -= lr.get("transport_cost_usd", 0) + lr.get("pick_cost_usd", 0) + lr.get("pack_cost_usd", 0)
+            picking_units += lr["qty"]
+            total_carbon += lr.get("carbon_kg", 0.0)
+            max_lead = max(max_lead, lr.get("lead_time_hours", 0.0))
+        if max_lead and max_lead <= sla_hours:
+            on_time += 1
+        if report["total_backordered_qty"] > 0:
+            gross_margin -= report["total_backordered_qty"] * BACKORDER_PENALTY_USD
+            n_backordered_orders += 1
+        total_requested += sum(l.qty_requested for l in order.lines)
+        total_fulfilled += sum(l.qty_fulfilled for l in order.lines)
+
+    return_cost = return_summary["total_handling_cost_usd"] if return_summary else 0.0
+    if return_summary:
+        gross_margin -= return_cost
+        gross_margin += return_summary.get("total_recovered_value_usd", 0.0)
+
+    working_capital = 0.0
+    for rec in network.inventory:
+        node = network.nodes.get(rec.node_id)
+        sku = network.skus.get(rec.sku_id)
+        if not node or not sku:
+            continue
+        days_held = WORKING_CAPITAL_DAYS_HELD.get(node.node_type, 10)
+        working_capital += rec.on_hand_qty * sku.unit_cost * (days_held / 365.0) * 12
+
+    n_orders = max(1, n_orders_with_lines)
+    return NetworkMetrics(
+        gross_margin_usd=round(gross_margin, 2),
+        fill_rate=round(total_fulfilled / total_requested, 4) if total_requested else 1.0,
+        on_time_sla_rate=round(on_time / n_orders, 4),
+        n_split_shipments=n_split,
+        split_shipment_rate=round(n_split / n_orders, 4),
+        picking_workload_units=picking_units,
+        return_handling_cost_usd=round(return_cost, 2),
+        total_carbon_kg=round(total_carbon, 2),
+        working_capital_usd=round(working_capital, 2),
+        n_orders=n_orders_with_lines,
+        n_backordered_orders=n_backordered_orders,
+    )

space-bundle/src/omnitower/omnitower/models.py

@@ -0,0 +1,118 @@
+"""Domain model for the omnichannel fulfillment and returns network."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, asdict
+from typing import Optional
+
+
+@dataclass
+class Node:
+    node_id: str
+    node_type: str
+    name: str
+    lat: float
+    lon: float
+    daily_pick_capacity: int = 800
+    picking_cost_multiplier: float = 1.0
+
+
+@dataclass
+class SKU:
+    sku_id: str
+    category: str
+    unit_price: float
+    unit_cost: float
+    weight_kg: float
+    substitute_group: str
+    return_rate: float
+    resalable: bool = True
+
+
+@dataclass
+class InventoryRecord:
+    node_id: str
+    sku_id: str
+    on_hand_qty: int
+    accuracy: float = 0.94  # fraction of on_hand_qty that is actually pickable
+
+
+@dataclass
+class TransportLink:
+    origin_id: str
+    dest_id: str
+    distance_km: float
+    ship_mode: str = "standard"
+
+
+@dataclass
+class OrderLine:
+    sku_id: str
+    qty_requested: int
+    qty_fulfilled: int = 0
+    substituted_sku_id: Optional[str] = None
+    source_node_id: Optional[str] = None
+    backordered_qty: int = 0
+    cancelled_qty: int = 0
+
+
+@dataclass
+class Order:
+    order_id: str
+    demand_node_id: str
+    channel: str  # "online" or "store"
+    priority_class: str
+    lines: list[OrderLine]
+    placed_at_hour: int
+    accepted: bool = True
+    split_shipment: bool = False
+    chosen_delivery_option: str = "economical"
+
+
+@dataclass
+class ReturnItem:
+    return_id: str
+    order_id: str
+    sku_id: str
+    qty: int
+    quality_score: float
+    origin_node_id: str
+    disposition: str = ""  # restock_store, restock_dc, repair, recycle, dispose
+    resold: bool = False
+
+
+@dataclass
+class ScenarioEvent:
+    event_type: str
+    description: str
+    affected_node_ids: list[str] = field(default_factory=list)
+    capacity_factor: float = 1.0
+    demand_multiplier: float = 1.0
+
+
+@dataclass
+class Network:
+    scenario_id: str
+    scenario_name: str
+    description: str
+    nodes: dict[str, Node]
+    skus: dict[str, SKU]
+    inventory: list[InventoryRecord]
+    links: list[TransportLink]
+    orders: list[Order]
+    events: list[ScenarioEvent]
+
+    def to_dict(self) -> dict:
+        return {
+            "scenario_id": self.scenario_id,
+            "scenario_name": self.scenario_name,
+            "description": self.description,
+            "nodes": {k: asdict(v) for k, v in self.nodes.items()},
+            "skus": {k: asdict(v) for k, v in self.skus.items()},
+            "inventory": [asdict(i) for i in self.inventory],
+            "links": [asdict(l) for l in self.links],
+            "orders": [
+                {**asdict(o), "lines": [asdict(ln) for ln in o.lines]} for o in self.orders
+            ],
+            "events": [asdict(e) for e in self.events],
+        }

space-bundle/src/omnitower/omnitower/network.py

@@ -0,0 +1,79 @@
+"""Graph utilities: distance lookup and candidate-source ranking.
+
+A lightweight NetworkX directed graph indexes transport links so the
+allocation and routing modules can query distance / mode without
+re-scanning the flat link list on every call.
+"""
+
+from __future__ import annotations
+
+import networkx as nx
+
+from .models import Network
+from .constants import (
+    COST_PER_KM_STANDARD_USD,
+    COST_PER_KM_EXPRESS_USD,
+    CARBON_KG_PER_KM_STANDARD,
+    CARBON_KG_PER_KM_EXPRESS,
+    CARBON_KG_PER_KM_GREEN,
+)
+
+FULFILLMENT_NODE_TYPES = ("central_dc", "regional_wh", "cross_dock", "supplier", "store")
+
+
+def build_graph(network: Network) -> nx.DiGraph:
+    graph = nx.DiGraph()
+    for node in network.nodes.values():
+        graph.add_node(node.node_id, node_type=node.node_type, capacity=node.daily_pick_capacity)
+    for link in network.links:
+        graph.add_edge(
+            link.origin_id,
+            link.dest_id,
+            **{f"distance_km_{link.ship_mode}": link.distance_km},
+        )
+    return graph
+
+
+def distance_km(graph: nx.DiGraph, origin_id: str, dest_id: str) -> float:
+    if origin_id == dest_id:
+        return 0.0
+    data = graph.get_edge_data(origin_id, dest_id, default=None)
+    if data is None:
+        return float("inf")
+    for key, value in data.items():
+        if key.startswith("distance_km_"):
+            return value
+    return float("inf")
+
+
+def transport_cost(distance: float, mode: str) -> float:
+    if distance == 0:
+        return 0.0
+    rate = COST_PER_KM_EXPRESS_USD if mode == "express" else COST_PER_KM_STANDARD_USD
+    return distance * rate
+
+
+def carbon_kg(distance: float, mode: str) -> float:
+    if distance == 0:
+        return 0.0
+    factor = {
+        "express": CARBON_KG_PER_KM_EXPRESS,
+        "green": CARBON_KG_PER_KM_GREEN,
+    }.get(mode, CARBON_KG_PER_KM_STANDARD)
+    return distance * factor
+
+
+def candidate_sources(network: Network, demand_node_id: str, exclude_demand_node: bool = False) -> list[str]:
+    """All nodes that can physically fulfill an order for a given demand node.
+
+    For online orders the demand node is the customer's assigned store
+    catchment, not a shelf the customer is standing in front of, so the
+    demand node itself is excluded from candidate sources — otherwise
+    every order would trivially "self-fulfill" from its own store with
+    zero transport cost, masking the multi-echelon allocation problem.
+    """
+    return [
+        n.node_id
+        for n in network.nodes.values()
+        if n.node_type in FULFILLMENT_NODE_TYPES and not (exclude_demand_node and n.node_id == demand_node_id)
+    ]

space-bundle/src/omnitower/omnitower/options.py

@@ -0,0 +1,84 @@
+"""Highlighted scenario: three delivery options per order.
+
+For a single order, computes the Fast / Economical / Green allocation
+independently (each against a snapshot of the current inventory and
+capacity pools) and reports the effect each option would have on future
+inventory and remaining warehouse/store picking capacity, so a planner can
+compare the three before committing to one.
+"""
+
+from __future__ import annotations
+
+import copy
+from dataclasses import dataclass
+
+from .models import Network, Order
+from .allocation import AllocationState, allocate_order, build_state
+from .network import build_graph
+from .constants import DELIVERY_OPTIONS
+
+
+@dataclass
+class OptionResult:
+    option: str
+    report: dict
+    total_cost_usd: float
+    total_lead_time_hours: float
+    total_carbon_kg: float
+    inventory_impact: list[dict]
+    capacity_impact: list[dict]
+
+
+def _totals(report: dict) -> tuple[float, float, float]:
+    cost = sum(r.get("transport_cost_usd", 0) + r.get("pick_cost_usd", 0) + r.get("pack_cost_usd", 0) for r in report["line_reports"])
+    lead = max((r.get("lead_time_hours", 0) for r in report["line_reports"]), default=0.0)
+    carbon = sum(r.get("carbon_kg", 0) for r in report["line_reports"])
+    if report["split_shipment"]:
+        cost += 3.20
+    return round(cost, 2), round(lead, 1), round(carbon, 2)
+
+
+def compare_delivery_options(network: Network, order: Order, base_state: AllocationState) -> list[OptionResult]:
+    graph = build_graph(network)
+    results = []
+    for option in DELIVERY_OPTIONS:
+        state_copy = AllocationState(inventory=dict(base_state.inventory), capacity=dict(base_state.capacity))
+        order_copy = copy.deepcopy(order)
+        report = allocate_order(network, order_copy, option, state_copy, graph)
+        cost, lead, carbon = _totals(report)
+
+        inv_impact = []
+        cap_impact = []
+        touched_nodes = set()
+        for line_report in report["line_reports"]:
+            node_id, sku_id = line_report["node_id"], line_report["sku_id"]
+            inv_impact.append(
+                {
+                    "node_id": node_id,
+                    "sku_id": sku_id,
+                    "qty_consumed": line_report["qty"],
+                    "remaining_after": round(state_copy.inventory.get((node_id, sku_id), 0), 1),
+                    "starting": round(base_state.inventory.get((node_id, sku_id), 0), 1),
+                }
+            )
+            touched_nodes.add(node_id)
+        for node_id in touched_nodes:
+            cap_impact.append(
+                {
+                    "node_id": node_id,
+                    "capacity_remaining_after": round(state_copy.capacity.get(node_id, 0), 1),
+                    "capacity_starting": round(base_state.capacity.get(node_id, 0), 1),
+                }
+            )
+        results.append(
+            OptionResult(
+                option=option,
+                report=report,
+                total_cost_usd=cost,
+                total_lead_time_hours=lead,
+                total_carbon_kg=carbon,
+                inventory_impact=inv_impact,
+                capacity_impact=cap_impact,
+            )
+        )
+    return results

space-bundle/src/omnitower/omnitower/pipeline.py

@@ -0,0 +1,70 @@
+"""End-to-end orchestration: generate -> allocate/admit -> improve -> return -> measure."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .models import Network
+from .generator import generate_network
+from .allocation import allocate_all, build_state
+from .admission import evaluate_all
+from .lns_solver import improve_allocation
+from .returns import generate_returns, summarize_returns
+from .metrics import compute_metrics, NetworkMetrics
+from .options import compare_delivery_options, OptionResult
+
+
+@dataclass
+class PipelineResult:
+    network: Network
+    reports: dict[str, dict]
+    admission_rejections: int
+    return_summary: dict
+    metrics: NetworkMetrics
+    cost_history: list[float]
+
+
+def run_scenario(
+    scenario_key: str,
+    seed: int = 42,
+    n_stores: int = 24,
+    n_skus: int = 60,
+    n_orders: int = 260,
+    delivery_option: str = "economical",
+    lns_iterations: int = 25,
+    use_admission_control: bool = True,
+) -> PipelineResult:
+    network = generate_network(scenario_key, seed=seed, n_stores=n_stores, n_skus=n_skus, n_orders=n_orders)
+
+    admission_rejections = 0
+    if use_admission_control:
+        preview_state = build_state(network)
+        decisions = evaluate_all(network, preview_state)
+        rejected_ids = {d.order_id for d in decisions if not d.admitted}
+        admission_rejections = len(rejected_ids)
+        network.orders = [o for o in network.orders if o.order_id not in rejected_ids]
+
+    state, reports, history = improve_allocation(network, option=delivery_option, iterations=lns_iterations, seed=seed)
+
+    fulfilled_orders = [o for o in network.orders if any(l.qty_fulfilled > 0 for l in o.lines)]
+    returns = generate_returns(network, fulfilled_orders, seed=seed + 1)
+    return_summary = summarize_returns(network, returns)
+
+    metrics = compute_metrics(network, reports, return_summary)
+
+    return PipelineResult(
+        network=network,
+        reports=reports,
+        admission_rejections=admission_rejections,
+        return_summary=return_summary,
+        metrics=metrics,
+        cost_history=history,
+    )
+
+
+def run_delivery_options_for_order(scenario_key: str, order_index: int = 0, seed: int = 42) -> tuple[Network, list[OptionResult]]:
+    network = generate_network(scenario_key, seed=seed)
+    state = build_state(network)
+    order = network.orders[order_index]
+    results = compare_delivery_options(network, order, state)
+    return network, results

space-bundle/src/omnitower/omnitower/returns.py

@@ -0,0 +1,77 @@
+"""Reverse logistics: return generation, routing, and resell decisioning.
+
+For each fulfilled order line, a return is sampled using the SKU's return
+probability. Each return gets a quality score (condition on arrival) and is
+then routed to the store (fast restock), the central DC, the repair
+center, the recycle center, or disposal — the "resell vs. scrap" decision
+required by the brief — using a rule-based disposition policy that mirrors
+what a reverse-logistics control tower would encode.
+"""
+
+from __future__ import annotations
+
+import random
+
+from .models import Network, Order, ReturnItem
+from .constants import RETURN_HANDLING_COST_USD, RETURN_RECOVERY_VALUE_FACTOR
+
+
+def _disposition(sku_resalable: bool, quality: float, category: str) -> str:
+    if not sku_resalable or quality < 0.25:
+        return "recycle" if category in ("electronics_accessory", "home_goods") else "dispose"
+    if quality >= 0.85:
+        return "restock_store"
+    if quality >= 0.60:
+        return "restock_dc"
+    if quality >= 0.35:
+        return "repair"
+    return "recycle"
+
+
+def generate_returns(network: Network, orders: list[Order], seed: int = 7) -> list[ReturnItem]:
+    rng = random.Random(seed)
+    returns: list[ReturnItem] = []
+    rid = 0
+    for order in orders:
+        for line in order.lines:
+            if line.qty_fulfilled <= 0 or line.sku_id not in network.skus:
+                continue
+            sku = network.skus[line.sku_id]
+            for _ in range(line.qty_fulfilled):
+                if rng.random() >= sku.return_rate:
+                    continue
+                quality = max(0.0, min(1.0, rng.gauss(0.68, 0.22)))
+                disposition = _disposition(sku.resalable, quality, sku.category)
+                returns.append(
+                    ReturnItem(
+                        return_id=f"RET{rid:05d}",
+                        order_id=order.order_id,
+                        sku_id=sku.sku_id,
+                        qty=1,
+                        quality_score=round(quality, 3),
+                        origin_node_id=order.demand_node_id,
+                        disposition=disposition,
+                        resold=disposition in ("restock_store", "restock_dc"),
+                    )
+                )
+                rid += 1
+    return returns
+
+
+def summarize_returns(network: Network, returns: list[ReturnItem]) -> dict:
+    total_handling_cost = 0.0
+    total_recovered_value = 0.0
+    by_disposition: dict[str, int] = {}
+    for r in returns:
+        total_handling_cost += RETURN_HANDLING_COST_USD.get(r.disposition, 3.0)
+        sku = network.skus.get(r.sku_id)
+        unit_price = sku.unit_price if sku else 0.0
+        total_recovered_value += unit_price * RETURN_RECOVERY_VALUE_FACTOR.get(r.disposition, 0.0)
+        by_disposition[r.disposition] = by_disposition.get(r.disposition, 0) + 1
+    return {
+        "n_returns": len(returns),
+        "total_handling_cost_usd": round(total_handling_cost, 2),
+        "total_recovered_value_usd": round(total_recovered_value, 2),
+        "resell_rate": round(sum(1 for r in returns if r.resold) / len(returns), 3) if returns else 0.0,
+        "by_disposition": by_disposition,
+    }

space-bundle/src/omnitower/omnitower/visualization.py

@@ -0,0 +1,47 @@
+"""Plotly chart builders for the interactive console."""
+
+from __future__ import annotations
+
+import plotly.graph_objects as go
+
+from .options import OptionResult
+
+
+def kpi_bar(metrics: dict) -> go.Figure:
+    keys = ["gross_margin_usd", "fill_rate", "on_time_sla_rate", "split_shipment_rate", "total_carbon_kg", "working_capital_usd"]
+    labels = ["Gross Margin ($)", "Fill Rate", "On-Time SLA Rate", "Split Shipment Rate", "Carbon (kg)", "Working Capital ($)"]
+    values = [metrics.get(k, 0) for k in keys]
+    fig = go.Figure(go.Bar(x=labels, y=values, marker_color="#2563eb"))
+    fig.update_layout(title="Network KPIs", template="plotly_white", height=420)
+    return fig
+
+
+def cost_history_plot(history: list[float]) -> go.Figure:
+    fig = go.Figure(go.Scatter(y=history, mode="lines+markers", line=dict(color="#16a34a")))
+    fig.update_layout(title="ALNS Improvement — Network Cost per Iteration", xaxis_title="Iteration", yaxis_title="Total Cost (USD)", template="plotly_white", height=380)
+    return fig
+
+
+def returns_disposition_pie(by_disposition: dict) -> go.Figure:
+    labels = list(by_disposition.keys())
+    values = list(by_disposition.values())
+    fig = go.Figure(go.Pie(labels=labels, values=values, hole=0.35))
+    fig.update_layout(title="Return Disposition Mix", template="plotly_white", height=380)
+    return fig
+
+
+def delivery_options_plot(results: list[OptionResult]) -> go.Figure:
+    fig = go.Figure()
+    fig.add_trace(go.Bar(name="Cost (USD)", x=[r.option for r in results], y=[r.total_cost_usd for r in results], marker_color="#2563eb"))
+    fig.add_trace(go.Bar(name="Lead Time (hours)", x=[r.option for r in results], y=[r.total_lead_time_hours for r in results], marker_color="#f59e0b"))
+    fig.add_trace(go.Bar(name="Carbon (kg)", x=[r.option for r in results], y=[r.total_carbon_kg for r in results], marker_color="#16a34a"))
+    fig.update_layout(barmode="group", title="Fast vs. Economical vs. Green — Same Order", template="plotly_white", height=420)
+    return fig
+
+
+def inventory_impact_table(results: list[OptionResult]) -> list[list]:
+    rows = []
+    for r in results:
+        for imp in r.inventory_impact:
+            rows.append([r.option, imp["node_id"], imp["sku_id"], imp["qty_consumed"], imp["starting"], imp["remaining_after"]])
+    return rows

space-bundle/src/omnitower/options.py

@@ -0,0 +1,84 @@
+"""Highlighted scenario: three delivery options per order.
+
+For a single order, computes the Fast / Economical / Green allocation
+independently (each against a snapshot of the current inventory and
+capacity pools) and reports the effect each option would have on future
+inventory and remaining warehouse/store picking capacity, so a planner can
+compare the three before committing to one.
+"""
+
+from __future__ import annotations
+
+import copy
+from dataclasses import dataclass
+
+from .models import Network, Order
+from .allocation import AllocationState, allocate_order, build_state
+from .network import build_graph
+from .constants import DELIVERY_OPTIONS
+
+
+@dataclass
+class OptionResult:
+    option: str
+    report: dict
+    total_cost_usd: float
+    total_lead_time_hours: float
+    total_carbon_kg: float
+    inventory_impact: list[dict]
+    capacity_impact: list[dict]
+
+
+def _totals(report: dict) -> tuple[float, float, float]:
+    cost = sum(r.get("transport_cost_usd", 0) + r.get("pick_cost_usd", 0) + r.get("pack_cost_usd", 0) for r in report["line_reports"])
+    lead = max((r.get("lead_time_hours", 0) for r in report["line_reports"]), default=0.0)
+    carbon = sum(r.get("carbon_kg", 0) for r in report["line_reports"])
+    if report["split_shipment"]:
+        cost += 3.20
+    return round(cost, 2), round(lead, 1), round(carbon, 2)
+
+
+def compare_delivery_options(network: Network, order: Order, base_state: AllocationState) -> list[OptionResult]:
+    graph = build_graph(network)
+    results = []
+    for option in DELIVERY_OPTIONS:
+        state_copy = AllocationState(inventory=dict(base_state.inventory), capacity=dict(base_state.capacity))
+        order_copy = copy.deepcopy(order)
+        report = allocate_order(network, order_copy, option, state_copy, graph)
+        cost, lead, carbon = _totals(report)
+
+        inv_impact = []
+        cap_impact = []
+        touched_nodes = set()
+        for line_report in report["line_reports"]:
+            node_id, sku_id = line_report["node_id"], line_report["sku_id"]
+            inv_impact.append(
+                {
+                    "node_id": node_id,
+                    "sku_id": sku_id,
+                    "qty_consumed": line_report["qty"],
+                    "remaining_after": round(state_copy.inventory.get((node_id, sku_id), 0), 1),
+                    "starting": round(base_state.inventory.get((node_id, sku_id), 0), 1),
+                }
+            )
+            touched_nodes.add(node_id)
+        for node_id in touched_nodes:
+            cap_impact.append(
+                {
+                    "node_id": node_id,
+                    "capacity_remaining_after": round(state_copy.capacity.get(node_id, 0), 1),
+                    "capacity_starting": round(base_state.capacity.get(node_id, 0), 1),
+                }
+            )
+        results.append(
+            OptionResult(
+                option=option,
+                report=report,
+                total_cost_usd=cost,
+                total_lead_time_hours=lead,
+                total_carbon_kg=carbon,
+                inventory_impact=inv_impact,
+                capacity_impact=cap_impact,
+            )
+        )
+    return results

space-bundle/src/omnitower/pipeline.py

@@ -0,0 +1,70 @@
+"""End-to-end orchestration: generate -> allocate/admit -> improve -> return -> measure."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .models import Network
+from .generator import generate_network
+from .allocation import allocate_all, build_state
+from .admission import evaluate_all
+from .lns_solver import improve_allocation
+from .returns import generate_returns, summarize_returns
+from .metrics import compute_metrics, NetworkMetrics
+from .options import compare_delivery_options, OptionResult
+
+
+@dataclass
+class PipelineResult:
+    network: Network
+    reports: dict[str, dict]
+    admission_rejections: int
+    return_summary: dict
+    metrics: NetworkMetrics
+    cost_history: list[float]
+
+
+def run_scenario(
+    scenario_key: str,
+    seed: int = 42,
+    n_stores: int = 24,
+    n_skus: int = 60,
+    n_orders: int = 260,
+    delivery_option: str = "economical",
+    lns_iterations: int = 25,
+    use_admission_control: bool = True,
+) -> PipelineResult:
+    network = generate_network(scenario_key, seed=seed, n_stores=n_stores, n_skus=n_skus, n_orders=n_orders)
+
+    admission_rejections = 0
+    if use_admission_control:
+        preview_state = build_state(network)
+        decisions = evaluate_all(network, preview_state)
+        rejected_ids = {d.order_id for d in decisions if not d.admitted}
+        admission_rejections = len(rejected_ids)
+        network.orders = [o for o in network.orders if o.order_id not in rejected_ids]
+
+    state, reports, history = improve_allocation(network, option=delivery_option, iterations=lns_iterations, seed=seed)
+
+    fulfilled_orders = [o for o in network.orders if any(l.qty_fulfilled > 0 for l in o.lines)]
+    returns = generate_returns(network, fulfilled_orders, seed=seed + 1)
+    return_summary = summarize_returns(network, returns)
+
+    metrics = compute_metrics(network, reports, return_summary)
+
+    return PipelineResult(
+        network=network,
+        reports=reports,
+        admission_rejections=admission_rejections,
+        return_summary=return_summary,
+        metrics=metrics,
+        cost_history=history,
+    )
+
+
+def run_delivery_options_for_order(scenario_key: str, order_index: int = 0, seed: int = 42) -> tuple[Network, list[OptionResult]]:
+    network = generate_network(scenario_key, seed=seed)
+    state = build_state(network)
+    order = network.orders[order_index]
+    results = compare_delivery_options(network, order, state)
+    return network, results

space-bundle/src/omnitower/returns.py

@@ -0,0 +1,77 @@
+"""Reverse logistics: return generation, routing, and resell decisioning.
+
+For each fulfilled order line, a return is sampled using the SKU's return
+probability. Each return gets a quality score (condition on arrival) and is
+then routed to the store (fast restock), the central DC, the repair
+center, the recycle center, or disposal — the "resell vs. scrap" decision
+required by the brief — using a rule-based disposition policy that mirrors
+what a reverse-logistics control tower would encode.
+"""
+
+from __future__ import annotations
+
+import random
+
+from .models import Network, Order, ReturnItem
+from .constants import RETURN_HANDLING_COST_USD, RETURN_RECOVERY_VALUE_FACTOR
+
+
+def _disposition(sku_resalable: bool, quality: float, category: str) -> str:
+    if not sku_resalable or quality < 0.25:
+        return "recycle" if category in ("electronics_accessory", "home_goods") else "dispose"
+    if quality >= 0.85:
+        return "restock_store"
+    if quality >= 0.60:
+        return "restock_dc"
+    if quality >= 0.35:
+        return "repair"
+    return "recycle"
+
+
+def generate_returns(network: Network, orders: list[Order], seed: int = 7) -> list[ReturnItem]:
+    rng = random.Random(seed)
+    returns: list[ReturnItem] = []
+    rid = 0
+    for order in orders:
+        for line in order.lines:
+            if line.qty_fulfilled <= 0 or line.sku_id not in network.skus:
+                continue
+            sku = network.skus[line.sku_id]
+            for _ in range(line.qty_fulfilled):
+                if rng.random() >= sku.return_rate:
+                    continue
+                quality = max(0.0, min(1.0, rng.gauss(0.68, 0.22)))
+                disposition = _disposition(sku.resalable, quality, sku.category)
+                returns.append(
+                    ReturnItem(
+                        return_id=f"RET{rid:05d}",
+                        order_id=order.order_id,
+                        sku_id=sku.sku_id,
+                        qty=1,
+                        quality_score=round(quality, 3),
+                        origin_node_id=order.demand_node_id,
+                        disposition=disposition,
+                        resold=disposition in ("restock_store", "restock_dc"),
+                    )
+                )
+                rid += 1
+    return returns
+
+
+def summarize_returns(network: Network, returns: list[ReturnItem]) -> dict:
+    total_handling_cost = 0.0
+    total_recovered_value = 0.0
+    by_disposition: dict[str, int] = {}
+    for r in returns:
+        total_handling_cost += RETURN_HANDLING_COST_USD.get(r.disposition, 3.0)
+        sku = network.skus.get(r.sku_id)
+        unit_price = sku.unit_price if sku else 0.0
+        total_recovered_value += unit_price * RETURN_RECOVERY_VALUE_FACTOR.get(r.disposition, 0.0)
+        by_disposition[r.disposition] = by_disposition.get(r.disposition, 0) + 1
+    return {
+        "n_returns": len(returns),
+        "total_handling_cost_usd": round(total_handling_cost, 2),
+        "total_recovered_value_usd": round(total_recovered_value, 2),
+        "resell_rate": round(sum(1 for r in returns if r.resold) / len(returns), 3) if returns else 0.0,
+        "by_disposition": by_disposition,
+    }

space-bundle/src/omnitower/visualization.py

@@ -0,0 +1,47 @@
+"""Plotly chart builders for the interactive console."""
+
+from __future__ import annotations
+
+import plotly.graph_objects as go
+
+from .options import OptionResult
+
+
+def kpi_bar(metrics: dict) -> go.Figure:
+    keys = ["gross_margin_usd", "fill_rate", "on_time_sla_rate", "split_shipment_rate", "total_carbon_kg", "working_capital_usd"]
+    labels = ["Gross Margin ($)", "Fill Rate", "On-Time SLA Rate", "Split Shipment Rate", "Carbon (kg)", "Working Capital ($)"]
+    values = [metrics.get(k, 0) for k in keys]
+    fig = go.Figure(go.Bar(x=labels, y=values, marker_color="#2563eb"))
+    fig.update_layout(title="Network KPIs", template="plotly_white", height=420)
+    return fig
+
+
+def cost_history_plot(history: list[float]) -> go.Figure:
+    fig = go.Figure(go.Scatter(y=history, mode="lines+markers", line=dict(color="#16a34a")))
+    fig.update_layout(title="ALNS Improvement — Network Cost per Iteration", xaxis_title="Iteration", yaxis_title="Total Cost (USD)", template="plotly_white", height=380)
+    return fig
+
+
+def returns_disposition_pie(by_disposition: dict) -> go.Figure:
+    labels = list(by_disposition.keys())
+    values = list(by_disposition.values())
+    fig = go.Figure(go.Pie(labels=labels, values=values, hole=0.35))
+    fig.update_layout(title="Return Disposition Mix", template="plotly_white", height=380)
+    return fig
+
+
+def delivery_options_plot(results: list[OptionResult]) -> go.Figure:
+    fig = go.Figure()
+    fig.add_trace(go.Bar(name="Cost (USD)", x=[r.option for r in results], y=[r.total_cost_usd for r in results], marker_color="#2563eb"))
+    fig.add_trace(go.Bar(name="Lead Time (hours)", x=[r.option for r in results], y=[r.total_lead_time_hours for r in results], marker_color="#f59e0b"))
+    fig.add_trace(go.Bar(name="Carbon (kg)", x=[r.option for r in results], y=[r.total_carbon_kg for r in results], marker_color="#16a34a"))
+    fig.update_layout(barmode="group", title="Fast vs. Economical vs. Green — Same Order", template="plotly_white", height=420)
+    return fig
+
+
+def inventory_impact_table(results: list[OptionResult]) -> list[list]:
+    rows = []
+    for r in results:
+        for imp in r.inventory_impact:
+            rows.append([r.option, imp["node_id"], imp["sku_id"], imp["qty_consumed"], imp["starting"], imp["remaining_after"]])
+    return rows