@genesislcap/ai-assistant 15.56.0 → 15.58.0

package/dist/esm/main/main.js

@@ -47,6 +47,7 @@ import { buildTimelineEntries } from '../state/persistence/build-timeline-entrie
 import { assembleDebugLog, withFreshMetaSnapshot } from '../state/persistence/diagnostics';
 import { deleteDiagnosticsCursorsFor, resetDiagnosticsCursorsFor, } from '../state/persistence/diagnostics-cursors';
 import { getOrCreatePersister, getPersister, deletePersister, } from '../state/persistence/persister-registry';
+import { resumeVerdict } from '../state/persistence/resume-verdict';
 import { SessionPersister, } from '../state/persistence/session-persister';
 import { lastUserMessageIndex } from '../state/persistence/session-snapshot';
 import { getSessionStore, hasSessionStore, deleteSessionStore, } from '../state/session-store';
@@ -3982,7 +3983,11 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             // the clobber this guards. A write through the captured ref after a swap/disconnect
             // is a harmless no-op on the now-detached store (the pattern `send()` uses).
             const ref = this._sessionRef;
+            // Captured with `ref`, for the same reason (GENC-1662): the restored flow must be resumed on
+            // THIS session's driver, and only while this session is still the one on screen.
+            const driver = this.driver;
             ref === null || ref === void 0 ? void 0 : ref.actions.aiAssistant.setRestoring(true);
+            let outcome;
             try {
                 try {
                     // The persister loads + owns the stored blob; reconcile overlays it on the
@@ -3995,12 +4000,79 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                     logger.error('Persistence init: loadPreferences failed (using defaults):', e);
                 }
                 if (this.persistence.enabled) {
-                    yield ((_b = this.persister()) === null || _b === void 0 ? void 0 : _b.restore());
+                    outcome = yield ((_b = this.persister()) === null || _b === void 0 ? void 0 : _b.restore());
+                }
+                // Re-activate the flow owner INSIDE the "Restoring…" gate (GENC-1662), so the composer stays
+                // disabled while its `onActivate` runs. Outside a turn nothing else marks the driver busy, and
+                // a send landing mid-activation used to run `onActivate` a second time.
+                if ((outcome === null || outcome === void 0 ? void 0 : outcome.flowOwnerAgentName) && !this.isRestoredSessionStale(key, driver)) {
+                    yield this.reactivateRestoredFlow(driver);
                 }
             }
             finally {
                 ref === null || ref === void 0 ? void 0 : ref.actions.aiAssistant.setRestoring(false);
             }
