@genesislcap/ai-assistant 14.488.1 → 14.488.2-GENC-1351.2

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/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"}

package/dist/esm/components/chat-driver/chat-driver.compact.test.js

@@ -0,0 +1,93 @@
+import { __awaiter } from "tslib";
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+// Side-effect import — MUST come before `./chat-driver` so the driver subclasses
+// jsdom's EventTarget rather than Node's native one (CustomEvent dispatch then
+// works). Mirrors `chat-driver.test.ts`.
+import './align-event-globals';
+import { ChatDriver } from './chat-driver';
+// GENC-1351 §5.7 — driver-level compaction: the atomic, destructive replace.
+// A minimal fake registry stands in for a provider, so no network is involved.
+const asMsg = (o) => o;
+/** A registry whose default provider summarizes via `prompt` (undefined = unsupported). */
+function registryWith(prompt) {
+    const provider = { prompt, getStatus: () => __awaiter(this, void 0, void 0, function* () { return ({ model: 'test-model' }); }) };
+    return { default: () => provider };
+}
+/** 10 messages alternating user/assistant (user at even indices); last carries usage. */
+function tenTurnHistory() {
+    return Array.from({ length: 10 }, (_, i) => asMsg(Object.assign({ role: i % 2 === 0 ? 'user' : 'assistant', content: `m${i}`, timestamp: `2026-01-01T00:00:${String(i).padStart(2, '0')}.000Z` }, (i === 9 ? { inputTokens: 1234 } : {}))));
+}
+const Suite = createLogicSuite('chat-driver-compact');
+Suite('compact() destructively replaces older turns with one head summary + metadata', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const driver = new ChatDriver(registryWith(() => __awaiter(void 0, void 0, void 0, function* () { return 'THE SUMMARY'; })));
+    driver.loadHistory(tenTurnHistory());
+    const before = driver.getHistory().length;
+    const summary = yield driver.compact();
+    assert.ok(summary, 'returns the created summary message');
+    assert.is(summary.role, 'compacted-summary');
+    assert.is(summary.content, 'THE SUMMARY');
+    assert.is((_a = summary.compaction) === null || _a === void 0 ? void 0 : _a.tokensBefore, 1234, 'captures pre-compaction input tokens');
+    assert.is((_b = summary.compaction) === null || _b === void 0 ? void 0 : _b.model, 'test-model', 'records the summarizing model');
+    const after = driver.getHistory();
+    assert.ok(after.length < before, 'history shrank (destructive)');
+    assert.is(after[0].role, 'compacted-summary', 'summary sits at the head');
+    assert.is(after[0].timestamp, '2026-01-01T00:00:00.000Z', 'summary inherits the covered region start → sorts to the head in time-ordered views');
+    assert.is((_c = after[0].compaction) === null || _c === void 0 ? void 0 : _c.compactedCount, before - (after.length - 1));
+    assert.ok(after.slice(1).every((m) => m.role !== 'compacted-summary'), 'exactly one summary — no marker chain');
+}));
+Suite('compact() is atomic on failure — no splice, surfaces a "sorry" message', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = new ChatDriver(registryWith(() => __awaiter(void 0, void 0, void 0, function* () {
+        throw new Error('network');
+    })));
+    const original = tenTurnHistory();
+    driver.loadHistory(original);
+    const result = yield driver.compact();
+    assert.is(result, null, 'returns null on failure');
+    const after = driver.getHistory();
+    assert.ok(after.every((m) => m.role !== 'compacted-summary'), 'nothing compacted');
+    // The covered turns are untouched (atomic); only a brief apology is appended so
+    // the user knows it failed (GENC-1351 follow-up — surfaced like a turn error).
+    assert.is(after.length, original.length + 1, 'only an apology appended');
+    assert.is(after[after.length - 1].role, 'assistant');
+    assert.ok(/sorry/i.test(after[after.length - 1].content), 'apology is an agent message');
+}));
+Suite('compact() rolls a prior summary into a single fresh one', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = new ChatDriver(registryWith(() => __awaiter(void 0, void 0, void 0, function* () { return 'COMBINED'; })));
+    driver.loadHistory([
+        asMsg({ role: 'compacted-summary', content: 'old', compaction: { compactedCount: 5 } }),
+        ...tenTurnHistory(),
+    ]);
+    const summary = yield driver.compact();
+    assert.ok(summary);
+    const after = driver.getHistory();
+    assert.is(after.filter((m) => m.role === 'compacted-summary').length, 1, 'still exactly one summary after re-compaction');
+    assert.is(after[0].content, 'COMBINED');
+}));
+Suite('compact() no-ops when there is nothing worth compacting', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = new ChatDriver(registryWith(() => __awaiter(void 0, void 0, void 0, function* () { return 'unused'; })));
+    driver.loadHistory([
+        asMsg({ role: 'user', content: 'hi' }),
+        asMsg({ role: 'assistant', content: 'yo' }),
+    ]);
+    assert.is(yield driver.compact(), null);
+    assert.is(driver.getHistory().length, 2, 'short history untouched');
+}));
+Suite('compact() no-ops when the default provider cannot summarize', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = new ChatDriver(registryWith(undefined));
+    driver.loadHistory(tenTurnHistory());
+    assert.is(yield driver.compact(), null);
+    assert.is(driver.getHistory().length, 10, 'history untouched without prompt support');
+}));
+Suite("canCompact reflects compact()-would-act, keyed on the driver's own history", () => {
+    const rich = new ChatDriver(registryWith(() => __awaiter(void 0, void 0, void 0, function* () { return 'x'; })));
+    rich.loadHistory(tenTurnHistory());
+    assert.is(rich.canCompact(), true, 'enough history → gate open');
+    const thin = new ChatDriver(registryWith(() => __awaiter(void 0, void 0, void 0, function* () { return 'x'; })));
+    thin.loadHistory([
+        asMsg({ role: 'user', content: 'hi' }),
+        asMsg({ role: 'assistant', content: 'yo' }),
+    ]);
+    assert.is(thin.canCompact(), false, 'too short → gate closed (same source compact() uses)');
+});
+Suite.run();

package/dist/esm/components/chat-driver/chat-driver.js

@@ -4,7 +4,7 @@ import { agenticActivityBus } from '../../channel/ai-activity-bus';
 import { resolveChatProvider } from '../../config/validate-providers';
 import { clearSession, getMetaEvents, mergeMetaEvents, recordMetaEvent, recordTurnError, recordTurnRetry, } from '../../state/debug-event-log';
 import { applyCondensation } from '../../utils/condense-history';
-import { applyHistoryCap } from '../../utils/history-transform';
+import { applyHistoryCap, buildCompactionSummaryPrompt, findCompactionCut, normalizeForProvider, } from '../../utils/history-transform';
 import { logger } from '../../utils/logger';
 import { TOOL_FOLD_SYMBOL } from '../../utils/tool-fold';
 const DEFAULT_MAX_TOOL_ITERATIONS = 50;
@@ -765,6 +765,89 @@ export class ChatDriver extends EventTarget {
                 .slice(0, count));
         });
     }
+    /**
+     * Whether `compact()` would do anything right now — a summarizable run of older
+     * turns exists behind a clean boundary. Uses the same `history` `compact()`
+     * acts on, so the UI's gate can't disagree with the action (GENC-1351 follow-up).
+     */
+    canCompact() {
+        return findCompactionCut(this.history) != null;
+    }
+    /**
+     * Destructively compact older turns into a single `compacted-summary` message
+     * (GENC-1351 §5.7). Summarizes everything before a clean recent-tail boundary
+     * via the registry-default provider's one-shot `prompt()`, then **atomically**
+     * replaces the covered turns with one summary message at the head — history is
+     * mutated only on success. Rolling: any existing head summary is folded into
+     * the new one. Returns the created summary message, or `null` when there is
+     * nothing worth compacting or the default provider cannot summarize.
+     */
+    compact() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            if (this.busy)
+                return null;
+            const defaultProvider = this.providerRegistry.default();
+            if (!defaultProvider.prompt) {
+                logger.warn('ChatDriver: default AI provider has no prompt(); cannot compact');
+                return null;
+            }
+            const history = this.history;
+            const cut = findCompactionCut(history);
+            if (cut == null)
+                return null;
+            const toCompact = history.slice(0, cut);
+            const tail = history.slice(cut);
+            // Summarize BEFORE mutating history — a failed/empty call leaves the
+            // transcript untouched (atomic generate-then-replace).
+            const { systemPrompt, userMessage } = buildCompactionSummaryPrompt(toCompact);
+            // Surface a failure the way turn errors are surfaced — a brief "sorry" agent
+            // message — while leaving the transcript itself untouched (atomic). Retrying
+            // is safe (nothing was spliced).
+            const failMessage = "Sorry, I couldn't compact the conversation just now. Nothing was changed — please try again.";
+            let summaryText;
+            try {
+                summaryText = (_b = (_a = (yield defaultProvider.prompt(userMessage, { systemPrompt }))) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : '';
+            }
+            catch (e) {
+                logger.warn(`ChatDriver: compaction summary failed: ${e instanceof Error ? e.message : e}`);
+                this.appendToHistory({ role: 'assistant', content: failMessage });
+                return null;
+            }
+            if (!summaryText) {
+                logger.warn('ChatDriver: compaction summary was empty; leaving history untouched');
+                this.appendToHistory({ role: 'assistant', content: failMessage });
+                return null;
+            }
+            let tokensBefore;
+            for (let i = history.length - 1; i >= 0; i -= 1) {
+                if (history[i].inputTokens != null) {
+                    tokensBefore = history[i].inputTokens;
+                    break;
+                }
+            }
+            const status = yield ((_c = defaultProvider.getStatus) === null || _c === void 0 ? void 0 : _c.call(defaultProvider));
+            const createdAt = new Date().toISOString();
+            const summaryMessage = {
+                role: 'compacted-summary',
+                content: summaryText,
+                // Stamp with the covered region's start, not "now": the summary stands in
+                // for the oldest messages and sits at the head of history, so this keeps it
+                // sorted to the head in any timestamp-ordered view (the debug timeline) and
+                // history time-monotonic. Its true creation time is in compaction.createdAt.
+                timestamp: (_e = (_d = toCompact[0]) === null || _d === void 0 ? void 0 : _d.timestamp) !== null && _e !== void 0 ? _e : createdAt,
+                compaction: {
+                    compactedCount: toCompact.length,
+                    coveredThroughTimestamp: (_f = toCompact[toCompact.length - 1]) === null || _f === void 0 ? void 0 : _f.timestamp,
+                    tokensBefore,
+                    model: status === null || status === void 0 ? void 0 : status.model,
+                    createdAt,
+                },
+            };
+            this.loadHistory([summaryMessage, ...tail]);
+            return summaryMessage;
+        });
+    }
     isBusy() {
         return this.busy;
     }
@@ -1595,9 +1678,11 @@ export class ChatDriver extends EventTarget {
                 const primer = [...((_b = this.primerHistory) !== null && _b !== void 0 ? _b : []), ...(transientPrimer !== null && transientPrimer !== void 0 ? transientPrimer : [])];
                 const baseHistory = firstLlmCall ? this.history.slice(0, -1) : this.history;
                 firstLlmCall = false;
-                // Collapse stale tool payloads this agent declared via `condenseWhen`, then
-                // pipe through any externally-set transform (e.g. multi-agent masking).
-                // Both run on a copy — stored history is untouched.
+                // Collapse stale tool payloads this agent declared via `condenseWhen`
+                // (GENC-1369), then translate any compacted-summary → a
+                // <conversation_summary> user message (GENC-1351 §5.7) before any per-agent
+                // masking, so the raw display-only role can never reach a transport. Each
+                // step runs on a copy — stored history is untouched.
                 const condensedHistory = applyCondensation([...baseHistory], this.condensePolicies, {
                     modelCall: this.modelCallSeq,
                     turn: this.turnSeq,
@@ -1608,9 +1693,10 @@ export class ChatDriver extends EventTarget {
                     // current via `endPhase()`.
                     phaseEnded: (phaseEpoch) => phaseEpoch < this.currentPhaseEpoch,
                 }, (detail) => recordMetaEvent(this.sessionKey, 'context.condensed', detail));
+                const normalizedHistory = normalizeForProvider(condensedHistory);
                 const historyForProvider = this.providerHistoryTransform
-                    ? this.providerHistoryTransform(condensedHistory)
-                    : condensedHistory;
+                    ? this.providerHistoryTransform(normalizedHistory)
+                    : normalizedHistory;
                 const historyForCall = [...primer, ...historyForProvider];
                 // Resolve the per-turn temperature and tool-call mode the same way the
                 // provider is resolved — static value or a function of the turn context

package/dist/esm/components/orchestrating-driver/orchestrating-driver.js

@@ -83,6 +83,13 @@ export class OrchestratingDriver extends EventTarget {
          * choice.
          */
         this.flowOwnerAgentName = null;
+        /**
+         * Per-agent restored state for a rehydrated session, keyed by agent name.
+         * Primed by the host on restore; each entry is passed to that agent's
+         * `onActivate` as `ctx.restored` on its next activation, then deleted so a
+         * later re-activation starts fresh.
+         */
+        this.restoredAgentStates = {};
         this.sessionKey = (_a = options.sessionKey) !== null && _a !== void 0 ? _a : '';
         this.maxHandoffs = (_b = options.maxHandoffs) !== null && _b !== void 0 ? _b : DEFAULT_MAX_HANDOFFS;
         this.classifierHistoryLength =
@@ -174,6 +181,14 @@ export class OrchestratingDriver extends EventTarget {
     getRawHistory() {
         return this.chatDriver.getHistory();
     }
+    /** {@inheritDoc AiDriver.compact} */
+    compact() {
+        return this.chatDriver.compact();
+    }
+    /** {@inheritDoc AiDriver.canCompact} */
+    canCompact() {
+        return this.chatDriver.canCompact();
+    }
     /** Delegates to the inner {@link ChatDriver} — turns are captured there. */
     getTurnSnapshots() {
         return this.chatDriver.getTurnSnapshots();
@@ -267,6 +282,14 @@ export class OrchestratingDriver extends EventTarget {
             return this.chatDriver.continueFromHistory(transientPrimer);
         });
     }
+    /** {@inheritDoc AiDriver.primeRestoredAgentState} */
+    primeRestoredAgentState(snapshots) {
+        this.restoredAgentStates = Object.assign({}, snapshots);
+    }
+    /** {@inheritDoc AiDriver.getActiveAgent} */
+    getActiveAgent() {
+        return this.activeAgent;
+    }
     applyAgent(agent) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -278,6 +301,8 @@ export class OrchestratingDriver extends EventTarget {
                 recordMetaEvent(this.sessionKey, 'agent.handoff', {
                     from: (_a = previousAgent === null || previousAgent === void 0 ? void 0 : previousAgent.name) !== null && _a !== void 0 ? _a : null,
                     to: agent.name,
+                    // GENC-1351: was a restored snapshot waiting for this agent at activation?
+                    restored: this.restoredAgentStates[agent.name] !== undefined,
                 });
             }
             // Fire lifecycle hooks around the swap — outgoing first, then incoming.
@@ -296,12 +321,19 @@ export class OrchestratingDriver extends EventTarget {
                 }
             }
             if (isSwitch && agent.onActivate) {
+                // On a session restore, hand this agent its persisted state exactly once
+                // (consumed here) so a stateful machine resumes at the right step; a later
+                // re-activation of the same agent then starts fresh.
+                const restored = this.restoredAgentStates[agent.name];
+                if (restored !== undefined)
+                    delete this.restoredAgentStates[agent.name];
                 try {
                     yield agent.onActivate({
                         agentName: agent.name,
                         sessionKey: this.sessionKey,
                         previousAgentName: previousAgent === null || previousAgent === void 0 ? void 0 : previousAgent.name,
                         signal: this.lifecycleAbortController.signal,
+                        restored,
                     });
                 }
                 catch (e) {

package/dist/esm/components/orchestrating-driver/orchestrating-driver.pin.test.js

@@ -0,0 +1,48 @@
+import { __awaiter } from "tslib";
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+// Side-effect import — MUST precede `./orchestrating-driver` so the driver
+// subclasses jsdom's EventTarget (CustomEvent dispatch then works in node).
+import '../chat-driver/align-event-globals';
+import { OrchestratingDriver } from './orchestrating-driver';
+// GENC-1351 — a set routing pin must be honoured on the next turn. This is the
+// invariant that broke on restore (found via the §5.8 diagnostics log): the pin
+// was hydrated into the store but never pushed to the driver, so the first
+// post-restore message fell through to the classifier and re-routed away from the
+// pinned agent. `Guided Booking` here is `excludeFromClassifier`, so the classifier
+// can NEVER pick it — a turn landing on it proves the pin (not classification)
+// routed it. The element-side fix (restore → `driver.setPinnedAgent`) is what makes
+// the pin reach the driver; this locks the driver half of the contract.
+const makeRegistry = (provider) => ({
+    get: () => provider,
+    default: () => provider,
+    defaultName: () => 'test',
+    names: () => ['test'],
+    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+});
+/** A provider that ends every turn immediately with a plain-text reply (no tools). */
+const noToolProvider = () => ({
+    chat: (_history, _userMessage, _options) => __awaiter(void 0, void 0, void 0, function* () { return ({ role: 'assistant', content: 'ok' }); }),
+});
+const agent = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
+const makeDriver = () => new OrchestratingDriver(makeRegistry(noToolProvider()), [
+    agent({ name: 'Genesis Assistant' }), // classifier-eligible specialist
+    agent({ name: 'Guided Booking', excludeFromClassifier: true }), // pin-only
+], { sessionKey: 'k' });
+const Suite = createLogicSuite('orchestrating-driver-pin');
+Suite('a set pin routes the next turn to the pinned agent (bypassing the classifier)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const driver = makeDriver();
+    driver.setPinnedAgent('Guided Booking');
+    yield driver.sendMessage('hi');
+    assert.is((_a = driver.getActiveAgent()) === null || _a === void 0 ? void 0 : _a.name, 'Guided Booking', 'pinned agent ran; it is excludeFromClassifier, so only the pin could have routed it');
+}));
+Suite('the pin is sticky across turns', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const driver = makeDriver();
+    driver.setPinnedAgent('Guided Booking');
+    yield driver.sendMessage('one');
+    yield driver.sendMessage('two');
+    assert.is((_a = driver.getActiveAgent()) === null || _a === void 0 ? void 0 : _a.name, 'Guided Booking', 'still pinned on the second turn');
+}));
+Suite.run();

package/dist/esm/components/settings-modal/settings-modal.styles.js

@@ -509,4 +509,28 @@ export const settingsModalStyles = css `
     max-width: 60%;
     line-height: 1.4;
   }
+
+  /*
+   * Inline spinner shown in the "Download agent log" button while the log builds
+   * (GENC-1351 §5.8) — the lifetime-stitch path is an async provider round-trip.
+   * Sized to the button label and tinted with currentColor so it tracks the
+   * button's text colour in every appearance / theme.
+   */
+  [part='download-button'] .download-spinner {
+    display: inline-block;
+    width: 12px;
+    height: 12px;
+    margin-right: calc(var(--design-unit) * 1px);
+    vertical-align: -1px;
+    border: 2px solid currentColor;
+    border-right-color: transparent;
+    border-radius: 50%;
+    animation: download-spin 0.6s linear infinite;
+  }
+
+  @keyframes download-spin {
+    to {
+      transform: rotate(360deg);
+    }
+  }
 `;

package/dist/esm/components/settings-modal/settings-modal.template.js

@@ -121,6 +121,9 @@ const chatBotSettingsTemplate = (switchTag, buttonTag) => html `
 }))}
   ${when((x) => { var _a; return ((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.showAgentSwitchIndicator) != null; }, chatBotToggleRow('Show delegation', 'Show in the chat window when tasks are delegated to different agents.', switchTag, 'toggle-agent-switch', (x) => x.showAgentSwitchIndicator, (x, c) => {
     x.showAgentSwitchIndicator = readSwitchChecked(c.event);
+}))}
+  ${when((x) => x.persistenceToggleable, chatBotToggleRow('Remember chat', 'Save this conversation so it can be restored after a page refresh. Turning this off deletes the saved copy.', switchTag, 'toggle-remember-chat', (x) => x.persistenceActive, (x, c) => {
+    x.setPersistenceEnabled(readSwitchChecked(c.event));
 }))}
   ${when((x) => { var _a, _b; return ((_b = (_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.animations) === null || _b === void 0 ? void 0 : _b.userConfigurable) === true; }, settingsToggleRow('Animations', 'Choose which loading and activity indicators appear while the assistant is working.', 'toggle-animations', animationsPickerTemplate(switchTag), 'column'))}
 `;
@@ -319,8 +322,18 @@ export const SettingsModalTemplate = (designSystemPrefix) => {
                   <${buttonTag}
                     part="download-button"
                     appearance="outline"
+                    ?disabled=${(x) => x.downloadingDebugLog}
                     @click=${(x) => x.downloadDebugLog()}
-                  >Download</${buttonTag}>
+                  >
+                    ${when((x) => x.downloadingDebugLog, html `
+                        <span
+                          class="download-spinner"
+                          part="download-spinner"
+                          aria-hidden="true"
+                        ></span>
+                      `)}
+                    ${(x) => (x.downloadingDebugLog ? 'Downloading…' : 'Download')}
+                  </${buttonTag}>
                 `)}
             </div>
           </section>