@genesislcap/ai-assistant 14.490.0 → 14.491.0-FUI-2567.1

package/dist/dts/state/persistence/session-persister.d.ts

@@ -0,0 +1,173 @@
+import type { AiDriver } from '../../components/ai-driver/ai-driver';
+import type { SessionStoreReturn } from '../session-store';
+import { type DiagnosticEntry } from './diagnostics';
+import type { SessionPersistenceConfig, SessionPreferences } from './session-persistence-provider';
+/**
+ * Dependencies the persister reads through — all getters so it always sees current
+ * state and never holds a stale reference (the driver can be rebuilt on
+ * agents-change, and the creating view can disconnect). Injected rather than read
+ * from the module registries directly so the class is unit-testable with fakes.
+ *
+ * @internal
+ */
+export interface SessionPersisterDeps {
+    /** Session identity — stable for the persister's lifetime. */
+    stateKey: string;
+    /** Current host persistence config (`enabled` + `provider`). Read fresh each op. */
+    getPersistence: () => SessionPersistenceConfig;
+    /** Names of the currently-configured agents (for the restore orphan check). */
+    getAgentNames: () => string[];
+    /** The session's shared driver, or `undefined` before it exists. */
+    getDriver: () => AiDriver | undefined;
+    /** The session's shared store, or `undefined` before it exists. */
+    getStore: () => SessionStoreReturn | undefined;
+    /**
+     * Build the current diagnostic entries (message/turn/event/meta-snapshot). Stays
+     * element-owned — it reads the host's agents, active-agent debug snapshot, meta
+     * events, etc. — and is diffed against the shared cursors here (GENC-1351 §5.10).
+     */
+    getDiagnosticEntries: () => DiagnosticEntry[];
+}
+/**
+ * Owns **restore-core** persistence for one session (GENC-1351 §5.10) — the
+ * save/restore/freeze of the {@link PersistedSession} snapshot plus the
+ * carry-forward cache. Created once per session via `persister-registry.ts` and
+ * shared by every element view, so there is a single save timer and a single
+ * cache: the per-view double-write races (and the corruption they caused under a
+ * non-atomic backend) are gone by construction.
+ *
+ * Owns all provider I/O for the session: the restore-core snapshot (save/restore/
+ * freeze), the user-preferences blob (load/save — the element keeps only the
+ * `chatConfig`-defaults reconciler), and the diagnostics-append scheduling (one
+ * timer per session; entry-building stays element-owned via `getDiagnosticEntries`).
+ *
+ * @internal
+ */
+export declare class SessionPersister {
+    private deps;
+    private _saveTimer?;
+    private _lastSaveAt;
+    private _diagnosticsTimer?;
+    private _lastDiagnosticsAt;
+    /**
+     * The flow-owner's last-known-good serialized image, carried forward when a
+     * post-restore autosave fires before the agent re-activates (its live capture is
+     * empty). Seeded on restore. See {@link reconcileAgentSnapshots}.
+     */
+    private _cache;
+    /**
+     * The loaded preferences blob (GENC-1351 §5.10 Phase 2), owned here so it's
+     * **shared per session** — the element's `applyPreferenceBaseline` reconciler reads
+     * it via {@link storedPreferences}. Kept fresh on every save, so a later re-reconcile
+     * uses the latest choices, not the stale startup blob. `null` = loaded, none stored.
+     */
+    private _storedPreferences;
+    /**
+     * Whether the user has changed any preference this session. **Shared per session**
+     * (was per-element, which let the two views disagree and one clobber the other's
+     * choice — issue #1). Once set, the reconciler freezes so `chatConfig` defaults
+     * can't overwrite a live user choice, regardless of which view toggled it.
+     */
+    private _preferencesUserChanged;
+    constructor(deps: SessionPersisterDeps);
+    /**
+     * Re-point the dependency getters at the currently-live element view. The
+     * persister outlives any single element (it's cached per session in
+     * `persister-registry.ts`), so when a later element mounts on the same session
+     * — e.g. an SPA teardown + remount — it MUST rebind, or the persister keeps
+     * calling the torn-down creator's `getDiagnosticEntries`/`getPersistence`/
+     * `getAgentNames` (which read a detached driver/store → empty), silently halting
+     * diagnostics + autosave capture (GENC-1351 §5.10). `stateKey` is unchanged.
+     *
+     * @internal
+     */
+    rebindDeps(deps: SessionPersisterDeps): void;
+    /** The loaded preferences blob (shared per session); read by the element's reconciler. */
+    get storedPreferences(): SessionPreferences | null;
+    /** True once the user has changed any preference this session (shared per session). */
+    get preferencesUserChanged(): boolean;
+    private get stateKey();
+    private logMeta;
+    /**
+     * Throttled autosave. Called by every view on each transcript change; the single
+     * shared timer coalesces them into at most one save per the provider's
+     * `saveDebounceMs`. `saveDebounceMs: 0` (e.g. `sessionStorage`) means save as
+     * soon as the current tick settles.
+     */
+    scheduleSave(): void;
+    /**
+     * Cancel a pending debounced autosave **without flushing it** (GENC-1351 §5.12).
+     * Called before a session switch/re-key so the outgoing transcript can never be
+     * written to the incoming session's file after the key changes — the clobber
+     * guard for in-place project switching.
+     */
+    cancelPendingSave(): void;
+    /**
+     * Capture the current session to durable storage (GENC-1351 §5.1). Reads the
+     * full transcript from the driver and the restorable scalars from the store, and
+     * captures the active stateful agent's `serialize()` into `agentSnapshots`.
+     */
+    private persistSession;
+    /**
+     * Page-reload restore (GENC-1351 §5.3). With a stored snapshot for this session,
+     * hydrate the store and reseed the driver so the conversation continues. No-op
+     * 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.
+     */
+    restore(): Promise<void>;
+    /**
+     * 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
+     * silent mystery on reload (GENC-1351 §6). Reuses the display-only `system-event`
+     * divider (like the "Restored…" one) — stripped before persist, so it never lands
+     * in the fresh session's saved history. `loadHistory` is safe here: this path only
+     * runs when nothing was restored, so the driver is empty.
+     */
+    private showRestoreFailedNotice;
+    /**
+     * Drop the restore-core snapshot (the "remember chat" toggle-off and the Clear
+     * action) and reset the carry-forward cache. Diagnostics + preferences are
+     * separate and untouched here.
+     */
+    clearRestoreCore(): Promise<void>;
+    /**
+     * Load the remembered preferences blob (bounded by {@link RESTORE_TIMEOUT_MS}) into
+     * {@link storedPreferences}. A throw propagates to the caller (the element wraps it
+     * and falls back to config defaults); on success `null` = no provider / none stored.
+     */
+    loadPreferences(): Promise<void>;
+    /**
+     * Persist the preferences blob. Only ever called on a genuine user change, so it
+     * also records that (freezing the reconciler — shared per session) and keeps
+     * {@link storedPreferences} fresh. Fires **regardless of "remember chat"** — display
+     * choices are the user's — needing only a provider that implements `savePreferences`.
+     */
+    savePreferences(prefs: SessionPreferences): void;
+    /**
+     * Throttled diagnostics append (GENC-1351 §5.8). On each transcript change, if the
+     * provider persists diagnostics, coalesce and append the new activity since the
+     * last flush (coarser than the restore-core save — the log is heavy). Keyed on
+     * provider capability only, **independent of "remember chat"**. No-op without a
+     * diagnostics-capable provider, so it's free for other consumers.
+     */
+    scheduleDiagnostics(): void;
+    /**
+     * Append the diagnostic entries created since the last flush to the provider's
+     * forward-only stream. Best-effort — a failed write is logged and never touches
+     * the chat. (The cursors advance on collect, so a dropped batch isn't retried;
+     * acceptable for a forensic stream that isn't the source of truth.) Also called
+     * directly by the download path to land the current delta before reassembly.
+     */
+    flushDiagnostics(): Promise<void>;
+    /**
+     * The diagnostic entries not yet appended this load — the forward-capture delta
+     * (§5.8). Skips messages present at restore or already appended; emits each turn
+     * (by turn-index) and meta-event (by index) once; appends a `meta-snapshot` only
+     * when the block changed. Advances the shared per-session cursors as it goes.
+     */
+    private collectDiagnosticsDelta;
+    /** Cancel any pending timers. Called on explicit session teardown. */
+    dispose(): void;
+}
+//# sourceMappingURL=session-persister.d.ts.map

package/dist/dts/state/persistence/session-persister.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-persister.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/session-persister.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sCAAsC,CAAC;AAWrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAsCnG;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,cAAc,EAAE,MAAM,wBAAwB,CAAC;IAC/C,+EAA+E;IAC/E,aAAa,EAAE,MAAM,MAAM,EAAE,CAAC;IAC9B,oEAAoE;IACpE,SAAS,EAAE,MAAM,QAAQ,GAAG,SAAS,CAAC;IACtC,mEAAmE;IACnE,QAAQ,EAAE,MAAM,kBAAkB,GAAG,SAAS,CAAC;IAC/C;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,eAAe,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,gBAAgB;IA0Bf,OAAO,CAAC,IAAI;IAzBxB,OAAO,CAAC,UAAU,CAAC,CAAgC;IACnD,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,iBAAiB,CAAC,CAAgC;IAC1D,OAAO,CAAC,kBAAkB,CAAK;IAC/B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAA+B;IAC7C;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB,CAAmC;IAC7D;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB,CAAS;gBAEpB,IAAI,EAAE,oBAAoB;IAE9C;;;;;;;;;;OAUG;IACH,UAAU,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI;IAI5C,0FAA0F;IAC1F,IAAI,iBAAiB,IAAI,kBAAkB,GAAG,IAAI,CAEjD;IAED,uFAAuF;IACvF,IAAI,sBAAsB,IAAI,OAAO,CAEpC;IAED,OAAO,KAAK,QAAQ,GAEnB;IAED,OAAO,CAAC,OAAO;IAIf;;;;;OAKG;IACH,YAAY,IAAI,IAAI;IAapB;;;;;OAKG;IACH,iBAAiB,IAAI,IAAI;IAOzB;;;;OAIG;YACW,cAAc;IAsJ5B;;;;;;OAMG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoK9B;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAU/B;;;;OAIG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBvC;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAatC;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAchD;;;;;;OAMG;IACH,mBAAmB,IAAI,IAAI;IAiB3B;;;;;;OAMG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAYvC;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAwC/B,sEAAsE;IACtE,OAAO,IAAI,IAAI;CAMhB"}

