@kodaris/krubble-app-components 1.0.123 → 1.0.125

package/dist/chatbot.js

@@ -202,6 +202,7 @@ export class KRChatbot extends LitElement {
         this._orgSkillRequestId = 0;
         this._globalSkillRequestId = 0;
         this._invocableSkillRequestId = 0;
+        this._suggestedActionRequestId = 0;
         /**
          * Codes of global skills with an in-flight enable/disable request. The `+`
          * button reads this to show a pending state and ignore repeat clicks. Mutated
@@ -295,6 +296,14 @@ export class KRChatbot extends LitElement {
         this._inputValue = '';
         this._isStreaming = false;
         this._error = '';
+        /**
+         * The current conversation's title. In the floating widget it replaces the
+         * static header label so the user sees which conversation they're in. Set from
+         * the loaded/switched conversation and from the live `CONVERSATION_TITLE` event
+         * (the server generates a title at the end of a new conversation's first turn);
+         * empty for a brand-new conversation, where the header falls back to `label`.
+         */
+        this._conversationTitle = '';
         /**
          * User-facing context warning text (`CONVERSATION_TOKEN_WARNING`). Shown as a
          * dismissible banner in all variants. Carries only friendly guidance, no numbers.
@@ -354,12 +363,23 @@ export class KRChatbot extends LitElement {
          */
         this._drawerOpen = false;
         /**
-         * Which view the drawer shows — settings, debug, or a single tool call's full
-         * detail. One drawer holds all three; the header buttons switch settings/debug
-         * and clicking a tool line switches to `toolDetail`. The content/width swap
-         * inside. Never null, so the content stays visible while the drawer slides shut.
+         * Which view the drawer shows — settings, debug, history, or a single tool
+         * call's full detail. One drawer holds them all; header buttons switch
+         * settings/debug/history and clicking a tool line switches to `toolDetail`. The
+         * content/width swap inside. Never null, so the content stays visible while the
+         * drawer slides shut. `history` is floating-only (the previous-conversations
+         * picker); in floating the drawer fills the panel over the transcript.
          */
         this._drawerView = 'settings';
+        /**
+         * The user's previous conversations, loaded from `/conversation/list` when the
+         * history view opens. Each is the raw ConversationViewDto (we read conversationID,
+         * title, lastModified). Empty until the first open; reloaded on each open so a
+         * freshly-created or renamed conversation shows.
+         */
+        this._conversations = [];
+        /** True while the history list is being fetched (drives a loading state). */
+        this._conversationsLoading = false;
         /**
          * The tool call whose full input/output the `toolDetail` drawer view shows —
          * the clicked `tool_use` message and its paired `tool_result` message, stored
@@ -405,6 +425,12 @@ export class KRChatbot extends LitElement {
          * so installed globals in the menu never leak into the "Your Org" tab.
          */
         this._invocableSkills = [];
+        /**
+         * Context-aware action chips for the empty state, from `/conversation/suggestedActions`.
+         * Loaded fresh every time the panel opens on an empty conversation (see `_loadSuggestedActions`);
+         * cleared when the first message is sent so they don't linger over a live conversation.
+         */
+        this._suggestedActions = [];
         /**
          * AI framework UI config flags fetched from `aiFrameworkConfig` on connect.
          * `debugTelemetryEnabled` (same server-side gate as TOKEN_USAGE emission) turns
@@ -597,6 +623,11 @@ export class KRChatbot extends LitElement {
     // --- Lifecycle ---
     connectedCallback() {
         super.connectedCallback();
+        // Capture the consumer's targeting BEFORE we default `load` below: a custom
+        // `load` or an explicitly-set `conversation-id` means the consumer owns which
+        // conversation shows, so the tab-scoped resume must not override it.
+        const usesBuiltInLoad = !this.load;
+        const consumerSetConversationId = this.conversationId != null;
         // Default to loading a conversation's messages when the consumer hasn't
         // provided their own `load`. With `conversationId` set we rebuild that
         // conversation; with none set the user wants a NEW conversation, so we start
@@ -679,7 +710,54 @@ export class KRChatbot extends LitElement {
                 })));
             };
         }
-        this.load().then((messages) => {
+        // Tab-scoped resume (floating only): a reload should redisplay the exact
+        // conversation this tab was on, and a brand-new tab should reopen the user's
+        // most-recent one. The pinned id lives in sessionStorage (per-tab — unlike
+        // localStorage it isn't shared across tabs, so two tabs can sit on different
+        // conversations). We resolve the id FIRST, then run the built-in load so it
+        // rebuilds the right transcript. Skipped when the consumer owns targeting (a
+        // custom `load` or an explicit `conversation-id`) or in inline mode (embedded
+        // as a page — the host route, not the tab, decides the conversation).
+        const resolveConversationId = () => {
+            if (this.variant !== 'floating' || !usesBuiltInLoad || consumerSetConversationId) {
+                return Promise.resolve();
+            }
+            const stored = Number(sessionStorage.getItem('kr-chatbot-conversation-id'));
+            if (stored > 0) {
+                this.conversationId = stored;
+                // Fetch the conversation so the header shows its title on reload (the
+                // transcript load doesn't carry it). Best-effort — the header falls back
+                // to the default label if this fails.
+                return KRHttp.fetch({ url: `/api/system/conversation/${stored}` })
+                    .then((r) => r.json())
+                    .then((res) => {
+                    this._conversationTitle = res?.data?.title || '';
+                })
+                    .catch(() => { });
+            }
+            // Fresh tab, nothing pinned yet — resume the user's most recent conversation
+            // (404 when they have none, which leaves us blank for a new one).
+            return KRHttp.fetch({ url: '/api/system/conversation/last' })
+                .then((r) => {
+                if (!r.ok) {
+                    return;
+                }
+                return r.json().then((res) => {
+                    const id = res?.data?.conversationID;
+                    if (typeof id === 'number') {
+                        this.conversationId = id;
+                        this._conversationTitle = res?.data?.title || '';
+                        this._persistConversationId();
+                    }
+                });
+            })
+                .catch(() => { });
+        };
+        // `this.load` is always set by here (defaulted above when the consumer didn't
+        // supply one), so capture it for the async chain — TS can't narrow the nullable
+        // property across the promise boundary.
+        const load = this.load;
+        resolveConversationId().then(() => load()).then((messages) => {
             if (messages && messages.length) {
                 this.messages = messages;
             }
@@ -759,6 +837,13 @@ export class KRChatbot extends LitElement {
                 }
             }, 200);
         }
+        // Load context-aware action chips every time the panel opens on an empty conversation. Fires for
+        // the floating variant on toggle-open and for the inline variant on its first render (which sets
+        // `opened` true at connect). Only when empty — a resumed conversation shows its transcript, not chips.
+        // The request-id guard inside handles a stale reply if the user closes/reopens quickly.
+        if (changed.has('opened') && this.opened && this.messages.length === 0) {
+            this._loadSuggestedActions();
+        }
         // Position the fixed skill menu above the composer, following the krubble
         // select-field pattern (fixed element positioned from the trigger's rect).
         if (this._skillMenuOpened) {
@@ -914,12 +999,31 @@ export class KRChatbot extends LitElement {
         }
         this._saveState();
     }
+    /**
+     * Persist the pinned conversation id per-tab so a reload redisplays this exact
+     * conversation. sessionStorage (not localStorage) is deliberate: it's scoped to
+     * the tab, so two tabs can sit on different conversations without clobbering
+     * each other. Only meaningful for the floating widget's built-in flow — inline
+     * embeds and custom-`load` consumers own their own targeting.
+     */
+    _persistConversationId() {
+        try {
+            if (this.conversationId != null) {
+                sessionStorage.setItem('kr-chatbot-conversation-id', String(this.conversationId));
+            }
+            else {
+                sessionStorage.removeItem('kr-chatbot-conversation-id');
+            }
+        }
+        catch { /* sessionStorage not available */ }
+    }
     _saveState() {
         try {
-            // `toolDetail` is a transient peek, not a saved view — persist only the two
-            // real preference views so a reload never reopens a stale tool.
+            // `toolDetail` and `history` are transient views, not saved ones — persist
+            // only the real preference views so a reload never reopens a stale tool or a
+            // stale conversation list.
             let persistedDrawerView = this._drawerView;
-            if (persistedDrawerView === 'toolDetail') {
+            if (persistedDrawerView === 'toolDetail' || persistedDrawerView === 'history') {
                 persistedDrawerView = 'settings';
             }
             const state = {
@@ -1191,6 +1295,41 @@ export class KRChatbot extends LitElement {
             console.error('kr-chatbot: invocable skill search failed', error);
         });
     }
+    /**
+     * Load the empty-state action chips from `/conversation/suggestedActions`, passing the user's
+     * current page/selection context (captured live, same as a send). The server picks a few skills
+     * the user can run that fit where they are and writes a label for each. Called every time the
+     * panel opens on an empty conversation (per product decision — context can change between opens).
+     *
+     * AI-only, no fallback: any failure, or v2 chat being off (server returns `[]`), just leaves the
+     * empty state with no chips. A request-id guard drops a response superseded by a newer open, so a
+     * slow reply from a previous open can't land after the user has started typing.
+     */
+    _loadSuggestedActions() {
+        this._suggestedActionRequestId++;
+        const requestId = this._suggestedActionRequestId;
+        const context = this._captureContext();
+        KRHttp.fetch({
+            url: '/api/system/conversation/suggestedActions',
+            method: 'POST',
+            body: {
+                pageContext: context.pageContext,
+                selectionContext: context.selectionContext,
+            },
+        })
+            .then((r) => r.json())
+            .then((res) => {
+            // Ignore a stale response from a prior open, and never overwrite chips once a conversation
+            // has started (the user opened, the reply was slow, they typed and sent in the meantime).
+            if (requestId !== this._suggestedActionRequestId || this.messages.length > 0) {
+                return;
+            }
+            this._suggestedActions = (res?.data || []);
+        })
+            .catch((error) => {
+            console.error('kr-chatbot: suggested actions load failed', error);
+        });
+    }
     /**
      * Load the browse dialog's "Kodaris" tab into `_globalSkills` — the whole
      * published Kodaris catalog for discovery, installed or not, runnable by this
@@ -1434,6 +1573,17 @@ export class KRChatbot extends LitElement {
             this._handleSkillSelect(skill);
         }
     }
+    /**
+     * Click an empty-state suggestion chip: prefill `/code ` into the composer, same as picking the
+     * skill from the `/` menu, and focus so the user can add details before sending. No permission
+     * guards here (unlike `_handleSkillSelect`) — a suggested action's code always comes from the
+     * server's role-filtered runnable set, so it's already known to be invokable by this user.
+     */
+    _handleSuggestedActionClick(action) {
+        this._inputValue = `/${action.code} `;
+        this._saveState();
+        this._inputEl?.focus();
+    }
     /** Copy a message's text to the clipboard and briefly flash "Copied". */
     _handleCopyMessage(content, index) {
         navigator.clipboard.writeText(content).then(() => {
@@ -1716,6 +1866,9 @@ export class KRChatbot extends LitElement {
         }
         this.messages = [...this.messages, userMessage];
         this._inputValue = '';
+        // The conversation has started — drop the empty-state chips so they don't linger above the
+        // transcript. A newer suggestedActions reply is also ignored now (its guard checks messages.length).
+        this._suggestedActions = [];
         this._saveState();
         this._error = '';
         this._userHasScrolledUp = false;
@@ -1875,6 +2028,8 @@ export class KRChatbot extends LitElement {
                                 const id = conversation?.conversationID;
                                 if (typeof id === 'number') {
                                     this.conversationId = id;
+                                    // Pin it to this tab so a reload redisplays this new conversation.
+                                    this._persistConversationId();
                                     // Announce the newly-created conversation so consumers can react
                                     // (e.g. update the route from /chat/new to /chat/{id}). The full
                                     // conversation object is passed, not just the id, so consumers
@@ -2072,9 +2227,111 @@ export class KRChatbot extends LitElement {
         else {
             this._drawerOpen = true;
             this._drawerView = view;
+            // Opening the history view refetches the user's previous conversations
+            // (most-recently modified first) so a just-created or renamed conversation
+            // shows without a reload. Ownership is enforced server-side (the endpoint
+            // scopes to the current administrator), so we only filter to active ones.
+            if (view === 'history') {
+                this._conversationsLoading = true;
+                KRHttp.fetch({
+                    url: '/api/system/conversation/list',
+                    method: 'POST',
+                    body: {
+                        page: 0,
+                        size: 50,
+                        sortBy: 'lastModified',
+                        sortDirection: 'desc',
+                        filterFields: [{
+                                name: 'active',
+                                operation: 'IS',
+                                value: 'true',
+                            }],
+                    },
+                })
+                    .then((r) => r.json())
+                    .then((res) => {
+                    this._conversations = res?.data?.content || [];
+                })
+                    .catch(() => {
+                    this._conversations = [];
+                })
+                    .then(() => {
+                    this._conversationsLoading = false;
+                });
+            }
         }
         this._saveState();
     }
+    /**
+     * Switch the floating widget to a previously-created conversation (clicked in the
+     * history list): stop any live turn, reset the transient turn/context state, pin
+     * the new id (persisted per-tab so a reload stays here), then rebuild its
+     * transcript via the built-in `load`. The drawer closes so the user lands back
+     * in the conversation.
+     */
+    _handleSwitchConversation(conversationID) {
+        if (conversationID === this.conversationId) {
+            this._handleCloseDrawer();
+            return;
+        }
+        this._handleStop();
+        this.conversationId = conversationID;
+        // Adopt the picked conversation's title for the header (empty for an untitled
+        // one, so the header falls back to the default label).
+        this._conversationTitle = this._conversations.find((c) => c.conversationID === conversationID)?.title || '';
+        this._persistConversationId();
+        this._resetConversationState();
+        this._drawerOpen = false;
+        this._saveState();
+        if (this.load) {
+            this.load().then((messages) => {
+                this.messages = messages || [];
+                // A turn may still be streaming server-side for the conversation we just
+                // opened (started in another tab/device) — attach to it if so.
+                if (this.conversationId && !this._isStreaming) {
+                    this._reconnectStream();
+                }
+            }).catch(() => { });
+        }
+    }
+    /**
+     * Start a brand-new conversation (clicked in the history list): unpin the id (the
+     * next turn sends `createNew` and the resolved id re-pins), clear the transcript
+     * and transient state, and close the drawer back to an empty composer.
+     */
+    _handleNewConversation() {
+        this._handleStop();
+        this.conversationId = null;
+        // New conversation has no title yet — the header shows the default label until
+        // the server generates one at the end of the first turn.
+        this._conversationTitle = '';
+        this._persistConversationId();
+        this.messages = [];
+        this._resetConversationState();
+        this._drawerOpen = false;
+        this._saveState();
+    }
+    /**
+     * Clear the transient, per-conversation state that must not bleed across a
+     * conversation switch/new — pending confirmations, context banners, errors, the
+     * reconnect counter, and staged composer files. The transcript itself is set by
+     * the caller (loaded for a switch, emptied for new).
+     */
+    _resetConversationState() {
+        this._pendingActions = [];
+        this._inlineConfirm = true;
+        this._contextWarning = '';
+        this._contextLimitReached = false;
+        this._contextLimitMessage = '';
+        this._error = '';
+        this._reconnectAttempts = 0;
+        this._pendingConversationFiles.forEach((p) => {
+            if (p.previewUrl) {
+                URL.revokeObjectURL(p.previewUrl);
+            }
+        });
+        this._pendingConversationFiles = [];
+    }
     /** Close the drawer. `_drawerView` is left intact so its content stays visible
      *  while the drawer slides shut. */
     _handleCloseDrawer() {
@@ -2358,7 +2615,7 @@ export class KRChatbot extends LitElement {
                         // deliberately never show). Adopt it as the header label and pass it
                         // up so consumers can update their own chrome, e.g. a breadcrumb.
                         if (data.data?.title) {
-                            this.label = data.data.title;
+                            this._conversationTitle = data.data.title;
                             this.dispatchEvent(new CustomEvent('conversation-title', {
                                 detail: { title: data.data.title },
                                 bubbles: true,
@@ -2944,10 +3201,75 @@ export class KRChatbot extends LitElement {
      * lifetime — plus a verbose per-iteration table. Never customer-facing.
      */
     /**
-     * The side drawer — one sliding panel that holds both the Settings and Debug
-     * views. The header buttons switch `_drawerView`; the title and body swap
-     * inside. The panel keeps one consistent (resizable) width across both views —
-     * switching views only changes the content, never the panel size.
+     * The History view's body — the user's previous conversations (most recent
+     * first) plus a "New conversation" action. Clicking a row switches the widget to
+     * that conversation; the current one is marked so the user sees where they are.
+     * Floating-only (opened from the header history button).
+     */
+    _renderHistoryContent() {
+        return html `
+      <div class="history">
+        ${this._conversationsLoading ? html `
+          <div class="history__empty">Loading…</div>
+        ` : this._conversations.length === 0 ? html `
+          <div class="history__empty">No previous conversations</div>
+        ` : html `
+          <div class="history__list">
+            ${this._conversations.map((conversation) => html `
+              <button
+                type="button"
+                class=${classMap({
+            'history__item': true,
+            'history__item--active': conversation.conversationID === this.conversationId,
+        })}
+                @click=${() => this._handleSwitchConversation(conversation.conversationID)}
+              >
+                <span class="history__item-title">${conversation.title || 'Untitled conversation'}</span>
+                ${conversation.lastModified ? html `
+                  <span class="history__item-date">${this._renderConversationDate(conversation.lastModified)}</span>
+                ` : nothing}
+              </button>
+            `)}
+          </div>
+        `}
+      </div>
+    `;
+    }
+    /**
+     * Format a conversation's lastModified for the history list: today shows the
+     * time, this year shows month/day, older shows month/day/year. Falls back to the
+     * raw value if it isn't a parseable date.
+     */
+    _renderConversationDate(lastModified) {
+        const date = new Date(lastModified);
+        if (isNaN(date.getTime())) {
+            return lastModified;
+        }
+        const now = new Date();
+        if (date.toDateString() === now.toDateString()) {
+            return date.toLocaleTimeString('en-US', {
+                hour: 'numeric',
+                minute: '2-digit',
+            });
+        }
+        if (date.getFullYear() === now.getFullYear()) {
+            return date.toLocaleDateString('en-US', {
+                month: 'short',
+                day: 'numeric',
+            });
+        }
+        return date.toLocaleDateString('en-US', {
+            month: 'short',
+            day: 'numeric',
+            year: 'numeric',
+        });
+    }
+    /**
+     * The side drawer — one sliding panel that holds the Settings, Debug, History,
+     * and tool-detail views. The header buttons switch `_drawerView`; the title and
+     * body swap inside. In inline mode it slides in beside the transcript at a
+     * consistent (resizable) width; in floating mode it fills the panel over the
+     * transcript with a back button (the panel is too narrow to show both).
      */
     _renderDrawer() {
         // The debug view is gated on the server-side flag (inline variant + debug
@@ -2965,41 +3287,101 @@ export class KRChatbot extends LitElement {
             title = this._toolDetail.use.data?.displayName || this._toolDetail.use.data?.toolName || 'Tool';
             body = this._renderToolDetailContent();
         }
+        else if (this._drawerView === 'history') {
+            title = 'Conversations';
+            body = this._renderHistoryContent();
+        }
+        // In the floating widget the drawer fills the panel over the transcript (a
+        // full-panel view with a back button) rather than sliding in beside it — the
+        // panel is too narrow to show both. Inline keeps the side-drawer behavior.
+        const fullPanel = this.variant === 'floating';
         return html `
       <div
         class=${classMap({
             'drawer': true,
             'drawer--open': this._drawerOpen,
             'drawer--resizing': this._isDrawerResizing,
+            'drawer--full': fullPanel,
         })}
-        style=${styleMap({ width: `${this._drawerWidth}px` })}
+        style=${styleMap(fullPanel ? {} : { width: `${this._drawerWidth}px` })}
       >
-        <div
-          class="drawer__resize"
-          @mousedown=${this._handleDrawerResizeMouseDown}
-        ></div>
+        ${fullPanel ? nothing : html `
+          <div
+            class="drawer__resize"
+            @mousedown=${this._handleDrawerResizeMouseDown}
+          ></div>
+        `}
         <div class="drawer__header">
+          ${fullPanel ? html `
+            <button
+              class="header-action"
+              @click=${this._handleCloseDrawer}
+              title="Back"
+            >
+              <svg
+                xmlns="http://www.w3.org/2000/svg"
+                fill="none"
+                viewBox="0 0 24 24"
+                stroke-width="2"
+                stroke="currentColor"
+                class="header-action-icon"
+              >
+                <path
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  d="M15.75 19.5 8.25 12l7.5-7.5"
+                />
+              </svg>
+            </button>
+          ` : nothing}
           <span class="drawer__title">${title}</span>
-          <button
-            class="header-action"
-            @click=${this._handleCloseDrawer}
-            title="Close"
-          >
-            <svg
-              xmlns="http://www.w3.org/2000/svg"
-              fill="none"
-              viewBox="0 0 24 24"
-              stroke-width="2"
-              stroke="currentColor"
-              class="header-action-icon"
+          ${this._drawerView === 'history' ? html `
+            <kr-button
+              class="history__new"
+              variant="flat"
+              color="primary"
+              size="small"
+              @click=${this._handleNewConversation}
             >
-              <path
-                stroke-linecap="round"
-                stroke-linejoin="round"
-                d="M6 18 18 6M6 6l12 12"
-              />
-            </svg>
-          </button>
+              <svg
+                slot="icon"
+                xmlns="http://www.w3.org/2000/svg"
+                fill="none"
+                viewBox="0 0 24 24"
+                stroke-width="1.75"
+                stroke="currentColor"
+              >
+                <path
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  d="M12 4.5v15m7.5-7.5h-15"
+                />
+              </svg>
+              New conversation
+            </kr-button>
+          ` : nothing}
+          ${fullPanel ? nothing : html `
+            <button
+              class="header-action"
+              @click=${this._handleCloseDrawer}
+              title="Close"
+            >
+              <svg
+                xmlns="http://www.w3.org/2000/svg"
+                fill="none"
+                viewBox="0 0 24 24"
+                stroke-width="2"
+                stroke="currentColor"
+                class="header-action-icon"
+              >
+                <path
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  d="M6 18 18 6M6 6l12 12"
+                />
+              </svg>
+            </button>
+          `}
         </div>
         <div class="drawer__body">
           ${body}
@@ -3260,9 +3642,10 @@ export class KRChatbot extends LitElement {
         const isDebugEnabled = this.variant === 'inline' && this._aiFrameworkConfig.debugTelemetryEnabled === true;
         // Push the content over by the open drawer's width so the drawer sits beside
         // the content rather than overlaying it. One consistent (resizable) width for
-        // both views. Only pushes while the drawer is open.
+        // both views. Only pushes while the drawer is open, and only inline — the
+        // floating drawer fills the panel over the transcript, so it must not push.
         const contentPadding = {};
-        if (this._drawerOpen) {
+        if (this._drawerOpen && this.variant === 'inline') {
             contentPadding.paddingRight = `${this._drawerWidth}px`;
         }
         // Group the transcript into runs so an agent turn (its reasoning/tool/text/
@@ -3380,10 +3763,52 @@ export class KRChatbot extends LitElement {
         <div class="header" @mousedown=${this._handleHeaderMouseDown}>
           <div class="header-left">
             <div class="header-info">
-              <span class="header-title">${this.label}</span>
+              <span class="header-title">${this._conversationTitle || this.label}</span>
             </div>
           </div>
           <div class="header-actions">
+            ${this.variant === 'floating' ? html `
+              <button
+                class="header-action"
+                @click=${this._handleNewConversation}
+                title="New conversation"
+              >
+                <svg
+                  xmlns="http://www.w3.org/2000/svg"
+                  fill="none"
+                  viewBox="0 0 24 24"
+                  stroke-width="1.75"
+                  stroke="currentColor"
+                  class="header-action-icon"
+                >
+                  <path
+                    stroke-linecap="round"
+                    stroke-linejoin="round"
+                    d="M12 4.5v15m7.5-7.5h-15"
+                  />
+                </svg>
+              </button>
+              <button
+                class="header-action"
+                @click=${() => this._toggleDrawer('history')}
+                title="Conversations"
+              >
+                <svg
+                  xmlns="http://www.w3.org/2000/svg"
+                  fill="none"
+                  viewBox="0 0 24 24"
+                  stroke-width="1.5"
+                  stroke="currentColor"
+                  class="header-action-icon"
+                >
+                  <path
+                    stroke-linecap="round"
+                    stroke-linejoin="round"
+                    d="M12 6v6h4.5m4.5 0a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z"
+                  />
+                </svg>
+              </button>
+            ` : nothing}
             <button
               class="header-action"
               @click=${() => this._toggleDrawer('settings')}
@@ -3461,6 +3886,17 @@ export class KRChatbot extends LitElement {
             ${this.messages.length === 0 ? html `
               <div class="empty">
                 <span class="empty-text">What can I help you with?</span>
+                ${this._suggestedActions.length ? html `
+                  <div class="empty-suggestions">
+                    ${this._suggestedActions.map((action) => html `
+                      <button
+                        type="button"
+                        class="empty-suggestions__chip"
+                        @click=${() => this._handleSuggestedActionClick(action)}
+                      >${action.label}</button>
+                    `)}
+                  </div>
+                ` : nothing}
               </div>
             ` : nothing}
             ${messageGroups.map((group) => {
@@ -4127,22 +4563,28 @@ KRChatbot.styles = css `
       display: flex;
       align-items: center;
       gap: 10px;
+      min-width: 0;
     }
 
     .header-info {
       display: flex;
       flex-direction: column;
+      min-width: 0;
     }
 
     .header-title {
       font-size: 16px;
       font-weight: 600;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
     }
 
     .header-actions {
       display: flex;
       align-items: center;
       gap: 4px;
+      flex-shrink: 0;
     }
 
     .header-action {
@@ -4316,7 +4758,7 @@ KRChatbot.styles = css `
       align-items: center;
       justify-content: center;
       color: var(--kr-chatbot-text-secondary);
-      gap: 8px;
+      gap: 16px;
     }
 
     .empty-text {
@@ -4324,6 +4766,35 @@ KRChatbot.styles = css `
       color: rgb(0 0 0 / 80%);
     }
 
+    /* Context-aware action chips under the empty-state prompt. A row of pills the user can click to
+       prefill a skill — capped small server-side so this reads as a few suggestions, not a menu. */
+    .empty-suggestions {
+      display: flex;
+      flex-wrap: wrap;
+      justify-content: center;
+      gap: 10px;
+      max-width: 420px;
+      margin-top: 4px;
+    }
+
+    .empty-suggestions__chip {
+      padding: 8px 12px;
+      background: rgb(0 0 0 / 6%);
+      border: none;
+      border-radius: 16px;
+      color: #000000;
+      font: inherit;
+      font-size: 13px;
+      line-height: 1.2;
+      cursor: pointer;
+      white-space: nowrap;
+    }
+
+    .empty-suggestions__chip:hover {
+      background: rgb(0 0 0 / 10%);
+      color: #000000;
+    }
+
     .message {
       position: relative;
       display: flex;
@@ -4968,6 +5439,13 @@ KRChatbot.styles = css `
       border-bottom: 1px solid rgba(0, 0, 0, 0.08);
     }
 
+    /* Full-panel (floating) header: back button then title, left-aligned. */
+    .drawer--full .drawer__header {
+      justify-content: flex-start;
+      gap: 8px;
+      padding: 0 12px;
+    }
+
     .drawer__title {
       font-size: 14px;
       font-weight: 600;
@@ -4981,6 +5459,78 @@ KRChatbot.styles = css `
       padding: 4px 0;
     }
 
+    /* Floating variant: the drawer fills the whole panel over the transcript (a
+       full-panel view with a back button), rather than sliding in beside it. */
+    .drawer--full {
+      left: 0;
+      width: 100%;
+      max-width: 100%;
+      z-index: 6;
+    }
+
+    .drawer--full.drawer--open {
+      box-shadow: none;
+    }
+
+    /* History (previous conversations) view. */
+    .history {
+      display: flex;
+      flex-direction: column;
+    }
+
+    /* "New conversation" action in the Conversations header — pushed to the right. */
+    .history__new {
+      margin-left: auto;
+    }
+
+    .history__empty {
+      padding: 24px 20px;
+      text-align: center;
+      font-size: 13px;
+      color: rgb(0 0 0 / 50%);
+    }
+
+    .history__list {
+      display: flex;
+      flex-direction: column;
+      padding: 4px 0;
+    }
+
+    .history__item {
+      display: flex;
+      flex-direction: column;
+      align-items: flex-start;
+      gap: 5px;
+      padding: 10px 20px;
+      background: transparent;
+      border: none;
+      text-align: left;
+      cursor: pointer;
+      transition: background 0.15s;
+    }
+
+    .history__item:hover {
+      background: rgba(0, 0, 0, 0.04);
+    }
+
+    .history__item--active {
+      background: rgba(0, 0, 0, 0.06);
+    }
+
+    .history__item-title {
+      font-size: 14px;
+      color: #000000;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      max-width: 100%;
+    }
+
+    .history__item-date {
+      font-size: 12px;
+      color: rgb(0 0 0 / 60%);
+    }
+
     .debug-section {
       padding: 14px 20px;
       border-bottom: 1px solid rgba(0, 0, 0, 0.06);
@@ -5915,6 +6465,9 @@ __decorate([
 __decorate([
     state()
 ], KRChatbot.prototype, "_error", void 0);
+__decorate([
+    state()
+], KRChatbot.prototype, "_conversationTitle", void 0);
 __decorate([
     state()
 ], KRChatbot.prototype, "_contextWarning", void 0);
@@ -5948,6 +6501,12 @@ __decorate([
 __decorate([
     state()
 ], KRChatbot.prototype, "_drawerView", void 0);
+__decorate([
+    state()
+], KRChatbot.prototype, "_conversations", void 0);
+__decorate([
+    state()
+], KRChatbot.prototype, "_conversationsLoading", void 0);
 __decorate([
     state()
 ], KRChatbot.prototype, "_toolDetail", void 0);
@@ -5987,6 +6546,9 @@ __decorate([
 __decorate([
     state()
 ], KRChatbot.prototype, "_invocableSkills", void 0);
+__decorate([
+    state()
+], KRChatbot.prototype, "_suggestedActions", void 0);
 __decorate([
     state()
 ], KRChatbot.prototype, "_aiFrameworkConfig", void 0);