Restore the Claude tool window with the journal (KL-native)

kec · kec · commit 9974a4af9d39 · 2026-06-06T12:12:54.000-07:00
A tool window hosts a non-entity KlToolArea, so it can't flow through the entity-centric EntityKlWindowFactory (whose create/restore are typed to AbstractEntityChapterKlWindow). Instead it persists its geometry + the hosting KlToolArea.Factory class name, and a static restore() resolves that factory across module layers via PluggableService.forName — the same cross-layer mechanism the Kl framework uses in KlView.restore. The journal dispatches to it by window-type prefix; entity windows keep the existing path. - ToolAreaChapterKlWindow: registered TOOL_WINDOW_TYPE; real save()/revert() (geometry + TOOL_AREA_FACTORY_CLASS); static restore(WindowSettings, prefs). - JournalController: createToolAreaWindow gives the window a real prefs node; restoreWindows branches by prefix to the KL-native restore; saveWindows now persists every window's state before recording the list. Conversations already persist per-KB/user, so a restored area reloads its rail. Refs: IKE-Network/ike-issues#562
diff --git a/kview/src/main/java/dev/ikm/komet/kview/klwindows/ToolAreaChapterKlWindow.java b/kview/src/main/java/dev/ikm/komet/kview/klwindows/ToolAreaChapterKlWindow.java
@@ -16,10 +16,12 @@
 package dev.ikm.komet.kview.klwindows;
 
 import dev.ikm.komet.framework.view.ViewProperties;
+import dev.ikm.komet.framework.window.WindowSettings;
 import dev.ikm.komet.layout.area.KlToolArea;
 import dev.ikm.komet.layout.preferences.KlPreferencesFactory;
 import dev.ikm.komet.layout.preferences.KlProfiles;
 import dev.ikm.komet.preferences.KometPreferences;
+import dev.ikm.tinkar.common.service.PluggableService;
 import javafx.scene.layout.BorderPane;
 import javafx.scene.layout.Pane;
 import javafx.scene.layout.Region;
@@ -28,26 +30,36 @@
 
 import java.util.UUID;
 