package/dist/dts/state/persistence/session-persister.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-persister.test.d.ts.map

package/dist/dts/state/persistence/session-persister.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-persister.test.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/session-persister.test.ts"],"names":[],"mappings":""}

package/dist/dts/state/persistence/session-snapshot.d.ts

@@ -0,0 +1,218 @@
+import type { ChatMessage } from '@genesislcap/foundation-ai';
+import type { LoadSessionPayload } from '../ai-assistant-slice';
+/**
+ * Schema version of the persisted session shape. Bump on an incompatible
+ * change; a snapshot whose `version` doesn't match is discarded on load rather
+ * than risk feeding a stale shape into restore.
+ *
+ * @public
+ */
+export declare const PERSISTED_SESSION_VERSION = 1;
+/**
+ * A durable, restorable snapshot of one chat session — the *restorable core* of
+ * the debug log (GENC-1351 §5.1/D1), captured losslessly and independently of
+ * the diagnostic timeline. Written by a `SessionPersistenceProvider` and read
+ * back on page-reload restore.
+ *
+ * @public
+ */
+export interface PersistedSession {
+    /** Schema version — see {@link PERSISTED_SESSION_VERSION}. */
+    version: number;
+    /** ISO timestamp the snapshot was written. */
+    savedAt: string;
+    /** `window.location.host` at save time — restore refuses a cross-host snapshot. */
+    host: string;
+    /** The session this snapshot belongs to (the assistant's state key). */
+    sessionKey: string;
+    /** Full conversation transcript (`driver.getRawHistory()`) — the source of truth. */
+    messages: ChatMessage[];
+    /** Name of the agent active at save time, if any. */
+    activeAgentName?: string;
+    /** User's pinned agent (sticky picker choice); `null` = Auto. */
+    pinnedAgentName: string | null;
+    /** Agent that owned a guided flow at save time; `null` = none. */
+    flowOwnerAgentName: string | null;
+    /** Aggregated USD cost across the session. */
+    sessionCostUsd: number;
+    /** Provider-reported context-window usage on the last turn. */
+    contextTokens?: number;
+    /** Context-window limit for the active model. */
+    contextLimit?: number;
+    /** Active model id (e.g. `claude-sonnet-4-6`). */
+    activeModel?: string;
+    /** Name of the provider used on the last turn. */
+    activeProviderName?: string;
+    /**
+     * Per-stateful-agent serialized state images (each from an agent's
+     * `serialize()`), keyed by agent name. Handed back to the agent's
+     * `init({ restored })` on restore. Typically holds at most the active
+     * flow-owner — other stateful agents are disposed when switched away. The
+     * value shape is the agent's own, hence `unknown`.
+     */
+    agentSnapshots: Record<string, unknown>;
+    /**
+     * Interrupted-flow marker (GENC-1351 §5.9). Present when the session was saved
+     * while an agent declared its current state non-resumable (`resumable === false`).
+     * The **conversation is still persisted and restored in full** — only the running
+     * agent's flow-state is dropped (`agentSnapshots` empty, `flowOwnerAgentName`
+     * null), so restore does not rehydrate the mid-flight flow. On restore the
+     * assistant appends `message` as a normal assistant bubble and pre-fills the
+     * composer with `prompt` so the user can re-run it.
+     */
+    interrupted?: {
+        /** Shown as an assistant message on return. */
+        message: string;
+        /** The prompt that started the flow, pre-filled into the composer on return. */
+        prompt?: string;
+    };
+}
+/**
+ * Everything needed to assemble a {@link PersistedSession} except the stamped
+ * metadata (`version`, `savedAt`), which `createPersistedSession` fills.
+ *
+ * @internal
+ */
+export interface PersistedSessionInput {
+    sessionKey: string;
+    host: string;
+    messages: ChatMessage[];
+    activeAgentName?: string;
+    pinnedAgentName: string | null;
+    flowOwnerAgentName: string | null;
+    sessionCostUsd: number;
+    contextTokens?: number;
+    contextLimit?: number;
+    activeModel?: string;
+    activeProviderName?: string;
+    agentSnapshots?: Record<string, unknown>;
+}
+/**
+ * Assemble a versioned {@link PersistedSession}, stamping `version` and
+ * `savedAt`. Pure but for the timestamp (reads the host clock at call time).
+ *
+ * @internal
+ */
+export declare function createPersistedSession(input: PersistedSessionInput): PersistedSession;
+/**
+ * Resolve the notice text + pre-fill prompt for an interrupted (non-resumable) flow
+ * (GENC-1351 §5.9). Pure — the decision half of the persist gate, split out so it's
+ * unit-testable independent of the save path:
+ *   - `resumeMessage`: the agent's `notResumableMessage` when non-blank, else the
+ *     passed default.
+ *   - `resumePrompt`: the captured flow-activating prompt, falling back to the last
+ *     user message in the transcript (covers a stateless agent that declines to
+ *     persist without owning a flow); `undefined` when neither exists.
+ *
+ * @internal
+ */
+export declare function resolveNonResumableNotice(input: {
+    notResumableMessage?: string;
+    flowActivationPrompt?: string | null;
+    messages: ReadonlyArray<ChatMessage>;
+    defaultMessage: string;
+}): {
+    resumeMessage: string;
+    resumePrompt?: string;
+};
+/**
+ * Index of the last `user`-role message in `messages`, or `-1` when there is none.
+ * The single backward scan behind "what did the user last say" — used to slice the
+ * transcript to a clean boundary (`keepThroughLastUserMessage`) and to recover a
+ * flow-activation prompt. Allocation-free (no reversed copy).
+ *
+ * @internal
+ */
+export declare function lastUserMessageIndex(messages: ReadonlyArray<ChatMessage>): number;
+/**
+ * Type guard: is `value` a {@link PersistedSession} we can safely restore?
+ * Gates on matching schema version, same host, and a messages array — the
+ * minimum needed to avoid feeding a stale or cross-app blob into restore.
+ *
+ * @internal
+ */
+export declare function isRestorableSession(value: unknown, opts: {
+    host: string;
+    version?: number;
+}): value is PersistedSession;
+/**
+ * Project a {@link PersistedSession} onto the Redux `loadSession` payload (the
+ * fields restored verbatim into the slice). Agent identity + machine snapshots
+ * are applied by the host separately.
+ *
+ * @internal
+ */
+export declare function toLoadSessionPayload(s: PersistedSession): LoadSessionPayload;
+/**
+ * Trim a restored transcript back to the last point a provider will accept.
+ *
+ * Autosave fires on every transcript change (GENC-1351 §5.3) so it can land
+ * mid-turn — meaning a snapshot can end on an *incomplete* turn:
+ *   • an assistant `tool_use` whose `tool_result` hasn't arrived (or only some
+ *     of its calls are answered) — an orphaned call makes the next turn invalid;
+ *   • an empty streaming/`thinking` placeholder assistant message;
+ *   • a pending (unresolved) interaction — a mid-`requestInteraction` turn that
+ *     can't be resumed (explicitly unsupported).
+ *
+ * Walks back from the end, dropping such trailing messages until the transcript
+ * is balanced — every assistant tool call has its matching result — and ends on
+ * a clean boundary. Returns the input unchanged (same reference) when already
+ * clean. Turns a mid-turn reload into "recover to the last complete exchange"
+ * rather than a hard drop.
+ *
+ * @internal
+ */
+export declare function trimToRestorableBoundary(messages: ChatMessage[]): ChatMessage[];
+/**
+ * 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
+ * fallback: when a flow goes non-resumable and there's no prior resumable snapshot
+ * to freeze at, we keep the conversation + the prompt that triggered the flow but
+ * discard the agent's in-flight work — so a reload shows the user's request, not the
+ * half-done agent turns. Returns the input unchanged (same ref) when it already ends
+ * on a user message, or when there is no user message at all (nothing to trim to).
+ *
+ * @internal
+ */
+export declare function keepThroughLastUserMessage(messages: ChatMessage[]): ChatMessage[];
+/**
+ * Names of agents the restored session holds machine/state snapshots for but
+ * which are **not** in the currently-configured agent set — their flow cannot
+ * resume. Common when the host's agent array is dynamic (agents gated by feature
+ * flags, project state, or permissions; e.g. genesis-create). Callers should
+ * surface these; the restore is otherwise non-fatal (the transcript and any
+ * known agents still restore). Returns `[]` when `knownAgentNames` is empty —
+ * the agent set isn't known yet, so we can't classify without false positives.
+ *
+ * @beta
+ */
+export declare function unknownAgentSnapshots(snapshot: PersistedSession, knownAgentNames: Iterable<string>): string[];
+/**
+ * Reconcile the per-agent `serialize()` images to persist on a session save,
+ * guarding against a post-restore autosave wiping a mid-flow machine (GENC-1351).
+ *
+ * A restore reads a good snapshot, but the restore's own history change fires an
+ * autosave **before** the pinned stateful agent re-activates — at which point the
+ * live capture (`getActiveAgent()?.serialize()`) is empty even though a flow is
+ * mid-stream. Writing that empty map would overwrite the stored machine snapshot,
+ * resetting the flow to its initial step on the *next* reload. So when a flow is
+ * owned (`flowOwnerName`) but its live image is missing, carry the last-known-good
+ * image forward instead of dropping it.
+ *
+ * Pure: the caller owns the `lastKnownGood` cache and its lifecycle (seeded on
+ * restore, reset on clear). This decides only what to persist now and what the
+ * cache should become — advanced only when non-empty, so an empty capture can
+ * never erase a good cache.
+ *
+ * @param live - Agent images captured live this save, keyed by agent name.
+ * @param flowOwnerName - The agent owning the in-flight flow, or `null`.
+ * @param lastKnownGood - The last non-empty images persisted or restored.
+ * @returns `snapshots` to persist, and the `cache` to remember for next time.
+ *
+ * @internal
+ */
+export declare function reconcileAgentSnapshots(live: Record<string, unknown>, flowOwnerName: string | null, lastKnownGood: Record<string, unknown>): {
+    snapshots: Record<string, unknown>;
+    cache: Record<string, unknown>;
+};
+//# sourceMappingURL=session-snapshot.d.ts.map

