@genesislcap/ai-assistant 15.29.0 → 15.30.0

package/dist/esm/main/main.js

@@ -58,6 +58,7 @@ import { deleteBankedBaseline } from '../utils/banked-usage-baselines';
 import { estimateContextTokens, isContextMeasurable, } from '../utils/context-tokens';
 import { logger } from '../utils/logger';
 import { filterVisibleMessages, trailingInteractionRow } from '../utils/message-partition';
+import { normalizeDebugLogNote, resolveDebugLogNoteConfig, } from '../utils/resolve-debug-log-note';
 import { DEFAULT_TIMESTAMP_DISPLAY, preferenceUnchanged, resolvePreferenceBaseline, } from '../utils/resolve-preference-baseline';
 import { stripAgentHandlers } from '../utils/strip-agent-handlers';
 import { emptyUsage, sumUsage, totalTokens } from '../utils/sum-usage';
@@ -92,6 +93,33 @@ export const genesisIconSvg = `<svg viewBox="-4 0 30 26" fill="none" xmlns="http
 function sanitizeIconMarkup(markup) {
     return DOMPurify.sanitize(markup, { USE_PROFILES: { svg: true, svgFilters: true } });
 }
+/**
+ * Await `outcome` (a promise, or a sync return) but give up after `ms`, rejecting with a
+ * named error. Used to bound a host callback we cannot otherwise trust to settle.
+ */
+function settleWithin(outcome, ms, what) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`${what} did not settle within ${ms}ms`)), ms);
+        });
+        try {
+            yield Promise.race([Promise.resolve(outcome), timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    });
+}
+/**
+ * How long the agent-log Send button shows its 'Sent'/'Failed' outcome before
+ * returning to idle — long enough to read, short enough that a retry is never blocked.
+ */
+const DEBUG_LOG_SUBMIT_RESULT_FLASH_MS = 4000;
+/** Default ceiling on the host's `debugLogSubmit.send` before the submission is failed. */
+const DEBUG_LOG_SUBMIT_TIMEOUT_MS = 30000;
+/** Announce the remaining note length once this few characters are left. */
+const DEBUG_LOG_NOTE_REMAINING_WARN = 20;
 /**
  * Reporter id for this element's OWN session persister in `brokenSources` (GENC-1511).
  *
@@ -306,6 +334,34 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
          * element has its own settings modal.
          */
         this.downloadingDebugLog = false;
+        /**
+         * True while `submitDebugLog` is building and handing off the log. Same role as
+         * `downloadingDebugLog` for the Send button: the lifetime-stitch and the host's
+         * `send` callback are async, so the button needs a visible in-flight state.
+         */
+        this.submittingDebugLog = false;
+        /**
+         * Outcome of the last log submission, shown briefly on the button ('Sent' /
+         * 'Failed — retry') then cleared by `setDebugLogSubmitResult`'s timer. `null` when idle.
+         */
+        this.debugLogSubmitResult = null;
+        /**
+         * Whether the agent-log compose box (note + Send/Cancel) is open. Opened by the row's
+         * Send button when `debugLogSubmit.note` is not `false`; closed by Cancel or a
+         * successful send. Stays open after a failure so the typed note is not lost.
+         */
+        this.debugLogComposeOpen = false;
+        /** The note typed in the compose box, raw (trimmed only at submit time). */
+        this.debugLogNote = '';
+        /** How long 'Sent' shows before idle. Overridable so tests need not wait 4 seconds. */
+        this.debugLogSubmitResultFlashMs = DEBUG_LOG_SUBMIT_RESULT_FLASH_MS;
+        /**
+         * Bumped by `resetDebugLogSubmitState`. An in-flight `submitDebugLog` captures it and
+         * drops its continuation when a reset (disconnect, session switch, Clear) happened
+         * while it awaited — otherwise the stale submission would write state, arm a timer on
+         * a torn-down element, or report 'Sent' into a session it never belonged to.
+         */
+        this.debugLogSubmitGeneration = 0;
         /**
          * GENC-1511 — persistence has failed repeatedly and it is no longer saving. Drives a BLOCKING
          * modal with a single Reload action: the whole failure class this ticket exists for is one the
@@ -2148,6 +2204,9 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             return;
         }
         this._deferredSwitchToKey = undefined;
+        // A note typed against the outgoing conversation must not caption the incoming one's
+        // log, and an outcome flash belongs to the session that produced it.
+        this.resetDebugLogSubmitState();
         // Cancel the outgoing session's debounced autosave FIRST, so it can't land in
         // the incoming session's file once `_sessionRef` swaps below.
         (_b = getPersister(oldKey)) === null || _b === void 0 ? void 0 : _b.cancelPendingSave();
@@ -2210,6 +2269,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         // After `_sessionActive` is cleared, so the sync sees "disconnected" and stops.
         this.syncTimestampClock();
         this.stopLoadingTimer();
+        this.resetDebugLogSubmitState();
         this.state = 'idle';
         // Note: `compacting`/`restoring` are NOT cleared here. They're written through the
         // in-flight op's captured session store (see `initPersistenceForNewStore` /
@@ -2968,6 +3028,9 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             if (this.driver)
                 this.teardownDriver(key);
             (_f = this._sessionRef) === null || _f === void 0 ? void 0 : _f.actions.aiAssistant.resetSession();
+            // Same reason as in `switchSession`: the compose box and its note were about the
+            // conversation just discarded.
+            this.resetDebugLogSubmitState();
             // `resetSession` zeroes the store-backed `contextTokens`; the gate's held copy
             // is ours to drop. Leaving it would carry a block into a conversation that no
             // longer exists — the one thing `contextGate` must never do (GENC-1582).
@@ -3140,6 +3203,145 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     get settingsSessionTokensVisible() {
         return this.settings.sessionTokensVisible;
     }
+    /**
+     * Whether the settings "Agent log" section renders — shown when either action is
+     * enabled: the download button (`allowDebugDownload`) or the host-transport Send
+     * button (`debugLogSubmit`). Each button is additionally gated on its own flag
+     * inside the section, so a host can enable one without the other.
+     */
+    get settingsAgentLogSectionVisible() {
+        const ui = this.chatConfig.ui;
+        return (ui === null || ui === void 0 ? void 0 : ui.allowDebugDownload) === true || (ui === null || ui === void 0 ? void 0 : ui.debugLogSubmit) != null;
+    }
+    /**
+     * The resolved compose-box settings for the agent-log Send button, or `null` when the
+     * host opted out (`debugLogSubmit.note: false`) and the button sends on first click.
+     */
+    get debugLogNoteConfig() {
+        var _a;
+        return resolveDebugLogNoteConfig((_a = this.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.debugLogSubmit);
+    }
+    /**
+     * Whether the typed note counts as empty — the ONE emptiness rule, shared by the
+     * compose box's disabled state and its "required" hint so the two cannot drift apart.
+     */
+    get debugLogNoteMissing() {
+        return normalizeDebugLogNote(this.debugLogNote) === undefined;
+    }
+    /** The Send button's idle label, as the host configured it. */
+    get debugLogSubmitLabel() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.debugLogSubmit) === null || _b === void 0 ? void 0 : _b.label) !== null && _c !== void 0 ? _c : 'Send';
+    }
+    /**
+     * Label on the agent-log row's Send button. While the compose box is open the row
+     * button is just the (disabled) trigger, so it keeps its idle label; otherwise it
+     * reflects the in-flight / flashed outcome of the last submission.
+     */
+    get debugLogSubmitButtonLabel() {
+        if (this.debugLogComposeOpen)
+            return this.debugLogSubmitLabel;
+        if (this.submittingDebugLog)
+            return 'Sending…';
+        if (this.debugLogSubmitResult === 'sent')
+            return 'Sent';
+        if (this.debugLogSubmitResult === 'error')
+            return 'Failed — retry';
+        return this.debugLogSubmitLabel;
+    }
+    /**
+     * The compose box's footer hint: a failure first, then the "required" nudge, else the
+     * live counter. Visual only — the same information reaches assistive technology via
+     * `debugLogNoteAriaLabel` (counter, required) and `debugLogSubmitAnnouncement` (outcome),
+     * because IDREF attributes such as `aria-describedby` cannot point across the
+     * design-system text-area's shadow boundary.
+     */
+    get debugLogComposeHint() {
+        var _a;
+        if (this.debugLogSubmitResult === 'error')
+            return 'Sending failed — try again.';
+        if (((_a = this.debugLogNoteConfig) === null || _a === void 0 ? void 0 : _a.required) && this.debugLogNoteMissing) {
+            return 'A short note is required.';
+        }
+        return this.debugLogNoteCounter;
+    }
+    /**
+     * Accessible name for the note. Deliberately STATIC apart from "(required)": a name
+     * that changed per keystroke would be re-read in full by NVDA on every key and never
+     * updated by JAWS. The running count reaches AT through `debugLogSubmitAnnouncement`
+     * at the thresholds where it matters.
+     */
+    get debugLogNoteAriaLabel() {
+        const note = this.debugLogNoteConfig;
+        const required = (note === null || note === void 0 ? void 0 : note.required) ? ' (required)' : '';
+        const max = note ? `, maximum ${note.maxLength} characters` : '';
+        return `Note to send with the agent log${required}${max}.`;
+    }
+    /**
+     * Text for the always-present live region beside the agent-log row, so the outcome of
+     * a submission is announced even when the compose box is closed or opted out
+     * (`note: false`), where the only visible change is the button label.
+     */
+    get debugLogSubmitAnnouncement() {
+        var _a;
+        if (this.submittingDebugLog)
+            return 'Sending the agent log.';
+        if (this.debugLogSubmitResult === 'sent')
+            return 'Agent log sent.';
+        if (this.debugLogSubmitResult === 'error')
+            return 'Sending the agent log failed. Try again.';
+        // The note's length, only as it nears the cap: `maxlength` is invisible to AT, so at
+        // the limit keystrokes would be silently dropped with nothing changing anywhere.
+        const max = (_a = this.debugLogNoteConfig) === null || _a === void 0 ? void 0 : _a.maxLength;
+        if (this.debugLogComposeOpen && max) {
+            const remaining = max - this.debugLogNote.length;
+            if (remaining <= 0) {
+                return `Note is at its ${max} character limit; further typing is dropped.`;
+            }
+            if (remaining <= DEBUG_LOG_NOTE_REMAINING_WARN)
+                return `${remaining} characters remaining.`;
+        }
+        return '';
+    }
+    /**
+     * The agent-log row's description, phrased for whichever actions the host enabled.
+     * Send is called out as transmitting: Download keeps the log on the user's machine,
+     * Send hands the full conversation to wherever the host's transport delivers it.
+     */
+    get debugLogRowDescription() {
+        var _a;
+        const ui = this.chatConfig.ui;
+        const download = (ui === null || ui === void 0 ? void 0 : ui.allowDebugDownload) === true;
+        const send = (ui === null || ui === void 0 ? void 0 : ui.debugLogSubmit) != null;
+        if (send && ((_a = ui === null || ui === void 0 ? void 0 : ui.debugLogSubmit) === null || _a === void 0 ? void 0 : _a.description))
+            return ui.debugLogSubmit.description;
+        const timeline = "a structured debug timeline of this assistant's activity";
+        // What actually travels (see `ChatDebugLogSubmission.logJson`): the lifetime stream,
+        // not just this conversation — say so where the user commits to it.
+        const transmits = 'transmits the full lifetime log — every conversation held here, including cleared ' +
+            'ones, with attachments, system prompts and agent configuration.';
+        if (download && send)
+            return `Export ${timeline}, or send it to support. Sending ${transmits}`;
+        if (send)
+            return `Send ${timeline} to support. This ${transmits}`;
+        return "Export a structured debug timeline of this session's agent activity.";
+    }
+    /**
+     * Whether the compose box's Send button is inert: a send is already in flight, or the
+     * host made the note required and it is still blank.
+     */
+    get debugLogSendDisabled() {
+        var _a;
+        if (this.submittingDebugLog)
+            return true;
+        return ((_a = this.debugLogNoteConfig) === null || _a === void 0 ? void 0 : _a.required) === true && this.debugLogNoteMissing;
+    }
+    /** Live "typed / max" counter for the compose box. */
+    get debugLogNoteCounter() {
+        var _a;
+        const max = (_a = this.debugLogNoteConfig) === null || _a === void 0 ? void 0 : _a.maxLength;
+        return max ? `${this.debugLogNote.length}/${max}` : '';
+    }
     /** Whether the chat header (and settings cog) should render. */
     get settingsCogVisible() {
         return this.settings.cogVisible;
@@ -3323,15 +3525,11 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     downloadDebugLog() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
             // Guard re-entry: the button is disabled while this runs, but a programmatic
             // or double-fire can't kick off a second stitch either.
             if (this.downloadingDebugLog)
                 return;
-            const timestamp = new Date().toISOString().replace(/:/g, '-');
-            const agentName = ((_c = (_b = (_a = this.activeAgent) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : this.headerTitle) !== null && _c !== void 0 ? _c : 'chat')
-                .toLowerCase()
-                .replace(/\s+/g, '-');
+            const filename = this.debugLogFilename();
             this.downloadingDebugLog = true;
             try {
                 const payload = yield this.buildDownloadLog();
@@ -3339,7 +3537,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                 const url = URL.createObjectURL(blob);
                 const a = document.createElement('a');
                 a.href = url;
-                a.download = `${agentName}-${timestamp}.json`;
+                a.download = filename;
                 a.click();
                 URL.revokeObjectURL(url);
             }
@@ -3348,6 +3546,187 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             }
         });
     }
+    /**
+     * Hand the agent log to the host's `ui.debugLogSubmit.send` callback — the Send
+     * button next to Download. Reuses `buildDownloadLog`, so the submitted log is
+     * byte-identical to what Download saves (lifetime-stitched when the provider
+     * persists diagnostics). The assistant is vendor-agnostic: the callback owns the
+     * transport (Sentry feedback, a support API, an upload endpoint). Outcome lands in
+     * `debugLogSubmitResult` so the button can flash 'Sent'/'Failed'; failures also go
+     * to the logger with the cause.
+     */
+    submitDebugLog() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.submittingDebugLog || this.debugLogSendDisabled)
+                return;
+            const config = (_a = this.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.debugLogSubmit;
+            if (!config)
+                return;
+            const generation = this.debugLogSubmitGeneration;
+            const agentName = this.debugLogAgentName;
+            const filename = this.debugLogFilename();
+            // Read at click time, BEFORE the async stitch: the user pressed Send on this note.
+            // Only a note the user could actually type travels with the log: with the compose box
+            // opted out there is no note, whatever a stale `debugLogNote` might hold.
+            const message = this.debugLogNoteConfig === null ? undefined : normalizeDebugLogNote(this.debugLogNote);
+            this.submittingDebugLog = true;
+            try {
+                const payload = yield this.buildDownloadLog();
+                if (generation !== this.debugLogSubmitGeneration)
+                    return;
+                yield settleWithin(config.send({
+                    logJson: JSON.stringify(payload, null, 2),
+                    filename,
+                    agentName,
+                    host: window.location.host,
+                    message,
+                }), (_b = config.timeoutMs) !== null && _b !== void 0 ? _b : DEBUG_LOG_SUBMIT_TIMEOUT_MS, 'debugLogSubmit.send');
+                if (generation !== this.debugLogSubmitGeneration)
+                    return;
+                // Success consumes the note; a failure (below) keeps the box open with it intact.
+                this.debugLogComposeOpen = false;
+                this.debugLogNote = '';
+                this.setDebugLogSubmitResult('sent');
+                this.restoreDebugLogTriggerFocus();
+            }
+            catch (e) {
+                if (generation !== this.debugLogSubmitGeneration)
+                    return;
+                logger.error('Submitting agent log failed:', e);
+                // Persists (no flash timer) until the user acts — see `setDebugLogSubmitResult`.
+                this.setDebugLogSubmitResult('error');
+                this.restoreDebugLogRetryFocus();
+            }
+            finally {
+                if (generation === this.debugLogSubmitGeneration)
+                    this.submittingDebugLog = false;
+            }
+        });
+    }
+    /** The agent name stamped on the log: the active agent, else the header title. */
+    get debugLogAgentName() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.activeAgent) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : this.headerTitle) !== null && _c !== void 0 ? _c : 'chat';
+    }
+    /**
+     * Filename for the agent log — the ONE derivation Download saves under and Send hands
+     * to the host, so `ChatDebugLogSubmission.filename`'s "same stem as the download"
+     * promise is enforced rather than relying on two copies agreeing.
+     */
+    debugLogFilename() {
+        const stem = this.debugLogAgentName.toLowerCase().replace(/\s+/g, '-');
+        return `${stem}-${new Date().toISOString().replace(/:/g, '-')}.json`;
+    }
+    /**
+     * Back to idle: nothing in flight, no flash, no open compose box, no note. Called on
+     * disconnect and on a session switch / Clear (a note typed against one conversation
+     * must not caption the next one's log). On disconnect — the
+     * flash timer would otherwise fire against a torn-down element, and clearing ONLY the
+     * timer would strand `debugLogSubmitResult` at 'sent'/'error' for good on a pop-out /
+     * pop-in (nothing else resets it), with the box remounting open on a stale note.
+     */
+    resetDebugLogSubmitState() {
+        this.debugLogSubmitGeneration += 1;
+        clearTimeout(this.debugLogSubmitResultTimer);
+        this.debugLogSubmitResultTimer = undefined;
+        // Including the in-flight flag: every escape route (Send, Cancel, the note, the row
+        // button) is gated on it, so a host transport that never settles would otherwise
+        // wedge the feature until reload.
+        this.submittingDebugLog = false;
+        this.debugLogSubmitResult = null;
+        this.debugLogComposeOpen = false;
+        this.debugLogNote = '';
+    }
+    /**
+     * The row's Send button. With a compose box configured (the default) it opens the box
+     * and focuses the note so the user can caption the log; with `note: false` it sends
+     * straight away, as before.
+     */
+    openDebugLogCompose() {
+        if (this.submittingDebugLog)
+            return;
+        if (this.debugLogNoteConfig === null) {
+            void this.submitDebugLog();
+            return;
+        }
+        // Opening again resets a lingering 'Failed' flash so the box starts clean.
+        clearTimeout(this.debugLogSubmitResultTimer);
+        this.debugLogSubmitResultTimer = undefined;
+        this.debugLogSubmitResult = null;
+        this.debugLogComposeOpen = true;
+        // Next frame so the `when` block has rendered the text-area. The design-system
+        // text-area does not delegate focus (see `maybeAutoFocusChatInput`), so drill in.
+        requestAnimationFrame(() => {
+            var _a, _b, _c;
+            if (!this.debugLogComposeOpen || !this.isConnected)
+                return;
+            const el = this.debugLogNoteEl;
+            (_c = ((_b = (_a = el === null || el === void 0 ? void 0 : el.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('textarea')) !== null && _b !== void 0 ? _b : el)) === null || _c === void 0 ? void 0 : _c.focus();
+        });
+    }
+    /** The note's `@input`: track the text, and let typing dismiss a standing failure. */
+    noteDebugLogInput(value) {
+        this.debugLogNote = value;
+        if (this.debugLogSubmitResult === 'error')
+            this.debugLogSubmitResult = null;
+    }
+    /** Close the compose box and discard the typed note. */
+    cancelDebugLogCompose() {
+        if (this.submittingDebugLog)
+            return;
+        this.debugLogComposeOpen = false;
+        this.debugLogNote = '';
+        this.restoreDebugLogTriggerFocus();
+    }
+    /**
+     * Closing the compose box unmounts the focused text-area, which drops focus to the
+     * document body and strands keyboard and screen-reader users. Hand it back to the row's
+     * Send button — next frame, once the `when` block has torn down and the button, disabled
+     * while the box was open, is interactive again.
+     */
+    restoreDebugLogTriggerFocus() {
+        requestAnimationFrame(() => {
+            var _a, _b;
+            if (!this.isConnected || this.debugLogComposeOpen)
+                return;
+            (_b = (_a = this.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('[part="submit-log-button"]')) === null || _b === void 0 ? void 0 : _b.focus();
+        });
+    }
+    /**
+     * After a FAILED send the controls come back but the element that started the send
+     * was disabled meanwhile, so focus has already dropped to the document body. Put it
+     * where the retry happens: the note when the box is open, else the row trigger.
+     */
+    restoreDebugLogRetryFocus() {
+        if (!this.debugLogComposeOpen) {
+            this.restoreDebugLogTriggerFocus();
+            return;
+        }
+        requestAnimationFrame(() => {
+            var _a, _b, _c;
+            if (!this.isConnected || !this.debugLogComposeOpen)
+                return;
+            const el = this.debugLogNoteEl;
+            (_c = ((_b = (_a = el === null || el === void 0 ? void 0 : el.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('textarea')) !== null && _b !== void 0 ? _b : el)) === null || _c === void 0 ? void 0 : _c.focus();
+        });
+    }
+    /**
+     * Record the submit outcome. 'sent' flashes and falls back to idle; 'error' PERSISTS
+     * until the user acts (types, reopens the box, cancels, or retries) — a failure that
+     * silently reverted to the counter after four seconds left no trace it had happened.
+     */
+    setDebugLogSubmitResult(result) {
+        clearTimeout(this.debugLogSubmitResultTimer);
+        this.debugLogSubmitResultTimer = undefined;
+        this.debugLogSubmitResult = result;
+        if (result !== 'sent')
+            return;
+        this.debugLogSubmitResultTimer = setTimeout(() => {
+            this.debugLogSubmitResult = null;
+            this.debugLogSubmitResultTimer = undefined;
+        }, this.debugLogSubmitResultFlashMs);
+    }
     /**
      * The log to download (GENC-1351 §5.8). When the provider persists diagnostics,
      * stitch the **whole lifetime** stream (every page load) rather than just the
@@ -3968,6 +4347,18 @@ __decorate([
 __decorate([
     observable
 ], FoundationAiAssistant.prototype, "downloadingDebugLog", void 0);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "submittingDebugLog", void 0);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "debugLogSubmitResult", void 0);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "debugLogComposeOpen", void 0);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "debugLogNote", void 0);
 __decorate([
     observable
 ], FoundationAiAssistant.prototype, "persistenceBroken", void 0);
@@ -4016,6 +4407,39 @@ __decorate([
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "agentPickerEnabled", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "settingsAgentLogSectionVisible", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogNoteConfig", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogNoteMissing", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogSubmitLabel", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogSubmitButtonLabel", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogComposeHint", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogNoteAriaLabel", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogSubmitAnnouncement", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogRowDescription", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogSendDisabled", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "debugLogNoteCounter", null);
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "pinnedAgentHint", null);

package/dist/esm/utils/resolve-debug-log-note.js

@@ -0,0 +1,37 @@
+/** Default cap on the user's note. Short by design — it is a caption for the log, not a report. */
+export const DEBUG_LOG_NOTE_DEFAULT_MAX_LENGTH = 500;
+/** Default prompt in the empty note. */
+export const DEBUG_LOG_NOTE_DEFAULT_PLACEHOLDER = 'What were you doing, or what went wrong? (optional)';
+/** The same prompt for a `required` note — "(optional)" would contradict the disabled Send. */
+export const DEBUG_LOG_NOTE_REQUIRED_PLACEHOLDER = 'What were you doing, or what went wrong?';
+/**
+ * Resolve `debugLogSubmit.note` — `undefined`/`true` mean "compose box with defaults",
+ * `false` means "no compose box, send on first click" (→ `null`), and an object customises
+ * the box. Keeps the template free of the boolean-or-object dance.
+ */
+export function resolveDebugLogNoteConfig(config) {
+    var _a;
+    if (!config || config.note === false)
+        return null;
+    // `typeof null === 'object'`: a host building its config dynamically can hand us `null`
+    // even though the type forbids it, and that must read as "defaults", not crash.
+    const note = typeof config.note === 'object' && config.note !== null ? config.note : {};
+    // `>= 1`, not `> 0`: a fractional cap under 1 would floor to 0 and lock the textarea.
+    const maxLength = typeof note.maxLength === 'number' && note.maxLength >= 1
+        ? Math.floor(note.maxLength)
+        : DEBUG_LOG_NOTE_DEFAULT_MAX_LENGTH;
+    const required = note.required === true;
+    return {
+        placeholder: (_a = note.placeholder) !== null && _a !== void 0 ? _a : (required ? DEBUG_LOG_NOTE_REQUIRED_PLACEHOLDER : DEBUG_LOG_NOTE_DEFAULT_PLACEHOLDER),
+        required,
+        maxLength,
+    };
+}
+/**
+ * Normalise the typed note for the submission: trimmed, and `undefined` when empty so a
+ * host can `message ?? fallback` without checking for whitespace.
+ */
+export function normalizeDebugLogNote(note) {
+    const trimmed = note.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "15.29.0",
+  "version": "15.30.0",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -74,26 +74,26 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "15.29.0",
-    "@genesislcap/genx": "15.29.0",
-    "@genesislcap/rollup-builder": "15.29.0",
-    "@genesislcap/ts-builder": "15.29.0",
-    "@genesislcap/uvu-playwright-builder": "15.29.0",
-    "@genesislcap/vite-builder": "15.29.0",
-    "@genesislcap/webpack-builder": "15.29.0",
+    "@genesislcap/foundation-testing": "15.30.0",
+    "@genesislcap/genx": "15.30.0",
+    "@genesislcap/rollup-builder": "15.30.0",
+    "@genesislcap/ts-builder": "15.30.0",
+    "@genesislcap/uvu-playwright-builder": "15.30.0",
+    "@genesislcap/vite-builder": "15.30.0",
+    "@genesislcap/webpack-builder": "15.30.0",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2",
     "esbuild": "0.25.12"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "15.29.0",
-    "@genesislcap/foundation-logger": "15.29.0",
-    "@genesislcap/foundation-notifications": "15.29.0",
-    "@genesislcap/foundation-redux": "15.29.0",
-    "@genesislcap/foundation-ui": "15.29.0",
-    "@genesislcap/foundation-utils": "15.29.0",
-    "@genesislcap/rapid-design-system": "15.29.0",
-    "@genesislcap/web-core": "15.29.0",
+    "@genesislcap/foundation-ai": "15.30.0",
+    "@genesislcap/foundation-logger": "15.30.0",
+    "@genesislcap/foundation-notifications": "15.30.0",
+    "@genesislcap/foundation-redux": "15.30.0",
+    "@genesislcap/foundation-ui": "15.30.0",
+    "@genesislcap/foundation-utils": "15.30.0",
+    "@genesislcap/rapid-design-system": "15.30.0",
+    "@genesislcap/web-core": "15.30.0",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },