@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/state/persistence/stateful-restore.e2e.test.ts

@@ -1,229 +0,0 @@
-import type {
-  AIProvider,
-  AIProviderRegistry,
-  ChatMessage,
-  ChatRequestOptions,
-} from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-// Side-effect import — MUST precede the driver import so it subclasses jsdom's
-// EventTarget (CustomEvent dispatch then works in node).
-import '../../components/chat-driver/align-event-globals';
-import { OrchestratingDriver } from '../../components/orchestrating-driver/orchestrating-driver';
-import type { AgentConfig } from '../../config/config';
-import { clearDiagnosticsCursorRegistry } from './diagnostics-cursors';
-import { clearPersisterRegistry } from './persister-registry';
-import { SessionPersister, type SessionPersisterDeps } from './session-persister';
-import type { PersistedSession } from './session-snapshot';
-
-// GENC-1351 — end-to-end save→restore→route→re-activate proof. The persister unit
-// tests exercise `persistSession`/`restore` against a FAKE driver; the driver pin/
-// flow-owner tests exercise routing against a real driver. NOTHING wired the two
-// together — the exact integration that broke once (bug #2: the live agent's
-// `serialize()` was read via `driver.getActiveAgent()` — a host minting fresh
-// configs handed back a never-activated closure whose `serialize()` returned
-// undefined, so the machine reset on reload). This test closes that gap with a REAL
-// `OrchestratingDriver` + a REAL `SessionPersister` + an in-memory provider:
-//   persist (capture the LIVE agent's state) → restore (prime + re-lock routing) →
-//   send (route back to the flow-owner without re-classifying) → re-activate aligned.
-// `Planner` is `excludeFromClassifier` AND never pinned, so a turn landing on it after
-// restore proves the RESTORED flow-owner lock (not the pin, not the classifier) routed
-// it — the `setFlowOwner`-on-restore half of the fix.
-
-const KEY = 'e2e-session';
-
-const makeRegistry = (provider: AIProvider): AIProviderRegistry => ({
-  get: () => provider,
-  default: () => provider,
-  defaultName: () => 'test',
-  names: () => ['test'],
-  getStatus: async () => null,
-  listStatuses: async () => [],
-});
-
-/** A provider that ends every turn immediately with a plain-text reply (no tools). */
-const noToolProvider = (): AIProvider =>
-  ({
-    chat: async (
-      _history: ChatMessage[],
-      _userMessage: string,
-      _options?: ChatRequestOptions,
-    ): Promise<ChatMessage> => ({ role: 'assistant', content: 'ok' }),
-  }) as AIProvider;
-
-const agentCfg = (overrides: Partial<AgentConfig> & { name: string }): AgentConfig =>
-  ({ description: 'test agent', ...overrides }) as AgentConfig;
-
-/** In-memory persistence provider (single session), enough for one save + one load. */
-function makeMemoryProvider() {
-  let stored: PersistedSession | null = null;
-  return {
-    saveDebounceMs: 0,
-    save: async (_k: string, snap: PersistedSession) => {
-      stored = snap;
-    },
-    load: async () => stored,
-    clear: async () => {
-      stored = null;
-    },
-    get current(): PersistedSession | null {
-      return stored;
-    },
-  };
-}
-
-/** The functional store shape the persister reads scalars from / hydrates into. */
-function makeStoreFake(over: Record<string, unknown> = {}) {
-  return {
-    store: {
-      aiAssistant: {
-        messages: [] as ChatMessage[],
-        flowOwnerAgentName: null as string | null,
-        flowActivationPrompt: null as string | null,
-        activeAgent: undefined as { name: string } | undefined,
-        pinnedAgentName: null as string | null,
-        // The persister reads `sessionUsage.costUsd` when building a snapshot, so this
-        // has to be the object rather than a bare cost scalar.
-        sessionUsage: {
-          costUsd: 0,
-          uncachedInputTokens: 0,
-          cacheReadTokens: 0,
-          cacheWriteTokens: 0,
-          outputTokens: 0,
-        },
-        contextTokens: 0,
-        contextLimit: 0,
-        activeModel: undefined,
-        activeProviderName: undefined,
-        restoring: false,
-        ...over,
-      },
-    },
-    actions: {
-      aiAssistant: {
-        loadSession: () => {},
-        setInputValue: () => {},
-      },
-    },
-  };
-}
-
-function makePersister(driver: unknown, storeFake: unknown, provider: unknown): SessionPersister {
-  const deps: SessionPersisterDeps = {
-    stateKey: KEY,
-    getPersistence: () => ({ enabled: true, provider: provider as never }),
-    getAgentNames: () => ['Genesis Assistant', 'Planner'],
-    getDriver: () => driver as never,
-    getStore: () => storeFake as never,
-    getDiagnosticEntries: () => [],
-  };
-  return new SessionPersister(deps);
-}
-
-const tick = (): Promise<void> =>
-  new Promise((r) => {
-    setTimeout(r, 0);
-  });
-
-const Suite = createLogicSuite('stateful-restore-e2e');
-
-Suite.before.each(() => {
-  clearPersisterRegistry();
-  clearDiagnosticsCursorRegistry();
-});
-
-Suite(
-  'a flow-owned stateful agent survives persist → restore → resume, routing back without re-classifying',
-  async () => {
-    const provider = makeMemoryProvider();
-
-    // ── Persist side ────────────────────────────────────────────────────────────
-    // `stateA` is the Planner's live state bag; `serialize` closes over it, exactly
-    // like a real stateful agent's machine snapshot.
-    let stateA: { cursor: number } = { cursor: 0 };
-    const planner1 = agentCfg({
-      name: 'Planner',
-      excludeFromClassifier: true,
-      onActivate: async ({ restored }) => {
-        if (restored !== undefined) stateA = restored as { cursor: number };
-      },
-      serialize: () => stateA,
-      systemPrompt: () => 'planner',
-    });
-    const driver1 = new OrchestratingDriver(
-      makeRegistry(noToolProvider()),
-      [agentCfg({ name: 'Genesis Assistant' }), planner1],
-      { sessionKey: KEY },
-    );
-
-    // Flow-owned but NOT pinned, then run a turn: the flow-owner lock routes the
-    // Planner (it's excludeFromClassifier, so the classifier could never pick it).
-    driver1.setFlowOwner('Planner');
-    await driver1.sendMessage('go');
-    assert.is(
-      driver1.getActiveAgent()?.name,
-      'Planner',
-      'flow-owner routed the Planner on persist side',
-    );
-
-    // The flow advances — mutate the SAME object `serialize()` returns.
-    stateA.cursor = 3;
-
-    // The store mirrors what main.ts keeps: the flow-owner lock lives in the store
-    // (that's the scalar `persistSession` reads).
-    const storeFake1 = makeStoreFake({ flowOwnerAgentName: 'Planner' });
-    const persister1 = makePersister(driver1, storeFake1, provider);
-    persister1.scheduleSave();
-    await tick();
-    await tick();
-
-    const saved = provider.current;
-    assert.ok(saved, 'a snapshot was persisted');
-    assert.is(saved!.flowOwnerAgentName, 'Planner', 'flow-owner lock persisted');
-    // Bug-#2 assertion: the LIVE (activated) agent's serialize was captured via
-    // driver.getActiveAgent(), so the advanced state is in the snapshot.
-    assert.equal(
-      saved!.agentSnapshots.Planner,
-      { cursor: 3 },
-      "live agent's advanced state captured (not a never-activated closure)",
-    );
-
-    // ── Restore side (fresh instances share the same in-memory provider) ──────────
-    let stateB: { cursor: number } = { cursor: -1 }; // sentinel; restore must overwrite
-    const planner2 = agentCfg({
-      name: 'Planner',
-      excludeFromClassifier: true,
-      onActivate: async ({ restored }) => {
-        if (restored !== undefined) stateB = restored as { cursor: number };
-      },
-      serialize: () => stateB,
-      systemPrompt: () => 'planner',
-    });
-    const driver2 = new OrchestratingDriver(
-      makeRegistry(noToolProvider()),
-      [agentCfg({ name: 'Genesis Assistant' }), planner2],
-      { sessionKey: KEY },
-    );
-    const storeFake2 = makeStoreFake();
-    const persister2 = makePersister(driver2, storeFake2, provider);
-
-    await persister2.restore();
-    // The restored flow-owner lock (setFlowOwner-on-restore) routes the next turn
-    // back to the Planner without re-classifying.
-    await driver2.sendMessage('again');
-
-    assert.is(
-      driver2.getActiveAgent()?.name,
-      'Planner',
-      'restored flow-owner routed the Planner (excludeFromClassifier + unpinned ⇒ only the restored lock could have)',
-    );
-    // primeRestoredAgentState → onActivate({ restored }) fed the snapshot back, so
-    // the fresh Planner resumed exactly where the persisted one left off.
-    assert.equal(
-      stateB,
-      { cursor: 3 },
-      'restored agent re-activated aligned to the persisted state',
-    );
-  },
-);
-
-Suite.run();

package/src/state/session-store.ts

@@ -1,56 +0,0 @@
-import { createStore } from '@genesislcap/foundation-redux';
-import {
-  aiAssistantSlice,
-  defaultSessionState,
-  type AiAssistantSessionState,
-} from './ai-assistant-slice';
-
-type SessionStoreReturn = ReturnType<typeof makeStore>;
-
-const sessionStores = new Map<string, SessionStoreReturn>();
-
-function makeStore(devTools: boolean | undefined) {
-  return createStore(
-    [aiAssistantSlice],
-    { aiAssistant: defaultSessionState },
-    devTools !== undefined ? { devTools } : undefined,
-  );
-}
-
-/**
- * Returns the session store for the given key, creating one if it does not
- * already exist. Omit `devTools` (or pass `undefined`) to defer to `isDev()`.
- * Pass `true` to force-enable or `false` to force-disable Redux DevTools.
- */
-export function getSessionStore(key: string, devTools?: boolean): SessionStoreReturn {
-  const existing = sessionStores.get(key);
-  if (existing) return existing;
-  const created = makeStore(devTools);
-  sessionStores.set(key, created);
-  return created;
-}
-
-/**
- * Returns true if a session store already exists for the given key.
- */
-export function hasSessionStore(key: string): boolean {
-  return sessionStores.has(key);
-}
-
-/**
- * Deletes the session store for the given key.
- */
-export function deleteSessionStore(key: string): void {
-  sessionStores.delete(key);
-}
-
-/**
- * Removes all session stores. Exposed for test isolation only — not part of the public API.
- *
- * @internal
- */
-export function clearAllSessionStores(): void {
-  sessionStores.clear();
-}
-
-export type { SessionStoreReturn, AiAssistantSessionState };

