From 8fd99ee6fa4f817d7220607a71a93f2e6fddfcf0 Mon Sep 17 00:00:00 2001
From: Richard <asmorous@googlemail.com>
Date: Sun, 6 Sep 2026 12:41:06 +0200
Subject: [PATCH] Positionsverwaltung: Herkunft sichtbar, Zuordnung aenderbar,
 Sperren einstellbar

Erster Teil von #485. Der PositionManager im Core beantwortet drei Fragen, die
sich beim Debuggen sofort stellen: Wem gehoert eine Position, was sagt der Broker
dazu, und was ist gesperrt.

Drei Zugaenge auf denselben Dienst - das Fenster der Shell, --positions und
--reassign im kopflosen Betrieb, GET /api/positions. Der Testbetrieb laeuft als
systemd-Dienst; ein Werkzeug, das nur in der Oberflaeche existiert, fehlt genau
dann, wenn man es braucht.

Entscheidungen, die im Code begruendet stehen:

- BrokerQuantity ist nullable und heisst "nicht bekannt", nicht "null Stueck".
  Ohne Verbindung sieht ein leergeraeumtes Konto genauso aus wie eine Stoerung;
  aus dem einen darf nicht auf das andere geschlossen werden.
- Umbuchen aendert die Zuordnung, nie die Menge. Eine Umbuchung, die eine
  Stueckzahl bewegt, waere ein Handel ohne Order und stuende in keiner Historie.
- Gegen eine entgegengesetzte Position wird abgelehnt: Das waere eine
  Glattstellung und gehoert ueber eine Order gemacht, mit Preis und Historie.
- Das Quellbuch ist Pflicht - Schutz gegen die falsche Zeile -, ebenso eine
  Begruendung, sonst ist der Eingriff spaeter nicht mehr erklaerbar.
- Das Cap des Zielbuchs sperrt NICHT. Die Position existiert bereits; sie zu
  benennen erzeugt kein neues Risiko. Wuerde die Grenze das verhindern, bliebe
  jede zu grosse Position fuer immer in UNASSIGNED.
- Der REST-Endpunkt ist lesend. Der Listener kennt keine Anmeldung; ein
  schreibender Zugriff waere ein Eingriff in die Buecher, den niemand belegen kann.

Beim ersten Testlauf gefunden: (Module, ContractKey) ist der Primaerschluessel
von core_position, das Buch laesst sich in der Zeile nicht ueberschreiben.
Umgebucht wird deshalb durch Loeschen und Neuanlegen.

471 Tests gruen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 src/IBKRTrader.App/Shell/CoreViews.cs         |   7 +
 src/IBKRTrader.App/ViewModels/Rows.cs         |  13 +
 .../Views/PositionsWindow.axaml               |  78 +++++
 .../Views/PositionsWindow.axaml.cs            | 217 ++++++++++++
 .../Positions/PositionManager.cs              | 309 ++++++++++++++++++
 .../Workers/BuiltIn/WebApiService.cs          |  63 +++-
 src/IBKRTrader.Daemon/PositionTool.cs         | 164 ++++++++++
 src/IBKRTrader.Daemon/Program.cs              |  17 +
 src/IBKRTrader.Hosting/AppHostBuilder.cs      |   1 +
 .../Positions/PositionManagerTests.cs         | 251 ++++++++++++++
 10 files changed, 1116 insertions(+), 4 deletions(-)
 create mode 100644 src/IBKRTrader.App/Views/PositionsWindow.axaml
 create mode 100644 src/IBKRTrader.App/Views/PositionsWindow.axaml.cs
 create mode 100644 src/IBKRTrader.Core/Positions/PositionManager.cs
 create mode 100644 src/IBKRTrader.Daemon/PositionTool.cs
 create mode 100644 tests/IBKRTrader.Tests/Positions/PositionManagerTests.cs

diff --git a/src/IBKRTrader.App/Shell/CoreViews.cs b/src/IBKRTrader.App/Shell/CoreViews.cs
index 049ecbf..ef9ad9e 100644
--- a/src/IBKRTrader.App/Shell/CoreViews.cs
+++ b/src/IBKRTrader.App/Shell/CoreViews.cs
@@ -32,6 +32,13 @@ public static class CoreViews
             CreateView = () => new WorkersWindow(host, sp.GetRequiredService<WorkerEngine>())
         });
 
