Archiv als eigenes Fenster: Trilium raus, Notizbaum mit In-Place-Bearbeitung

Trilium-Integration komplett zurückgenommen (Revert von 47951a6): keine
verwaltete Instanz, kein Runtime-Download, kein ETAPI, kein Keyring-Token,
kein Setup-Wizard. Das Archiv sind wieder Markdown-Dateien unter archiveHome
samt FTS5-Suche und Wikilinks.

Notizmodell (an Trilium orientiert, ohne dessen Überbau):
- Jeder Knoten besitzt eine Textdatei — ensure_node_texts legt fehlende beim
  Seitenaufbau an (Ordner: gleichnamiges .md daneben, Wurzel: index.md);
  Ordner und Zwillingsdatei sind EINE Notiz mit Inhalt und Kindern.
- Der angezeigte Titel steht im Frontmatter der Datei, der Datei-/Ordnername
  ist technischer Verwaltungsname; move_folder nimmt den Knotentext mit.

Archiv-Ansicht (wiki-view):
- Baum links: Knoten- und Blatt-Symbole, Führungslinien pro Ebene, Dokumente
  näher an der Linie als Ordner; ganze Zeile wählt aus, nur der Pfeil klappt.
- Notiz-Ansicht rechts: großer Titel (Klick bearbeitet ihn → archive_set_title),
  Zurück-Knopf mit Auswahl-Verlauf, Details als Popup am Info-Knopf, Kindliste
  als abgesetzter Karten-Block mit Anlage-/Änderungsdatum.
- Bearbeiten in place: Split-View aus Rohtext und Live-Vorschau, Speichern per
  Knopf oder Ctrl+S (archive_read/archive_write; Frontmatter bleibt).
- Rechte Maustaste im Baum als einziger Aktionsweg (eigenes Kontextmenü,
  Standard-Menü des Webviews aus); Anlegen/Umbenennen über modale Dialoge.

Feste Flächenaufteilung statt Ablösen/Andocken:
- Angedocktes Panel = Session-Begleiter (ToDo, Befehle, flüchtiger Entwurf);
  der Dokument-Tab ist aus der Leiste raus.
- Archiv-Fenster = Archiv + Suche, Größe und Position einmalig beim Öffnen
  aus dem Monitor des rufenden Terminal-Fensters (85 % / 92 %); Öffner-Klick
  bei stehendem Fenster fokussiert und schaltet den Tab (panel-mode).
- Terminal-Fenster zu → Archiv-Fenster geht mit.

Neue Commands: archive_read, archive_write, archive_set_title.

src/panel-wiring.ts

@@ -1,11 +1,14 @@
 /// Gemeinsame Panel-Verdrahtung für das angedockte Panel (terminal.ts) und
-/// das abgelöste Fenster (panel.ts): alle Tabs kommen aus der Modul-Registry
-/// (src/modules) — Tab-Knöpfe und Content-Container entstehen hier aus der
-/// Liste der aktiven Module, Erstbefüllung per buffer_read, Updates über
-/// `<buffer>-update`-Events.
+/// das abgelöste Fenster (panel.ts): die Entwurfs-Ansicht als Kern, alle
+/// weiteren Tabs aus der Modul-Registry (src/modules) — Tab-Knöpfe und
+/// Content-Container entstehen hier aus der Liste der aktiven Module,
+/// Erstbefüllung per buffer_read, Updates über `<buffer>-update`-Events.
+/// Die Element-IDs des Entwurfs-Markups sind in beiden HTML-Dateien
+/// identisch; die Draft-Controls trägt das Markup als `.draft-only`.
 
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
+import { initPanelView, type PanelView } from "./panel-view";
 import { initPanelMode, type ModeTab, type PanelMode } from "./commands-view";
 import { panelToast } from "./tiles";
 import { PANEL_TABS, type ModuleCtx, type ModuleView } from "./modules";
