feat: cwd-aware launch, neues App-Logo, ROADMAP

- open_file startet Tools mit Arbeitsverzeichnis = Ordner der Ziel-Datei
  (os.startfile cwd / ShellExecuteW lpDirectory) -> behebt Apps, die
  Ressourcen relativ zur cwd laden
- neues App-Icon/Logo (icon.ico, DesktopIcon.ico, store_assets, web_companion)
- ROADMAP.md: universeller Ablagelayer (Dateien/Ordner/Dokumente) + Project-Boards
- Test fuer cwd-Launch (tests/test_open_file_cwd.py)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V5RVPpPGT4fb2idwJrttoJ

Author: lukisch

CHANGELOG.md

@@ -8,6 +8,10 @@ All notable changes to this project will be documented in this file.
 - Icon/EXE/START-Health-Check 2026-06-19: vorhandenes `icon.ico` weiterverwendet, `START.bat` auf EXE-first umgestellt, `build_exe.bat` auf lokalen Buildpfad `C:\_Local_DEV\codex_build\softwarecenter` mit Build-Exclude-Scanner aktualisiert und `SoftwareCenter.exe` neu gebaut.
 - EXE neu gebaut 2026-06-01 (PyInstaller, `SoftwareCenter.spec`); 9/9 Tests grün, Smoke-Test bestanden. Vorherige EXE: 2026-05-01.
 
+### Added
+- Neues App-Icon im Superman-Wappen-Stil: rotes Schild mit fettem, leicht schrägem weißem „SC" und weißem Rand. Reproduzierbar über `generate_icon.py`; ersetzt `icon.ico`, `DesktopIcon.ico`, die Windows-Store-Logos (`store_assets/*.png`) sowie die PWA-Icons und das `icon.svg` des Web-Companions (maskable-/apple-touch-Varianten mit rotem Vollhintergrund).
+- Kontextmenü „Senden an" (verschieben) und „Duplizieren auf" (kopieren): Einträge lassen sich per Rechtsklick auf ein anderes Board (Tab) verschieben oder zusätzlich dort anzeigen. Submenüs listen alle Boards außer dem aktuellen und erscheinen nur bei vorhandener Auswahl und mindestens einem weiteren Board. Label, Typ und Notizen bleiben erhalten, bereits vorhandene Pfade werden im Ziel-Board nicht dupliziert. Tests in `tests/test_features_board_transfer.py`.
+
 ### Changed
 - Windows-`.lnk`-Dateien, die auf eine `.exe` oder einen Ordner zeigen, werden beim Hinzufügen jetzt als Originalziel gespeichert und angezeigt; direkte Ordner-Drops werden ebenfalls unterstützt, nicht auflösbare Links bleiben kompatibel als `.lnk`-Eintrag erhalten.
 - Web Companion: Service-Worker-Cache auf v3 angehoben und Offline-Fetch-Fehler liefern jetzt einen HTTP-503-Fallback statt unkontrolliert zu scheitern.

DesktopIcon.ico

@@ -0,0 +1,29 @@
+# SoftwareCenter — ROADMAP
+
+> Strategische Ideen und geplante Erweiterungen. Status-Schnappschuss; abgeschlossene Punkte wandern ins CHANGELOG.
+
+## Vision: Universeller Ordnungslayer außerhalb des Dateisystems
+
+SoftwareCenter soll **nicht nur App-Verknüpfungen** aufnehmen, sondern **alles, was man ablegen will** — Verknüpfungen, Dokumente, Ordner, Dateien, URLs. Der Nutzer ordnet Dinge frei in Tabs/Boards, **unabhängig davon, wo sie physisch im Dateisystem liegen**. Damit wird SoftwareCenter zu einem zweiten Ordnungslayer **über** dem Dateisystem.
+
+- **Bereits unterstützt (technisch):** Drag & Drop von Dateien, Ordnern, `.lnk`-Verknüpfungen, `.url`, Skripten und Dokumenten. Intern unterscheidet die Engine schon die Typen `file`, `directory`, `windows_shortcut`, `url`, `script`, `mac_app`, `linux_desktop` (siehe `detect_entry_kind` / `is_supported_launch_target`).
+- **Auszubauen:**
+  - Klar kommunizieren, dass **beliebige** Dateien/Ordner/Dokumente ablegbar sind (nicht nur EXEs) — UI-Hinweis, Doku, Store-Listing.
+  - Komfort für Nicht-App-Einträge: Kontextmenü „Im Explorer anzeigen", optionale Vorschau/Notiz, Sortierung.
+  - Robustes Verhalten bei fehlenden Zielen (Eintrag bleibt sichtbar, klare Warnung).
+
+## Idee: Zwillings-Produkt „Project-Boards"
+
+Eine **identische Variante** des SoftwareCenter unter eigenem Namen **„Project-Boards"** herausbringen — positioniert als **eigenständiges, zweites Ordnungslayer außerhalb des Dateisystems** (Projekt-/Themen-Boards statt App-Launcher).
+
+- **Gleiche Code-Basis, andere Positionierung/Branding:** SoftwareCenter = Fokus App-Launcher; Project-Boards = allgemeines Projekt-/Ordnungs-Board (Verknüpfungen, Dokumente, Ordner, Notizen je Projekt/Thema in eigenen Boards/Tabs).
+- **Umsetzung:**
+  - Identische Engine; separater Name, Icon, Store-Listing.
+  - **Eigener QSettings-Namespace** (z. B. `QSettings("LukasGeiger", "ProjectBoards")`), damit beide Programme **parallel** mit getrennten Profilen laufen.
+  - Gemeinsamer Kern als Modul, dünne App-Wrapper je Produkt — vermeidet Code-Duplikation.
+  - Profil-Austauschformat (`softwarecenter-profile-v1.json`) für beide nutzbar.
+
+## Offene technische Nachsorge (aus Build-/Reparaturlauf 2026-06-27)
+
+- `build_exe.bat` nutzt feste Spec-Excludes statt `build_exclude_scanner.py` (Abweichung von BUILD-VERFAHREN §3/§4) — bei Gelegenheit angleichen.
+- onedir-Builds erzeugen große `_internal/`-Strukturen in OneDrive (Sync-Last) — für Releases onefile bevorzugen, wo sinnvoll.

ROADMAP.md

@@ -299,13 +299,40 @@ def validate_profile_payload(payload: dict) -> list[dict]:
         raise ValueError("Das Profil enthält keine lesbaren Tabs.")
     return tabs
 
+def _startfile_in_dir(path: str, workdir: str | None) -> None:
+    """Startet eine Datei unter Windows mit gesetztem Arbeitsverzeichnis.
+
+    Viele gebuendelte Apps suchen Ressourcen/Module relativ zum Arbeitsverzeichnis
+    (cwd). Eine Desktop-Verknuepfung setzt dafuer "Ausfuehren in:"; os.startfile()
+    erbt dagegen die cwd des SoftwareCenter-Prozesses, was solche Apps brechen kann.
+    Daher hier explizit das Verzeichnis der Ziel-Datei als cwd setzen.
+    """
+    # Python 3.13+: os.startfile akzeptiert cwd direkt.
+    try:
+        os.startfile(path, cwd=workdir)  # type: ignore[call-arg]
+        return
+    except TypeError:
+        pass  # aelteres Python ohne cwd-Parameter -> ShellExecuteW
+    except OSError:
+        raise
+    import ctypes
+    # ShellExecuteW(hwnd, lpVerb, lpFile, lpParameters, lpDirectory, nShowCmd)
+    # lpDirectory = Arbeitsverzeichnis (wie "Ausfuehren in" einer Verknuepfung).
+    rc = ctypes.windll.shell32.ShellExecuteW(None, None, path, None, workdir, 1)
+    if rc <= 32:  # ShellExecute meldet Fehler als Wert <= 32
+        os.startfile(path)  # letzter Fallback ohne Arbeitsverzeichnis
+
+
 def open_file(path: str) -> None:
     if not os.path.exists(path):
         QMessageBox.warning(None, "Datei nicht gefunden", f"Pfad existiert nicht:\n{path}")
         return
     try:
         if sys.platform.startswith("win"):
-            os.startfile(path)  # type: ignore[attr-defined]
+            # Windows: Arbeitsverzeichnis = Ordner der Ziel-Datei (wie "Ausfuehren in"
+            # einer Verknuepfung), damit Apps ihre Ressourcen relativ zur cwd finden.
+            workdir = os.path.dirname(os.path.abspath(path)) or None
+            _startfile_in_dir(path, workdir)
         elif sys.platform == "darwin":
             subprocess.Popen(["open", path])
         else:
@@ -324,6 +351,9 @@ def open_file(path: str) -> None:
 
 class SoftwareListWidget(QListWidget):
     requestDelete = Signal(list)
+    # Transfer zwischen Boards (Tabs): jeweils (entries: list[dict], target_index: int)
+    requestMoveToBoard = Signal(list, int)
+    requestCopyToBoard = Signal(list, int)
     def __init__(self, parent=None):
         super().__init__(parent)
         self.setAcceptDrops(True)