package/dist/dts/state/persistence/session-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-snapshot.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/session-snapshot.ts"],"names":[],"mappings":"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"}

package/dist/dts/state/persistence/session-snapshot.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-snapshot.test.d.ts.map

package/dist/dts/state/persistence/session-snapshot.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-snapshot.test.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/session-snapshot.test.ts"],"names":[],"mappings":""}

package/dist/dts/state/persistence/stateful-restore.e2e.test.d.ts

@@ -0,0 +1,2 @@
+import '../../components/chat-driver/align-event-globals';
+//# sourceMappingURL=stateful-restore.e2e.test.d.ts.map

package/dist/dts/state/persistence/stateful-restore.e2e.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateful-restore.e2e.test.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/stateful-restore.e2e.test.ts"],"names":[],"mappings":"AASA,OAAO,kDAAkD,CAAC"}

package/dist/dts/state/session-store.d.ts

@@ -19,7 +19,11 @@ declare function makeStore(devTools: boolean | undefined): import("@genesislcap/
     setActiveAgent(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<Omit<import("..").AgentConfig, "toolHandlers"> | undefined>): void;
     setPinnedAgentName(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<string | null>): void;
     setFlowOwnerAgentName(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<string | null>): void;
+    setFlowActivationPrompt(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<string | null>): void;
     setAgentPickerOpen(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<boolean>): void;
+    setSessionMenuOpen(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<boolean>): void;
+    setCompacting(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<boolean>): void;
+    setRestoring(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<boolean>): void;
     setInputValue(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<string>): void;
     setLiveSubAgentTrace(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<import("@genesislcap/foundation-ai").ChatMessage[]>): void;
     setLiveSubAgentName(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<string | null>): void;
@@ -27,6 +31,8 @@ declare function makeStore(devTools: boolean | undefined): import("@genesislcap/
     removeInputOverride(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<{
         id: string;
     }>): void;
+    loadSession(state: import("immer").WritableDraft<AiAssistantSessionState>, action: import("@reduxjs/toolkit").PayloadAction<import("./ai-assistant-slice").LoadSessionPayload>): void;
+    resetSession(state: import("immer").WritableDraft<AiAssistantSessionState>): void;
 }, "aiAssistant", "aiAssistant", {}>[]>;
 /**
  * Returns the session store for the given key, creating one if it does not

package/dist/dts/state/session-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../../src/state/session-store.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAE9B,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;AAIvD,iBAAS,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAM/C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAMnF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../../src/state/session-store.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAE9B,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;AAIvD,iBAAS,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAM/C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAMnF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/dts/utils/history-transform.d.ts

@@ -10,4 +10,42 @@ export declare function transformHistoryForAgent(history: ChatMessage[], agentNa
  * verbatim; older messages have their tool payloads masked.
  */
 export declare function applyHistoryCap(history: readonly ChatMessage[], cap: number): ChatMessage[];
+/** Recent messages kept verbatim when compacting; everything earlier is summarized. */
+export declare const COMPACT_KEEP_RECENT_MESSAGES = 4;
+/** Don't bother compacting unless at least this many messages would be summarized. */
+export declare const COMPACT_MIN_MESSAGES_TO_COMPACT = 4;
+/**
+ * Index at which the verbatim tail begins — everything before it gets summarized.
+ * The tail starts on a clean turn boundary (a `user` message): a user message
+ * never appears between a `tool_use` and its `tool_result`, so cutting there
+ * guarantees the summarized region is tool-pair-balanced (compaction only runs
+ * when idle, so history is turn-complete). Returns `null` when there is nothing
+ * worth compacting (too short, or no earlier user boundary) — e.g. a freshly
+ * restored session whose only user turn is the current one.
+ */
+export declare function findCompactionCut(history: readonly ChatMessage[]): number | null;
+/**
+ * Build the one-shot summarizer prompt for a run of older messages (used with
+ * `AIProvider.prompt`). Mirrors the `<conversation_history>` block convention
+ * that suggestions use. Any existing `compacted-summary` at the head is folded
+ * in (rendered as prior-summary context), so rolling re-compaction produces one
+ * combined summary.
+ */
+export declare function buildCompactionSummaryPrompt(toCompact: readonly ChatMessage[]): {
+    systemPrompt: string;
+    userMessage: string;
+};
+/**
+ * Normalize history for a provider request (GENC-1351 §5.7): translate each
+ * `compacted-summary` message into a `user` message that wraps its summary in a
+ * `<conversation_summary>` block, so the raw display-only role never reaches a
+ * transport. Other roles pass through untouched. Pure — returns a new array.
+ *
+ * Applied at the request-build chokepoint *before* per-agent masking, so the
+ * guarantee holds for every provider/transport regardless of any optional
+ * per-agent history transform.
+ */
+export declare function normalizeForProvider(history: readonly ChatMessage[]): ChatMessage[];
+/** Human-facing divider label for a `compacted-summary` message. */
+export declare function compactionDividerLabel(m: ChatMessage): string;
 //# sourceMappingURL=history-transform.d.ts.map

package/dist/dts/utils/history-transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history-transform.d.ts","sourceRoot":"","sources":["../../../src/utils/history-transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAoB9D;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,EAAE,CAKjG;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,EAAE,CAG3F"}
+{"version":3,"file":"history-transform.d.ts","sourceRoot":"","sources":["../../../src/utils/history-transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAoB9D;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,EAAE,CAKjG;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,EAAE,CAG3F;AAID,uFAAuF;AACvF,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAE9C,sFAAsF;AACtF,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,GAAG,IAAI,CAWhF;AAkCD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,SAAS,WAAW,EAAE,GAAG;IAC/E,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,CAYA;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,EAAE,CAanF;AAED,oEAAoE;AACpE,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAG7D"}

package/dist/dts/utils/history-transform.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=history-transform.test.d.ts.map

package/dist/dts/utils/history-transform.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history-transform.test.d.ts","sourceRoot":"","sources":["../../../src/utils/history-transform.test.ts"],"names":[],"mappings":""}

package/dist/dts/utils/message-partition.d.ts

@@ -1,4 +1,24 @@
 import type { ChatMessage } from '@genesislcap/foundation-ai';
+/**
+ * Display-only session-restore notices (GENC-1351 §6): the "Restored…" divider on
+ * a successful reload restore, and the "Couldn't restore…" divider when a saved
+ * session existed but couldn't be brought back (timeout / error / unusable
+ * snapshot). Both are `system-event` rows, stripped from the persisted snapshot so
+ * they never become permanent history — and, unlike agent-switch indicators, they
+ * belong to the persistence ("remember chat") feature, so `filterVisibleMessages`
+ * gates them by `showRestoreNotices` rather than `showAgentSwitchIndicator`.
+ *
+ * @internal
+ */
+export declare const SESSION_RESTORED_LABEL = "Restored previous conversation";
+/** @internal */
+export declare const SESSION_RESTORE_FAILED_LABEL = "Couldn't restore the previous conversation";
+/** @internal */
+export declare const isSessionRestoredMarker: (m: ChatMessage) => boolean;
+/** @internal */
+export declare const isSessionRestoreFailedMarker: (m: ChatMessage) => boolean;
+/** Either restore notice — both display-only, stripped before persist. @internal */
+export declare const isSessionNoticeMarker: (m: ChatMessage) => boolean;
 /**
  * Toggle state that drives which messages appear in the scrolling list. Mirrors
  * the cog-menu switches; `showAgentSwitchIndicator` is pre-resolved by the
@@ -10,6 +30,13 @@ export interface MessageFilterState {
     showThinkingSteps: boolean;
     showNarration: boolean;
     showAgentSwitchIndicator: boolean;
+    /**
+     * Whether session-restore notices show — driven by the persistence ("remember
+     * chat") toggle, since restore is that feature's concern (GENC-1351 §6). Kept
+     * separate from `showAgentSwitchIndicator` so those two unrelated switches don't
+     * cross-control each other.
+     */
+    showRestoreNotices: boolean;
 }
 /**
  * The trailing interaction to render in a pinned slot, separate from the

package/dist/dts/utils/message-partition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message-partition.d.ts","sourceRoot":"","sources":["../../../src/utils/message-partition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,OAAO,CAAC;IACvB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,wBAAwB,EAAE,OAAO,CAAC;CACnC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAG7E;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,EAAE,kBAAkB,GAC1B,WAAW,EAAE,CA8Bf"}
+{"version":3,"file":"message-partition.d.ts","sourceRoot":"","sources":["../../../src/utils/message-partition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,mCAAmC,CAAC;AACvE,gBAAgB;AAChB,eAAO,MAAM,4BAA4B,+CAA+C,CAAC;AACzF,gBAAgB;AAChB,eAAO,MAAM,uBAAuB,GAAI,GAAG,WAAW,KAAG,OACU,CAAC;AACpE,gBAAgB;AAChB,eAAO,MAAM,4BAA4B,GAAI,GAAG,WAAW,KAAG,OACW,CAAC;AAC1E,oFAAoF;AACpF,eAAO,MAAM,qBAAqB,GAAI,GAAG,WAAW,KAAG,OACQ,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,OAAO,CAAC;IACvB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,wBAAwB,EAAE,OAAO,CAAC;IAClC;;;;;OAKG;IACH,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAG7E;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,EAAE,kBAAkB,GAC1B,WAAW,EAAE,CAsCf"}

package/dist/dts/utils/resolve-preference-baseline.d.ts

@@ -0,0 +1,43 @@
+import type { ChatConfig } from '@genesislcap/foundation-ai';
+import { type AiAssistantAnimation } from '../main/main.types';
+import type { SessionPreferences } from '../state/persistence/session-persistence-provider';
+/**
+ * The effective user-facing preference state for a freshly created session store
+ * (GENC-1351 #2), resolved from the two inputs that feed it.
+ *
+ * @internal
+ */
+export interface ResolvedPreferenceBaseline {
+    showToolCalls: boolean;
+    showThinkingSteps: boolean;
+    showNarration: boolean;
+    showAgentSwitchIndicator: boolean;
+    enabledAnimations: AiAssistantAnimation[];
+    /**
+     * The remembered "remember chat" toggle — present only when stored prefs carried
+     * an `enabled` value. Left `undefined` otherwise so the caller keeps the
+     * host-configured default rather than forcing a value.
+     */
+    enabled?: boolean;
+}
+/**
+ * Resolve the effective preference baseline for a fresh store, applying the
+ * precedence (lowest → highest):
+ *
+ *   slice defaults  <  `chatConfig.ui` defaults  <  stored user preferences
+ *
+ * The `chatConfig.ui` layer is the fallback when the user has no stored prefs
+ * (e.g. a first-ever load, or after the persistence backend is wiped) — the case
+ * the old "read config once on connect" path got wrong whenever `chatConfig` had
+ * not bound yet. Stored prefs, when present, override only the fields they carry;
+ * absent fields keep the config default. Pure, so the precedence is unit-testable
+ * independent of the element/store wiring.
+ *
+ * Config-supplied animations are normalised through {@link resolveExclusiveLoadingStyle}
+ * (a raw config list may name both loading styles); stored animations are applied
+ * as-is, since they were already normalised when saved.
+ *
+ * @internal
+ */
+export declare function resolvePreferenceBaseline(ui: ChatConfig['ui'], stored: SessionPreferences | null | undefined): ResolvedPreferenceBaseline;
+//# sourceMappingURL=resolve-preference-baseline.d.ts.map

package/dist/dts/utils/resolve-preference-baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-preference-baseline.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve-preference-baseline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAG5F;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,aAAa,EAAE,OAAO,CAAC;IACvB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,wBAAwB,EAAE,OAAO,CAAC;IAClC,iBAAiB,EAAE,oBAAoB,EAAE,CAAC;IAC1C;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,EACpB,MAAM,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,GAC5C,0BAA0B,CAgC5B"}

package/dist/dts/utils/resolve-preference-baseline.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resolve-preference-baseline.test.d.ts.map

package/dist/dts/utils/resolve-preference-baseline.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-preference-baseline.test.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve-preference-baseline.test.ts"],"names":[],"mappings":""}

package/dist/dts/utils/with-timeout.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolve `promise`, or **reject** if it doesn't settle within `ms`. Rejecting
+ * (rather than resolving to a fallback) lets restore tell a genuine timeout apart
+ * from a clean "nothing stored" result, so it can surface a notice for the former
+ * and stay silent for the latter. Because the loser of the race is abandoned, a
+ * late-resolving `load()` is discarded and can never clobber a now-live session;
+ * a late *rejection* is swallowed so it doesn't surface as an unhandled rejection.
+ *
+ * @internal
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T>;
+//# sourceMappingURL=with-timeout.d.ts.map

package/dist/dts/utils/with-timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-timeout.d.ts","sourceRoot":"","sources":["../../../src/utils/with-timeout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAahF"}