@genesislcap/ai-assistant 15.25.1 → 15.27.0-agent-log-submit.3

package/dist/esm/main/main.js

@@ -58,7 +58,8 @@ 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 { resolvePreferenceBaseline } from '../utils/resolve-preference-baseline';
+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';
 import { AttachmentController } from './attachment-controller';
@@ -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).
  *
@@ -114,6 +142,14 @@ const DEFAULT_PERSISTENCE_SOURCE = 'host';
  * cannot drift apart.
  */
 const BLOCKED_PLACEHOLDER = 'AI usage limit reached';
+/**
+ * How often the transcript's relative timestamps are recomputed (GENC-1257).
+ *
+ * The relative tier changes at minute granularity, so a 30s tick caps how stale a label
+ * can look at half a minute — close enough that a user watching one never sees it lag,
+ * without a per-second timer. The work per tick is one string format per visible row.
+ */
+const TIMESTAMP_CLOCK_INTERVAL_MS = 30000;
 /**
  * Budget formatting helpers, re-exported so they stay on this module's public
  * surface (`src/index.ts` does `export * from './main/main'`). They live in
@@ -276,6 +312,16 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.persistence = {};
         /** When set, enables Redux DevTools for this instance's session store. */
         this.debugRedux = false;
+        /**
+         * Epoch ms the transcript's relative timestamps are measured against.
+         *
+         * A relative label is only correct at the instant it renders: FAST evaluates the
+         * binding once, and an idle conversation never re-renders, so "2 minutes ago" would
+         * still read "2 minutes ago" an hour later. Making the formatter read this observable
+         * instead of `Date.now()` gives every row one shared, invalidatable clock — a tick
+         * re-evaluates them all.
+         */
+        this.timestampClock = Date.now();
         // ---- Transient UI state (stays as @observable on the component) ----
         this._suggestionsGeneration = 0;
         /** Whether the loading spinner is currently visible. Controlled by the loading delay timer. */