package/src/styles/ai-colours.ts

@@ -1,30 +0,0 @@
-/**
- * Shared brand colours used across the AI animation effects
- * (halo overlay border/glow and loading dot indicators).
- * Defined once here so both stay in sync.
- */
-export const AI_COLOUR_AMBER = '#feb60a';
-export const AI_COLOUR_PINK = '#ff0062';
-export const AI_COLOUR_CYAN = '#00dbf9';
-export const AI_COLOUR_VIOLET = '#da00f7';
-
-/**
- * Pin tint palette, cycled by an agent's position in the assistant's `agents`
- * array. Lives here beside the other brand colours because two components need
- * it: the composer's agent button tints its pin with the ACTIVE agent's colour,
- * and the picker menu tints every row's dot — and those two have to agree, so
- * they read the same list and index it the same way.
- */
-export const PIN_COLOURS = [
-  AI_COLOUR_AMBER,
-  AI_COLOUR_PINK,
-  AI_COLOUR_CYAN,
-  AI_COLOUR_VIOLET,
-] as const;
-
-/**
- * The tint for the agent at `index` in the full agents array, or `undefined`
- * when the index is out of range (an unknown or stale agent name).
- */
-export const pinColourAt = (index: number): string | undefined =>
-  index < 0 ? undefined : PIN_COLOURS[index % PIN_COLOURS.length];

