Fixed session name not saved to the stopped session in the Save & Switch dialog

CHANGELOG.md

@@ -1,3 +1,4 @@
+- Fixed the session name entered in the Save & Switch dialog not being saved to the session that was closed (affected named connection profiles, projects with several sessions, and conversations switched with /resume inside the terminal), including when choosing Restart Advanced
 # 1.3.45 (2026-10-28)
 - Fixed edit-mode detection and switching while background agents or shells are listed under the status line
 # 1.3.42 (2026-10-22)

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>io.github.nbplugins</groupId>
     <artifactId>netbeans-plugin-claude-code-gui</artifactId>
-    <version>1.3.69-SNAPSHOT</version>
+    <version>1.3.71-SNAPSHOT</version>
     <packaging>nbm</packaging>
     <name>Netbeans Plugin Claude Code GUI</name>
     <description>NetBeans plugin that provides a GUI for Claude Code CLI — run claude code sessions directly inside the IDE.</description>

src/main/java/io/github/nbplugins/claudecodegui/process/ClaudeProcess.java

@@ -82,6 +82,12 @@ public ClaudeProcess() {}
     /** UUID of the active OpenAI proxy session; {@code null} when not using OpenAI proxy. */
     private volatile String openAIProxyUuid;
 
+    /**
+     * Effective {@code CLAUDE_CONFIG_DIR} used by the running process (never
+     * {@code null} while a process is running).  Defaults to {@code ~/.claude}.
+     */
+    private volatile Path effectiveConfigDir;
+
     /**
      * Starts a Claude CLI PTY process in the given working directory using
      * the Default profile (no extra env vars injected).
@@ -158,6 +164,7 @@ public PtyProcess start(String workingDir, ClaudeProfile profile, String extraCl
         String executable = ClaudeCodePreferences.resolveClaudeExecutable();
 
         Map<String, String> env = buildEnv(profile, ClaudeCodePreferences.getProfilesDir());
+        effectiveConfigDir = configDirFrom(env);
 
         // OpenAI proxy: register session and inject ANTHROPIC_BASE_URL pointing to internal proxy
         if (profile != null
@@ -333,10 +340,7 @@ void appendSessionFlags(List<String> cmd, String workingDir, Map<String, String>
         }
 
         if (mode == SessionMode.CONTINUE_LAST) {
-            String configDirStr = env.get("CLAUDE_CONFIG_DIR");
-            Path claudeConfigDir = configDirStr != null
-                    ? Path.of(configDirStr)
-                    : Path.of(System.getProperty("user.home"), ".claude");
+            Path claudeConfigDir = configDirFrom(env);
             if (ClaudeSessionStore.hasAnySessions(Path.of(workingDir), claudeConfigDir)) {
                 cmd.add("--continue");
                 LOG.fine("Session mode: --continue (existing session found)");
@@ -822,6 +826,42 @@ static Map<String, String> buildEnv(ClaudeProfile profile, java.nio.file.Path pr
         return env;
     }
 
+    /**
+     * Resolves the effective {@code CLAUDE_CONFIG_DIR} from an environment map.
+     *
+     * @param env environment map used for the child process
+     * @return the configured directory, or {@code ~/.claude} when not overridden
+     */
+    static java.nio.file.Path configDirFrom(Map<String, String> env) {
+        String configDirStr = env.get("CLAUDE_CONFIG_DIR");
+        return configDirStr != null && !configDirStr.isBlank()
+                ? java.nio.file.Path.of(configDirStr)
+                : java.nio.file.Path.of(System.getProperty("user.home"), ".claude");
+    }
+
+    /**
+     * Resolves the config dir the given profile will use once started.
+     *
+     * <p>This mirrors {@link #buildEnv} (including profile extra env vars), so it
+     * can be used to inspect the session store before the process is launched.
+     *
+     * @param profile     connection profile; {@code null} for Default
+     * @param profilesDir base directory for profile config dirs
+     * @return effective config dir of a session started with this profile
+     */
+    public static java.nio.file.Path resolveConfigDir(ClaudeProfile profile, java.nio.file.Path profilesDir) {
+        return configDirFrom(buildEnv(profile, profilesDir));
+    }
+
+    /**
+     * Returns the effective config dir of the current (or most recent) process.
+     *
+     * @return resolved config dir, or {@code null} if no process was started yet
+     */
+    public java.nio.file.Path getConfigDir() {
+        return effectiveConfigDir;
+    }
+
     private static void ensureLocalhostInNoProxy(Map<String, String> env) {
         // Normalize lowercase no_proxy → NO_PROXY (Linux systems may use either)
         if (!env.containsKey("NO_PROXY") && env.containsKey("no_proxy")) {

src/main/java/io/github/nbplugins/claudecodegui/process/PtyTtyConnector.java

@@ -34,6 +34,9 @@ public final class PtyTtyConnector implements TtyConnector {
     private final PtyProcess process;
     private final InputStreamReader reader;
 
+    /** Time source for the submission timestamps passed to the input listener. */
+    private final java.util.function.LongSupplier clock;
+
     private String tag = "";
 
     /** Accumulates raw chars between newlines for line-based detection. */
@@ -42,13 +45,41 @@ public final class PtyTtyConnector implements TtyConnector {
     /** Invoked with each stripped line; {@code null} means no listener. */
     private volatile Consumer<String> lineListener;
 
+    /** Invoked with every byte block written to the PTY and the time the write
+     *  started; {@code null} means no listener. */
+    private volatile java.util.function.BiConsumer<byte[], Long> inputListener;
+
+    /**
+     * Lock held while bytes are forwarded to the child and the input listener
+     * is notified; {@code null} means no serialization. The controller passes
+     * the lock it also holds while it writes the GUI prompt's Enter, so
+     * terminal input cannot reach the child on one side of that Enter while
+     * being recorded on the other.
+     */
+    private volatile Object inputLock;
+
+    /**
+     * Sets the lock that serializes forwarding with the plugin's own writes.
+     *
+     * @param lock the lock, or {@code null} for none
+     */
+    public void setInputLock(Object lock) {
+        this.inputLock = lock;
+    }
+
     /**
      * Creates a connector for the given PTY process.
      *
      * @param process a running PTY process
      */
     public PtyTtyConnector(PtyProcess process) {
+        this(process, System::currentTimeMillis);
+    }
+
+    /** Package-private for tests: injects the clock used for terminal submissions. */
+    PtyTtyConnector(PtyProcess process, java.util.function.LongSupplier clock) {
         this.process = process;
+        this.clock = clock;
         this.reader = new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8);
     }
 
@@ -64,6 +95,21 @@ public void setLineListener(Consumer<String> listener) {
         this.lineListener = listener;
     }
 
+    /**
+     * Sets a listener that receives every block of bytes written to the PTY —
+     * both plugin-sent input and text typed in the terminal — together with the
+     * time the write started.
+     *
+     * <p>The timestamp is sampled before the bytes are forwarded so that a
+     * child which appends the submitted prompt to its session file right after
+     * reading them cannot produce a record later than the reported time.
+     *
+     * @param listener the listener, or {@code null} to clear
+     */
+    public void setInputListener(java.util.function.BiConsumer<byte[], Long> listener) {
+        this.inputListener = listener;
+    }
+
     /**
      * Sets a session tag used as a log prefix for debugging.
      *
@@ -107,8 +153,32 @@ public int read(char[] buf, int offset, int length) throws IOException {
 
     @Override
     public void write(byte[] bytes) throws IOException {
+        // Terminal input and the plugin's own writes (in particular the GUI
+        // prompt's Enter) must reach the child in the same order in which they
+        // are recorded: forwarding bytes before the GUI Enter while notifying
+        // the listener only after the plugin reset its recorder would leave
+        // those bytes behind as the draft of the next line. The controller
+        // takes the same lock for the GUI Enter.
+        Object lock = inputLock;
+        if (lock == null) {
+            forward(bytes);
+            return;
+        }
+        synchronized (lock) {
+            forward(bytes);
+        }
+    }
+
+    private void forward(byte[] bytes) throws IOException {
+        // Sampled before the bytes are forwarded: the child can append the
+        // submitted prompt to its session file as soon as it reads them, so a
+        // timestamp taken after the write/listener could be later than the
+        // record the controller uses as evidence.
+        long sentAt = clock.getAsLong();
         process.getOutputStream().write(bytes);
         process.getOutputStream().flush();
+        java.util.function.BiConsumer<byte[], Long> l = inputListener;
+        if (l != null) l.accept(bytes, sentAt);
     }
 
     @Override

src/main/java/io/github/nbplugins/claudecodegui/ui/ClaudePromptPanel.java

@@ -84,6 +84,12 @@ public final class ClaudePromptPanel extends JPanel {
     private final Runnable               onShowSessionStatistics;
     /** Returns whether Session Statistics is available for the current session's connection type. */
     private final Supplier<Boolean>      sessionStatisticsAvailable;
+    /**
+     * Returns whether a prompt can be delivered right now. The send key must
+     * respect it: while a session is still starting, {@code onSend} would drop
+     * the text, so the field keeps it instead.
+     */
+    private volatile Supplier<Boolean>   sendAvailable = () -> true;
 
     /** Current position in the history list; {@code -1} = newest (empty field). */
     private int historyIndex = -1;
@@ -243,6 +249,19 @@ public void setReadyState(boolean ready) {
         cancelButton.setEnabled(!ready);
     }
 
+    /**
+     * Sets the predicate that decides whether a sent prompt can be delivered.
+     *
+     * <p>When it returns {@code false}, {@code doSend()} leaves the input text
+     * untouched instead of clearing it for a prompt that would be dropped —
+     * e.g. while the session process is still starting.
+     *
+     * @param sendAvailable the availability predicate, or {@code null} to always allow
+     */
+    public void setSendAvailable(Supplier<Boolean> sendAvailable) {
+        this.sendAvailable = sendAvailable != null ? sendAvailable : () -> true;
+    }
+
     /**
      * Requests keyboard focus on the text input area.
      */
@@ -321,6 +340,9 @@ public void keyPressed(KeyEvent e) {
     private void doSend() {
         String text = inputArea.getText();
         if (text.isEmpty()) return;
+        // Nothing can consume the prompt yet (e.g. the session is still
+        // starting): keep the text so the user does not lose it.
+        if (!Boolean.TRUE.equals(sendAvailable.get())) return;
 
         inputArea.setText("");
         inputArea.requestFocusInWindow();

src/main/java/io/github/nbplugins/claudecodegui/ui/ClaudeSessionSelectorPanel.java

@@ -407,6 +407,46 @@ private void reloadSessionModePanel() {
         }
     }
 
+    /**
+     * Reloads the session list of the embedded mode panel without changing the
+     * selected mode.  Called after a session stops so a name saved by the
+     * Save & Switch dialog is visible immediately.
+     *
+     * <p>The transcript files are parsed on a worker (the reload runs while the
+     * tab tears down its chat UI); only the table update happens on the EDT.
+     */
+    public void refreshSessionList() {
+        if (sessionModePanel == null) return;
+        File dir = resolveDir();
+        java.nio.file.Path workingDir = dir != null ? dir.toPath() : null;
+        java.nio.file.Path configDir = resolveClaudeConfigDir();
+        if (workingDir == null) {
+            sessionModePanel.reload(null, configDir, null);
+            return;
+        }
+        long requestId = ++sessionListRequestSeq;
+        Thread loader = new Thread(() -> {
+            java.util.List<io.github.nbplugins.claudecodegui.model.SavedSession> sessions;
+            try {
+                sessions = io.github.nbplugins.claudecodegui.process.ClaudeSessionStore
+                        .listSessions(workingDir, configDir);
+            } catch (RuntimeException e) {
+                LOG.fine("Could not reload the session list: " + e);
+                sessions = java.util.List.of();
+            }
+            java.util.List<io.github.nbplugins.claudecodegui.model.SavedSession> loaded = sessions;
+            javax.swing.SwingUtilities.invokeLater(() -> {
+                if (requestId != sessionListRequestSeq) return; // superseded
+                sessionModePanel.applySessionsIfCurrent(workingDir, configDir, loaded);
+            });
+        }, "session-list-reload");
+        loader.setDaemon(true);
+        loader.start();
+    }
+
+    /** Sequence of the last asynchronous refresh, to drop superseded results. */
+    private long sessionListRequestSeq;
+
     private File resolveDir() {
         Object item = pathCombo != null ? pathCombo.getSelectedItem() : null;
         if (item == null || item.toString().isBlank()) return null;
@@ -453,6 +493,12 @@ private void onOpen() {
             saveToHistory(dir.getAbsolutePath());
         }
 
+        if (!sessionModePanel.isSelectionValid()) {
+            showError(NbBundle.getMessage(ClaudeSessionSelectorPanel.class,
+                    "ERR_NoSessionSelected"));
+            return;
+        }
+
         errorLabel.setVisible(false);
         openListener.onOpen(dir, getSelectedProfileName(), extraArgsField.getText().trim(),
                 sessionModePanel.getSelectedMode(),