+            // After the gate lifts, so the resumed turn runs like any other. Not awaited: a resumed turn
+            // can run as long as any turn, and nothing here waits on it.
+            if (outcome === null || outcome === void 0 ? void 0 : outcome.resumeNote)
+                void this.resumeInterruptedTurn(key, driver, ref, outcome);
+        });
+    }
+    /**
+     * Whether the session restored for `key` is no longer the one on screen (GENC-1662): switched in
+     * place, or the element disconnected, while the load was in flight.
+     */
+    isRestoredSessionStale(key, driver) {
+        return this._activeStateKey !== key || !driver || this.driver !== driver;
+    }
+    /**
+     * Re-activate a restored flow owner (GENC-1662), so a stateful agent's `init({ restored })` — and
+     * anything the host hangs off it, like a progress stepper — runs straight after the reload
+     * instead of on the next message.
+     */
+    reactivateRestoredFlow(driver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                yield ((_a = driver === null || driver === void 0 ? void 0 : driver.resumeRestoredFlow) === null || _a === void 0 ? void 0 : _a.call(driver));
+            }
+            catch (e) {
+                logger.error('Session restore: re-activating the flow owner failed:', e);
+            }
+        });
+    }
+    /**
+     * Run the turn a reload interrupted (GENC-1662), shown as busy exactly as a send is — or, when it
+     * cannot run, withdraw the resume the restore divider promised.
+     */
+    resumeInterruptedTurn(key, driver, ref, outcome) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const verdict = resumeVerdict(outcome, {
+                stale: this.isRestoredSessionStale(key, driver),
+                sendBlocked: this.sendBlocked,
+            });
+            const persister = getPersister(key);
+            if (verdict.action === 'withdraw') {
+                persister === null || persister === void 0 ? void 0 : persister.withdrawResume(verdict.reason);
+                return;
+            }
+            if (verdict.action !== 'resume' || !(driver === null || driver === void 0 ? void 0 : driver.resumeRestoredFlow))
+                return;
+            this.state = 'loading';
+            this.startLoadingTimer();
+            try {
+                const result = yield driver.resumeRestoredFlow(verdict.note);
+                if ((result === null || result === void 0 ? void 0 : result.reason) === 'done') {
+                    this.budget.latchFrom(result.failureReason, ref, result.budget);
+                }
+            }
+            catch (e) {
+                logger.error('Session restore: resuming the restored flow failed:', e);
+                persister === null || persister === void 0 ? void 0 : persister.withdrawResume('error');
+            }
+            finally {
+                this.settleAfterTurn(ref);
+            }
         });
     }
     triggerFileInput() {
@@ -4216,31 +4288,38 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                 }
             }
             finally {
-                this.stopLoadingTimer();
                 this._pendingSendPrompt = undefined;
-                // Write directly via captured ref — this._sessionRef may be null if the element
-                // disconnected mid-execution. The state setter also calls syncShowHalo(); replicate
-                // that here for the case where this element is still connected.
-                const prevState = capturedSessionRef === null || capturedSessionRef === void 0 ? void 0 : capturedSessionRef.store.aiAssistant.state;
-                capturedSessionRef === null || capturedSessionRef === void 0 ? void 0 : capturedSessionRef.actions.aiAssistant.setState('idle');
-                // The setter's `state.changed` log is bypassed on this direct write, so
-                // emit it here — otherwise the debug timeline shows the turn entering
-                // loading/cancelling but never returning to idle.
-                if (prevState && prevState !== 'idle') {
-                    this.logMeta('state.changed', { from: prevState, to: 'idle' });
-                }
-                this.syncShowHalo();
-                this.fetchSuggestions();
-                // setState was dispatched directly via the captured ref (not via the
-                // state setter) so the setter's loading→idle cleanup path doesn't fire
-                // here. Replicate the parts of it that matter for the post-turn settle.
-                this.rearmContextGate();
-                this.maybeAutoFocusChatInput();
-                this.applyDeferredSessionSwitch();
-                this.applyDeferredAgentsSwap();
+                this.settleAfterTurn(capturedSessionRef);
             }
         });
     }