@@ -13,28 +16,82 @@ import { t } from "./messages";
 import "./panel-tiles.css";
 
 export interface PanelWiring {
+  view: PanelView;
   /// Modul-Ansichten nach Tab-Modus; enthält nur Tabs aktiver Module.
   views: Map<string, ModuleView>;
   mode: { to(m: PanelMode): void; clear(): void; current(): PanelMode | null };
+  /// Entwurfstext beim Start (für die Anfangs-Modus-Entscheidung).
+  draft: string;
 }
 
 export async function wirePanel(
   project: string,
   onIncoming?: () => void,
+  standalone = false,
 ): Promise<PanelWiring> {
   const titleEl = document.querySelector(".panel-title") as HTMLElement;
-  const enabled = await invoke<string[]>("enabled_modules", { project });
-  const tabs = PANEL_TABS.filter((tab) => enabled.includes(tab.module));
+  const [enabled, defaultLang, draft] = await Promise.all([
+    invoke<string[]>("enabled_modules", { project }),
+    invoke<string>("spellcheck_lang"),
+    invoke<string>("buffer_read", { project, buffer: "panel" }),
+  ]);
+  // Feste Aufgabenteilung: Session-Tabs (ToDo, Befehle) leben im angedockten
+  // Panel, Archiv-Tabs (popupOnly: Archiv, Suche) im eigenen Panel-Fenster.
+  // Im Dock erscheinen die Archiv-Tabs nur als Öffner-Knöpfe (terminal.ts
+  // fängt den Klick und öffnet das Fenster).
+  const tabs = PANEL_TABS.filter((tab) => enabled.includes(tab.module)).filter(
+    (tab) => (standalone ? !!tab.popupOnly : true),
+  );
 
-  const ctx: ModuleCtx = { project, toast: panelToast };
+  // Ohne Archiv-Modul (abgewählt oder kein Archiv-Home) verschwinden auch
+  // die Archiv-Werkzeuge des Entwurfs-Tabs.
+  if (!enabled.includes("archive")) {
+    for (const sel of ["#panel-archive", "#panel-wiki-jump"]) {
+      const el = document.querySelector<HTMLElement>(sel)!;
+      el.hidden = true;
+      // Raus aus der draft-only-Menge, sonst blendet der Modus-Umschalter
+      // die Archiv-Werkzeuge im Dokument-Modus wieder ein.
+      el.classList.remove("draft-only");
+    }
+  }
+
+  // Jeder Wiki-Sprung (Wikilink, Chip, Dokument-Sprung) geht als ein Invoke an
+  // den Kern; das Ergebnis kommt über den Wiki-Puffer und `wiki-update` zurück.
+  // Fehler (z. B. Ziel nicht im Archiv) erscheinen als Toast.
+  const openWiki = (name: string) =>
+    void invoke("wiki_open", { project, name }).catch((e) => panelToast(String(e)));
+
+  const ctx: ModuleCtx = {
+    project,
+    standalone,
+    toast: panelToast,
+    openDoc: (path) =>
+      void invoke("panel_load", { project, path }).catch((e) => panelToast(String(e))),
+    openWiki,
+  };
+
+  const view = initPanelView({
+    content: document.getElementById("panel-content")!,
+    copyBtn: document.getElementById("panel-copy")!,
+    modeBtn: document.getElementById("panel-mode")!,
+    titleEl,
+    editBtn: document.getElementById("panel-title-edit")!,
+    editContentBtn: document.getElementById("panel-content-edit")!,
+    langSelect: document.getElementById("panel-lang") as HTMLSelectElement,
+    defaultLang,
+    onCommit: (text) => invoke("panel_set", { project, text }),
+    onWikiLink: openWiki,
+  });
 
   // Tab-Leiste und Container aus der Registry. Die Container-IDs
   // (`<mode>-content`) sind zugleich die CSS-Anker der Ansichten; die
-  // Container reihen sich hinter der Kopfzeile (.panel-head) ein.
+  // Container reihen sich hinter #panel-content ein.
   const tabsEl = document.getElementById("panel-tabs")!;
   const views = new Map<string, ModuleView>();
   const modeTabs: ModeTab[] = [];
-  let anchor = document.querySelector(".panel-head") as HTMLElement;
+  /// Tabs mit eigener Ansicht in DIESER Fläche (Öffner-Knöpfe zählen nicht).
+  const activeTabs: typeof tabs = [];
+  let anchor = document.getElementById("panel-content")!;
   for (const tab of tabs) {
     const btn = document.createElement("button");
     btn.className = "panel-btn";
@@ -47,12 +104,20 @@ export async function wirePanel(
       sep.className = "tab-sep";
       tabsEl.append(sep);
     }
-    const content = document.createElement("div");
-    content.id = `${tab.mode}-content`;
-    content.hidden = true;
-    anchor.after(content);
-    anchor = content;
-    views.set(tab.mode, tab.init(content, ctx));
+    // Archiv-Tabs im Dock: nur der Öffner-Knopf, keine Ansicht.
+    if (tab.popupOnly && !standalone) {
+      continue;
+    }
+    activeTabs.push(tab);
+    let content: HTMLElement | null = null;
+    if (tab.init) {
+      content = document.createElement("div");
+      content.id = `${tab.mode}-content`;
+      content.hidden = true;
+      anchor.after(content);
+      anchor = content;
+      views.set(tab.mode, tab.init(content, ctx));
+    }
     modeTabs.push({
       mode: tab.mode,
       btn,
@@ -63,34 +128,43 @@ export async function wirePanel(
         : undefined,
     });
   }
-  // Archiv-Zugang: fester Knopf hinter den Tabs — öffnet das Trilium-Fenster
-  // des Projekts (kein Modus, kein Content-Container).
-  if (enabled.includes("trilium")) {
-    const btn = document.createElement("button");
-    btn.className = "panel-btn";
-    btn.textContent = t("panel.archiveOpen");
-    btn.title = t("panel.archiveOpenTitle");
-    btn.addEventListener("click", () =>
-      void invoke("trilium_open", { project, noteId: null }).catch((e) =>
-        panelToast(String(e)),
-      ),
-    );
-    tabsEl.append(btn);
-  }
+  const mode = initPanelMode({
+    tabs: modeTabs,
+    draftEls: [
+      document.getElementById("panel-content")!,
+      ...document.querySelectorAll<HTMLElement>(".draft-only"),
+    ],
+    titleEl,
+    flush: () => void view.flush(),
+  });
 
-  const mode = initPanelMode({ tabs: modeTabs, titleEl });
+  // Sprung Dokument → Wiki: öffnet den Archiv-Navigator (Dokumentseiten im
+  // Wiki gibt es nicht mehr — Dokumente öffnen immer im Dokument-Tab).
+  document
+    .getElementById("panel-wiki-jump")!
+    .addEventListener("click", () => openWiki("tag:"));
 
+  view.set(draft);
+  await listen<string>("panel-update", (e) => {
+    // Erst umschalten, dann setzen: to("draft") restauriert den gemerkten
+    // Titel — der neue Inhalt (und damit sein Titel) muss danach kommen.
+    mode.to("draft");
+    view.set(e.payload);
+    onIncoming?.();
+  });
   await Promise.all(
-    tabs.map(async (tab) => {
-      const v = views.get(tab.mode)!;
-      v.set(await invoke<string>("buffer_read", { project, buffer: tab.buffer }));
-      await listen<string>(`${tab.buffer}-update`, (e) => {
-        v.set(e.payload);
-        mode.to(tab.mode);
-        onIncoming?.();
-      });
-    }),
+    activeTabs
+      .filter((tab) => tab.init)
+      .map(async (tab) => {
+        const v = views.get(tab.mode)!;
+        v.set(await invoke<string>("buffer_read", { project, buffer: tab.buffer }));
+        await listen<string>(`${tab.buffer}-update`, (e) => {
+          v.set(e.payload);
+          mode.to(tab.mode);
+          onIncoming?.();
+        });
+      }),
   );
 
-  return { views, mode };
+  return { view, views, mode, draft };
 }