@@ -288,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
@@ -622,12 +696,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set showToolCalls(value) {
         var _a;
-        // Idempotent: a same-value set is a no-op. The design-system switch fires
-        // `@change` when its `:checked` binding is applied on render (not just on user
-        // interaction), which would otherwise spuriously mark prefs "user-changed" and
-        // save config defaults — freezing the reconciler so real stored prefs never apply
-        // on reload (GENC-1351 #1).
-        if (this.showToolCalls === value)
+        if (preferenceUnchanged(this.showToolCalls, value))
             return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowToolCalls(value);
         this.persistPreferences();
@@ -639,8 +708,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set showThinkingSteps(value) {
         var _a;
-        if (this.showThinkingSteps === value)
-            return; // idempotent — see showToolCalls
+        if (preferenceUnchanged(this.showThinkingSteps, value))
+            return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowThinkingSteps(value);
         this.persistPreferences();
     }
@@ -651,8 +720,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set showNarration(value) {
         var _a;
-        if (this.showNarration === value)
-            return; // idempotent — see showToolCalls
+        if (preferenceUnchanged(this.showNarration, value))
+            return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowNarration(value);
         this.persistPreferences();
     }
@@ -663,11 +732,55 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set showAgentSwitchIndicator(value) {
         var _a;
-        if (this.showAgentSwitchIndicator === value)
-            return; // idempotent — see showToolCalls
+        if (preferenceUnchanged(this.showAgentSwitchIndicator, value))
+            return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowAgentSwitchIndicator(value);
         this.persistPreferences();
     }
+    /**
+     * When each message shows its timestamp — `'off'`, `'hover'` (default) or `'always'`.
+     *
+     * Falls back to `DEFAULT_TIMESTAMP_DISPLAY` rather than `'off'` when there is no
+     * store yet: this preference defaults ON, so the pre-store render must match the state
+     * the baseline is about to resolve to, or timestamps would visibly pop in on connect.
+     */
+    get timestampDisplay() {
+        var _a, _b;
+        return (_b = (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.store.aiAssistant.timestampDisplay) !== null && _b !== void 0 ? _b : DEFAULT_TIMESTAMP_DISPLAY;
+    }
+    set timestampDisplay(value) {
+        var _a;
+        if (preferenceUnchanged(this.timestampDisplay, value))
+            return;
+        (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setTimestampDisplay(value);
+        this.persistPreferences();
+        // The mode decides whether the clock needs to run at all.
+        this.syncTimestampClock();
+    }
+    /**
+     * Start or stop the timestamp clock to match the current mode and connection state.
+     *
+     * Idempotent, and safe to call from either lifecycle end — it is driven from
+     * `connectedCallback`, `disconnectedCallback` and the `timestampDisplay` setter, which
+     * can fire in any order. Nothing runs while the mode is `'off'` (no binding reads the
+     * clock) or while disconnected (a timer outliving its element is a leak, and a
+     * popped-out view disconnects without the session ending).
+     */
+    syncTimestampClock() {
+        const wanted = this._sessionActive && this.timestampDisplay !== 'off';
+        if (wanted === !!this._timestampClockTimer)
+            return;
+        if (!wanted) {
+            clearInterval(this._timestampClockTimer);
+            this._timestampClockTimer = undefined;
+            return;
+        }
+        // Re-sync immediately: the element may have sat disconnected across several ticks.
+        this.timestampClock = Date.now();
+        this._timestampClockTimer = setInterval(() => {
+            this.timestampClock = Date.now();
+        }, TIMESTAMP_CLOCK_INTERVAL_MS);
+    }
     /** Currently enabled animations. */
     get enabledAnimations() {
         var _a, _b;
@@ -675,10 +788,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     set enabledAnimations(value) {
         var _a;
-        // Idempotent (order-insensitive) — see showToolCalls: the per-animation switches
-        // fire the same spurious render-time `@change`.
-        const current = this.enabledAnimations;
-        if (current.length === value.length && current.every((a) => value.includes(a)))
+        if (preferenceUnchanged(this.enabledAnimations, value))
             return;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setEnabledAnimations(value);
         this.persistPreferences();
@@ -2062,6 +2172,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         window.addEventListener('pagehide', this._handlePageHide);
         logger.debug('FoundationAiAssistant connected');
         this._sessionActive = true;
+        // After `_sessionActive`, which `syncTimestampClock` reads as "connected".
+        this.syncTimestampClock();
     }
     /**
      * Switch this element to a different session **in place**, without a page reload
@@ -2092,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();
@@ -2151,7 +2266,10 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.costLedger.flush();
         super.disconnectedCallback();
         this._sessionActive = false;
+        // 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` /
@@ -2740,6 +2858,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             showThinkingSteps: this.showThinkingSteps,
             showNarration: this.showNarration,
             showAgentSwitchIndicator: this.showAgentSwitchIndicator,
+            timestampDisplay: this.timestampDisplay,
             animations: [...this.enabledAnimations],
         };
     }
@@ -2800,6 +2919,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             this.showThinkingSteps = resolved.showThinkingSteps;
             this.showNarration = resolved.showNarration;
             this.showAgentSwitchIndicator = resolved.showAgentSwitchIndicator;
+            this.timestampDisplay = resolved.timestampDisplay;
             this.enabledAnimations = resolved.enabledAnimations;
         }
         finally {
@@ -2908,6 +3028,9 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             if (this.driver)
                 this.teardownDriver(key);
             (_g = this._sessionRef) === null || _g === void 0 ? void 0 : _g.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).
@@ -3080,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;
@@ -3263,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();
@@ -3279,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);
             }
@@ -3288,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
@@ -3896,6 +4335,9 @@ __decorate([
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "busy", null);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "timestampClock", void 0);
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "effectiveChatInputDuringExecution", null);
@@ -3905,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);
@@ -3953,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);