+        host.RegisterView(new ModuleView
+        {
+            Id = "core.positions", Title = "Positionen", Group = "Core", Order = 15,
+            CreateView = () => new PositionsWindow(
+                host, sp.GetRequiredService<Core.Positions.PositionManager>())
+        });
+
         host.RegisterView(new ModuleView
         {
             Id = "core.logs", Title = "Logs", Group = "Core", Order = 20,
diff --git a/src/IBKRTrader.App/ViewModels/Rows.cs b/src/IBKRTrader.App/ViewModels/Rows.cs
index 5035c9f..c141da2 100644
--- a/src/IBKRTrader.App/ViewModels/Rows.cs
+++ b/src/IBKRTrader.App/ViewModels/Rows.cs
@@ -22,6 +22,19 @@ public sealed record LogRow(string Text, IBrush Color);
 /// <summary>Eine offene Position im Modul-Fenster.</summary>
 public sealed record PositionRow(string Symbol, int Quantity, decimal AvgPrice, decimal Notional);
 
+/// <summary>
+/// Eine Zeile der Positionsverwaltung (#485). Zahlen kommen als fertiger Text: Die Formatierung
+/// gehoert an eine Stelle, und „Broker“ muss zwischen „null Stück“ und „keine Auskunft“
+/// unterscheiden koennen - ein Zahlentyp kann das nicht.
+/// </summary>
+public sealed record ManagedPositionRow(
+    string Book, string Origin, string Instrument, string Quantity, string AvgPrice,
+    string Bound, string Broker, string Restrictions);
+
+/// <summary>Bestand, den der Broker fuehrt und den kein Buch beansprucht.</summary>
+public sealed record UnknownPositionRow(
+    string Symbol, string SecType, string Currency, string Quantity, string AvgCost, string Note);
+
 /// <summary>Eine Zeile der Supervisor-Berichtsliste. Tokens als fertiger Text (Prompt / Completion).</summary>
 public sealed record SupervisorReportRow(
     DateTime CreatedAt, string Profile, string Model, string Question, int ToolCallCount, string Tokens);
diff --git a/src/IBKRTrader.App/Views/PositionsWindow.axaml b/src/IBKRTrader.App/Views/PositionsWindow.axaml
new file mode 100644
index 0000000..2282859
--- /dev/null
+++ b/src/IBKRTrader.App/Views/PositionsWindow.axaml
@@ -0,0 +1,78 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:dg="clr-namespace:Avalonia.Controls;assembly=Avalonia.Controls.DataGrid"
+        xmlns:vm="clr-namespace:IBKRTrader.App.ViewModels"
+        x:Class="IBKRTrader.App.Views.PositionsWindow"
+        Title="Positionen"
+        Width="1280" Height="720"
+        MinWidth="900" MinHeight="480"
+        WindowStartupLocation="CenterScreen">
+
+    <DockPanel>
+        <Menu x:Name="WindowMenuBar" DockPanel.Dock="Top" />
+
+        <Border Classes="toolbar" DockPanel.Dock="Top">
+            <StackPanel Orientation="Horizontal" Spacing="8">
+                <Button x:Name="RefreshButton" Content="Aktualisieren"
+                        ToolTip.Tip="Liest Buchführung und Bestand des Brokers neu ein." />
+
+                <CheckBox x:Name="IncludeBrokerCheck" Content="Broker abfragen" IsChecked="True"
+                          ToolTip.Tip="Ohne Häkchen wird nur die eigene Buchführung gezeigt – das geht sofort." />
+
+                <Rectangle Width="1" Fill="#40808080" Margin="6,2" />
+
+                <TextBlock Text="Sperre:" VerticalAlignment="Center" />
+                <ComboBox x:Name="LockBox" Width="200"
+                          ToolTip.Tip="Gilt für die ausgewählte Position." />
+                <Button x:Name="ApplyLockButton" Content="Sperre setzen" />
+
+                <Rectangle Width="1" Fill="#40808080" Margin="6,2" />
+
+                <TextBlock Text="Umbuchen nach:" VerticalAlignment="Center" />
+                <ComboBox x:Name="TargetBookBox" Width="160" />
+                <TextBox  x:Name="ReasonBox" Width="240" Watermark="Grund (Pflicht)" />
+                <Button   x:Name="ReassignButton" Content="Umbuchen" />
+            </StackPanel>
+        </Border>
+
+        <Border Classes="statusbar" DockPanel.Dock="Bottom">
+            <TextBlock x:Name="StatusText" TextWrapping="Wrap" />
+        </Border>
+
+        <Grid RowDefinitions="*,Auto,140">
+            <dg:DataGrid x:Name="PositionsGrid" Grid.Row="0"
+                         AutoGenerateColumns="False" SelectionMode="Single" IsReadOnly="True"
+                         x:DataType="vm:ManagedPositionRow">
+                <dg:DataGrid.Columns>
+                    <dg:DataGridTextColumn Header="Buch"       Binding="{Binding Book}"       Width="100" />
+                    <dg:DataGridTextColumn Header="Herkunft"   Binding="{Binding Origin}"     Width="150" />
+                    <dg:DataGridTextColumn Header="Instrument" Binding="{Binding Instrument}" Width="220" />
+                    <dg:DataGridTextColumn Header="Menge"      Binding="{Binding Quantity}"   Width="90" />
+                    <dg:DataGridTextColumn Header="Einstand"   Binding="{Binding AvgPrice}"   Width="100" />
+                    <dg:DataGridTextColumn Header="Gebunden"   Binding="{Binding Bound}"      Width="120" />
+                    <dg:DataGridTextColumn Header="Broker"     Binding="{Binding Broker}"     Width="90" />
+                    <dg:DataGridTextColumn Header="Sperren"    Binding="{Binding Restrictions}" Width="*" />
+                </dg:DataGrid.Columns>
+            </dg:DataGrid>
+
+            <TextBlock Grid.Row="1" x:Name="UnknownHeader" Margin="8,10,8,4" FontWeight="SemiBold"
+                       Text="Beim Broker, in keinem Buch" IsVisible="False" />
+
+            <!-- Bestand, den der Broker führt und den wir niemandem zuordnen können. Er steht
+                 bewusst getrennt und nicht zwischen den eigenen Zeilen: Es ist eine andere Art von
+                 Aussage – nicht „gehört jemandem", sondern „gehört niemandem, den wir kennen". -->
+            <dg:DataGrid x:Name="UnknownGrid" Grid.Row="2"
+                         AutoGenerateColumns="False" SelectionMode="Single" IsReadOnly="True"
+                         IsVisible="False" x:DataType="vm:UnknownPositionRow">
+                <dg:DataGrid.Columns>
+                    <dg:DataGridTextColumn Header="Symbol"   Binding="{Binding Symbol}"   Width="120" />
+                    <dg:DataGridTextColumn Header="Typ"      Binding="{Binding SecType}"  Width="80" />
+                    <dg:DataGridTextColumn Header="Währung"  Binding="{Binding Currency}" Width="90" />
+                    <dg:DataGridTextColumn Header="Menge"    Binding="{Binding Quantity}" Width="100" />
+                    <dg:DataGridTextColumn Header="Einstand" Binding="{Binding AvgCost}"  Width="110" />
+                    <dg:DataGridTextColumn Header="Hinweis"  Binding="{Binding Note}"     Width="*" />
+                </dg:DataGrid.Columns>
+            </dg:DataGrid>
+        </Grid>
+    </DockPanel>
+</Window>
diff --git a/src/IBKRTrader.App/Views/PositionsWindow.axaml.cs b/src/IBKRTrader.App/Views/PositionsWindow.axaml.cs
new file mode 100644
index 0000000..59bb3eb
--- /dev/null
+++ b/src/IBKRTrader.App/Views/PositionsWindow.axaml.cs
@@ -0,0 +1,217 @@
+using System.Globalization;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using IBKRTrader.App.Shell;
+using IBKRTrader.App.ViewModels;
+using IBKRTrader.Core.Capital;
+using IBKRTrader.Core.Modularity;
+using IBKRTrader.Core.Positions;
+using IBKRTrader.Core.Time;
+using IBKRTrader.Core.Trading;
+
+namespace IBKRTrader.App.Views;
+
+/// <summary>
+/// Core-Ansicht: die Positionsverwaltung (#485). Zeigt, wem eine Position gehört, was der Broker
+/// dazu sagt und welche Sperren gelten – und erlaubt beides zu ändern.
+///
+/// <para><b>Die Logik liegt nicht hier.</b> Dieses Fenster ruft <see cref="PositionManager"/> auf
+/// und formatiert dessen Antwort. Eine Umbuchung, die nur über die Oberfläche ginge, wäre auf einer
+/// kopflosen Instanz nicht durchführbar – dort gibt es dieselben Aufrufe über
+/// <c>--positions</c> und <c>--reassign</c>.</para>
+///
+/// <para>Datenbank- und Broker-Zugriffe laufen NUR auf Anzeige und Nutzerinteraktion, nie im
+/// Konstruktor: <c>--smoke-ui</c> prüft die Fenster-Konstruktion ohne Datenbank.</para>
+/// </summary>
+public partial class PositionsWindow : Window
+{
+    private readonly PositionManager _manager;
+
+    /// <summary>Die Ziele einer Umbuchung. Reservierte Bücher, plus alles, was Module halten.</summary>
+    private static readonly string[] ReassignTargets =
+        [BookId.Manual.Value, BookId.Unassigned.Value, BookId.House.Value, BookId.Diagnostics.Value];
+
+    private static readonly (string Label, PositionLock Level)[] LockLevels =
+    [
+        ("frei – keine Sperre",              PositionLock.Free),
+        ("nur abbauen (kein Zukauf)",        PositionLock.CloseOnly),
+        ("nur aufbauen (kein Verkauf)",      PositionLock.OpenOnly),
+        ("ganz gesperrt (auch Schließen!)",  PositionLock.Locked)
+    ];
+
+    public PositionsWindow(IModuleUiHost uiHost, PositionManager manager)
+    {
+        _manager = manager;
+
+        InitializeComponent();
+        WindowMenu.Wire(this.FindControl<Menu>("WindowMenuBar")!, uiHost, "core.positions");
+
+        this.FindControl<ComboBox>("LockBox")!.ItemsSource       = LockLevels.Select(l => l.Label).ToList();
+        this.FindControl<ComboBox>("LockBox")!.SelectedIndex     = 0;
+        this.FindControl<ComboBox>("TargetBookBox")!.ItemsSource = ReassignTargets;
+
+        this.FindControl<Button>("RefreshButton")!.Click    += async (_, _) => await RefreshAsync();
+        this.FindControl<Button>("ApplyLockButton")!.Click  += async (_, _) => await ApplyLockAsync();
+        this.FindControl<Button>("ReassignButton")!.Click   += async (_, _) => await ReassignAsync();
+
+        Opened += async (_, _) => await RefreshAsync();
+    }
+
+    private void InitializeComponent() => AvaloniaXamlLoader.Load(this);
+
+    // ─── Anzeigen ────────────────────────────────────────────────────────────────
+
+    /// <summary>Die zuletzt geladene Fassung – die Grid-Zeilen sind Text und taugen nicht als Quelle.</summary>
+    private IReadOnlyList<ManagedPosition> _loaded = [];
+
+    private async Task RefreshAsync()
+    {
+        var inv           = CultureInfo.InvariantCulture;
+        var includeBroker = this.FindControl<CheckBox>("IncludeBrokerCheck")!.IsChecked == true;
+
+        try
+        {
+            SetStatus(includeBroker ? "Lade Positionen und Bestand des Brokers …" : "Lade Positionen …");
+
+            var overview = await _manager.GetOverviewAsync(includeBroker);
+            _loaded = overview.Positions;
+
+            this.FindControl<DataGrid>("PositionsGrid")!.ItemsSource = overview.Positions
+                .Select(p => new ManagedPositionRow(
+                    Book:         p.Book.Value,
+                    Origin:       p.Origin,
+                    Instrument:   p.Instrument.Key,
+                    Quantity:     p.Quantity.ToString("N0", inv),
+                    AvgPrice:     p.AvgPrice.ToString("N2", inv),
+                    Bound:        p.BoundCapital.ToString("N0", inv) + " " + p.Instrument.Currency,
+                    // Der Gedankenstrich ist nicht Kosmetik: "0" hieße, der Broker hält nichts.
+                    // Ohne Verbindung wissen wir es schlicht nicht.
+                    Broker:       p.BrokerQuantity is { } b ? b.ToString("N0", inv) : "–",
+                    Restrictions: Describe(p)))
+                .ToList();
+
+            var unknownGrid   = this.FindControl<DataGrid>("UnknownGrid")!;
+            var unknownHeader = this.FindControl<TextBlock>("UnknownHeader")!;
+
+            unknownGrid.ItemsSource = overview.UnknownToUs
+                .Select(p => new UnknownPositionRow(
+                    p.Symbol, p.SecType, p.Currency,
+                    p.Quantity.ToString("N0", inv), p.AvgCost.ToString("N2", inv),
+                    "Der Abgleich schreibt sie nach UNASSIGNED; von dort zuordnen."))
+                .ToList();
+
+            unknownGrid.IsVisible   = overview.UnknownToUs.Count > 0;
+            unknownHeader.IsVisible = overview.UnknownToUs.Count > 0;
+
+            var diverging = overview.Positions.Count(p => p.Diverges);
+
+            SetStatus(
+                $"{overview.Positions.Count} Position(en)" +
+                (diverging > 0 ? $", {diverging} weichen vom Broker ab" : "") +
+                (overview.UnknownToUs.Count > 0 ? $", {overview.UnknownToUs.Count} ohne Buch" : "") +
+                (includeBroker && !overview.BrokerReachable
+                    ? ". Der Broker hat nichts gemeldet – die Spalte bleibt leer, weil ein leeres " +
+                      "Konto und eine gestörte Verbindung von hier aus gleich aussehen."
+                    : "."));
+        }
+        catch (Exception ex)
+        {
+            SetStatus($"Laden fehlgeschlagen: {ex.Message}");
+        }
+    }
+
+    private static string Describe(ManagedPosition p)
+    {
+        var parts = new List<string>(3);
+
+        if (p.Lock != PositionLock.Free)
+            parts.Add(p.Lock switch
+            {
+                PositionLock.CloseOnly => "nur abbauen",
+                PositionLock.OpenOnly  => "nur aufbauen",
+                PositionLock.Locked    => "GESPERRT (auch Schließen)",
+                _                      => p.Lock.ToString()
+            });
+
+        if (p.Rule.Blocked) parts.Add("Instrument gesperrt");
+        if (p.Rule.MaxQuantity is { } max)
+            parts.Add(FormattableString.Invariant($"höchstens {max} Stück"));
+
+        return string.Join(", ", parts);
+    }
+
+    // ─── Eingreifen ──────────────────────────────────────────────────────────────
+
+    private ManagedPosition? Selected()
+    {
+        var index = this.FindControl<DataGrid>("PositionsGrid")!.SelectedIndex;
+        return index >= 0 && index < _loaded.Count ? _loaded[index] : null;
+    }
+
+    private async Task ApplyLockAsync()
+    {
+        if (Selected() is not { } position)
+        {
+            SetStatus("Keine Position ausgewählt.");
+            return;
+        }
+
+        var index = this.FindControl<ComboBox>("LockBox")!.SelectedIndex;
+        if (index < 0 || index >= LockLevels.Length) return;
+
+        var (label, level) = LockLevels[index];
+
+        try
+        {
+            await _manager.SetLockAsync(position.Book, position.Instrument, level, "über die Positionsansicht gesetzt");
+
+            SetStatus($"{position.Instrument.Key} in {position.Book.Value}: {label}." +
+                      (level == PositionLock.Locked
+                          ? " Achtung: Diese Stufe verhindert auch, dass ein Modul die Position schließt."
+                          : ""));
+
+            await RefreshAsync();
+        }
+        catch (Exception ex)
+        {
+            SetStatus($"Sperre nicht gesetzt: {ex.Message}");
+        }
+    }
+
+    private async Task ReassignAsync()
+    {
+        if (Selected() is not { } position)
+        {
+            SetStatus("Keine Position ausgewählt.");
+            return;
+        }
+
+        if (this.FindControl<ComboBox>("TargetBookBox")!.SelectedItem is not string targetName)
+        {
+            SetStatus("Kein Zielbuch gewählt.");
+            return;
+        }
+
+        var reason = this.FindControl<TextBox>("ReasonBox")!.Text ?? "";
+
+        try
+        {
+            var result = await _manager.ReassignAsync(
+                position.Instrument, position.Book, BookId.Parse(targetName), reason);
+
+            SetStatus(result.Message);
+            if (result.Success)
+            {
+                this.FindControl<TextBox>("ReasonBox")!.Text = "";
+                await RefreshAsync();
+            }
+        }
+        catch (Exception ex)
+        {
+            SetStatus($"Umbuchung fehlgeschlagen: {ex.Message}");
+        }
+    }
+
+    private void SetStatus(string text) =>
+        this.FindControl<TextBlock>("StatusText")!.Text = $"{text}  |  {AppTimeZone.Now:HH:mm:ss}";
+}
diff --git a/src/IBKRTrader.Core/Positions/PositionManager.cs b/src/IBKRTrader.Core/Positions/PositionManager.cs
new file mode 100644
index 0000000..2e1892c
--- /dev/null
+++ b/src/IBKRTrader.Core/Positions/PositionManager.cs
@@ -0,0 +1,309 @@
+using System.Globalization;
+using IBKRTrader.Core.Capital;
+using IBKRTrader.Core.Logging;
+using IBKRTrader.Core.Persistence.Ef;
+using IBKRTrader.Core.Persistence.Entities;
+using IBKRTrader.Core.Trading;
+using Microsoft.EntityFrameworkCore;
+
+namespace IBKRTrader.Core.Positions;
+
+/// <summary>
+/// Eine Position, wie die Verwaltung sie zeigt: eigener Bestand, Herkunft, Sperren – und daneben,
+/// was der Broker führt.
+/// </summary>
+/// <param name="Book">Buch, dem sie zugeordnet ist. MANUAL und UNASSIGNED sind gleichwertige Bücher.</param>
+/// <param name="Instrument">Betroffenes Instrument.</param>
+/// <param name="Quantity">Eigener Bestand, vorzeichenbehaftet.</param>
+/// <param name="AvgPrice">Durchschnittlicher Einstand.</param>
+/// <param name="BoundCapital">Gebundenes Kapital – bei geschriebenen Puts die Verpflichtung, nicht die Prämie.</param>
+/// <param name="Lock">Sperrstufe des Betreibers für dieses Buch und Instrument.</param>
+/// <param name="Rule">Regel des Instruments (Handelsverbot, Stückgrenze) – gilt über alle Bücher.</param>
+/// <param name="BrokerQuantity">
+/// Was der Broker führt. <c>null</c> heißt <b>nicht bekannt</b> und ausdrücklich nicht „null Stück":
+/// Ohne Verbindung ist jede Aussage über Abweichungen wertlos.
+///
+/// <para>Dezimal und nicht ganzzahlig, weil der Broker es so meldet – Bruchstücke gibt es. Sie hier
+/// zu runden hieße, eine Abweichung wegzurechnen, die es gibt.</para>
+/// </param>
+public sealed record ManagedPosition(
+    BookId         Book,
+    InstrumentRef  Instrument,
+    int            Quantity,
+    decimal        AvgPrice,
+    decimal        BoundCapital,
+    PositionLock   Lock,
+    InstrumentRule Rule,
+    decimal?       BrokerQuantity)
+{
+    /// <summary>Herkunft in einem Wort – das, wonach beim Aufräumen zuerst gefragt wird.</summary>
+    public string Origin => Book.Kind switch
+    {
+        BookKind.Manual     => "Von Hand",
+        BookKind.Unassigned => "Herkunft unbekannt",
+        BookKind.House      => "Haus",
+        _                   => Book.Value
+    };
+
+    /// <summary>
+    /// Weicht unser Bestand von dem des Brokers ab? <c>false</c>, solange der Broker nichts gesagt
+    /// hat – eine Abweichung, die nur aus fehlenden Daten besteht, ist keine.
+    /// </summary>
+    public bool Diverges => BrokerQuantity is { } broker && broker != Quantity;
+
+    public bool IsRestricted => Lock != PositionLock.Free || Rule.IsRestrictive;
+}
+
+/// <summary>
+/// Was der Überblick über alle Bücher hergibt.
+/// </summary>
+/// <param name="Positions">Alle offenen Positionen, über sämtliche Bücher.</param>
+/// <param name="BrokerReachable">
+/// Stand die Verbindung zum Broker? Ist sie es nicht, sind sämtliche <c>BrokerQuantity</c> leer und
+/// aus dem Vergleich darf nichts gefolgert werden.
+/// </param>
+/// <param name="UnknownToUs">
+/// Positionen, die der Broker führt und wir in keinem Buch haben. Sie sind der eigentliche Grund
+/// für diese Ansicht: Bestand, den niemand angelegt zu haben behauptet.
+/// </param>
+public sealed record PositionOverview(
+    IReadOnlyList<ManagedPosition> Positions,
+    bool                           BrokerReachable,
+    IReadOnlyList<BrokerPosition>  UnknownToUs);
+
+/// <summary>
+/// Die Positionsverwaltung (#485): sehen, wem eine Position gehört, sie umhängen und sie
+/// stufenweise sperren.
+///
+/// <para><b>Warum das ein eigener Dienst ist und nicht Teil der Oberfläche.</b> Alle drei
+/// Handlungen sind Eingriffe des Betreibers in die Buchführung, nicht Anzeige. Sie brauchen
+/// dieselbe Sorgfalt wie ein Handelspfad: eine Umbuchung, die eine Menge verändert, wäre ein
+/// stiller Handel; eine Sperre, die nur in einem Fenster steht, wäre keine. Deshalb liegen sie
+/// hier – abrufbar aus der Shell, aus der REST-Schnittstelle und aus dem Daemon, mit identischem
+/// Verhalten.</para>
+///
+/// <para><b>Was diese Klasse nicht tut:</b> Sie handelt nicht. Kein Aufruf hier löst eine Order
+/// aus, weder zum Glattstellen noch zum Ausgleichen einer Abweichung. Was mit einer fremden
+/// Position geschieht, entscheidet ein Mensch.</para>
+/// </summary>
+public sealed class PositionManager
+{
+    private const string LogModule = "Positionen";
+
+    private readonly IDbContextFactory<CoreDbContext> _dbf;
+    private readonly IPortfolioService                _portfolio;
+    private readonly IBrokerPortfolioReader           _broker;
+    private readonly TradingRuleService               _rules;
+    private readonly LoggingService                   _logger;
+
+    public PositionManager(
+        IDbContextFactory<CoreDbContext> dbf,
+        IPortfolioService                portfolio,
+        IBrokerPortfolioReader           broker,
+        TradingRuleService               rules,
+        LoggingService                   logger)
+    {
+        _dbf       = dbf;
+        _portfolio = portfolio;
+        _broker    = broker;
+        _rules     = rules;
+        _logger    = logger;
+    }
+
+    // ─── Sehen ───────────────────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Der Überblick über alle Bücher, angereichert um Sperren und den Bestand des Brokers.
+    /// </summary>
+    /// <param name="includeBroker">
+    /// Den Broker mit abfragen. <c>false</c> für eine reine Anzeige der eigenen Buchführung – die
+    /// Abfrage kostet eine Verbindung und mehrere Sekunden.
+    /// </param>
+    public async Task<PositionOverview> GetOverviewAsync(
+        bool includeBroker = true, CancellationToken ct = default)
+    {
+        var own = await _portfolio.GetAllPositionsAsync(ct).ConfigureAwait(false);
+
+        IReadOnlyList<BrokerPosition> brokerPositions = Array.Empty<BrokerPosition>();
+        var reachable = false;
+
+        if (includeBroker)
+        {
+            brokerPositions = await _broker.GetPositionsAsync(ct).ConfigureAwait(false);
+
+            // Eine leere Antwort ist zweideutig: keine Positionen oder keine Verbindung. Solange wir
+            // das nicht auseinanderhalten koennen, gilt sie NICHT als Feststellung - sonst sieht ein
+            // Verbindungsabbruch aus wie ein leergeraeumtes Konto.
+            reachable = brokerPositions.Count > 0;
+        }
+
+        var byKey = brokerPositions
+            .Where(p => p.Instrument is not null)
+            .GroupBy(p => p.Instrument!.Value.Key, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(g => g.Key, g => g.Sum(p => p.Quantity), StringComparer.OrdinalIgnoreCase);
+
+        var managed = new List<ManagedPosition>(own.Count);
+        foreach (var position in own.Where(p => p.Quantity != 0))
+        {
+            var book = BookId.Parse(position.Module);
+
+            // Verbindung steht und der Broker kennt das Papier nicht: Das ist eine Aussage – nämlich
+            // null Stück – und keine fehlende Angabe. Ohne Verbindung bleibt es leer, weil dann
+            // jeder Vergleich wertlos wäre.
+            decimal? brokerQuantity = null;
+            if (reachable)
+                brokerQuantity = byKey.TryGetValue(position.Instrument.Key, out var q) ? q : 0m;
+
+            managed.Add(new ManagedPosition(
+                Book:           book,
+                Instrument:     position.Instrument,
+                Quantity:       position.Quantity,
+                AvgPrice:       position.AvgPrice,
+                BoundCapital:   position.BoundCapital,
+                Lock:           await _rules.GetLockAsync(book, position.Instrument, ct).ConfigureAwait(false),
+                Rule:           await _rules.GetRuleAsync(position.Instrument, ct).ConfigureAwait(false),
+                BrokerQuantity: brokerQuantity));
+        }
+
+        // Bestand, den der Broker fuehrt und den wir in keinem Buch haben. Der Abgleich (#306)
+        // schreibt solche Positionen nach UNASSIGNED; bis er gelaufen ist, stehen sie hier.
+        var ownKeys = own.Where(p => p.Quantity != 0)
+                         .Select(p => p.Instrument.Key)
+                         .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var unknown = brokerPositions
+            .Where(p => p.Quantity != 0)
+            .Where(p => p.Instrument is not { } key || !ownKeys.Contains(key.Key))
+            .ToList();
+
+        return new PositionOverview(
+            [.. managed.OrderBy(m => m.Book.Value, StringComparer.Ordinal)
+                       .ThenBy(m => m.Instrument.Key, StringComparer.Ordinal)],
+            reachable,
+            unknown);
+    }
+
+    // ─── Umhängen ────────────────────────────────────────────────────────────────
+
+    /// <summary>Ergebnis einer Umbuchung.</summary>
+    /// <param name="Success">Hat sie stattgefunden?</param>
+    /// <param name="Message">Was geschehen ist bzw. warum nicht.</param>
+    public readonly record struct ReassignResult(bool Success, string Message);
+
+    /// <summary>
+    /// Hängt eine Position von einem Buch in ein anderes um – der häufigste Fall ist UNASSIGNED
+    /// nach MANUAL, wenn der Betreiber eine Position wiedererkennt.
+    ///
+    /// <para><b>Die Menge bleibt unangetastet.</b> Umgehängt wird die Zuordnung, nicht der Bestand.
+    /// Eine Umbuchung, die eine Stückzahl verändert, wäre ein Handel ohne Order – und stünde in
+    /// keiner Historie.</para>
+    ///
+    /// <para><b>Warum das Cap des Zielbuchs hier nicht sperrt.</b> Die Position existiert bereits;
+    /// sie zu benennen erzeugt kein neues Risiko. Würde die Grenze die Umbuchung verhindern, bliebe
+    /// jede zu große Position für immer in UNASSIGNED – dem einzigen Buch ohne Grenze. Das
+    /// Überschreiten ist ein zulässiger Zustand (<see cref="Headroom.OverCap"/>): Es sperrt Zukäufe,
+    /// heilt aber nichts durch Verkauf. Gemeldet wird es trotzdem, und zwar deutlich.</para>
+    /// </summary>
+    /// <param name="instrument">Die betroffene Position.</param>
+    /// <param name="from">Buch, aus dem sie kommt – als Schutz gegen das Umhängen der falschen Zeile.</param>
+    /// <param name="to">Zielbuch.</param>
+    /// <param name="reason">Begründung des Betreibers; landet im Log.</param>
+    public async Task<ReassignResult> ReassignAsync(
+        InstrumentRef instrument, BookId from, BookId to, string reason,
+        CancellationToken ct = default)
+    {
+        if (from == to)
+            return new ReassignResult(false, $"Quelle und Ziel sind dasselbe Buch ({from.Value}).");
+
+        if (string.IsNullOrWhiteSpace(reason))
+            return new ReassignResult(false,
+                "Eine Umbuchung ohne Begründung ist später nicht mehr nachvollziehbar.");
+
+        await using var db = await _dbf.CreateDbContextAsync(ct).ConfigureAwait(false);
+
+        var source = await db.Positions
+            .FirstOrDefaultAsync(p => p.Module == from.Value && p.ContractKey == instrument.Key, ct)
+            .ConfigureAwait(false);
+
+        if (source is null || source.Quantity == 0)
+            return new ReassignResult(false,
+                $"Im Buch {from.Value} liegt keine offene Position auf {instrument.Key}.");
+
+        var target = await db.Positions
+            .FirstOrDefaultAsync(p => p.Module == to.Value && p.ContractKey == instrument.Key, ct)
+            .ConfigureAwait(false);
+
+        var moved     = source.Quantity;
+        var movedCost = source.AvgPrice;
+
+        // Die Gegenrichtung zuerst, BEVOR irgendetwas angefasst wird: 100 Stück long in ein Buch zu
+        // schieben, das 100 short hält, ergibt eine Position von null - also eine Glattstellung. Die
+        // gehört über eine Order gemacht, mit Preis und Historie, nicht über die Verwaltung.
+        if (target is not null && target.Quantity != 0 &&
+            Math.Sign(target.Quantity) != Math.Sign(source.Quantity))
+            return new ReassignResult(false,
+                $"{to.Value} hält {instrument.Key} in der Gegenrichtung " +
+                $"({target.Quantity} gegen {source.Quantity}). Das ist eine Glattstellung, keine " +
+                "Umbuchung – sie gehört über eine Order gemacht, nicht über die Verwaltung.");
+
+        // Immer löschen und neu anlegen, nie das Buch in der bestehenden Zeile überschreiben:
+        // (Module, ContractKey) ist der Primärschlüssel von core_position. EF lehnt eine Änderung am
+        // Schlüssel ab - im Test sofort, in Betrieb ebenso. Aufgefallen beim ersten Testlauf.
+        var quantity = (target?.Quantity ?? 0) + source.Quantity;
+        var price    = target is null || quantity == 0
+            ? source.AvgPrice
+            // Zusammengelegt wird mengengewichtet. Ein neuer Einstand wäre eine erfundene Zahl, und
+            // die GuV des Zielbuchs hängt daran.
+            : (target.Quantity * target.AvgPrice + source.Quantity * source.AvgPrice) / quantity;
+
+        var moving = new CorePosition
+        {
+            Module      = to.Value,
+            ContractKey = source.ContractKey,
+            Symbol      = source.Symbol,
+            Kind        = source.Kind,
+            Expiry      = source.Expiry,
+            Strike      = source.Strike,
+            Right       = source.Right,
+            Multiplier  = source.Multiplier,
+            Currency    = source.Currency,
+            Quantity    = quantity,
+            AvgPrice    = price,
+            UpdatedAt   = DateTime.UtcNow
+        };
+
+        db.Positions.Remove(source);
+        if (target is not null) db.Positions.Remove(target);
+        await db.SaveChangesAsync(ct).ConfigureAwait(false);
+
+        db.Positions.Add(moving);
+        await db.SaveChangesAsync(ct).ConfigureAwait(false);
+
+        var text = string.Create(CultureInfo.InvariantCulture,
+            $"Position umgebucht: {moved} x {instrument.Key} zu {movedCost:F2} von {from.Value} " +
+            $"nach {to.Value}. Grund: {reason}");
+
+        // Warn und nicht Info: Das ist ein Eingriff von Hand in die Buchfuehrung. Er soll in der
+        // Datei stehen, die man liest, wenn man wissen will, warum eine Zahl sich geaendert hat.
+        _logger.Warn(LogModule, text);
+
+        return new ReassignResult(true, text);
+    }
+
+    // ─── Sperren ─────────────────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Setzt die Sperrstufe einer Position. Reicht durch an den <see cref="TradingRuleService"/>,
+    /// damit die Oberfläche nur einen Dienst kennen muss.
+    /// </summary>
+    public Task SetLockAsync(
+        BookId book, InstrumentRef instrument, PositionLock level, string? note = null,
+        CancellationToken ct = default) =>
+        _rules.SetLockAsync(book, instrument, level, note, ct);
+
+    /// <summary>Setzt oder löscht die Regel eines Instruments (Handelsverbot, Stückgrenze).</summary>
+    public Task SetRuleAsync(
+        string contractKeyOrSymbol, InstrumentRule rule, string? note = null,
+        CancellationToken ct = default) =>
+        _rules.SetRuleAsync(contractKeyOrSymbol, rule, note, ct);
+}
diff --git a/src/IBKRTrader.Core/Workers/BuiltIn/WebApiService.cs b/src/IBKRTrader.Core/Workers/BuiltIn/WebApiService.cs
index afb1095..8f54a18 100644
--- a/src/IBKRTrader.Core/Workers/BuiltIn/WebApiService.cs
+++ b/src/IBKRTrader.Core/Workers/BuiltIn/WebApiService.cs
@@ -4,18 +4,26 @@ using System.Net;
 using System.Text;
 using System.Text.Json;
 using IBKRTrader.Core.Logging;
+using IBKRTrader.Core.Positions;
 using IBKRTrader.Core.Settings;
 
 namespace IBKRTrader.Core.Workers.BuiltIn;
 
 /// <summary>
 /// WebApiService – permanenter REST-API-Service auf Basis von HttpListener.
-/// Basis-Routen: GET /api/status, GET /api/workers
-/// Wird später schrittweise um vollständige API-Endpunkte erweitert.
+///
+/// <para>Routen: <c>GET /api/status</c>, <c>GET /api/workers</c>, <c>GET /api/positions</c>.</para>
+///
+/// <para><b>Ausschließlich lesend, und das ist Absicht.</b> Der Listener lauscht auf
+/// <c>localhost</c> und kennt keine Anmeldung. Solange das so ist, gehört hierher nichts, was
+/// etwas verändert – eine Umbuchung oder eine Sperre über eine offene Schnittstelle wäre ein
+/// Eingriff in die Bücher, den niemand belegen kann. Schreibende Endpunkte kommen erst mit
+/// Anmeldung und Herkunftsnachweis.</para>
 /// </summary>
 public class WebApiService : WorkerBase
 {
     private readonly SettingsService _settings;
+    private readonly PositionManager _positions;
     private WorkerEngine? _engine; // wird nach DI-Aufbau gesetzt (kein readonly)
     private HttpListener?            _listener;
 
@@ -28,10 +36,12 @@ public class WebApiService : WorkerBase
 
     protected override TimeSpan? Interval => null;
 
-    public WebApiService(LoggingService logger, IDbContextFactory<CoreDbContext> db, SettingsService settings)
+    public WebApiService(LoggingService logger, IDbContextFactory<CoreDbContext> db,
+                         SettingsService settings, PositionManager positions)
         : base(logger, db)
     {
-        _settings = settings;
+        _settings  = settings;
+        _positions = positions;
         Info.Active  = settings.Settings.Webserver.Enabled;
         Info.RunEvery = "Service";
     }
@@ -69,6 +79,50 @@ public class WebApiService : WorkerBase
         }
     }
 
+    /// <summary>
+    /// Der Positionsbestand über alle Bücher (#485).
+    ///
+    /// <para>Die Broker-Abfrage kostet eine Verbindung und mehrere Sekunden und bleibt deshalb
+    /// abschaltbar: <c>?broker=0</c> antwortet allein aus der eigenen Buchführung. <c>brokerQuantity</c>
+    /// ist <c>null</c>, wenn der Broker nichts gemeldet hat – das ist ausdrücklich etwas anderes als
+    /// null Stück, und ein Client darf daraus keine Abweichung ableiten.</para>
+    /// </summary>
+    private async Task<object> PositionsAsync(HttpListenerContext ctx)
+    {
+        var includeBroker = !string.Equals(
+            ctx.Request.QueryString["broker"], "0", StringComparison.Ordinal);
+
+        var overview = await _positions.GetOverviewAsync(includeBroker).ConfigureAwait(false);
+
+        return new
+        {
+            brokerReachable = overview.BrokerReachable,
+            positions = overview.Positions.Select(p => new
+            {
+                book           = p.Book.Value,
+                origin         = p.Origin,
+                instrument     = p.Instrument.Key,
+                currency       = p.Instrument.Currency,
+                quantity       = p.Quantity,
+                avgPrice       = p.AvgPrice,
+                boundCapital   = p.BoundCapital,
+                brokerQuantity = p.BrokerQuantity,
+                diverges       = p.Diverges,
+                positionLock   = p.Lock.ToString(),
+                blocked        = p.Rule.Blocked,
+                maxQuantity    = p.Rule.MaxQuantity
+            }),
+            unknownToUs = overview.UnknownToUs.Select(p => new
+            {
+                symbol   = p.Symbol,
+                secType  = p.SecType,
+                currency = p.Currency,
+                quantity = p.Quantity,
+                avgCost  = p.AvgCost
+            })
+        };
+    }
+
     private async Task RouteAsync(HttpListenerContext ctx)
     {
         try
@@ -81,6 +135,7 @@ public class WebApiService : WorkerBase
                 "/api/workers" => _engine?.WorkerInfos
                                       .Select(w => new { w.WorkerName, w.Module, w.Type,
                                                          w.Info, w.Active }) ?? [],
+                "/api/positions" => await PositionsAsync(ctx).ConfigureAwait(false),
                 _              => null
             };
 
diff --git a/src/IBKRTrader.Daemon/PositionTool.cs b/src/IBKRTrader.Daemon/PositionTool.cs
new file mode 100644
index 0000000..daf668d
--- /dev/null
+++ b/src/IBKRTrader.Daemon/PositionTool.cs
@@ -0,0 +1,164 @@
+using System.Globalization;
+using IBKRTrader.Core.Capital;
+using IBKRTrader.Core.Positions;
+using IBKRTrader.Core.Trading;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace IBKRTrader.Daemon;
+
+/// <summary>
+/// Die Positionsverwaltung auf der Kommandozeile (#485) – dieselben Aufrufe, die auch das Fenster
+/// der Shell macht.
+///
+/// <para><b>Wozu doppelt.</b> Der Testbetrieb läuft kopflos als systemd-Dienst. Wer dort wissen
+/// will, wem eine Position gehört, hat kein Fenster – und ein Werkzeug, das nur in der Oberfläche
+/// existiert, fehlt genau dann, wenn man es braucht.</para>
+/// </summary>
+internal static class PositionTool
+{
+    public static async Task<int> ListAsync(IServiceProvider services, bool includeBroker)
+    {
+        var inv = CultureInfo.InvariantCulture;
+        var manager = services.GetRequiredService<PositionManager>();
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(120));
+        var overview = await manager.GetOverviewAsync(includeBroker, cts.Token).ConfigureAwait(false);
+
+        Console.WriteLine();
+        Console.WriteLine("=== Offene Positionen ===");
+
+        if (overview.Positions.Count == 0)
+        {
+            Console.WriteLine("Keine.");
+        }
+        else
+        {
+            Console.WriteLine($"{"Buch",-12} {"Herkunft",-20} {"Instrument",-24} {"Menge",8} " +
+                              $"{"Einstand",10} {"Gebunden",12} {"Broker",8}  Sperren");
+
+            foreach (var p in overview.Positions)
+            {
+                var broker = p.BrokerQuantity is { } b ? b.ToString("N0", inv) : "–";
+                var flags  = Describe(p);
+
+                Console.WriteLine(
+                    $"{p.Book.Value,-12} {p.Origin,-20} {p.Instrument.Key,-24} " +
+                    $"{p.Quantity.ToString("N0", inv),8} {p.AvgPrice.ToString("N2", inv),10} " +
+                    $"{p.BoundCapital.ToString("N0", inv),12} {broker,8}  {flags}");
+            }
+        }
+
+        if (includeBroker && !overview.BrokerReachable)
+        {
+            Console.WriteLine();
+            Console.WriteLine("Der Broker hat nichts gemeldet. Die Spalte „Broker\" bleibt deshalb leer:");
+            Console.WriteLine("Ein leeres Konto und eine gestörte Verbindung sehen von hier aus gleich aus,");
+            Console.WriteLine("und aus dem einen darf nicht auf das andere geschlossen werden.");
+        }
+
+        var diverging = overview.Positions.Where(p => p.Diverges).ToList();
+        if (diverging.Count > 0)
+        {
+            Console.WriteLine();
+            Console.WriteLine("=== Abweichungen gegen den Broker ===");
+            foreach (var p in diverging)
+                Console.WriteLine($"  {p.Instrument.Key}: wir {p.Quantity}, Broker {p.BrokerQuantity}");
+            Console.WriteLine("Zum Auflösen: --reconcile --dry-run, dann ohne --dry-run.");
+        }
+
+        if (overview.UnknownToUs.Count > 0)
+        {
+            Console.WriteLine();
+            Console.WriteLine("=== Beim Broker, in keinem Buch ===");
+            foreach (var p in overview.UnknownToUs)
+                Console.WriteLine($"  {p.Symbol} ({p.SecType}, {p.Currency}): " +
+                                  $"{p.Quantity.ToString("N0", inv)} zu {p.AvgCost.ToString("N2", inv)}");
+            Console.WriteLine("Der Abgleich schreibt sie nach UNASSIGNED; von dort lassen sie sich zuordnen:");
+            Console.WriteLine("  --reassign <INSTRUMENT> --from UNASSIGNED --to MANUAL --reason \"...\"");
+        }
+
+        return 0;
+    }
+
+    private static string Describe(ManagedPosition p)
+    {
+        var parts = new List<string>(3);
+
+        if (p.Lock != PositionLock.Free)
+            parts.Add(p.Lock switch
+            {
+                PositionLock.CloseOnly => "nur abbauen",
+                PositionLock.OpenOnly  => "nur aufbauen",
+                PositionLock.Locked    => "GESPERRT (auch Schließen)",
+                _                      => p.Lock.ToString()
+            });
+
+        if (p.Rule.Blocked) parts.Add("Instrument gesperrt");
+        if (p.Rule.MaxQuantity is { } max)
+            parts.Add(FormattableString.Invariant($"höchstens {max}"));
+
+        return parts.Count == 0 ? "" : string.Join(", ", parts);
+    }
+
+    /// <summary>
+    /// Hängt eine Position um. <b>Ohne <c>--confirm</c> ein Trockenlauf</b> – eine Umbuchung ändert
+    /// die Buchführung, und wer sie versehentlich auslöst, merkt es erst an einer falschen Zahl.
+    /// </summary>
+    public static async Task<int> ReassignAsync(
+        IServiceProvider services, string instrumentKey, string? from, string? to, string? reason,
+        bool confirm)
+    {
+        if (string.IsNullOrWhiteSpace(from) || string.IsNullOrWhiteSpace(to))
+        {
+            Console.Error.WriteLine("ABBRUCH: --from und --to sind Pflicht. Das Quellbuch ist keine " +
+                                    "Zierde, sondern der Schutz gegen die falsche Zeile.");
+            return 1;
+        }
+
+        if (string.IsNullOrWhiteSpace(reason))
+        {
+            Console.Error.WriteLine("ABBRUCH: --reason ist Pflicht. Eine Umbuchung ohne Begründung " +
+                                    "ist in einem Monat nicht mehr erklärbar.");
+            return 1;
+        }
+
+        if (!InstrumentRef.TryParse(instrumentKey, out var instrument))
+        {
+            Console.Error.WriteLine($"ABBRUCH: \"{instrumentKey}\" ist kein lesbarer Instrumentenschlüssel.");
+            return 1;
+        }
+
+        BookId source, target;
+        try
+        {
+            source = BookId.Parse(from);
+            target = BookId.Parse(to);
+        }
+        catch (ArgumentException ex)
+        {
+            Console.Error.WriteLine($"ABBRUCH: {ex.Message}");
+            return 1;
+        }
+
+        Console.WriteLine($"Vorhaben: {instrument.Key} von {source.Value} nach {target.Value}.");
+        Console.WriteLine($"Grund:    {reason}");
+
+        if (!confirm)
+        {
+            Console.WriteLine();
+            Console.WriteLine("=== TROCKENLAUF – nichts umgebucht ===");
+            Console.WriteLine("Zum Ausführen denselben Aufruf mit --confirm wiederholen.");
+            return 0;
+        }
+
+        var manager = services.GetRequiredService<PositionManager>();
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
+
+        var result = await manager
+            .ReassignAsync(instrument, source, target, reason, cts.Token)
+            .ConfigureAwait(false);
+
+        Console.WriteLine(result.Message);
+        return result.Success ? 0 : 1;
+    }
+}
diff --git a/src/IBKRTrader.Daemon/Program.cs b/src/IBKRTrader.Daemon/Program.cs
index 61ab583..d3eed02 100644
--- a/src/IBKRTrader.Daemon/Program.cs
+++ b/src/IBKRTrader.Daemon/Program.cs
@@ -63,6 +63,13 @@ internal static class Program
         // Eine hängende Order zurücknehmen. Braucht --confirm: Stornieren ist ein Eingriff.
         var cancelOrder = ArgAfter(args, "--cancel-order");
 
+        // Positionsverwaltung (#485): wem gehört was, und was ist gesperrt. Liest nur;
+        // --no-broker laesst die Broker-Abfrage weg und antwortet damit sofort.
+        var positions = HasFlag(args, "--positions");
+
+        // Eine Position umhängen. Braucht --from, --to, --reason und --confirm.
+        var reassign = ArgAfter(args, "--reassign");
+
         var modules = AppHostBuilder.CreateModules();
         using var host = AppHostBuilder.Build(modules);
 
@@ -94,6 +101,16 @@ internal static class Program
         if (reconcile)
             return await RunReconcileAsync(host.Services, !HasFlag(args, "--dry-run")).ConfigureAwait(false);
 
+        if (positions)
+            return await PositionTool.ListAsync(
+                host.Services, !HasFlag(args, "--no-broker")).ConfigureAwait(false);
+
+        if (reassign is not null)
+            return await PositionTool.ReassignAsync(
+                host.Services, reassign,
+                ArgAfter(args, "--from"), ArgAfter(args, "--to"), ArgAfter(args, "--reason"),
+                HasFlag(args, "--confirm")).ConfigureAwait(false);
+
         if (openOrders)
             return await OrderBookTool.ListAsync(host.Services).ConfigureAwait(false);
 
diff --git a/src/IBKRTrader.Hosting/AppHostBuilder.cs b/src/IBKRTrader.Hosting/AppHostBuilder.cs
index 864eb18..47e9c0d 100644
--- a/src/IBKRTrader.Hosting/AppHostBuilder.cs
+++ b/src/IBKRTrader.Hosting/AppHostBuilder.cs
@@ -266,6 +266,7 @@ public static class AppHostBuilder
             CreateModules().Select(BookNameOf).Append(BookId.Diagnostics.Value)));
         services.AddSingleton<ReservationService>();
         services.AddSingleton<TradingRuleService>();
+        services.AddSingleton<Core.Positions.PositionManager>();
         services.AddSingleton<CapitalService>();
         services.AddSingleton<ICapitalService>(sp => sp.GetRequiredService<CapitalService>());
 
diff --git a/tests/IBKRTrader.Tests/Positions/PositionManagerTests.cs b/tests/IBKRTrader.Tests/Positions/PositionManagerTests.cs
new file mode 100644
index 0000000..b83f1cd
--- /dev/null
+++ b/tests/IBKRTrader.Tests/Positions/PositionManagerTests.cs
@@ -0,0 +1,251 @@
+using FluentAssertions;
+using IBKRTrader.Core.Capital;
+using IBKRTrader.Core.Logging;
+using IBKRTrader.Core.Persistence.Ef;
+using IBKRTrader.Core.Persistence.Entities;
+using IBKRTrader.Core.Positions;
+using IBKRTrader.Core.Trading;
+using Microsoft.EntityFrameworkCore;
+using NSubstitute;
+
+namespace IBKRTrader.Tests.Positions;
+
+/// <summary>
+/// Die Positionsverwaltung (#485). Geprüft wird gegen die EF-InMemory-Datenbank; Broker und
+/// Buchführung sind gemockt.
+///
+/// <para>Der Schwerpunkt liegt auf dem Umhängen. Es ist die einzige Handlung hier, die Daten
+/// verändert – und die einzige, bei der ein Fehler wie ein Handel aussähe, den niemand ausgelöst
+/// hat.</para>
+/// </summary>
+[Trait("cat", "unit")]
+public class PositionManagerTests
+{
+    private sealed class InMemoryFactory(DbContextOptions<CoreDbContext> options)
+        : IDbContextFactory<CoreDbContext>
+    {
+        public CoreDbContext CreateDbContext() => new(options);
+    }
+
+    private static readonly InstrumentRef Sap = InstrumentRef.ForStock("SAP", "EUR");
+    private static readonly BookId        Ct  = BookId.ForModule("CT");
+
+    private readonly IPortfolioService      _portfolio = Substitute.For<IPortfolioService>();
+    private readonly IBrokerPortfolioReader _broker    = Substitute.For<IBrokerPortfolioReader>();
+
+    private PositionManager CreateSut(out IDbContextFactory<CoreDbContext> factory)
+    {
+        var options = new DbContextOptionsBuilder<CoreDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        factory = new InMemoryFactory(options);
+
+        var logger = new LoggingService();
+        return new PositionManager(factory, _portfolio, _broker, new TradingRuleService(factory, logger), logger);
+    }
+
+    private static CorePosition Row(string book, int quantity, decimal avgPrice) => new()
+    {
+        Module      = book,
+        ContractKey = Sap.Key,
+        Symbol      = "SAP",
+        Currency    = "EUR",
+        Quantity    = quantity,
+        AvgPrice    = avgPrice,
+        Multiplier  = 1,
+        UpdatedAt   = DateTime.UtcNow
+    };
+
+    private static async Task SeedAsync(IDbContextFactory<CoreDbContext> factory, params CorePosition[] rows)
+    {
+        await using var db = factory.CreateDbContext();
+        db.Positions.AddRange(rows);
+        await db.SaveChangesAsync();
+    }
+
+    // ─── Umhängen ────────────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Reassign_MovesTheBook_ButNeverTheQuantity()
+    {
+        var sut = CreateSut(out var factory);
+        await SeedAsync(factory, Row(BookId.Unassigned.Value, 100, 230m));
+
+        var result = await sut.ReassignAsync(
+            Sap, BookId.Unassigned, BookId.Manual, "beim Aufräumen wiedererkannt");
+
+        result.Success.Should().BeTrue();
+
+        await using var db = factory.CreateDbContext();
+        var rows = await db.Positions.ToListAsync();
+
+        rows.Should().ContainSingle("es entsteht keine zweite Zeile");
+        rows[0].Module.Should().Be(BookId.Manual.Value);
+        rows[0].Quantity.Should().Be(100, "umgebucht wird die Zuordnung, nicht der Bestand");
+        rows[0].AvgPrice.Should().Be(230m, "ein neuer Einstand wäre eine erfundene Zahl");
+    }
+
+    [Fact]
+    public async Task Reassign_WithoutAReason_IsRefused()
+    {
+        // Eine Umbuchung ohne Begründung ist ein Monat später nicht mehr erklärbar – und sie ist
+        // der einzige Weg, auf dem Bestand ohne Order das Buch wechselt.
+        var sut = CreateSut(out var factory);
+        await SeedAsync(factory, Row(BookId.Unassigned.Value, 100, 230m));
+
+        var result = await sut.ReassignAsync(Sap, BookId.Unassigned, BookId.Manual, "   ");
+
+        result.Success.Should().BeFalse();
+        result.Message.Should().Contain("Begründung");
+    }
+
+    [Fact]
+    public async Task Reassign_FromTheWrongBook_ChangesNothing()
+    {
+        // Das Quellbuch ist nicht Zierde, sondern Schutz: Wer sich in der Zeile vertut, soll eine
+        // Absage bekommen und nicht eine fremde Position verschieben.
+        var sut = CreateSut(out var factory);
+        await SeedAsync(factory, Row(BookId.Unassigned.Value, 100, 230m));
+
+        var result = await sut.ReassignAsync(Sap, Ct, BookId.Manual, "Tippfehler");
+
+        result.Success.Should().BeFalse();
+        result.Message.Should().Contain("CT");
+
+        await using var db = factory.CreateDbContext();
+        (await db.Positions.SingleAsync()).Module.Should().Be(BookId.Unassigned.Value);
+    }
+
+    [Fact]
+    public async Task Reassign_IntoABookThatAlreadyHoldsIt_MergesWithWeightedCost()
+    {
+        var sut = CreateSut(out var factory);
+        await SeedAsync(factory,
+            Row(BookId.Unassigned.Value, 100, 200m),
+            Row(BookId.Manual.Value,     100, 300m));
+
+        var result = await sut.ReassignAsync(Sap, BookId.Unassigned, BookId.Manual, "zusammenlegen");
+
+        result.Success.Should().BeTrue();
+
+        await using var db = factory.CreateDbContext();
+        var row = await db.Positions.SingleAsync();
+
+        row.Module.Should().Be(BookId.Manual.Value);
+        row.Quantity.Should().Be(200);
+        row.AvgPrice.Should().Be(250m, "mengengewichtet aus 100x200 und 100x300");
+    }
+
+    [Fact]
+    public async Task Reassign_AgainstAnOppositePosition_IsRefused_BecauseThatWouldBeATrade()
+    {
+        // 100 long nach einem Buch mit 100 short zu schieben, ergäbe eine Position von null – also
+        // eine Glattstellung. Die gehört über eine Order gemacht, mit Preis und Historie.
+        var sut = CreateSut(out var factory);
+        await SeedAsync(factory,
+            Row(BookId.Unassigned.Value,  100, 200m),
+            Row(BookId.Manual.Value,     -100, 300m));
+
+        var result = await sut.ReassignAsync(Sap, BookId.Unassigned, BookId.Manual, "zusammenlegen");
+
+        result.Success.Should().BeFalse();
+        result.Message.Should().Contain("Glattstellung");
+
+        await using var db = factory.CreateDbContext();
+        (await db.Positions.CountAsync()).Should().Be(2, "es wurde nichts angefasst");
+    }
+
+    [Fact]
+    public async Task Reassign_ToTheSameBook_IsRefused()
+    {
+        var sut = CreateSut(out var factory);
+        await SeedAsync(factory, Row(BookId.Manual.Value, 100, 230m));
+
+        (await sut.ReassignAsync(Sap, BookId.Manual, BookId.Manual, "egal"))
+            .Success.Should().BeFalse();
+    }
+
+    // ─── Überblick ───────────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task Overview_WithoutABroker_LeavesTheComparisonEmpty_InsteadOfClaimingZero()
+    {
+        // Der wichtigste Fall der ganzen Ansicht: Ohne Verbindung darf keine Abweichung behauptet
+        // werden. Stünde dort "Broker: 0", sähe jede Störung aus wie ein leergeräumtes Konto.
+        var sut = CreateSut(out _);
+        _portfolio.GetAllPositionsAsync(Arg.Any<CancellationToken>())
+                  .Returns(Task.FromResult<IReadOnlyList<Position>>([new Position("CT", Sap, 100, 230m)]));
+        _broker.GetPositionsAsync(Arg.Any<CancellationToken>())
+               .Returns(Task.FromResult<IReadOnlyList<BrokerPosition>>([]));
+
+        var overview = await sut.GetOverviewAsync();
+
+        overview.BrokerReachable.Should().BeFalse();
+        overview.Positions.Should().ContainSingle();
+        overview.Positions[0].BrokerQuantity.Should().BeNull();
+        overview.Positions[0].Diverges.Should().BeFalse("eine Abweichung aus fehlenden Daten ist keine");
+    }
+
+    [Fact]
+    public async Task Overview_ShowsTheOrigin_AndFindsWhatNoBookClaims()
+    {
+        var sut = CreateSut(out _);
+
+        _portfolio.GetAllPositionsAsync(Arg.Any<CancellationToken>())
+                  .Returns(Task.FromResult<IReadOnlyList<Position>>(
+                      [new Position(BookId.Unassigned.Value, Sap, 100, 230m)]));
+
+        var alv = InstrumentRef.ForStock("ALV", "EUR");
+        _broker.GetPositionsAsync(Arg.Any<CancellationToken>())
+               .Returns(Task.FromResult<IReadOnlyList<BrokerPosition>>(
+               [
+                   new BrokerPosition { Symbol = "SAP", SecType = "STK", Currency = "EUR",
+                                        ConId = 1, Quantity = 100, AvgCost = 230m, Instrument = Sap },
+                   new BrokerPosition { Symbol = "ALV", SecType = "STK", Currency = "EUR",
+                                        ConId = 2, Quantity = 5,   AvgCost = 450m, Instrument = alv }
+               ]));
+
+        var overview = await sut.GetOverviewAsync();
+
+        overview.BrokerReachable.Should().BeTrue();
+        overview.Positions[0].Origin.Should().Be("Herkunft unbekannt");
+        overview.Positions[0].Diverges.Should().BeFalse();
+
+        overview.UnknownToUs.Should().ContainSingle("ALV führt der Broker, wir in keinem Buch")
+                .Which.Symbol.Should().Be("ALV");
+    }
+
+    [Fact]
+    public async Task Overview_ReportsADivergenceWhenTheBrokerHoldsSomethingElse()
+    {
+        var sut = CreateSut(out _);
+        _portfolio.GetAllPositionsAsync(Arg.Any<CancellationToken>())
+                  .Returns(Task.FromResult<IReadOnlyList<Position>>([new Position("CT", Sap, 100, 230m)]));
+        _broker.GetPositionsAsync(Arg.Any<CancellationToken>())
+               .Returns(Task.FromResult<IReadOnlyList<BrokerPosition>>(
+                   [new BrokerPosition { Symbol = "SAP", SecType = "STK", Currency = "EUR",
+                                         ConId = 1, Quantity = 60, AvgCost = 230m, Instrument = Sap }]));
+
+        var overview = await sut.GetOverviewAsync();
+
+        overview.Positions[0].BrokerQuantity.Should().Be(60m);
+        overview.Positions[0].Diverges.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task Overview_CarriesTheLockThrough()
+    {
+        var sut = CreateSut(out _);
+        _portfolio.GetAllPositionsAsync(Arg.Any<CancellationToken>())
+                  .Returns(Task.FromResult<IReadOnlyList<Position>>([new Position("CT", Sap, 100, 230m)]));
+        _broker.GetPositionsAsync(Arg.Any<CancellationToken>())
+               .Returns(Task.FromResult<IReadOnlyList<BrokerPosition>>([]));
+
+        await sut.SetLockAsync(Ct, Sap, PositionLock.CloseOnly, "nur noch abbauen");
+
+        var overview = await sut.GetOverviewAsync(includeBroker: false);
+
+        overview.Positions[0].Lock.Should().Be(PositionLock.CloseOnly);
+        overview.Positions[0].IsRestricted.Should().BeTrue();
+    }
+}