clay-server 2.38.0 → 2.39.0-beta.1

package/lib/project-connection.js

@@ -151,6 +151,12 @@ function attachConnection(ctx) {
     sendTo(ws, { type: "email_accounts_list", accounts: emailAccountsList, providers: emailAccounts.PROVIDER_PRESETS });
     sendTo(ws, { type: "notes_list", notes: nm.list() });
     sendTo(ws, { type: "loop_registry_updated", records: getHubSchedules() });
+    // Initial per-user preference: how to render Claude sessions.
+    if (usersModule && typeof usersModule.getClaudeOpenMode === "function") {
+      var _comUid = (wsUser && wsUser.id) || null;
+      var _comVal = _comUid ? usersModule.getClaudeOpenMode(_comUid) : "tui";
+      sendTo(ws, { type: "claude_open_mode_changed", claudeOpenMode: _comVal || "tui" });
+    }
     _loop.sendConnectionState(ws);
     if (_mcp) _mcp.sendConnectionState(ws);
     if (_notifications) _notifications.sendConnectionState(ws, sendTo);
@@ -201,7 +207,7 @@ function attachConnection(ctx) {
       }
       ws._clayActiveSession = active.localId;
       var _vendorCaps = (sm.capabilitiesByVendor && sm.capabilitiesByVendor[active.vendor || sm.defaultVendor || "claude"]) || {};
-      sendTo(ws, { type: "session_switched", id: active.localId, cliSessionId: active.cliSessionId || null, loop: active.loop || null, vendor: active.vendor || null, hasHistory: (active.history && active.history.length > 0), capabilities: _vendorCaps });
+      sendTo(ws, { type: "session_switched", id: active.localId, cliSessionId: active.cliSessionId || null, loop: active.loop || null, vendor: active.vendor || null, hasHistory: (active.history && active.history.length > 0), capabilities: _vendorCaps, mode: active.mode || "gui", terminalId: typeof active.terminalId === "number" ? active.terminalId : null, runtimeMode: active.runtimeMode || null, runtimeTerminalId: typeof active.runtimeTerminalId === "number" ? active.runtimeTerminalId : null });
       // Send per-session context sources
       var sessionSources = loadContextSources(slug, active.localId);
       sendTo(ws, { type: "context_sources_state", active: sessionSources });

package/lib/project-sessions.js

@@ -1,5 +1,6 @@
 var fs = require("fs");
 var path = require("path");
+var crypto = require("crypto");
 var { execFileSync } = require("child_process");
 var { CODEX_DEFAULTS, getCodexConfig } = require("./codex-defaults");
 
@@ -99,6 +100,89 @@ function attachSessions(ctx) {
   var loadContextSources = ctx.loadContextSources;
   var saveContextSources = ctx.saveContextSources;
 
+  // Resolve the active user's Claude open-mode preference ('gui' or 'tui').
+  // Multi-user mode reads per-user storage; single-user mode falls back to
+  // the daemon-level default ('gui').
+  function getClaudeOpenModeForWs(ws) {
+    if (!usersModule || typeof usersModule.getClaudeOpenMode !== "function") return "tui";
+    var uid = ws && ws._clayUser ? ws._clayUser.id : null;
+    if (!uid) return "tui";
+    try { return usersModule.getClaudeOpenMode(uid) || "tui"; } catch (e) { return "tui"; }
+  }
+
+  // Spawn a transient PTY for "view this Claude GUI session as TUI" (the
+  // user's claudeOpenMode is 'tui'). The session itself stays a GUI session
+  // on disk; we only attach a runtime terminal so xterm can render
+  // `claude --resume <cliSessionId>`. When the PTY dies the runtime link
+  // clears and the next click can re-attach without converting the session.
+  function spawnRuntimeTuiPty(session, ws) {
+    if (!tm || !session || !session.cliSessionId) return null;
+    if (typeof session.runtimeTerminalId === "number") {
+      // A previous click already spawned one; reuse it. tm.attach will
+      // replay scrollback on the new client subscription.
+      return session.runtimeTerminalId;
+    }
+    var sid = session.cliSessionId;
+    var localId = session.localId;
+    var cmd = "claude --resume " + sid + "; exit\n";
+    var term = tm.create(80, 24, getOsUserInfoForWs(ws), ws, {
+      initialInput: cmd,
+      kind: "tui-session",
+      title: "claude (resume) " + sid.slice(0, 8),
+      onExit: function () {
+        // Don't delete the session record - the underlying GUI session is
+        // still real. Just drop the runtime link so the sidebar/icon can
+        // refresh.
+        var s = sm.sessions.get(localId);
+        if (s) {
+          s.runtimeTerminalId = null;
+          try { sm.broadcastSessionList(); } catch (e) {}
+        }
+      },
+    });
+    if (term) {
+      session.runtimeTerminalId = term.id;
+      return term.id;
+    }
+    return null;
+  }
+
+  // In-place conversion of a TUI session to GUI when the user's preference
+  // is 'gui'. Reads the jsonl transcript through the existing import path
+  // (same code Import CLI uses), populates session.history, flips the mode
+  // to 'gui', and kills the PTY. Subsequent clicks render via the SDK chat.
+  function convertTuiSessionToGui(session) {
+    if (!session || session.cliSessionId == null) return;
+    var cliSess;
+    try { cliSess = require("./cli-sessions"); } catch (e) { return; }
+    var history = null;
+    try { history = cliSess.readCliSessionHistory(cwd, session.cliSessionId); } catch (e) { history = null; }
+    if (Array.isArray(history)) {
+      session.history = history;
+    }
+    session.mode = "gui";
+    if (typeof session.terminalId === "number" && tm) {
+      try { tm.close(session.terminalId); } catch (e) {}
+    }
+    session.terminalId = null;
+    try { sm.saveSessionFile(session); } catch (e) {}
+  }
+
+  // Compute the runtimeMode the client should render for this session given
+  // the user's current preference. Pure function over session + pref; the
+  // caller decides whether to also mutate state (spawn PTY, convert, etc.)
+  // via the helpers above.
+  function computeRuntimeMode(session, pref) {
+    if (!session) return "gui";
+    if (session.vendor && session.vendor !== "claude") return session.mode || "gui";
+    var effPref = (pref === "gui") ? "gui" : "tui";
+    if (session.mode === "tui") {
+      return effPref === "gui" ? "gui" : "tui";
+    }
+    // session.mode === 'gui'
+    return effPref === "tui" ? "tui" : "gui";
+  }
+
   function handleSessionsMessage(ws, msg) {
 
     if (msg.type === "push_subscribe") {
@@ -128,7 +212,57 @@ function attachSessions(ctx) {
       if (ws._clayUser && usersModule.isMultiUser()) sessionOpts.ownerId = ws._clayUser.id;
       if (msg.sessionVisibility) sessionOpts.sessionVisibility = msg.sessionVisibility;
       if (msg.vendor) sessionOpts.vendor = msg.vendor;
-      var newSess = sm.createSession(sessionOpts, ws);
+      // Mode resolution: codex sessions are always GUI (no TUI adapter).
+      // Claude sessions honor the explicit msg.mode if provided, otherwise
+      // fall back to the user's claudeOpenMode preference. This is what
+      // makes the sidebar's "Claude" icon button create the right kind of
+      // session without the client needing to know the preference.
+      var requestedMode;
+      if (msg.vendor === "codex") {
+        requestedMode = "gui";
+      } else if (msg.mode === "tui" || msg.mode === "gui") {
+        requestedMode = msg.mode;
+      } else {
+        requestedMode = getClaudeOpenModeForWs(ws);
+      }
+      var newSess;
+      if (requestedMode === "tui") {
+        // TUI sessions own their cliSessionId up-front so we can launch
+        // `claude --session-id <uuid>` and resume the same conversation
+        // from external terminals (claude --resume <uuid>) and from the
+        // jsonl watcher (~/.claude/projects/<cwd>/<uuid>.jsonl).
+        //
+        // Construction order matters: createSession() fires session_switched
+        // synchronously, so we must populate terminalId on the record before
+        // switching. Use createSessionRaw + switchSession to get the right
+        // ordering and avoid an extra rebroadcast.
+        sessionOpts.mode = "tui";
+        sessionOpts.cliSessionId = crypto.randomUUID();
+        sessionOpts.vendor = sessionOpts.vendor || "claude";
+        newSess = sm.createSessionRaw(sessionOpts);
+        if (tm) {
+          var tuiSid = newSess.cliSessionId;
+          var tuiLocalId = newSess.localId;
+          var tuiCmd = "claude --session-id " + tuiSid + "; exit\n";
+          var tuiTerm = tm.create(80, 24, getOsUserInfoForWs(ws), ws, {
+            initialInput: tuiCmd,
+            kind: "tui-session",
+            title: "claude " + tuiSid.slice(0, 8),
+            onExit: function () {
+              if (sm.sessions.has(tuiLocalId)) {
+                try { sm.deleteSessionQuiet(tuiLocalId); } catch (e) {}
+                try { sm.broadcastSessionList(); } catch (e) {}
+              }
+            },
+          });
+          if (tuiTerm) {
+            newSess.terminalId = tuiTerm.id;
+          }
+        }
+        sm.switchSession(newSess.localId, ws);
+      } else {
+        newSess = sm.createSession(sessionOpts, ws);
+      }
       ws._clayActiveSession = newSess.localId;
       // Apply project-level email defaults to new session
       if (typeof ctx._email === "object" && ctx._email.getEmailDefaults) {
@@ -194,6 +328,15 @@ function attachSessions(ctx) {
         deletableIds.push(bulkId);
       }
       if (deletableIds.length > 0) {
+        // TUI sessions: kill their PTYs before the records are wiped.
+        if (tm) {
+          for (var bdi = 0; bdi < deletableIds.length; bdi++) {
+            var bdTarget = sm.sessions.get(deletableIds[bdi]);
+            if (bdTarget && bdTarget.mode === "tui" && typeof bdTarget.terminalId === "number") {
+              try { tm.close(bdTarget.terminalId); } catch (e) {}
+            }
+          }
+        }
         sm.deleteSessionsBulk(deletableIds, ws);
       }
       return true;
@@ -324,6 +467,44 @@ function attachSessions(ctx) {
 
     if (msg.type === "switch_session") {
       if (msg.id && sm.sessions.has(msg.id)) {
+        // Apply the claudeOpenMode preference to the target Claude session
+        // before sm.switchSession fires session_switched. Two transforms:
+        //
+        //  - born-GUI viewed under TUI pref:  spawn a transient PTY running
+        //    `claude --resume <cliSessionId>`; the session record stays GUI
+        //    so a later pref flip back to GUI just hides the runtime link.
+        //  - born-TUI viewed under GUI pref:  in-place convert via the
+        //    Import CLI code path (jsonl history -> session.history,
+        //    session.mode -> 'gui', kill PTY). This is destructive but
+        //    matches "TUI->GUI is what Import CLI was always for."
+        //
+        // runtimeMode / runtimeTerminalId are set on the session record so
+        // the session_switched and session_list broadcasts surface them to
+        // the client without sessions.js needing to know about the pref.
+        var xmTarget = sm.sessions.get(msg.id);
+        if (xmTarget && (xmTarget.vendor === "claude" || !xmTarget.vendor)) {
+          var xmPref = getClaudeOpenModeForWs(ws);
+          var xmRuntime = computeRuntimeMode(xmTarget, xmPref);
+          if (xmRuntime === "gui" && xmTarget.mode === "tui") {
+            convertTuiSessionToGui(xmTarget);
+            xmTarget.runtimeMode = null;
+            xmTarget.runtimeTerminalId = null;
+          } else if (xmRuntime === "tui" && xmTarget.mode === "gui" && xmTarget.cliSessionId) {
+            var xmRid = spawnRuntimeTuiPty(xmTarget, ws);
+            if (typeof xmRid === "number") {
+              xmTarget.runtimeMode = "tui";
+              xmTarget.runtimeTerminalId = xmRid;
+            } else {
+              xmTarget.runtimeMode = null;
+              xmTarget.runtimeTerminalId = null;
+            }
+          } else {
+            // Same-mode click. Don't leak a stale runtime override into the
+            // payload, but keep any background runtime PTY alive (it may be
+            // re-attached on the next pref flip).
+            xmTarget.runtimeMode = null;
+          }
+        }
         // If the target session's vendor doesn't own the currently cached
         // model, clear sm.currentModel so the UI and next query don't leak
         // the previous session's vendor-specific model into this one.
@@ -383,6 +564,12 @@ function attachSessions(ctx) {
         }
       }
       if (msg.id && sm.sessions.has(msg.id)) {
+        // TUI session: kill the underlying PTY before deleting the session
+        // record so the `claude` process is reaped and not left orphaned.
+        var dsTarget = sm.sessions.get(msg.id);
+        if (dsTarget && dsTarget.mode === "tui" && typeof dsTarget.terminalId === "number" && tm) {
+          try { tm.close(dsTarget.terminalId); } catch (e) {}
+        }
         sm.deleteSession(msg.id, ws);
       }
       return true;
@@ -1371,6 +1558,27 @@ function attachSessions(ctx) {
       return true;
     }
 
+    if (msg.type === "set_claude_open_mode") {
+      // Per-user preference: when Clay opens a Claude session, render it as
+      // the SDK-driven custom chat ("gui") or as an embedded `claude` TUI
+      // ("tui"). Applies to the next session open; currently displayed
+      // sessions are not re-rendered retroactively.
+      var comUserId = ws._clayUser ? ws._clayUser.id : null;
+      if (!comUserId) {
+        sendTo(ws, { type: "set_claude_open_mode_result", ok: false, error: "no_user" });
+        return true;
+      }
+      var comResult = usersModule.setClaudeOpenMode(comUserId, msg.value);
+      if (comResult && comResult.ok) {
+        sendTo(ws, { type: "set_claude_open_mode_result", ok: true, claudeOpenMode: comResult.claudeOpenMode });
+        // Echo as a "changed" broadcast for this user's other tabs/devices.
+        sendTo(ws, { type: "claude_open_mode_changed", claudeOpenMode: comResult.claudeOpenMode });
+      } else {
+        sendTo(ws, { type: "set_claude_open_mode_result", ok: false, error: (comResult && comResult.error) || "unknown" });
+      }
+      return true;
+    }
+
     if (msg.type === "set_image_retention") {
       if (typeof opts.onSetImageRetention === "function") {
         var irResult = opts.onSetImageRetention(msg.days);

package/lib/public/css/input.css

@@ -737,6 +737,24 @@
   flex-shrink: 0;
 }
 #vendor-toggle-wrap.hidden { display: none; }
+
+/* Compact session-vendor icon shown next to the config-chip when the
+   full vendor-toggle is hidden (because the session's vendor is already
+   committed). Visual only - not clickable. */
+#active-vendor-indicator {
+  display: inline-flex;
+  align-items: center;
+  margin-right: 6px;
+  opacity: 0.85;
+  flex-shrink: 0;
+}
+#active-vendor-indicator.hidden { display: none; }
+#active-vendor-icon {
+  width: 18px;
+  height: 18px;
+  border-radius: 4px;
+  object-fit: cover;
+}
 #vendor-toggle-wrap.locked {
   border: none;
   height: auto;

package/lib/public/css/sidebar.css

@@ -993,7 +993,7 @@
 
 .session-top-actions {
   display: grid;
-  grid-template-columns: repeat(2, minmax(0, 1fr));
+  grid-template-columns: repeat(3, minmax(0, 1fr));
   gap: 2px;
   padding: 0 0 2px;
 }
@@ -1026,6 +1026,128 @@
   flex-shrink: 0;
 }
 
+.session-top-action-icon {
+  width: 16px;
+  height: 16px;
+  flex-shrink: 0;
+  border-radius: 4px;
+  object-fit: cover;
+}
+
+/* Split-button variant used by the Claude tile: main click area + a
+   thin chevron strip on the right that opens the mode picker. The
+   wrapping div carries the .session-top-action hover/opacity styling so
+   the two children read as a single visual unit. */
+.session-top-action-split {
+  display: flex;
+  align-items: stretch;
+  padding: 0;
+  overflow: hidden;
+}
+.session-top-action-main {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex: 1 1 auto;
+  min-width: 0;
+  padding: 0 8px 0 12px;
+  border: none;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  cursor: pointer;
+  text-align: left;
+}
+.session-top-action-chevron {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px;
+  padding: 0;
+  border: none;
+  border-left: 1px solid var(--border-subtle);
+  background: transparent;
+  color: inherit;
+  cursor: pointer;
+}
+.session-top-action-chevron .lucide,
+.session-top-action-chevron svg {
+  width: 12px;
+  height: 12px;
+}
+.session-top-action-split:hover .session-top-action-chevron {
+  background: rgba(var(--overlay-rgb), 0.05);
+}
+
+/* Claude mode dropdown menu (opened by the chevron).
+   Theme-aware: mirrors .tool-palette-ctx-menu so it follows light/dark. */
+.claude-mode-menu {
+  position: fixed;
+  z-index: 9999;
+  min-width: 200px;
+  padding: 4px 0;
+  border-radius: 10px;
+  background: var(--sidebar-bg);
+  border: 1px solid var(--border);
+  box-shadow: 0 4px 16px rgba(var(--shadow-rgb), 0.4);
+  font-family: inherit;
+}
+.claude-mode-menu-item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  width: 100%;
+  padding: 8px 12px;
+  border: none;
+  background: none;
+  color: var(--text-secondary);
+  cursor: pointer;
+  text-align: left;
+  font: inherit;
+  font-size: 13px;
+  transition: background 0.15s;
+}
+.claude-mode-menu-item:hover {
+  background: rgba(var(--overlay-rgb), 0.05);
+}
+.claude-mode-menu-label {
+  font-weight: 500;
+}
+.claude-mode-menu-hint {
+  color: var(--text-dimmer);
+  font-size: 11px;
+  margin-left: 12px;
+}
+
+/* TUI session indicator: a tiny black "screen" with a bold green prompt
+   glyph, meant to read as a miniature terminal (CRT-style cursor) at
+   sidebar scale. Aligned to the middle of the text x-height so it sits
+   visually centered with the session title rather than dropping below. */
+.session-tui-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 14px;
+  height: 14px;
+  border-radius: 3px;
+  background: #000;
+  margin-right: 6px;
+  vertical-align: middle;
+  flex-shrink: 0;
+  /* Nudge upward a hair so the icon optical-centers with lowercase glyphs
+     (lucide icons render slightly below the geometric center). */
+  position: relative;
+  top: -1px;
+}
+.session-tui-icon svg,
+.session-tui-icon .lucide {
+  width: 10px;
+  height: 10px;
+  color: #50fa7b;
+  stroke: #50fa7b;
+  stroke-width: 3;
+}
+
 .session-top-action:hover {
   background: var(--sidebar-hover);
   color: var(--text);

package/lib/public/index.html

@@ -482,6 +482,9 @@
                   <span class="vendor-toggle-label">Codex</span>
                 </button>
               </div>
+              <div id="active-vendor-indicator" class="hidden" title="Session vendor">
+                <img id="active-vendor-icon" alt="">
+              </div>
               <div id="config-chip-wrap" class="hidden">
                 <button id="config-chip" title="Model, mode, and effort settings">
                   <i class="config-chip-icon" data-lucide="sliders-horizontal"></i>
@@ -1037,6 +1040,16 @@
               <span class="toggle-track"><span class="toggle-thumb"></span></span>
             </label>
           </div>
+          <div class="settings-card">
+            <label class="settings-toggle-row">
+              <div>
+                <span class="settings-label">Open Claude as terminal (TUI)</span>
+                <div class="settings-hint">Render Claude sessions in an embedded `claude` terminal instead of Clay's chat UI. Keeps usage in the Interactive billing bucket (post 2026-06-15 Agent SDK split). Applies on the next session open.</div>
+              </div>
+              <input type="checkbox" id="us-claude-open-mode">
+              <span class="toggle-track"><span class="toggle-thumb"></span></span>
+            </label>
+          </div>
         </div>
 
         <!-- Mates section -->

package/lib/public/modules/app-messages.js

@@ -27,6 +27,7 @@ import { handleFsList, handleFsRead, handleFileChanged, handleDirChanged, handle
 import { isProjectSettingsOpen, handleInstructionsRead, handleInstructionsWrite, handleProjectEnv, handleProjectEnvSaved, handleProjectSharedEnv, handleProjectSharedEnvSaved, handleProjectOwnerChanged } from './project-settings.js';
 import { updateSettingsModels, updateSettingsStats, updateDaemonConfig, handleSetPinResult, handleKeepAwakeChanged, handleAutoContinueChanged, handleRestartResult, handleShutdownResult, handleSharedEnv, handleSharedEnvSaved, handleGlobalClaudeMdRead, handleGlobalClaudeMdWrite } from './server-settings.js';
 import { handleTermList, handleTermCreated, sendTerminalCommand, handleTermOutput, handleTermResized, handleTermExited, handleTermClosed } from './terminal.js';
+import { attachTuiView, detachTuiView, tuiHandleTermOutput, tuiHandleTermResized, tuiHandleTermExited, tuiHandleTermClosed } from './session-tui-view.js';
 import { updateTerminalList, handleContextSourcesState, updateEmailAccountList, updateEmailUnreadCounts, handleEmailTestResult, handleEmailAddResult, handleEmailRemoveResult, handleEmailDefaults } from './context-sources.js';
 import { refreshEmailSettings } from './user-settings.js';
 import { handleNotesList, handleNoteCreated, handleNoteUpdated, handleNoteDeleted } from './sticky-notes.js';
@@ -589,7 +590,24 @@ export function processMessage(msg) {
         } else if (_prevSid) {
           delete store.get('sessionDrafts')[_prevSid];
         }
-        store.set({ activeSessionId: msg.id, cliSessionId: msg.cliSessionId || null, vendorCapabilities: msg.capabilities || {}, sessionIsProcessing: !!msg.isProcessing });
+        // runtimeMode/runtimeTerminalId take precedence over the session's
+        // born mode so the user's current claudeOpenMode preference applies
+        // to existing sessions too (born-GUI viewed under TUI pref runs
+        // claude --resume in xterm; born-TUI viewed under GUI pref was
+        // in-place converted to GUI by the server before this message).
+        var _effectiveMode = msg.runtimeMode || msg.mode || "gui";
+        var _effectiveTerminalId = (typeof msg.runtimeTerminalId === "number")
+          ? msg.runtimeTerminalId
+          : (typeof msg.terminalId === "number" ? msg.terminalId : null);
+        store.set({ activeSessionId: msg.id, cliSessionId: msg.cliSessionId || null, vendorCapabilities: msg.capabilities || {}, sessionIsProcessing: !!msg.isProcessing, activeSessionMode: _effectiveMode, activeTerminalId: _effectiveTerminalId, sessionHasHistory: !!msg.hasHistory });
+        // TUI sessions swap the chat UI for an embedded xterm running
+        // `claude` inside a real PTY. Mount or tear down before the rest of
+        // the chat-side bookkeeping runs so we don't waste work on hidden DOM.
+        if (_effectiveMode === "tui" && typeof _effectiveTerminalId === "number") {
+          attachTuiView(_effectiveTerminalId);
+        } else {
+          detachTuiView();
+        }
         if (msg.vendor) {
           if (!store.get('vendorSelectionLocked') || msg.hasHistory) {
             store.set({ currentVendor: msg.vendor });
@@ -621,11 +639,44 @@ export function processMessage(msg) {
         if (!msg.hasHistory && !msg.vendor) {
           // Preserve explicit pre-message vendor choice on brand-new sessions.
         }
-        // Show vendor toggle only for new sessions (no history)
+        // Vendor toggle visibility + active-vendor indicator next to the
+        // model chip.
+        //   - Session has an explicit vendor: hide the toggle (it's
+        //     committed for this conversation) and show a small avatar
+        //     next to the config chip so the user still sees which vendor
+        //     is in use.
+        //   - History without recorded vendor: show locked toggle, no icon
+        //     (we don't know what to render).
+        //   - Brand-new no-vendor session: show toggle, no icon.
         var _vtw = document.getElementById("vendor-toggle-wrap");
+        var _avi = document.getElementById("active-vendor-indicator");
+        var _avIcon = document.getElementById("active-vendor-icon");
         if (_vtw) {
-          if (msg.hasHistory) { _vtw.classList.remove("hidden"); _vtw.classList.add("locked"); }
-          else { _vtw.classList.remove("locked"); _vtw.classList.remove("hidden"); }
+          if (msg.vendor) {
+            _vtw.classList.add("hidden");
+            _vtw.classList.remove("locked");
+          } else if (msg.hasHistory) {
+            _vtw.classList.remove("hidden");
+            _vtw.classList.add("locked");
+          } else {
+            _vtw.classList.remove("locked");
+            _vtw.classList.remove("hidden");
+          }
+        }
+        if (_avi && _avIcon) {
+          if (msg.vendor === "claude") {
+            _avIcon.src = "/claude-code-avatar.png";
+            _avIcon.alt = "Claude";
+            _avi.title = "Claude session";
+            _avi.classList.remove("hidden");
+          } else if (msg.vendor === "codex") {
+            _avIcon.src = "/codex-avatar.png";
+            _avIcon.alt = "Codex";
+            _avi.title = "Codex session";
+            _avi.classList.remove("hidden");
+          } else {
+            _avi.classList.add("hidden");
+          }
         }
         // Session presence is now tracked server-side (user-presence.json)
         clearRemoteCursors();
@@ -1230,19 +1281,21 @@ export function processMessage(msg) {
         break;
 
       case "term_output":
-        handleTermOutput(msg);
+        // TUI session view owns its terminal id exclusively; only fall
+        // through to the bottom-panel handler when the id doesn't match.
+        if (!tuiHandleTermOutput(msg)) handleTermOutput(msg);
         break;
 
       case "term_resized":
-        handleTermResized(msg);
+        if (!tuiHandleTermResized(msg)) handleTermResized(msg);
         break;
 
       case "term_exited":
-        handleTermExited(msg);
+        if (!tuiHandleTermExited(msg)) handleTermExited(msg);
         break;
 
       case "term_closed":
-        handleTermClosed(msg);
+        if (!tuiHandleTermClosed(msg)) handleTermClosed(msg);
         break;
 
       case "notes_list":
@@ -1630,6 +1683,16 @@ export function processMessage(msg) {
         handleAutoContinueChanged(msg);
         break;
 
+      case "set_claude_open_mode_result":
+      case "claude_open_mode_changed":
+        if (msg.claudeOpenMode === "tui" || msg.claudeOpenMode === "gui") {
+          store.set({ claudeOpenMode: msg.claudeOpenMode });
+          // Reflect into the user-settings toggle if it's already in the DOM.
+          var _comToggle = document.getElementById("us-claude-open-mode");
+          if (_comToggle) _comToggle.checked = msg.claudeOpenMode === "tui";
+        }
+        break;
+
       case "restart_server_result":
         handleRestartResult(msg);
         break;

package/lib/public/modules/app-panels.js

@@ -176,8 +176,16 @@ function hasBeta(name) {
 
 function rebuildModelList() {
   if (!configModelList) return;
-  configModelList.innerHTML = "";
+  // GUI chat sessions have their model bound at creation time (picked from
+  // the new-session config before the first message). Showing a picker
+  // inside the chat is misleading: changing it mid-thread breaks tool
+  // schemas and cache reuse. Hide the entire MODEL section in GUI mode.
+  var modelSection = configModelList.parentElement;
   var s = store.snap();
+  var hideModelPicker = s.activeSessionMode === "gui";
+  if (modelSection) modelSection.style.display = hideModelPicker ? "none" : "";
+  configModelList.innerHTML = "";
+  if (hideModelPicker) return;
   var list = s.currentModels.length > 0 ? s.currentModels : (s.currentModel ? [{ value: s.currentModel, displayName: s.currentModel }] : []);
   for (var i = 0; i < list.length; i++) {
     var item = list[i];
@@ -453,7 +461,9 @@ export function initPanels() {
         state.currentVendor !== prev.currentVendor ||
         state.codexApproval !== prev.codexApproval ||
         state.codexSandbox !== prev.codexSandbox ||
-        state.codexWebSearch !== prev.codexWebSearch) {
+        state.codexWebSearch !== prev.codexWebSearch ||
+        state.sessionHasHistory !== prev.sessionHasHistory ||
+        state.activeSessionMode !== prev.activeSessionMode) {
       updateConfigChip();
     }
   });

package/lib/public/modules/session-tui-view.js

@@ -0,0 +1,276 @@
+// session-tui-view.js
+//
+// Renders a Claude Code TUI inside the main session view area when the
+// active session is a `mode: 'tui'` session. The PTY itself is managed by
+// the server's terminal-manager (same infra that powers the bottom-panel
+// shell tabs); this module is responsible only for the embedded xterm and
+// for relaying input/output/resize for the bound terminal.
+//
+// Lifecycle (driven by app-messages.js on session_switched):
+//   attachTuiView(terminalId)  - mount xterm, send term_attach
+//   detachTuiView()            - send term_detach, dispose xterm
+//
+// PTY survives detach (server keeps the terminal alive). On `/exit` or
+// claude exit the server's onExit hook deletes the session and broadcasts
+// the new session list; this view tears itself down via handleTermExited.
+
+import { getWs } from './ws-ref.js';
+
+// Claude TUI sessions intentionally ignore Clay's dark/light theme and
+// always render with a classic black terminal look. The bottom-panel
+// shell terminal still follows the theme; this is specific to the TUI
+// session view so `claude` renders consistently across themes.
+var TUI_TERMINAL_THEME = {
+  background: "#000000",
+  foreground: "#e5e5e5",
+  cursor: "#e5e5e5",
+  cursorAccent: "#000000",
+  selectionBackground: "#3a3a3a",
+  black: "#000000",
+  red: "#cd3131",
+  green: "#0dbc79",
+  yellow: "#e5e510",
+  blue: "#2472c8",
+  magenta: "#bc3fbc",
+  cyan: "#11a8cd",
+  white: "#e5e5e5",
+  brightBlack: "#666666",
+  brightRed: "#f14c4c",
+  brightGreen: "#23d18b",
+  brightYellow: "#f5f543",
+  brightBlue: "#3b8eea",
+  brightMagenta: "#d670d6",
+  brightCyan: "#29b8db",
+  brightWhite: "#ffffff",
+};
+
+var hostEl = null;       // container div mounted over #messages
+var xterm = null;        // xterm.js instance
+var fitAddon = null;
+var webglAddon = null;
+var currentTermId = null;
+var resizeObserver = null;
+var windowResizeBound = false;
+function onWindowResize() {
+  if (currentTermId != null) fitNow();
+}
+
+function ensureHostEl() {
+  if (hostEl) return hostEl;
+  // Anchor the host to the chat content area (the bounding box of
+  // #messages) rather than the viewport. Using `position: fixed` worked
+  // visually but broke layout when the sidebar, header, or any side panel
+  // was open - the xterm slid under them. Re-position on every show via
+  // syncHostBounds() so resizes and panel toggles stay in sync.
+  hostEl = document.createElement("div");
+  hostEl.id = "tui-session-host";
+  hostEl.style.position = "fixed";
+  hostEl.style.display = "none";
+  hostEl.style.background = "#000000";
+  hostEl.style.zIndex = "5";
+  hostEl.style.overflow = "hidden";
+  hostEl.style.boxSizing = "border-box";
+  document.body.appendChild(hostEl);
+  return hostEl;
+}
+
+function syncHostBounds() {
+  if (!hostEl) return;
+  var messagesEl = document.getElementById("messages");
+  if (!messagesEl) return;
+  var r = messagesEl.getBoundingClientRect();
+  // Extend down to the bottom of the viewport so the empty band that used
+  // to sit below #messages (where #input-area lived before we hid it) gets
+  // covered by the same terminal background instead of showing through.
+  hostEl.style.top = r.top + "px";
+  hostEl.style.left = r.left + "px";
+  hostEl.style.width = r.width + "px";
+  hostEl.style.height = (window.innerHeight - r.top) + "px";
+}
+
+function hideGuiChrome(hide) {
+  var messagesEl = document.getElementById("messages");
+  var inputArea = document.getElementById("input-area");
+  if (messagesEl) messagesEl.style.visibility = hide ? "hidden" : "";
+  if (inputArea) inputArea.style.display = hide ? "none" : "";
+  var newMsgBtn = document.getElementById("new-msg-btn");
+  if (newMsgBtn) newMsgBtn.style.display = hide ? "none" : "";
+}
+
+function fitNow() {
+  if (!xterm || !fitAddon || !hostEl) return;
+  syncHostBounds();
+  try {
+    fitAddon.fit();
+    // Inform the server so its PTY's idea of cols/rows matches what xterm
+    // just rendered. Without this, claude TUI redraws using stale dims.
+    if (currentTermId != null && getWs() && getWs().readyState === 1) {
+      getWs().send(JSON.stringify({
+        type: "term_resize",
+        id: currentTermId,
+        cols: xterm.cols,
+        rows: xterm.rows,
+      }));
+    }
+  } catch (e) {}
+}
+
+function createXterm() {
+  if (typeof Terminal === "undefined") return null;
+  var theme = TUI_TERMINAL_THEME;
+  // Match the host background to the xterm theme so any sub-cell gap
+  // between the last rendered row and the host's bottom blends in.
+  if (hostEl) hostEl.style.background = theme.background;
+  var term = new Terminal({
+    cursorBlink: true,
+    fontSize: 13,
+    fontFamily: "'SF Mono', Menlo, Monaco, 'Courier New', monospace",
+    theme: theme,
+    scrollback: 5000,
+  });
+  if (typeof FitAddon !== "undefined") {
+    fitAddon = new FitAddon.FitAddon();
+    term.loadAddon(fitAddon);
+  }
+  if (typeof WebLinksAddon !== "undefined") {
+    try { term.loadAddon(new WebLinksAddon.WebLinksAddon()); } catch (e) {}
+  }
+  term.open(hostEl);
+  if (typeof WebglAddon !== "undefined") {
+    try {
+      webglAddon = new WebglAddon.WebglAddon();
+      webglAddon.onContextLoss(function () {
+        try { webglAddon.dispose(); } catch (e) {}
+        webglAddon = null;
+      });
+      term.loadAddon(webglAddon);
+    } catch (e) {}
+  }
+  // Route keystrokes back to the PTY.
+  term.onData(function (data) {
+    if (currentTermId == null) return;
+    var ws = getWs();
+    if (ws && ws.readyState === 1) {
+      ws.send(JSON.stringify({ type: "term_input", id: currentTermId, data: data }));
+    }
+  });
+  return term;
+}
+
+function teardownXterm() {
+  if (webglAddon) {
+    try { webglAddon.dispose(); } catch (e) {}
+    webglAddon = null;
+  }
+  if (xterm) {
+    try { xterm.dispose(); } catch (e) {}
+    xterm = null;
+  }
+  fitAddon = null;
+}
+
+export function attachTuiView(terminalId) {
+  if (typeof terminalId !== "number") return;
+  // Re-attaching to the same terminal: just refit and refocus.
+  if (currentTermId === terminalId && xterm) {
+    if (hostEl) hostEl.style.display = "";
+    hideGuiChrome(true);
+    fitNow();
+    try { xterm.focus(); } catch (e) {}
+    return;
+  }
+  // Switching to a different TUI terminal: tear down the old one cleanly.
+  if (currentTermId != null && currentTermId !== terminalId) {
+    detachTuiView();
+  }
+  if (!ensureHostEl()) return;
+  hostEl.style.display = "";
+  hideGuiChrome(true);
+  syncHostBounds();
+
+  currentTermId = terminalId;
+  if (!xterm) xterm = createXterm();
+  if (!xterm) return;
+
+  // Subscribe to the terminal's output stream on the server. The server
+  // replays its scrollback buffer on attach so we never start blank.
+  var ws = getWs();
+  if (ws && ws.readyState === 1) {
+    ws.send(JSON.stringify({ type: "term_attach", id: terminalId }));
+  }
+
+  // First fit pass; defer a second pass for layout to settle.
+  fitNow();
+  setTimeout(fitNow, 50);
+  try { xterm.focus(); } catch (e) {}
+
+  if (!resizeObserver && typeof ResizeObserver !== "undefined") {
+    // Watch the chat-content area, not the host: the host's size is
+    // derived from #messages via syncHostBounds, so observing it would
+    // miss the actual source of truth (sidebar toggles, panel opens, etc.)
+    var msgEl = document.getElementById("messages");
+    if (msgEl) {
+      resizeObserver = new ResizeObserver(function () { fitNow(); });
+      resizeObserver.observe(msgEl);
+    }
+  }
+  if (!windowResizeBound) {
+    window.addEventListener("resize", onWindowResize);
+    windowResizeBound = true;
+  }
+}
+
+export function detachTuiView() {
+  if (resizeObserver) {
+    try { resizeObserver.disconnect(); } catch (e) {}
+    resizeObserver = null;
+  }
+  if (currentTermId != null) {
+    var ws = getWs();
+    if (ws && ws.readyState === 1) {
+      try { ws.send(JSON.stringify({ type: "term_detach", id: currentTermId })); } catch (e) {}
+    }
+  }
+  currentTermId = null;
+  teardownXterm();
+  if (hostEl) hostEl.style.display = "none";
+  hideGuiChrome(false);
+}
+
+// Route a term_output frame to the embedded xterm if it belongs to the
+// current TUI session. Returns true if consumed so app-messages can skip
+// the bottom-panel handler.
+export function tuiHandleTermOutput(msg) {
+  if (!msg || msg.id !== currentTermId || !xterm || !msg.data) return false;
+  xterm.write(msg.data);
+  return true;
+}
+
+export function tuiHandleTermResized(msg) {
+  if (!msg || msg.id !== currentTermId || !xterm) return false;
+  if (msg.cols > 0 && msg.rows > 0) {
+    try { xterm.resize(msg.cols, msg.rows); } catch (e) {}
+  }
+  return true;
+}
+
+export function tuiHandleTermExited(msg) {
+  if (!msg || msg.id !== currentTermId) return false;
+  if (xterm) {
+    try { xterm.write("\r\n\x1b[90m[claude exited - session will close]\x1b[0m\r\n"); } catch (e) {}
+  }
+  // The server's onExit hook deletes the session record and broadcasts a
+  // fresh session_list. The next session_switched (or empty state) will
+  // call detachTuiView for us.
+  return true;
+}
+
+export function tuiHandleTermClosed(msg) {
+  if (!msg || msg.id !== currentTermId) return false;
+  detachTuiView();
+  return true;
+}
+
+export function getActiveTuiTerminalId() {
+  return currentTermId;
+}

package/lib/public/modules/sidebar-sessions.js

@@ -297,20 +297,105 @@ function appendSessionCloseButton(el, session) {
   el.appendChild(closeBtn);
 }
 
+// Dropdown anchored to the Claude split-button chevron. Renders two
+// explicit choices (TUI / GUI) and dismisses on click-outside, Escape,
+// or window blur. Kept local to this module since it's the only caller.
+var _claudeModeMenu = null;
+function closeClaudeModeMenu() {
+  if (_claudeModeMenu && _claudeModeMenu.parentNode) {
+    _claudeModeMenu.parentNode.removeChild(_claudeModeMenu);
+  }
+  _claudeModeMenu = null;
+}
+function openClaudeModeMenu(x, y) {
+  closeClaudeModeMenu();
+  var menu = document.createElement("div");
+  menu.className = "claude-mode-menu";
+  var items = [
+    { label: "Start as TUI", hint: "Real claude terminal", mode: "tui" },
+    { label: "Start as GUI", hint: "Clay chat UI",         mode: "gui" },
+  ];
+  for (var i = 0; i < items.length; i++) {
+    (function (it) {
+      var b = document.createElement("button");
+      b.type = "button";
+      b.className = "claude-mode-menu-item";
+      b.innerHTML = '<span class="claude-mode-menu-label">' + it.label + '</span>' +
+                    '<span class="claude-mode-menu-hint">' + it.hint + '</span>';
+      b.addEventListener("click", function (e) {
+        e.stopPropagation();
+        closeClaudeModeMenu();
+        if (getWs() && store.get('connected')) {
+          getWs().send(JSON.stringify({ type: "new_session", vendor: "claude", mode: it.mode }));
+        }
+      });
+      menu.appendChild(b);
+    })(items[i]);
+  }
+  document.body.appendChild(menu);
+  // Clamp to viewport.
+  var rect = menu.getBoundingClientRect();
+  var px = x, py = y;
+  if (px + rect.width > window.innerWidth - 4) px = window.innerWidth - rect.width - 4;
+  if (py + rect.height > window.innerHeight - 4) py = window.innerHeight - rect.height - 4;
+  menu.style.left = px + "px";
+  menu.style.top = py + "px";
+  _claudeModeMenu = menu;
+}
+document.addEventListener("click", function () { closeClaudeModeMenu(); });
+document.addEventListener("keydown", function (e) { if (e.key === "Escape") closeClaudeModeMenu(); });
+window.addEventListener("blur", function () { closeClaudeModeMenu(); });
+window.addEventListener("resize", function () { closeClaudeModeMenu(); });
+
 function renderSessionTopActions() {
   var wrap = document.createElement("div");
   wrap.className = "session-top-actions";
 
-  var newBtn = document.createElement("button");
-  newBtn.className = "session-top-action";
-  newBtn.type = "button";
-  newBtn.innerHTML = iconHtml("plus") + '<span>New Session</span>';
-  newBtn.addEventListener("click", function () {
+  // Claude: split button. Default click starts a TUI session (the path
+  // most users want post 2026-06-15 Agent SDK billing split). The small
+  // chevron on the right opens a dropdown that lets the user explicitly
+  // pick TUI or GUI for this one session, bypassing the saved pref.
+  var claudeWrap = document.createElement("div");
+  claudeWrap.className = "session-top-action session-top-action-split";
+
+  var claudeMain = document.createElement("button");
+  claudeMain.className = "session-top-action-main";
+  claudeMain.type = "button";
+  claudeMain.title = "New Claude session (TUI)";
+  claudeMain.innerHTML = '<img src="/claude-code-avatar.png" class="session-top-action-icon" alt=""><span>Claude</span>';
+  claudeMain.addEventListener("click", function () {
     if (getWs() && store.get('connected')) {
-      getWs().send(JSON.stringify({ type: "new_session" }));
+      getWs().send(JSON.stringify({ type: "new_session", vendor: "claude", mode: "tui" }));
     }
   });
-  wrap.appendChild(newBtn);
+  claudeWrap.appendChild(claudeMain);
+
+  var claudeChevron = document.createElement("button");
+  claudeChevron.className = "session-top-action-chevron";
+  claudeChevron.type = "button";
+  claudeChevron.title = "Choose session mode";
+  claudeChevron.innerHTML = iconHtml("chevron-down");
+  claudeChevron.addEventListener("click", function (e) {
+    e.stopPropagation();
+    var rect = claudeWrap.getBoundingClientRect();
+    openClaudeModeMenu(rect.left, rect.bottom + 4);
+  });
+  claudeWrap.appendChild(claudeChevron);
+
+  wrap.appendChild(claudeWrap);
+
+  // Codex: always GUI (no TUI adapter for Codex).
+  var codexBtn = document.createElement("button");
+  codexBtn.className = "session-top-action";
+  codexBtn.type = "button";
+  codexBtn.title = "New Codex session";
+  codexBtn.innerHTML = '<img src="/codex-avatar.png" class="session-top-action-icon" alt=""><span>Codex</span>';
+  codexBtn.addEventListener("click", function () {
+    if (getWs() && store.get('connected')) {
+      getWs().send(JSON.stringify({ type: "new_session", vendor: "codex" }));
+    }
+  });
+  wrap.appendChild(codexBtn);
 
   var importBtn = document.createElement("button");
   importBtn.className = "session-top-action";
@@ -1049,6 +1134,9 @@ function renderSessionItem(s) {
   if (store.get('isMultiUserMode') && s.sessionVisibility === "private") {
     textHtml += '<span class="session-private-icon" title="Private session">' + iconHtml("lock") + '</span>';
   }
+  if (s.mode === "tui") {
+    textHtml += '<span class="session-tui-icon" title="Claude Code terminal session">' + iconHtml("terminal") + '</span>';
+  }
   textHtml += highlightMatch(s.title || "New Session", searchQuery);
   textSpan.innerHTML = textHtml;
   el.appendChild(textSpan);

package/lib/public/modules/terminal.js

@@ -662,7 +662,12 @@ function updateTerminalBadge() {
 // --- Handle server messages ---
 
 export function handleTermList(msg) {
-  var serverTerminals = msg.terminals || [];
+  // TUI session terminals are owned by session-tui-view.js and must not
+  // appear in the bottom terminal panel. Filter them out before any tab
+  // bookkeeping so the panel never tries to render or auto-attach them.
+  var serverTerminals = (msg.terminals || []).filter(function (t) {
+    return t && t.kind !== "tui-session";
+  });
   var serverIds = new Set();
 
   // Add/update tabs from server list

package/lib/public/modules/user-settings.js

@@ -8,6 +8,7 @@ import { showEmailSetupModal, getEmailAccountListCache } from './context-sources
 import { setSTTLang } from './stt.js';
 import { userAvatarUrl } from './avatar.js';
 import { store } from './store.js';
+import { getWs } from './ws-ref.js';
 
 var ctx = null;
 var settingsEl = null;
@@ -167,6 +168,22 @@ export function initUserSettings(appCtx) {
     });
   }
 
+  // Claude open mode toggle: GUI (default) vs TUI. The server persists the
+  // pref per user; the WS broadcast `claude_open_mode_changed` keeps the
+  // store and other tabs in sync.
+  var claudeOpenModeToggle = document.getElementById('us-claude-open-mode');
+  if (claudeOpenModeToggle) {
+    claudeOpenModeToggle.checked = store.get('claudeOpenMode') === 'tui';
+    claudeOpenModeToggle.addEventListener('change', function () {
+      var want = this.checked ? 'tui' : 'gui';
+      var ws = getWs();
+      if (ws && ws.readyState === 1) {
+        ws.send(JSON.stringify({ type: 'set_claude_open_mode', value: want }));
+        showToast(want === 'tui' ? 'Claude opens as terminal' : 'Claude opens as chat');
+      }
+    });
+  }
+
   // Mates UI toggle. Default-on, so flipping off hides every Mates
   // surface in the app (sidebar avatars, DM picker entry, home-hub strip)
   // via the body.mates-disabled CSS gate. Flipping back on restores the

package/lib/sdk-bridge.js

@@ -910,7 +910,21 @@ function createSDKBridge(opts) {
       if (session.abortController === myAbortController) session.abortController = null;
       session.taskStopRequested = false;
       session.pendingPermissions = {};
-      session.pendingAskUser = {};
+      // Preserve MCP-mode AskUserQuestion entries across turn boundaries.
+      // The MCP path is intentionally stateless: the tool returns immediately
+      // ("card posted, end your turn") and the user's answer is expected to
+      // arrive as a brand-new user_message on the *next* turn. That means the
+      // pending entry MUST survive this finally block. Without it, the
+      // ask_user_response handler can't find the toolId and silently drops
+      // the answer. canUseTool-mode entries (Claude's native path) still hold
+      // an open SDK permission callback that dies with the query, so those
+      // are correctly cleared here.
+      var keepAskUser = {};
+      for (var _tid in session.pendingAskUser) {
+        var _pending = session.pendingAskUser[_tid];
+        if (_pending && _pending.mode === "mcp") keepAskUser[_tid] = _pending;
+      }
+      session.pendingAskUser = keepAskUser;
       session.pendingElicitations = {};
 
       // Auto-continue on rate limit (scheduler sessions, or user setting)

package/lib/sessions.js

@@ -246,6 +246,10 @@ function createSessionManager(opts) {
       favoriteOrder: typeof s.favoriteOrder === "number" ? s.favoriteOrder : null,
       unread: unreadMap[s.localId] || 0,
       vendor: s.vendor || null,
+      mode: s.mode || "gui",
+      terminalId: typeof s.terminalId === "number" ? s.terminalId : null,
+      runtimeMode: s.runtimeMode || null,
+      runtimeTerminalId: typeof s.runtimeTerminalId === "number" ? s.runtimeTerminalId : null,
     };
   }
 
@@ -289,7 +293,7 @@ function createSessionManager(opts) {
       localId: localId,
       queryInstance: null,
       messageQueue: null,
-      cliSessionId: null,
+      cliSessionId: (sessionOpts && sessionOpts.cliSessionId) || null,
       blocks: {},
       sentToolResults: {},
       pendingPermissions: {},
@@ -308,6 +312,8 @@ function createSessionManager(opts) {
       bookmarked: false,
       favoriteOrder: null,
       vendor: (sessionOpts && sessionOpts.vendor) || null,
+      mode: (sessionOpts && sessionOpts.mode === "tui") ? "tui" : "gui",
+      terminalId: null,
     };
     sessions.set(localId, session);
     switchSession(localId, targetWs);
@@ -321,7 +327,7 @@ function createSessionManager(opts) {
       localId: localId,
       queryInstance: null,
       messageQueue: null,
-      cliSessionId: null,
+      cliSessionId: (sessionOpts && sessionOpts.cliSessionId) || null,
       blocks: {},
       sentToolResults: {},
       pendingPermissions: {},
@@ -340,6 +346,8 @@ function createSessionManager(opts) {
       bookmarked: false,
       favoriteOrder: null,
       vendor: (sessionOpts && sessionOpts.vendor) || null,
+      mode: (sessionOpts && sessionOpts.mode === "tui") ? "tui" : "gui",
+      terminalId: null,
     };
     sessions.set(localId, session);
     return session;
@@ -423,7 +431,7 @@ function createSessionManager(opts) {
     var _capsByVendor = capabilitiesByVendor || {};
     var _sessionVendor = session.vendor || defaultVendor || "claude";
     var _vendorCaps = _capsByVendor[_sessionVendor] || {};
-    _send({ type: "session_switched", id: localId, cliSessionId: session.cliSessionId || null, loop: session.loop || null, vendor: session.vendor || null, hasHistory: (session.history && session.history.length > 0), capabilities: _vendorCaps, isProcessing: !!session.isProcessing });
+    _send({ type: "session_switched", id: localId, cliSessionId: session.cliSessionId || null, loop: session.loop || null, vendor: session.vendor || null, hasHistory: (session.history && session.history.length > 0), capabilities: _vendorCaps, isProcessing: !!session.isProcessing, mode: session.mode || "gui", terminalId: typeof session.terminalId === "number" ? session.terminalId : null, runtimeMode: session.runtimeMode || null, runtimeTerminalId: typeof session.runtimeTerminalId === "number" ? session.runtimeTerminalId : null });
     // Send vendor-specific slash commands
     var _vendorCmds = slashCommandsByVendor[_sessionVendor] || slashCommands || [];
     _send({ type: "slash_commands", commands: _vendorCmds, vendor: _sessionVendor });

package/lib/terminal-manager.js

@@ -16,10 +16,23 @@ function createTerminalManager(opts) {
   var nextId = 1;
   var terminals = new Map(); // id -> terminal session
 
-  function create(cols, rows, osUserInfo, ownerWs) {
+  /**
+   * Create a PTY-backed terminal.
+   *
+   * opts (optional):
+   *   - initialInput: string injected into the PTY right after spawn
+   *     (used by TUI sessions to launch `claude --session-id <uuid>`).
+   *   - title: initial title override.
+   *   - kind: free-form tag (e.g. "tui-session") for callers to discriminate
+   *     their terminals from generic shell tabs. Not used by the manager.
+   *   - onExit(session): callback fired after the PTY exits and subscribers
+   *     are notified. Used by TUI sessions to delete their session record so
+   *     stale entries don't accumulate.
+   */
+  function create(cols, rows, osUserInfo, ownerWs, opts) {
     if (terminals.size >= MAX_TERMINALS) return null;
 
-    var pty = createTerminal(cwd, cols, rows, osUserInfo);
+    var pty = createTerminal(cwd, cols, rows, osUserInfo, opts);
     if (!pty) return null;
 
     var id = nextId++;
@@ -31,11 +44,13 @@ function createTerminalManager(opts) {
       totalBytesWritten: 0,
       cols: cols || 80,
       rows: rows || 24,
-      title: "Terminal " + id,
+      title: (opts && opts.title) || ("Terminal " + id),
+      kind: (opts && opts.kind) || "shell",
       exited: false,
       exitCode: null,
       subscribers: new Set(),
       ownerWs: ownerWs || null,
+      onExitHook: (opts && typeof opts.onExit === "function") ? opts.onExit : null,
     };
 
     pty.onData(function (data) {
@@ -68,6 +83,13 @@ function createTerminalManager(opts) {
 
       // Broadcast updated list
       send({ type: "term_list", terminals: list() });
+
+      // Caller-supplied hook: e.g. TUI session manager uses this to delete
+      // its session record once `claude` exits, so stale entries don't pile
+      // up in the sidebar.
+      if (session.onExitHook) {
+        try { session.onExitHook(session); } catch (err) {}
+      }
     });
 
     terminals.set(id, session);
@@ -173,6 +195,7 @@ function createTerminalManager(opts) {
       result.push({
         id: session.id,
         title: session.title,
+        kind: session.kind,
         exited: session.exited,
       });
     }

package/lib/terminal.js

@@ -7,7 +7,15 @@ try {
 
 var { buildUserEnv } = require("./build-user-env");
 
-function createTerminal(cwd, cols, rows, osUserInfo) {
+/**
+ * Spawn a PTY.
+ *
+ * opts (optional):
+ *   - initialInput: string written to the PTY immediately after spawn.
+ *     Used by TUI session mode to inject `claude --session-id <uuid>\n`
+ *     so /exit drops back to the shell instead of killing the PTY.
+ */
+function createTerminal(cwd, cols, rows, osUserInfo, opts) {
   if (!pty) return null;
 
   // Determine shell: prefer target user's shell, then $SHELL, then platform default
@@ -33,6 +41,10 @@ function createTerminal(cwd, cols, rows, osUserInfo) {
   var args = osUserInfo ? ["-l"] : [];
   var term = pty.spawn(shell, args, spawnOpts);
 
+  if (opts && opts.initialInput) {
+    try { term.write(opts.initialInput); } catch (e) {}
+  }
+
   return term;
 }
 

package/lib/users-preferences.js

@@ -217,6 +217,45 @@ function attachPreferences(deps) {
     return { error: "User not found" };
   }
 
+  // --- Per-user Claude open mode ---
+  //
+  // Decides how Claude sessions are rendered when the user clicks into one:
+  //   'gui' - Clay's custom chat UI driven by the Claude Agent SDK (default).
+  //   'tui' - Embedded xterm running the real `claude` CLI. Keeps usage in
+  //           the Interactive billing bucket post 2026-06-15.
+  //
+  // The preference applies on the next session open. Currently displayed
+  // sessions are not re-rendered retroactively. Existing TUI-born sessions
+  // always stay TUI regardless of preference (use Import CLI to bring a TUI
+  // conversation into the GUI flow).
+
+  function getClaudeOpenMode(userId) {
+    var data = loadUsers();
+    for (var i = 0; i < data.users.length; i++) {
+      if (data.users[i].id === userId) {
+        var m = data.users[i].claudeOpenMode;
+        // Default 'tui': post 2026-06-15 Agent SDK split, TUI keeps usage
+        // in the Interactive billing bucket so it's the right default for
+        // most users. Explicit 'gui' opts back into the SDK chat flow.
+        return (m === "gui") ? "gui" : "tui";
+      }
+    }
+    return "tui";
+  }
+
+  function setClaudeOpenMode(userId, mode) {
+    var normalized = (mode === "gui") ? "gui" : "tui";
+    var data = loadUsers();
+    for (var i = 0; i < data.users.length; i++) {
+      if (data.users[i].id === userId) {
+        data.users[i].claudeOpenMode = normalized;
+        saveUsers(data);
+        return { ok: true, claudeOpenMode: normalized };
+      }
+    }
+    return { error: "User not found" };
+  }
+
   // --- Per-user Mates UI toggle ---
   //
   // When false, the entire Mates surface (sidebar avatars, DM "Create a
@@ -321,6 +360,8 @@ function attachPreferences(deps) {
     setChatLayout: setChatLayout,
     getAutoContinue: getAutoContinue,
     setAutoContinue: setAutoContinue,
+    getClaudeOpenMode: getClaudeOpenMode,
+    setClaudeOpenMode: setClaudeOpenMode,
     getMatesEnabled: getMatesEnabled,
     setMatesEnabled: setMatesEnabled,
     getToolPalettes: getToolPalettes,

package/lib/users.js

@@ -416,6 +416,8 @@ var getChatLayout = preferences.getChatLayout;
 var setChatLayout = preferences.setChatLayout;
 var getAutoContinue = preferences.getAutoContinue;
 var setAutoContinue = preferences.setAutoContinue;
+var getClaudeOpenMode = preferences.getClaudeOpenMode;
+var setClaudeOpenMode = preferences.setClaudeOpenMode;
 var getMatesEnabled = preferences.getMatesEnabled;
 var setMatesEnabled = preferences.setMatesEnabled;
 var getToolPalettes = preferences.getToolPalettes;
@@ -477,6 +479,8 @@ module.exports = {
   setMateOnboarded: setMateOnboarded,
   getAutoContinue: getAutoContinue,
   setAutoContinue: setAutoContinue,
+  getClaudeOpenMode: getClaudeOpenMode,
+  setClaudeOpenMode: setClaudeOpenMode,
   getMatesEnabled: getMatesEnabled,
   setMatesEnabled: setMatesEnabled,
   getToolPalettes: getToolPalettes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "2.38.0",
+  "version": "2.39.0-beta.1",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js",