package/src/styles/menu.ts

@@ -1,187 +0,0 @@
-import { css } from '@genesislcap/web-core';
-
-/**
- * The look of a row inside a composer menu — the agent picker and the session
- * (⋮) menu.
- *
- * Shared as a `css` partial rather than written twice because the two menus live
- * in DIFFERENT shadow roots: the picker is its own custom element, the session
- * menu is rendered by the assistant's own template. Hand-matching them is what
- * let them drift apart in the first place, so the rows are defined once here and
- * imported by both stylesheets. The *panel* around them (surface, position,
- * animation) belongs to the assistant, which renders both — see
- * `composerMenuStyles` in `main.styles.ts`.
- *
- * Expects markup shaped as:
- *
- * ```html
- * <button class="menu-item" role="menuitemradio" aria-checked="true">
- *   <span class="menu-item-mark"></span>
- *   <span class="menu-item-body">
- *     <span class="menu-item-name">Positions</span>
- *     <span class="menu-item-hint">Read-only position queries</span>
- *   </span>
- * </button>
- * ```
- *
- * `--menu-item-mark` (unset by default) tints the leading dot; a row that sets
- * it gets a filled dot in that colour, one that doesn't gets a hollow ring.
- *
- * An ACTION menu (the session menu) swaps `.menu-item-mark` for
- * `.menu-item-icon` in the same leading slot — a dot would imply a selectable
- * state the row doesn't have — and marks a destructive row with `.is-danger`.
- *
- * @internal
- */
-export const menuItemStyles = css`
-  .menu-item {
-    display: flex;
-    align-items: flex-start;
-    gap: calc(var(--design-unit) * 2px);
-    width: 100%;
-    box-sizing: border-box;
-    padding: calc(var(--design-unit) * 1.5px) calc(var(--design-unit) * 2px);
-    border: none;
-    border-radius: calc(var(--control-corner-radius) * 1px);
-    background: transparent;
-    color: var(--neutral-foreground-rest);
-    font-family: var(--body-font);
-    font-size: var(--type-ramp-minus-1-font-size, 0.85em);
-    text-align: start;
-    cursor: pointer;
-  }
-
-  .menu-item:hover {
-    background: var(--neutral-fill-stealth-hover);
-  }
-
-  .menu-item:focus-visible {
-    outline: 1px solid var(--focus-stroke-outer);
-    outline-offset: -1px;
-  }
-
-  .menu-item[disabled] {
-    opacity: 45%;
-    cursor: not-allowed;
-  }
-
-  .menu-item[disabled]:hover {
-    background: transparent;
-  }
-
-  /* The leading slot, shared by both menus so their text columns line up at the
-     same indent whichever kind of row is in it. Sized for the icon (the larger
-     of the two occupants) and positioned on the name's first line — a
-     flex-start row keeps a two-line item's marker beside the name rather than
-     floating to the vertical middle of the block. */
-  .menu-item-mark,
-  .menu-item-icon {
-    flex: 0 0 12px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    height: 12px;
-    margin-top: 0.3em;
-  }
-
-  /* The dot itself, centred in that slot rather than filling it. */
-  .menu-item-mark::before {
-    content: '';
-    width: 8px;
-    height: 8px;
-    box-sizing: border-box;
-    border-radius: 50%;
-    background: var(--menu-item-mark, transparent);
-    border: 1px solid var(--menu-item-mark, var(--neutral-stroke-rest));
-  }
-
-  /* The checked row reads by weight + the filled dot, not by a tick glyph: a
-     tick would need a column of its own that every other row pays for in
-     indentation. */
-  .menu-item[aria-checked='true'] {
-    background: var(--neutral-fill-stealth-rest);
-  }
-
-  .menu-item[aria-checked='true'] .menu-item-name {
-    font-weight: 600;
-  }
-
-  .menu-item[aria-checked='true'] .menu-item-mark::before {
-    background: var(--menu-item-mark, var(--accent-fill-rest));
-    border-color: var(--menu-item-mark, var(--accent-fill-rest));
-  }
-
-  /* Auto is not one of the agents — it is the absence of a pin, so it reads as a
-     different KIND of row rather than a first entry in the list. Its marker stays
-     a ring in every state: a filled dot is what says "this particular agent",
-     and Auto is precisely the choice not to name one. Selected, the ring picks up
-     the accent so the state is still legible; unselected it keeps the neutral
-     stroke every other unselected row has. */
-  .menu-item.menu-item-auto .menu-item-mark::before {
-    background: transparent;
-    border-color: var(--neutral-stroke-rest);
-  }
-
-  .menu-item.menu-item-auto[aria-checked='true'] .menu-item-mark::before {
-    background: transparent;
-    border-color: var(--accent-fill-rest);
-  }
-
-  /* Kept quieter than a pinned row's fill — the mode is the default, not a
-     choice the user made and needs reflected back at them. */
-  .menu-item.menu-item-auto[aria-checked='true'] {
-    background: var(--neutral-fill-stealth-hover);
-  }
-
-  /* A rule between Auto and the agents, drawn as its own element so neither row's
-     hover background has to give up its rounded corners to carry a border. */
-  .menu-separator {
-    height: 1px;
-    margin: calc(var(--design-unit) * 1px) calc(var(--design-unit) * 2px);
-    background: var(--neutral-stroke-divider-rest);
-  }
-
-  .menu-item-body {
-    display: flex;
-    flex-direction: column;
-    gap: 1px;
-    min-width: 0;
-  }
-
-  .menu-item-name {
-    /* Long agent names wrap rather than truncate — the menu is the one place
-       the full name has to be readable, since the composer button truncates it. */
-    overflow-wrap: anywhere;
-  }
-
-  .menu-item-hint {
-    color: var(--neutral-foreground-hint);
-    font-size: 0.9em;
-    line-height: 1.35;
-  }
-
-  /* Action rows put an icon in that slot — a dot would imply a selectable state
-     the row doesn't have. */
-  .menu-item-icon {
-    font-size: 0.9em;
-    color: var(--neutral-foreground-hint);
-  }
-
-  .menu-item:hover .menu-item-icon {
-    color: inherit;
-  }
-
-  .menu-item.is-danger {
-    color: var(--error-color);
-  }
-
-  .menu-item.is-danger .menu-item-icon,
-  .menu-item.is-danger .menu-item-hint {
-    color: inherit;
-    opacity: 80%;
-  }
-
-  .menu-item.is-danger:hover {
-    background: color-mix(in srgb, var(--error-color), transparent 88%);
-  }
-`;