+    /**
+     * The post-turn settle shared by `send()` and a resumed restore turn: back to idle through
+     * the session ref captured at turn start, then the cleanup the state setter would have done.
+     */
+    settleAfterTurn(capturedSessionRef) {
+        this.stopLoadingTimer();
+        // Write directly via captured ref — this._sessionRef may be null if the element
+        // disconnected mid-execution. The state setter also calls syncShowHalo(); replicate
+        // that here for the case where this element is still connected.
+        const prevState = capturedSessionRef === null || capturedSessionRef === void 0 ? void 0 : capturedSessionRef.store.aiAssistant.state;
+        capturedSessionRef === null || capturedSessionRef === void 0 ? void 0 : capturedSessionRef.actions.aiAssistant.setState('idle');
+        // The setter's `state.changed` log is bypassed on this direct write, so
+        // emit it here — otherwise the debug timeline shows the turn entering
+        // loading/cancelling but never returning to idle.
+        if (prevState && prevState !== 'idle') {
+            this.logMeta('state.changed', { from: prevState, to: 'idle' });
+        }
+        this.syncShowHalo();
+        this.fetchSuggestions();
+        // setState was dispatched directly via the captured ref (not via the
+        // state setter) so the setter's loading→idle cleanup path doesn't fire
+        // here. Replicate the parts of it that matter for the post-turn settle.
+        this.rearmContextGate();
+        this.maybeAutoFocusChatInput();
+        this.applyDeferredSessionSwitch();
+        this.applyDeferredAgentsSwap();
+    }
     onChatHeaderMouseDown(e) {
         if (this.popoutMode === 'collapse')
             return;

package/dist/esm/state/debug-event-log.js

@@ -81,6 +81,10 @@ export const META_EVENT_IMPORTANCE = {
     'session.switched': 'low',
     'session.switch-deferred': 'low',
     'persistence.restored': 'normal',
+    // Whether a restored flow will be re-activated and resumed (GENC-1662), and how much the trim cut.
+    'persistence.resume-planned': 'normal',
+    // A planned resume that did not run, and why (GENC-1662) — the divider was put back to plain.
+    'persistence.resume-withdrawn': 'normal',
     'persistence.suppressed': 'normal',
     'persistence.not-resumable': 'normal',
     'driver.wired': 'low',

package/dist/esm/state/persistence/resume-verdict.js

@@ -0,0 +1,20 @@
+/**
+ * Decide the resumed turn (GENC-1662). Pure, so the element's branching is testable on its own.
+ *
+ * - No note → nothing to resume (and nothing was promised).
+ * - `stale` → the session on screen is no longer the one restored (switched or disconnected while
+ *   the load was in flight); running would put one session's turn on another's flow.
+ * - `sendBlocked` → a send would be refused right now (an exhausted budget, a full context), so is
+ *   the resumed turn; the user resumes by hand once the block clears.
+ *
+ * @internal
+ */
+export function resumeVerdict(outcome, context) {
+    if (!(outcome === null || outcome === void 0 ? void 0 : outcome.resumeNote))
+        return { action: 'none' };
+    if (context.stale)
+        return { action: 'withdraw', reason: 'session-changed' };
+    if (context.sendBlocked)
+        return { action: 'withdraw', reason: 'send-blocked' };
+    return { action: 'resume', note: outcome.resumeNote };
+}

package/dist/esm/state/persistence/session-persister.js

@@ -2,12 +2,12 @@ import { __awaiter } from "tslib";
 import { asOrchestrator } from '../../components/orchestrating-driver/orchestrating-driver';
 import { flattenSubAgentMessages } from '../../utils/flatten-sub-agent-messages';
 import { logger } from '../../utils/logger';
-import { isSessionNoticeMarker, SESSION_RESTORE_FAILED_LABEL, SESSION_RESTORED_LABEL, } from '../../utils/message-partition';
+import { isSessionNoticeMarker, SESSION_RESTORE_FAILED_LABEL, SESSION_RESTORED_LABEL, SESSION_RESUMED_LABEL, } from '../../utils/message-partition';
 import { withTimeout } from '../../utils/with-timeout';
 import { recordMetaEvent } from '../debug-event-log';
 import { diagnosticsMessageKey } from './diagnostics';
 import { getDiagnosticsCursors } from './diagnostics-cursors';
-import { createPersistedSession, isRestorableSession, keepThroughLastUserMessage, reconcileAgentSnapshots, resolveNonResumableNotice, toLoadSessionPayload, trimToRestorableBoundary, unknownAgentSnapshots, } from './session-snapshot';
+import { buildResumeNote, createPersistedSession, isRestorableSession, keepThroughLastUserMessage, reconcileAgentSnapshots, resolveNonResumableNotice, toLoadSessionPayload, trimToRestorableBoundary, unknownAgentSnapshots, } from './session-snapshot';
 /**
  * Backstop for a slow/hung persistence provider on startup restore (GENC-1351
  * §6). Deliberately long: silently losing a restorable session is a far worse
@@ -518,13 +518,17 @@ export class SessionPersister {
      * when disabled, absent, or version/host mismatched. An `interrupted` snapshot
      * (§5.9) restores the conversation but shows a "start again" assistant message
      * instead of rehydrating the mid-flight flow.
+     *
+     * Resolves to a `RestoreOutcome` when a session was restored, `undefined` otherwise. The
+     * outcome says whether the restored flow should resume (GENC-1662); acting on it is the host's
+     * job, after its "Restoring…" gate has lifted, so the resumed turn runs like any other.
      */
     restore() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d, _e, _f, _g, _h;
             const { provider } = this.deps.getPersistence();
             if (!provider)
-                return;
+                return undefined;
             const key = this.stateKey;
             const driver = this.deps.getDriver();
             // Bound a slow/hung provider so a stuck load can't brick startup. On timeout
@@ -540,25 +544,34 @@ export class SessionPersister {
             catch (e) {
                 logger.warn('Session restore: load failed or timed out — starting fresh', e);
                 this.showRestoreFailedNotice();
-                return;
+                return undefined;
             }
             if (!snapshot)
-                return; // genuinely nothing stored → fresh session, no notice
+                return undefined; // genuinely nothing stored → fresh session, no notice
             try {
                 if (!isRestorableSession(snapshot, { host: window.location.host })) {
                     // A saved snapshot existed but can't be used (schema bump / cross-host) —
                     // tell the user rather than silently dropping their conversation.
                     logger.debug('Session restore skipped: version/host mismatch', { key });
                     this.showRestoreFailedNotice();
-                    return;
+                    return undefined;
                 }
                 // Trim a trailing incomplete turn (orphaned tool call / placeholder / pending
                 // interaction) so a snapshot saved mid-loop restores to the last
                 // provider-valid boundary (§5.3 step 2).
-                const trimmed = trimToRestorableBoundary(snapshot.messages).filter((m) => !isSessionNoticeMarker(m));
+                const bounded = trimToRestorableBoundary(snapshot.messages);
+                const trimmed = bounded.filter((m) => !isSessionNoticeMarker(m));
+                // GENC-1662: re-activate a flow that is still owned, was not frozen as non-resumable, and
+                // whose owner this driver knows; resume it as well when the reload interrupted a turn and the
+                // owner has not opted out. Otherwise the restore is exactly what it was.
+                const savedOwner = snapshot.interrupted ? null : ((_a = snapshot.flowOwnerAgentName) !== null && _a !== void 0 ? _a : null);
+                const flowOwner = savedOwner && ((_b = driver === null || driver === void 0 ? void 0 : driver.canRestoreFlowOwner) === null || _b === void 0 ? void 0 : _b.call(driver, savedOwner)) ? savedOwner : null;
+                const resumeNote = flowOwner && ((_c = driver === null || driver === void 0 ? void 0 : driver.canResumeRestoredFlow) === null || _c === void 0 ? void 0 : _c.call(driver, flowOwner))
+                    ? buildResumeNote(trimmed, snapshot.messages.slice(bounded.length))
+                    : undefined;
                 const ref = this.deps.getStore();
                 if (!ref)
-                    return;
+                    return undefined;
                 // Diagnostics watermark (§5.8): messages present at restore already live in a
                 // prior load's diagnostics stream — record their identities in the shared
                 // per-session cursors so this load's forward capture never re-appends them
@@ -633,21 +646,22 @@ export class SessionPersister {
                     trailers = [
                         {
                             role: 'system-event',
-                            content: SESSION_RESTORED_LABEL,
+                            // Says why the next question may not read exactly as it did (GENC-1662).
+                            content: resumeNote ? SESSION_RESUMED_LABEL : SESSION_RESTORED_LABEL,
                             timestamp: trailerTs,
                         },
                     ];
                 }
                 const messages = [...trimmed, ...trailers];
                 ref.actions.aiAssistant.loadSession(toLoadSessionPayload(Object.assign(Object.assign({}, snapshot), { messages })));
-                (_a = driver === null || driver === void 0 ? void 0 : driver.loadHistory) === null || _a === void 0 ? void 0 : _a.call(driver, [...messages]);
+                (_d = driver === null || driver === void 0 ? void 0 : driver.loadHistory) === null || _d === void 0 ? void 0 : _d.call(driver, [...messages]);
                 // Re-arm the condense policies that had not fired at save time (GENC-1632) — AFTER
                 // `loadHistory`, because the driver keeps only entries whose tool call is in the history it
                 // now holds, which is how an entry for a call `trimToRestorableBoundary` cut away is dropped
                 // rather than resurrected. A snapshot from before the field existed has none, so this is a
                 // no-op and the restore is exactly what it was. Timing against the agent's re-activation is
                 // the driver's problem, not ours: it defers the activation stamp to the next `installAgent`.
-                const condenseRestore = (_b = driver === null || driver === void 0 ? void 0 : driver.restoreCondensePolicies) === null || _b === void 0 ? void 0 : _b.call(driver, snapshot.condensePolicies);
+                const condenseRestore = (_e = driver === null || driver === void 0 ? void 0 : driver.restoreCondensePolicies) === null || _e === void 0 ? void 0 : _e.call(driver, snapshot.condensePolicies);
                 // Observability (GENC-1351, counts refined for GENC-1632 review): record exactly what the
                 // restore primed, so a post-reload debug-log export shows whether a stateful agent's snapshot
                 // actually came back (meta events reset on reload, so this is the only window onto the
@@ -659,7 +673,7 @@ export class SessionPersister {
                 // are left OFF the object (not zeroed) when there is no driver or it predates this method, so
                 // that case can't be misread as "re-armed none" either.
                 this.logMeta('persistence.restored', {
-                    agents: Object.keys((_c = snapshot.agentSnapshots) !== null && _c !== void 0 ? _c : {}),
+                    agents: Object.keys((_f = snapshot.agentSnapshots) !== null && _f !== void 0 ? _f : {}),
                     condensePolicies: Object.assign({ stored: Array.isArray(snapshot.condensePolicies) ? snapshot.condensePolicies.length : 0 }, condenseRestore),
                     agentSnapshots: snapshot.agentSnapshots,
                     pinnedAgentName: snapshot.pinnedAgentName,
@@ -687,17 +701,43 @@ export class SessionPersister {
                 // driver's routing agrees with the restored (picker-locked) store state.
                 const orchestrator = asOrchestrator(driver);
                 if (orchestrator) {
-                    orchestrator.setPinnedAgent((_d = snapshot.pinnedAgentName) !== null && _d !== void 0 ? _d : null);
-                    orchestrator.setFlowOwner((_e = snapshot.flowOwnerAgentName) !== null && _e !== void 0 ? _e : null);
+                    orchestrator.setPinnedAgent((_g = snapshot.pinnedAgentName) !== null && _g !== void 0 ? _g : null);
+                    orchestrator.setFlowOwner((_h = snapshot.flowOwnerAgentName) !== null && _h !== void 0 ? _h : null);
+                }
+                if (flowOwner) {
+                    this.logMeta('persistence.resume-planned', {
+                        flowOwner,
+                        resume: !!resumeNote,
+                        dropped: snapshot.messages.length - bounded.length,
+                    });
                 }
                 logger.debug('Session restored', { key, messages: messages.length });
+                return { sessionKey: key, flowOwnerAgentName: flowOwner, resumeNote };
             }
             catch (e) {
                 logger.error('Session restore failed:', e);
                 this.showRestoreFailedNotice();
+                return undefined;
             }
         });
     }
+    /**
+     * Take back a resume the restore promised (GENC-1662). `restore()` picks the divider wording when
+     * it plans a resume, but the host decides afterwards whether the turn actually runs — a blocked
+     * send, a session switched away, a driver error. When it does not, this puts the plain divider
+     * back so the transcript does not claim a resume that never happened, and records why.
+     */
+    withdrawResume(reason) {
+        var _a;
+        const driver = this.deps.getDriver();
+        const history = (_a = driver === null || driver === void 0 ? void 0 : driver.getRawHistory) === null || _a === void 0 ? void 0 : _a.call(driver);
+        if (driver &&
+            (history === null || history === void 0 ? void 0 : history.some((m) => m.role === 'system-event' && m.content === SESSION_RESUMED_LABEL))) {
+            driver.loadHistory(history.map((m) => m.role === 'system-event' && m.content === SESSION_RESUMED_LABEL
+                ? Object.assign(Object.assign({}, m), { content: SESSION_RESTORED_LABEL }) : m));
+        }
+        this.logMeta('persistence.resume-withdrawn', { reason });
+    }
     /**
      * Surface a non-fatal "couldn't restore" notice after a failed restore (load
      * timeout/error, or an unusable snapshot) so a vanished conversation isn't a

package/dist/esm/state/persistence/session-snapshot.js

@@ -141,6 +141,73 @@ export function trimToRestorableBoundary(messages) {
     }
     return end === messages.length ? messages : messages.slice(0, end);
 }
+/** Longest argument rendering the resume note carries per call — a hint, not a replay. */
+const RESUME_NOTE_ARGS_MAX = 300;
+/** The driver's marker for a turn the user stopped — a turn that ended, not one a reload cut. */
+const STOPPED_EVENT = 'Stopped.';
+/**
+ * The note for the turn that resumes a flow after a reload (GENC-1662), or `undefined` when the
+ * reload interrupted nothing.
+ *
+ * Interrupted means the model owed a reply when the page went. Three ways that shows up:
+ *  - `dropped` holds a tool call — `trimToRestorableBoundary` cut an unanswered call (often one
+ *    waiting on a widget);
+ *  - the restored transcript ends on a `tool` result — the results landed, the model call that
+ *    would read them never finished;
+ *  - it ends on a user message — the user's turn never got its first reply.
+ * An assistant reply, or the driver's `Stopped.` event, ends the transcript on a finished turn.
+ *
+ * The note gives CONTEXT, never an instruction to repeat anything: the model reads where things
+ * stand and decides afresh. A cut call may have asked the user something (unanswered), or may
+ * have partly run before the reload (a write that landed), so a blind repeat could be wrong.
+ *
+ * @internal
+ */
+export function buildResumeNote(restored, dropped) {
+    const lead = '[Session restored] The page was reloaded part-way through your turn.';
+    const tail = 'Continue from where the conversation now stands.';
+    const calls = dropped.flatMap((m) => { var _a; return (_a = m.toolCalls) !== null && _a !== void 0 ? _a : []; });
+    if (calls.length) {
+        const listed = calls.map((c) => `\`${c.name}\` ${truncateArgs(c.args)}`).join('; ');
+        const plural = calls.length > 1;
+        return (`${lead} Your last ${plural ? 'calls' : 'call'} did not complete, so ${plural ? 'they were' : 'it was'} ` +
+            `cut from the conversation: ${listed}. If ${plural ? 'one was' : 'it was'} asking the user ` +
+            `something, they have not answered. Otherwise it may not have run, or may have partly run — ` +
+            `check the current state before repeating it. ${tail}`);
+    }
+    const last = lastTurnRow(restored);
+    if ((last === null || last === void 0 ? void 0 : last.role) === 'tool') {
+        return `${lead} Your last tool results came back, but you had not yet responded to them. ${tail}`;
+    }
+    if ((last === null || last === void 0 ? void 0 : last.role) === 'user' || (last === null || last === void 0 ? void 0 : last.role) === 'synthetic-user') {
+        return `${lead} You had not yet replied to the user's last message. ${tail}`;
+    }
+    return undefined;
+}
+/**
+ * The last row that says how the turn stood: skips display-only `system-event` rows (agent switch
+ * indicators, restore dividers), except the driver's `Stopped.` event, which is returned because it
+ * ends the turn.
+ */
+function lastTurnRow(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const m = messages[i];
+        if ((m === null || m === void 0 ? void 0 : m.role) === 'system-event' && m.content !== STOPPED_EVENT)
+            continue;
+        return m;
+    }
+    return undefined;
+}
+function truncateArgs(args) {
+    let text;
+    try {
+        text = JSON.stringify(args !== null && args !== void 0 ? args : {});
+    }
+    catch (_a) {
+        return '';
+    }
+    return text.length > RESUME_NOTE_ARGS_MAX ? `${text.slice(0, RESUME_NOTE_ARGS_MAX)}…` : text;
+}
 /**
  * Keep the transcript through the **last user message** (inclusive), dropping any
  * trailing assistant/tool messages after it (GENC-1351 §5.9). Used by the freeze

package/dist/esm/utils/message-partition.js

@@ -10,10 +10,19 @@
  * @internal
  */
 export const SESSION_RESTORED_LABEL = 'Restored previous conversation';
+/**
+ * The restore divider when the restore also resumes the flow the reload interrupted (GENC-1662).
+ * Deliberately promises a place in the conversation, not an action: the resumed turn is a fresh
+ * model decision and may not repeat what was on screen before the reload.
+ *
+ * @internal
+ */
+export const SESSION_RESUMED_LABEL = 'Restored previous conversation. Resuming from where we were interrupted.';
 /** @internal */
 export const SESSION_RESTORE_FAILED_LABEL = "Couldn't restore the previous conversation";
-/** @internal */
-export const isSessionRestoredMarker = (m) => m.role === 'system-event' && m.content === SESSION_RESTORED_LABEL;
+/** Either restore divider — plain or resumed. Both are display-only. @internal */
+export const isSessionRestoredMarker = (m) => m.role === 'system-event' &&
+    (m.content === SESSION_RESTORED_LABEL || m.content === SESSION_RESUMED_LABEL);
 /** @internal */
 export const isSessionRestoreFailedMarker = (m) => m.role === 'system-event' && m.content === SESSION_RESTORE_FAILED_LABEL;
 /** Either restore notice — both display-only, stripped before persist. @internal */

package/package.json

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