@@ -332,6 +362,10 @@ def __init__(self, parent=None):
         self.customContextMenuRequested.connect(self._on_context_menu)
         self.itemActivated.connect(self._on_item_activated)
         self._icon_provider = QFileIconProvider()
+        # Callable -> list[(index, name)] der ANDEREN Boards (ohne dieses).
+        # Wird von MainWindow.add_new_tab gesetzt; ohne Provider bleiben die
+        # Transfer-Submenues ausgeblendet (z. B. bei isolierter Nutzung in Tests).
+        self.board_provider = None
         self.configure_as_tiles()
 
     def configure_as_tiles(self):
@@ -384,8 +418,24 @@ def _on_context_menu(self, pos):
         menu = QMenu(self)
         act_open = menu.addAction("Öffnen/Starten")
         act_del = menu.addAction("Löschen")
+
+        # "Senden an" (verschieben) / "Duplizieren auf" (kopieren) nur anbieten,
+        # wenn etwas ausgewählt ist UND mindestens ein anderes Board existiert.
+        move_actions: dict = {}
+        copy_actions: dict = {}
+        boards = self.board_provider() if callable(self.board_provider) else []
+        if self.selectedItems() and boards:
+            menu.addSeparator()
+            move_menu = menu.addMenu("Senden an")
+            copy_menu = menu.addMenu("Duplizieren auf")
+            for index, name in boards:
+                move_actions[move_menu.addAction(name)] = index
+                copy_actions[copy_menu.addAction(name)] = index
+
         global_pos = self.viewport().mapToGlobal(pos)
         action = menu.exec(global_pos)
+        if action is None:
+            return
         if action == act_open:
             for item in self.selectedItems():
                 path = item.data(Qt.ItemDataRole.UserRole)
@@ -394,6 +444,38 @@ def _on_context_menu(self, pos):
             paths = [it.data(Qt.ItemDataRole.UserRole) for it in self.selectedItems()]
             if paths:
                 self.requestDelete.emit(paths)
+        elif action in move_actions:
+            entries = self._selected_entries()
+            if entries:
+                self.requestMoveToBoard.emit(entries, move_actions[action])
+        elif action in copy_actions:
+            entries = self._selected_entries()
+            if entries:
+                self.requestCopyToBoard.emit(entries, copy_actions[action])
+
+    def _selected_entries(self) -> list[dict]:
+        """Vollständige Eintrags-Dicts (Pfad, Label, Typ, Notizen) der Auswahl.
+
+        Spiegelt den Fallback aus get_all_entries(), falls ein Item kein
+        ENTRY_METADATA_ROLE-Dict trägt (z. B. Alt-Daten)."""
+        entries = []
+        for item in self.selectedItems():
+            metadata = item.data(ENTRY_METADATA_ROLE)
+            if isinstance(metadata, dict):
+                entries.append(normalize_entry(metadata))
+            else:
+                path = item.data(Qt.ItemDataRole.UserRole)
+                entries.append(
+                    normalize_entry(
+                        {
+                            "path": path,
+                            "label": item.text(),
+                            "kind": detect_entry_kind(path),
+                            "notes": None,
+                        }
+                    )
+                )
+        return [entry for entry in entries if entry]
 
     def _on_item_activated(self, item: QListWidgetItem):
         path = item.data(Qt.ItemDataRole.UserRole)