package/src/styles/settings-section.ts

@@ -1,40 +0,0 @@
-import { css, type ElementStyles } from '@genesislcap/web-core';
-
-/**
- * Heading style for a settings-modal section, published so a host can title its own section.
- *
- * The assistant renders no heading for the `settings-app` slot — no text and no icon — because
- * only the host knows what that section is. The consequence is that a host supplying one has to
- * reproduce the styling of the built-in headings beside it, and a copied rule drifts the moment
- * either side changes. So the declarations live here, are applied by the assistant's own
- * headings, and are exported for the host to apply to its.
- *
- * Compose it into a component's styles and put `ai-settings-section-title` on the heading:
- *
- * ```ts
- * import { assistantSettingsSectionTitleStyles } from '@genesislcap/ai-assistant';
- *
- * const styles = css`
- *   ${assistantSettingsSectionTitleStyles}
- *   :host { display: block; }
- * `;
- * ```
- *
- * Carries no margin on purpose: spacing belongs to the surrounding layout, which differs
- * between the assistant's own sections and a slotted one, and is the single declaration hosts
- * had to diverge on when they copied this rule.
- *
- * @beta
- */
-export const assistantSettingsSectionTitleStyles: ElementStyles = css`
-  .ai-settings-section-title {
-    display: flex;
-    align-items: center;
-    gap: calc(var(--design-unit) * 2px);
-    font-size: 11px;
-    font-weight: 600;
-    letter-spacing: 0.08em;
-    text-transform: uppercase;
-    color: var(--neutral-foreground-hint);
-  }
-`;