+import static dev.ikm.komet.kview.events.EventTopics.JOURNAL_TOPIC;
+
 /**
  * A non-entity chapter window that hosts a {@link KlToolArea} (e.g. the Claude Assistant)
  * inside the Journal workspace.
  *
  * <p>The window is a thin host: it instantiates the supplied tool-area factory, hands the
  * area the journal {@link ViewProperties} and a close callback, and exposes the area's
- * {@code fxObject()} as its content pane. Tool windows are ephemeral — their conversation
- * state is not persisted or restored across sessions — so {@link #save()} and
- * {@link #revert()} are intentionally no-ops.
+ * {@code fxObject()} as its content pane.
+ *
+ * <p><b>Restoration uses the Kl framework, not the entity-centric path.</b> Because a tool
+ * window has no {@link dev.ikm.tinkar.terms.EntityFacade}, it cannot flow through
+ * {@link EntityKlWindowFactory} (whose {@code create}/{@code restore} are typed to
+ * {@link AbstractEntityChapterKlWindow}). Instead {@link #save()} records the hosting
+ * {@link KlToolArea.Factory} class name, and the static {@link #restore} resolves it across
+ * module layers with {@link PluggableService#forName(String)} — the same cross-layer
+ * mechanism the Kl framework uses in {@code KlView.restore}. The journal dispatches to it by
+ * {@linkplain EntityKlWindowType#getPrefix() window-type prefix}. The area's conversations
+ * persist independently (per knowledge base, per user), so a restored area reloads its rail.
  */
 public final class ToolAreaChapterKlWindow extends AbstractChapterKlWindow<Pane> {
 
     private static final Logger LOG = LoggerFactory.getLogger(ToolAreaChapterKlWindow.class);
 
     /**
-     * Ephemeral, non-entity window type shared by all tool-area windows. The prefix is
-     * distinct from the entity window types so persisted-workspace scans never mistake a
-     * tool window for an entity chapter.
+     * Non-entity window type shared by all tool-area windows. The prefix is distinct from the
+     * entity window types so the journal can dispatch restoration to {@link #restore} and so
+     * persisted-workspace scans never mistake a tool window for an entity chapter.
      */
-    private static final EntityKlWindowType TOOL_WINDOW_TYPE = new EntityKlWindowType() {
+    public static final EntityKlWindowType TOOL_WINDOW_TYPE = new EntityKlWindowType() {
         @Override
         public String getPrefix() {
             return "journal_tool_";
@@ -59,22 +71,37 @@ public String toString() {
         }
     };
 
+    /** Preference key holding the hosting {@link KlToolArea.Factory} class name. */
+    public static final String TOOL_AREA_FACTORY_CLASS = "TOOL_AREA_FACTORY_CLASS";
+
+    static {
+        // Register the (non-enum) tool window type so EntityKlWindowState.fromPreferences and
+        // revert() can round-trip the persisted WINDOW_TYPE string. Idempotent.
+        try {
+            EntityKlWindowType.Registry.registerInstance(TOOL_WINDOW_TYPE);
+        } catch (RuntimeException alreadyRegistered) {
+            // already registered (duplicate prefix) — fine
+        }
+    }
+
     private final UUID windowTopic;
+    private final String areaFactoryClassName;
 
     /**
      * Creates a tool window hosting the area produced by {@code toolAreaFactory}.
      *
      * @param windowTopic     unique identifier for this window instance
      * @param toolAreaFactory the discovered factory that produces the tool area to host
      * @param viewProperties  the hosting journal's view properties, passed through to the area
-     * @param preferences     window preferences, or {@code null} for an ephemeral window
+     * @param preferences     window preferences node (non-null so the window can be restored)
      */
     public ToolAreaChapterKlWindow(UUID windowTopic,
                                    KlToolArea.Factory<?, ?> toolAreaFactory,
                                    ViewProperties viewProperties,
                                    KometPreferences preferences) {
         super(viewProperties, preferences);
         this.windowTopic = windowTopic;
+        this.areaFactoryClassName = toolAreaFactory.getClass().getName();
 
         final KlPreferencesFactory areaPreferencesFactory =
                 KlProfiles.sharedWindowPreferenceFactory(toolAreaFactory.getClass());
@@ -89,6 +116,41 @@ public ToolAreaChapterKlWindow(UUID windowTopic,
         LOG.info("Created tool window {} hosting {}", windowTopic, toolAreaFactory.toolName());
     }
 
+    /**
+     * Restores a tool window from its saved preferences using the Kl framework's native,
+     * cross-layer factory resolution: it reads the persisted {@link KlToolArea.Factory} class
+     * name and loads it with {@link PluggableService#forName(String)} (which spans the plugin
+     * module layer), re-creates the area, and re-applies the saved window geometry. No
+     * {@code EntityFacade} is involved.
+     *
+     * @param windowSettings the journal's parent window settings
+     * @param preferences    the saved window preferences node
+     * @return the restored tool window
+     */
+    public static ToolAreaChapterKlWindow restore(WindowSettings windowSettings, KometPreferences preferences) {
+        final EntityKlWindowState windowState = EntityKlWindowState.fromPreferences(preferences);
+        final UUID windowTopic = windowState.getWindowId();
+        final UUID journalTopic = preferences.getUuid(JOURNAL_TOPIC)
+                .orElseThrow(() -> new IllegalStateException("No journal topic for tool window " + windowTopic));
+        final ViewProperties viewProperties =
+                KlWindowPreferencesUtils.getJournalViewProperties(windowSettings, journalTopic);
+        final String factoryClassName = preferences.get(TOOL_AREA_FACTORY_CLASS)
+                .orElseThrow(() -> new IllegalStateException("No tool-area factory class for " + windowTopic));
+        try {
+            final Class<?> factoryClass = PluggableService.forName(factoryClassName);
+            final KlToolArea.Factory<?, ?> toolAreaFactory =
+                    (KlToolArea.Factory<?, ?>) factoryClass.getDeclaredConstructor().newInstance();
+            final ToolAreaChapterKlWindow window =
+                    new ToolAreaChapterKlWindow(windowTopic, toolAreaFactory, viewProperties, preferences);
+            window.revert();
+            LOG.info("Restored tool window {} hosting {}", windowTopic, factoryClassName);
+            return window;
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException("Failed to restore tool window " + windowTopic
+                    + " from factory " + factoryClassName, e);
+        }
+    }
+
     @Override
     public UUID getWindowTopic() {
         return windowTopic;
@@ -101,19 +163,29 @@ public EntityKlWindowType getWindowType() {
 
     @Override
     public void onShown() {
-        // No deferred initialization required; the area builds its UI on construction.
+        // Persist immediately so the journal can restore this window next session
+        // (the journal's saveWindows() later re-saves the final placement).
+        save();
     }
 
-    // ---- Ephemeral: conversation state is not persisted across sessions ------------------
+    // ---- Persistence: window geometry + the hosting tool-area factory class --------------
 
     @Override
     public void save() {
-        // Intentionally no-op: tool windows are not restored across sessions.
+        super.save();   // base: WINDOW_ID, WINDOW_TYPE, position, size
+        if (preferences != null && areaFactoryClassName != null) {
+            preferences.put(TOOL_AREA_FACTORY_CLASS, areaFactoryClassName);
+            try {
+                preferences.flush();
+            } catch (Exception e) {
+                LOG.error("Failed to persist tool-area factory class for {}", windowTopic, e);
+            }
+        }
     }
 
     @Override
     public void revert() {
-        // Intentionally no-op: nothing to restore.
+        super.revert();   // base: re-apply persisted position/size
     }
 
     // ---- AbstractChapterKlWindow contract (no property panel for tool windows) -----------
@@ -140,11 +212,11 @@ protected void setSelectedPropertyPanel(String selectedPanel) {
 
     @Override
     protected void captureAdditionalState(EntityKlWindowState state) {
-        // Ephemeral window: no additional state to capture.
+        // The factory-class key is written directly in save(); no extra state object fields.
     }
 
     @Override
     protected void applyAdditionalState(EntityKlWindowState state) {
-        // Ephemeral window: no additional state to apply.
+        // No additional state to apply.
     }
 }
diff --git a/kview/src/main/java/dev/ikm/komet/kview/mvvm/view/journal/JournalController.java b/kview/src/main/java/dev/ikm/komet/kview/mvvm/view/journal/JournalController.java
@@ -100,6 +100,7 @@
 import dev.ikm.komet.kview.fxutils.SlideOutTrayHelper;
 import dev.ikm.komet.kview.klwindows.AbstractEntityChapterKlWindow;
 import dev.ikm.komet.kview.klwindows.ChapterKlWindow;
+import dev.ikm.komet.kview.klwindows.AbstractChapterKlWindow;
 import dev.ikm.komet.kview.klwindows.ToolAreaChapterKlWindow;
 import dev.ikm.komet.kview.klwindows.EntityKlWindowTypes;
 import dev.ikm.komet.kview.klwindows.KlWindowPreferencesUtils;
@@ -544,8 +545,11 @@ private void initContextMenuWithKLWindows() {
     private void createToolAreaWindow(KlToolArea.Factory toolAreaFactory) {
         ViewProperties viewProperties =
                 windowView.makeOverridableViewProperties("JournalController.createToolAreaWindow");
+        final java.util.UUID windowTopic = java.util.UUID.randomUUID();
+        final KometPreferences windowPreferences = KlWindowPreferencesUtils.getWindowPreferences(
+                journalTopic, windowTopic, ToolAreaChapterKlWindow.TOOL_WINDOW_TYPE);
         ToolAreaChapterKlWindow toolWindow = new ToolAreaChapterKlWindow(
-                java.util.UUID.randomUUID(), toolAreaFactory, viewProperties, null);
+                windowTopic, toolAreaFactory, viewProperties, windowPreferences);
         setupWorkspaceWindow(toolWindow);
     }
 
@@ -1581,6 +1585,18 @@ public UUID getJournalTopic() {
     public void saveWindows(KometPreferences journalWindowPreferences) {
         Objects.requireNonNull(journalWindowPreferences, "journalWindowPreferences cannot be null");
 
+        // Persist each window's current state before recording the list, so restoration
+        // brings them back where they were (tool windows have no reactive save trigger).
+        workspace.getWindows().forEach(window -> {
+            if (window instanceof AbstractChapterKlWindow<?> chapterWindow) {
+                try {
+                    chapterWindow.save();
+                } catch (Exception e) {
+                    LOG.error("Error saving window state for {}", window.getWindowTopic(), e);
+                }
+            }
+        });
+
         final ImmutableList<String> windowNames = Lists.immutable.fromStream(workspace.getWindows()
                 .stream().map(window -> {
                     final UUID windowTopic = window.getWindowTopic();
@@ -1643,7 +1659,13 @@ public void restoreWindows(WindowSettings windowSettings, PrefX journalWindowSet
                 final KometPreferences windowPreferences = journalPreferences.node(windowId);
                 windowPreferences.putUuid(JOURNAL_TOPIC, getJournalTopic());
                 try {
-                    setupWorkspaceWindow(restoreWindow(windowSettings, windowPreferences));
+                    if (windowId.startsWith(ToolAreaChapterKlWindow.TOOL_WINDOW_TYPE.getPrefix())) {
+                        // Non-entity tool window: restore via the Kl framework (PluggableService),
+                        // not the entity-centric EntityKlWindowFactory path.
+                        setupWorkspaceWindow(ToolAreaChapterKlWindow.restore(windowSettings, windowPreferences));
+                    } else {
+                        setupWorkspaceWindow(restoreWindow(windowSettings, windowPreferences));
+                    }
                 } catch (Exception e) {
                     LOG.error("Error restoring window: {}", windowId, e);
                 }