@@ -603,10 +685,50 @@ def add_new_tab(self, name: str | None = None, view_mode="tiles", paths=None, en
             page.list.set_all_entries(entries)
         elif paths:
             page.list.set_all_paths(paths)
+        # Board-Transfer verdrahten: Provider liefert zur Menü-Zeit die anderen
+        # Boards, die Signale lösen Verschieben/Duplizieren aus.
+        page.list.board_provider = self._board_provider_for(page)
+        page.list.requestMoveToBoard.connect(
+            lambda transfer, target_index, source=page: self.move_entries_to_board(source, transfer, target_index)
+        )
+        page.list.requestCopyToBoard.connect(self.copy_entries_to_board)
         idx = self.tabs.addTab(page, name or "Neuer Tab")
         self._update_tab_closable_state()
         self.tabs.setCurrentIndex(idx)
 
+    def _board_provider_for(self, page: "TabPage"):
+        """Closure: liefert zur Aufrufzeit (index, name) aller Boards außer `page`.
+
+        Dynamisch, damit verschobene/umbenannte/geschlossene Tabs korrekt
+        berücksichtigt werden."""
+        def provider():
+            result = []
+            for i in range(self.tabs.count()):
+                if self.tabs.widget(i) is page:
+                    continue
+                result.append((i, self.tabs.tabText(i)))
+            return result
+        return provider
+
+    def move_entries_to_board(self, source_page: "TabPage", entries: list, target_index: int):
+        target_page = self.tabs.widget(target_index)
+        if not isinstance(target_page, TabPage) or target_page is source_page:
+            return
+        if not entries:
+            return
+        target_page.list.add_entries(entries)
+        source_page.list.remove_paths([e["path"] for e in entries if isinstance(e, dict) and e.get("path")])
+        self.save_settings()
+
+    def copy_entries_to_board(self, entries: list, target_index: int):
+        target_page = self.tabs.widget(target_index)
+        if not isinstance(target_page, TabPage):
+            return
+        if not entries:
+            return
+        target_page.list.add_entries(entries)
+        self.save_settings()
+
     def export_profile(self):
         default_name = os.path.join(os.path.expanduser("~"), f"{PROFILE_FORMAT}.json")
         target, _selected_filter = QFileDialog.getSaveFileName(

SoftwareCenter.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+"""Erzeugt das SoftwareCenter-Icon im Superman-Wappen-Stil.
+
+Motiv: rotes Wappen-Schild mit fettem, leicht schraegem weissem "SC".
+Erzeugt reproduzierbar alle App-, Store- und PWA-Assets aus einem Master.
+
+Aufruf:
+    PYTHONIOENCODING=utf-8 python generate_icon.py          # schreibt alle Assets
+    PYTHONIOENCODING=utf-8 python generate_icon.py --preview out.png   # nur Vorschau
+
+Abhaengigkeit: Pillow. Font: Arial Black (C:\\Windows\\Fonts\\ariblk.ttf).
+"""
+import os
+import sys
+
+from PIL import Image, ImageDraw, ImageFont
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+
+SS = 4                              # Supersampling
+BASE = 1024
+N = BASE * SS
+
+RED = (206, 27, 35, 255)           # Superman-Rot
+WHITE = (255, 255, 255, 255)
+FONT_PATH = r"C:\Windows\Fonts\ariblk.ttf"
+
+
+def _quad(p0, p1, p2, steps):
+    out = []
+    for i in range(steps + 1):
+        t = i / steps
+        x = (1 - t) ** 2 * p0[0] + 2 * (1 - t) * t * p1[0] + t * t * p2[0]
+        y = (1 - t) ** 2 * p0[1] + 2 * (1 - t) * t * p1[1] + t * t * p2[1]
+        out.append((x, y))
+    return out
+
+
+def _cubic(p0, p1, p2, p3, steps):
+    out = []
+    for i in range(steps + 1):
+        t = i / steps
+        mt = 1 - t
+        x = mt ** 3 * p0[0] + 3 * mt ** 2 * t * p1[0] + 3 * mt * t * t * p2[0] + t ** 3 * p3[0]
+        y = mt ** 3 * p0[1] + 3 * mt ** 2 * t * p1[1] + 3 * mt * t * t * p2[1] + t ** 3 * p3[1]
+        out.append((x, y))
+    return out
+
+
+def _shield_points(n):
+    """Wappen-Schild als Polygonpunkte, normiert auf Kantenlaenge n."""
+    def S(x, y):
+        return (x * n, y * n)
+
+    tl, tr = (0.13, 0.16), (0.87, 0.16)
+    top_ctrl = (0.50, 0.085)
+    tip = (0.50, 0.95)
+    r_c1, r_c2 = (1.00, 0.33), (0.74, 0.74)
+    l_c2, l_c1 = (0.26, 0.74), (0.00, 0.33)
+
+    pts = _quad(tl, top_ctrl, tr, 120)
+    pts += _cubic(tr, r_c1, r_c2, tip, 200)[1:]
+    pts += _cubic(tip, l_c2, l_c1, tl, 200)[1:]
+    return [S(x, y) for (x, y) in pts]
+
+
+def _draw_sc(canvas, n, font_frac=0.30, y_center=0.40):
+    """Rendert ein leicht schraeges weisses 'SC' mittig auf canvas (Kantenlaenge n)."""
+    font = ImageFont.truetype(FONT_PATH, int(font_frac * n))
+    layer = Image.new("RGBA", (n, n), (0, 0, 0, 0))
+    d = ImageDraw.Draw(layer)
+    bbox = d.textbbox((0, 0), "SC", font=font)
+    tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
+    tx = (n - tw) / 2 - bbox[0]
+    ty = (y_center * n) - th / 2 - bbox[1]
+    d.text((tx, ty), "SC", font=font, fill=WHITE)
+    shear = -0.16
+    layer = layer.transform(
+        (n, n), Image.AFFINE, (1, shear, -shear * n * 0.5, 0, 1, 0),
+        resample=Image.BICUBIC,
+    )
+    return Image.alpha_composite(canvas, layer)
+
+
+def shield_master():
+    """Transparentes Schild-Master (N x N): weisser Rand, rote Flaeche, weisses SC."""
+    img = Image.new("RGBA", (N, N), (0, 0, 0, 0))
+    d = ImageDraw.Draw(img)
+    poly = _shield_points(N)
+    d.polygon(poly, fill=WHITE)                       # weisser Aussenrand
+    c = N / 2
+    inner = [(c + (x - c) * 0.93, c + (y - c) * 0.93) for (x, y) in poly]
+    d.polygon(inner, fill=RED)                         # rote Innenflaeche
+    return _draw_sc(img, N)
+
+
+def filled_master():
+    """Rotes Vollbild-Master (N x N) mit weissem SC — fuer maskable/apple-touch."""
+    img = Image.new("RGBA", (N, N), RED)
+    return _draw_sc(img, N, font_frac=0.42, y_center=0.50)
+
+
+def _save_png(master, size, path, canvas=None):
+    out = master.resize((size, size), Image.LANCZOS)
+    if canvas:  # in groesseren/anders geformten Rahmen zentrieren
+        bg = Image.new("RGBA", canvas, (0, 0, 0, 0))
+        bg.alpha_composite(out, ((canvas[0] - size) // 2, (canvas[1] - size) // 2))
+        out = bg
+    out.save(path)
+    print("PNG :", os.path.relpath(path, HERE))
+
+
+def _save_ico(master, path):
+    sizes = [256, 128, 64, 48, 32, 16]
+    imgs = [master.resize((s, s), Image.LANCZOS) for s in sizes]
+    imgs[0].save(path, format="ICO", sizes=[(s, s) for s in sizes], append_images=imgs[1:])
+    print("ICO :", os.path.relpath(path, HERE))
+
+
+SVG = """<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256">
+  <path d="M 33.3 41 Q 128 21.8 222.7 41 C 256 84.5 189.4 189.4 128 243.2 C 66.6 189.4 0 84.5 33.3 41 Z"
+        fill="#ce1b23" stroke="#ffffff" stroke-width="6" stroke-linejoin="round"/>
+  <g transform="translate(128,118)">
+    <text transform="skewX(-9)" text-anchor="middle"
+          font-family="'Arial Black','Arial',sans-serif" font-weight="900"
+          font-size="92" fill="#ffffff">SC</text>
+  </g>
+</svg>
+"""
+
+
+def main():
+    if len(sys.argv) > 2 and sys.argv[1] == "--preview":
+        shield_master().resize((512, 512), Image.LANCZOS).save(sys.argv[2])
+        print("Vorschau:", sys.argv[2])
+        return
+
+    shield = shield_master()
+    filled = filled_master()
+
+    # App-Icons
+    _save_ico(shield, os.path.join(HERE, "icon.ico"))
+    _save_ico(shield, os.path.join(HERE, "DesktopIcon.ico"))
+
+    # Windows-Store-Assets (transparent)
+    store = os.path.join(HERE, "store_assets")
+    _save_png(shield, 44, os.path.join(store, "Square44x44Logo.png"))
+    _save_png(shield, 150, os.path.join(store, "Square150x150Logo.png"))
+    _save_png(shield, 310, os.path.join(store, "Square310x310Logo.png"))
+    _save_png(shield, 150, os.path.join(store, "Wide310x150Logo.png"), canvas=(310, 150))
+
+    # PWA-Icons
+    icons = os.path.join(HERE, "web_companion", "icons")
+    _save_png(shield, 192, os.path.join(icons, "Icon-192.png"))
+    _save_png(shield, 512, os.path.join(icons, "Icon-512.png"))
+    _save_png(filled, 192, os.path.join(icons, "Icon-maskable-192.png"))
+    _save_png(filled, 512, os.path.join(icons, "Icon-maskable-512.png"))
+    _save_png(filled, 180, os.path.join(icons, "apple-touch-icon-180.png"))
+
+    # Skalierbares SVG fuer den Web-Companion
+    svg_path = os.path.join(HERE, "web_companion", "icon.svg")
+    with open(svg_path, "w", encoding="utf-8") as fh:
+        fh.write(SVG)
+    print("SVG :", os.path.relpath(svg_path, HERE))
+
+
+if __name__ == "__main__":
+    main()