@zeniai/client-epic-state 5.0.82-betaAS1 → 5.0.83-betaRR0

package/lib/common/aiCfo/aiCfoSuggestedQuestionsPageContext.d.ts

@@ -16,4 +16,4 @@
  *
  * @see README.md in this directory for maintenance expectations.
  */
-export type AiCfoSuggestedQuestionsPageContext = 'balance_sheet' | 'profit_loss' | 'vendors' | 'transactions' | 'cash_flow' | 'accounts_receivable' | 'accounts_payable' | 'transaction_details' | 'dashboard' | 'cash_balance' | 'card_balance' | 'cash_in_cash_out' | 'net_burn_or_income' | 'cash_position' | 'top_expenses' | 'revenue' | 'operating_expenses' | 'command_centre' | 'je_schedules' | 'reconciliation' | 'flux_analysis' | 'receipts' | 'mei' | 'task_checklist' | 'performance' | 'bills_list' | 'bills_details' | 'reimbursement_list' | 'reimbursement_details' | 'vendors_summary' | 'opex_by_vendor' | 'prepaid_expenses' | 'fixed_assets' | 'form_1099' | 'accrued_expenses' | 'forecast' | 'checking' | 'checking_details' | 'treasury' | 'cards' | 'cards_detail' | 'people' | 'rewards' | 'notifications';
+export type AiCfoSuggestedQuestionsPageContext = 'balance_sheet' | 'profit_loss' | 'vendors' | 'transactions' | 'cash_flow' | 'accounts_receivable' | 'accounts_payable' | 'transaction_details' | 'dashboard' | 'cash_balance' | 'card_balance' | 'cash_in_cash_out' | 'net_burn_or_income' | 'cash_position' | 'top_expenses' | 'revenue' | 'operating_expenses' | 'command_centre' | 'je_schedules' | 'reconciliation' | 'flux_analysis' | 'receipts' | 'mei' | 'task_checklist' | 'performance' | 'bills_list' | 'bills_details' | 'reimbursement_list' | 'reimbursement_details' | 'vendors_summary' | 'opex_by_vendor' | 'prepaid_expenses' | 'fixed_assets' | 'form_1099' | 'accrued_expenses' | 'forecast' | 'checking' | 'checking_details' | 'treasury' | 'cards' | 'cards_creation' | 'cards_detail' | 'card_policy' | 'card_policy_detail' | 'people' | 'rewards' | 'notifications';

package/lib/entity/aiCfo/aiCfoPayload.d.ts

@@ -20,8 +20,147 @@ export interface ChartVisualizationPayload {
     lines?: string[] | null;
     y_format?: YFormatPayload;
 }
+/**
+ * Single AI-suggested card on the wire. The controller ships an array of
+ * these mixing vendor, department, and category entries. Entries with
+ * `is_suggested: true` seed step 1 (`review`) or the step-2 editable table
+ * (`create`); entries with `is_suggested: false` aren't pre-rendered as
+ * rows but are available in the step-2 Card dropdown (and, in `review`,
+ * the step-1 "Add something else" search).
+ *
+ * `owner_id` may be `null` (or empty string, defensively normalized by the
+ * reducer) when the AI hasn't picked an owner.
+ */
+export interface SuggestedCardPayload {
+    avg_spend: number;
+    card_name: string;
+    card_name_id: string;
+    card_type: 'vendor' | 'department' | 'category';
+    credit_limit: number;
+    is_suggested: boolean;
+    owner_id: string | null;
+}
+/**
+ * Wire payload for the AI Card Creation interactive form. Both `review`
+ * and `create` modes share an identical envelope — a flat
+ * `suggested_cards[]` (mix of suggested + not-suggested rows). The only
+ * thing that varies is `mode`, which the FE uses to pick the step UX:
+ *
+ * - `review` (2-step): user reviews / toggles the `is_suggested: true`
+ *   rows in step 1, then configures one card per surviving row in step 2.
+ * - `create` (1-step): the FE seeds the step-2 editable table directly
+ *   from the `is_suggested: true` rows; step 1 is skipped.
+ *
+ * In both modes the full `suggested_cards[]` universe (including
+ * `is_suggested: false`) feeds the step-2 Card-cell dropdown so the user
+ * can swap a row to any vendor / department / category of the same kind.
+ *
+ * Note: `card_options` (physical / virtual / subscription) is NOT part of
+ * the wire. The FE injects a single `virtual` option via
+ * `AI_CARD_CREATION_VIRTUAL_ONLY_CARD_OPTIONS`; the reducer defaults each
+ * seeded row's `cardOptionId` to `'virtual'`.
+ */
+export interface CardsCreationInitialDataPayload {
+    mode: 'review' | 'create';
+    suggested_cards: SuggestedCardPayload[];
+}
+/**
+ * Per-policy allow / block bucket on the wire. The two arrays are
+ * independent (a draft policy may populate both, only one, or neither).
+ */
+export interface DraftPolicyEntityPayload {
+    category_codes: string[];
+    merchant_names: string[];
+}
+/**
+ * Spend-limit bucket per policy. `transaction` is the only cadence the
+ * BE ships today; left open-ended for future cadences (e.g.
+ * `monthly`, `quarterly`).
+ */
+export interface DraftPolicySpendLimitsPayload {
+    transaction: number;
+    [cadence: string]: number | undefined;
+}
+/**
+ * Single draft policy on the wire. The controller emits one of these
+ * per recommended policy in `step_5_review.draft_policies`. Identity is
+ * positional (no stable `id` from the BE); the FE synthesizes one on
+ * decode.
+ */
+export interface DraftPolicyPayload {
+    allowed_entity: DraftPolicyEntityPayload;
+    apply_to_cards: string[];
+    blocked_entity: DraftPolicyEntityPayload;
+    description: string;
+    /** Enforcement mode for the policy (e.g. `"strict"`). Carried into
+     * state for guided submit; ignored for `auto` / `upload`. */
+    mode: string;
+    name: string;
+    required_receipt_threshold: number;
+    spend_limits: DraftPolicySpendLimitsPayload;
+}
+/**
+ * `step_5_review` block — the only step in `wizard_plan` the FE reads.
+ * Steps 1–4 are intentionally not modeled.
+ */
+export interface CardPolicyStep5ReviewPayload {
+    draft_policies: DraftPolicyPayload[];
+    /** Header text shown above the review list / wizard. */
+    prompt: string;
+    /** How the BE grouped the suggested policies. `"none"` today; may
+     * surface as a header banner in a future iteration. */
+    grouping_source?: string;
+}
+export interface CardPolicyWizardPlanPayload {
+    step_5_review: CardPolicyStep5ReviewPayload;
+}
+/**
+ * Upload-mode metadata that the `policy-recommendation-from-upload` API
+ * returns alongside the wizard plan. Absent on the initial controller
+ * response; populated after the file upload + recommendation chain.
+ */
+export interface CardPolicyUploadSourcePayload {
+    confidence_score: number;
+    file_name: string;
+    low_confidence_fields: string[];
+}
+/**
+ * Discriminated payload for the AI Card Policy interactive form.
+ * All three modes share the same `wizard_plan.step_5_review.draft_policies`
+ * envelope; the FE renders different forms based on `mode`.
+ *
+ * - `auto` (1-step review): user reviews suggested policies and submits.
+ * - `guided` (5-step wizard): Steps 1–4 seeded from `draft_policies[0]`,
+ *   Step 5 lists every draft policy.
+ * - `upload` (3-step): upload doc → pick cards → review. Controller
+ *   responses for `mode === "upload"` arrive *before* the user uploads,
+ *   so `wizard_plan` is optional; populated after the upload-recommendation
+ *   API returns.
+ */
+export type CardPolicyInitialDataPayload = {
+    mode: 'auto';
+    wizard_plan: CardPolicyWizardPlanPayload;
+} | {
+    mode: 'guided';
+    wizard_plan: CardPolicyWizardPlanPayload;
+} | {
+    mode: 'upload';
+    source?: CardPolicyUploadSourcePayload;
+    wizard_plan?: CardPolicyWizardPlanPayload;
+};
+/**
+ * Discriminated visualization payload. The FE narrows on `form_type` and
+ * casts `payload` to the matching shape.
+ */
+export type InteractiveFormVisualizationPayload = {
+    form_type: 'cards_creation';
+    payload: CardsCreationInitialDataPayload;
+} | {
+    form_type: 'card_policy';
+    payload: CardPolicyInitialDataPayload;
+};
 export interface AiCfoVisualizationPayload {
-    data: TableVisualizationPayload | ChartVisualizationPayload | null;
+    data: TableVisualizationPayload | ChartVisualizationPayload | InteractiveFormVisualizationPayload | null;
     type: string | null;
 }
 export interface AiCfoAnswerPayload {

package/lib/entity/aiCfo/aiCfoReducer.d.ts

@@ -1,7 +1,8 @@
 import { ID } from '../../commonStateTypes/common';
 import { ZeniDate } from '../../zeniDayJS';
 import { AiCfoAnswerPayload, AiCfoVisualizationPayload, ChatSessionPayload, MessagePayload } from './aiCfoPayload';
-import { AiCfoState, AiCfoVisualization, FileAttachmentMetadata } from './aiCfoState';
+import { AiCfoState, AiCfoVisualization, FileAttachmentMetadata, SyntheticAiCfoAnswerKind } from './aiCfoState';
+import type { CardPolicyUploadSource, CardPolicyWizardPlan } from './aiCfoState';
 export declare const initialAiCfoState: AiCfoState;
 export declare const toAiCfoVisualization: (visualization: AiCfoVisualizationPayload) => AiCfoVisualization | undefined;
 export declare const setNewSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
@@ -41,6 +42,26 @@ export declare const setNewSession: import("@reduxjs/toolkit").ActionCreatorWith
 }, "aiCfo/addQuestionPayload">, clearAiCfo: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfo/clearAiCfo">, deleteQuestion: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     chatSessionId: ID;
     questionAnswerId: ID;
-}, "aiCfo/deleteQuestion">;
+}, "aiCfo/deleteQuestion">, updateAiCfoAnswerCardPolicyWizardPlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    answerId: ID;
+    chatSessionId: ID;
+    wizardPlan: CardPolicyWizardPlan;
+    source?: CardPolicyUploadSource;
+}, "aiCfo/updateAiCfoAnswerCardPolicyWizardPlan">, appendSyntheticAiCfoAnswer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    createdAt: ZeniDate;
+    id: ID;
+    kind: SyntheticAiCfoAnswerKind;
+    sourceQuestionAnswerId: ID;
+    entityIds?: ID[];
+}, "aiCfo/appendSyntheticAiCfoAnswer">, updateSyntheticAiCfoAnswer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    id: ID;
+    kind: SyntheticAiCfoAnswerKind;
+    entityIds?: ID[];
+}, "aiCfo/updateSyntheticAiCfoAnswer">, removeSyntheticAiCfoAnswer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    id: ID;
+}, "aiCfo/removeSyntheticAiCfoAnswer">, clearSyntheticAiCfoAnswers: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "aiCfo/clearSyntheticAiCfoAnswers">;
 declare const _default: import("redux").Reducer<AiCfoState>;
 export default _default;

package/lib/entity/aiCfo/aiCfoReducer.js

@@ -1,13 +1,14 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteQuestion = exports.clearAiCfo = exports.addQuestionPayload = exports.upsertOrAddQuestionAnswerPayload = exports.upsertAnswerPayload = exports.setChatHistory = exports.setSessions = exports.clearSession = exports.setNewSession = exports.toAiCfoVisualization = exports.initialAiCfoState = void 0;
+exports.clearSyntheticAiCfoAnswers = exports.removeSyntheticAiCfoAnswer = exports.updateSyntheticAiCfoAnswer = exports.appendSyntheticAiCfoAnswer = exports.updateAiCfoAnswerCardPolicyWizardPlan = exports.deleteQuestion = exports.clearAiCfo = exports.addQuestionPayload = exports.upsertOrAddQuestionAnswerPayload = exports.upsertAnswerPayload = exports.setChatHistory = exports.setSessions = exports.clearSession = exports.setNewSession = exports.toAiCfoVisualization = exports.initialAiCfoState = void 0;
 const toolkit_1 = require("@reduxjs/toolkit");
 const zeniDayJS_1 = require("../../zeniDayJS");
 const aiCfoState_1 = require("./aiCfoState");
 exports.initialAiCfoState = {
     aiCfoByChatSessionId: {},
     partialQuestionAnswers: {},
+    syntheticAnswersByChatSessionId: {},
 };
 // Utility: Merge two arrays of Q&A pairs, combining responses for the same question
 function mergeQuestionAnswerPairs(existing, newQAs) {
@@ -139,12 +140,219 @@ const toAiCfoVisualization = (visualization) => {
     if (visualization.type == null || visualization.data == null) {
         return undefined;
     }
+    // Reject unknown viz types instead of silently defaulting to `table`.
+    // The previous `?? 'table'` fallback funneled any non-strict-union
+    // payload into `toAiCfoVisualizationData`, which is the table/chart
+    // decoder and dereferences `data.values.map(...)`. Interactive-form
+    // payloads (e.g. when the BE ships `type: <new_form_kind>` we don't
+    // know about yet) carry no `values`, so that path threw during answer
+    // upsert and broke rendering for the whole Q/A. Returning `undefined`
+    // matches the existing "missing type / data" guard above — callers
+    // already handle a no-visualization answer.
+    const normalizedType = (0, aiCfoState_1.toAiCfoVisualizationTypeStrict)(visualization.type);
+    if (normalizedType == null) {
+        return undefined;
+    }
     return {
-        type: (0, aiCfoState_1.toAiCfoVisualizationTypeStrict)(visualization.type) ?? 'table',
-        data: toAiCfoVisualizationData(visualization.data),
+        type: normalizedType,
+        data: normalizedType === 'interactive_form'
+            ? toInteractiveFormVisualization(visualization.data)
+            : toAiCfoVisualizationData(visualization.data),
     };
 };
 exports.toAiCfoVisualization = toAiCfoVisualization;
+const toInteractiveFormVisualization = (data) => {
+    // When `form_type` is missing / mistyped, fall back to a payload-shape
+    // heuristic instead of blindly defaulting to `cards_creation`. A
+    // `card_policy` payload always carries `mode: 'auto' | 'guided' |
+    // 'upload'` (see `CardPolicyInitialDataPayload`); a `cards_creation`
+    // payload carries `suggested_cards` and never that exact `mode` set.
+    // Without this, a card-policy answer with a malformed `form_type`
+    // would be decoded as cards_creation, surfacing the wrong interactive
+    // form (and wrong submit path) in the UI.
+    const formType = (0, aiCfoState_1.toInteractiveFormTypeStrict)(data.form_type) ??
+        inferInteractiveFormTypeFromPayload(data.payload);
+    if (formType === 'card_policy') {
+        return {
+            formType: 'card_policy',
+            payload: toCardPolicyInitialData(data.payload),
+        };
+    }
+    return {
+        formType: 'cards_creation',
+        payload: toCardsCreationInitialData(data.payload),
+    };
+};
+const inferInteractiveFormTypeFromPayload = (payload) => {
+    if (payload != null && typeof payload === 'object' && 'mode' in payload) {
+        const mode = payload.mode;
+        if (mode === 'auto' || mode === 'guided' || mode === 'upload') {
+            return 'card_policy';
+        }
+    }
+    return 'cards_creation';
+};
+/**
+ * Decode the unified `cards_creation` interactive-form payload into the FE
+ * state shape. Both `review` and `create` modes ship the same envelope
+ * (`{mode, suggested_cards[]}`); the only thing that varies is how the
+ * common derivations are exposed:
+ *
+ * - `review` (2-step): `is_suggested: true` rows -> `teamRows`; the full
+ *   universe -> `cardNameOptions` (step-2 swap + step-1 "Add something
+ *   else" search).
+ * - `create` (1-step): `is_suggested: true` rows -> `cardRows` pre-seeded
+ *   for the step-2 editable table (with `cardOptionId` defaulted to
+ *   `'virtual'`); the full universe -> `cardNameOptions` (step-2 swap).
+ *
+ * `cardOptions` (physical / virtual / subscription) is intentionally not
+ * derived here — the wire never carries it. The component prop is fed
+ * from `AI_CARD_CREATION_VIRTUAL_ONLY_CARD_OPTIONS` at render time. The
+ * state field is preserved as `[]` for backward compatibility with
+ * consumers that still narrow on it.
+ */
+const toCardsCreationInitialData = (payload) => {
+    const suggestedCards = payload.suggested_cards ?? [];
+    const ordered = [...suggestedCards].sort((a, b) => KIND_RANK[a.card_type] - KIND_RANK[b.card_type]);
+    const withUniqueIds = withSynthesizedIds(ordered);
+    const suggestedOnly = withUniqueIds.filter(({ card }) => card.is_suggested);
+    const cardNameOptions = withUniqueIds.map(({ card, uniqueId }) => ({
+        id: uniqueId,
+        kind: toCardKind(card.card_type),
+        label: card.card_name,
+    }));
+    const suggestedOwnerUserIdByTeamId = Object.fromEntries(suggestedOnly.map(({ card, uniqueId }) => [
+        uniqueId,
+        normalizeOwnerId(card.owner_id),
+    ]));
+    const common = {
+        cardNameOptions,
+        cardOptions: [],
+        suggestedOwnerUserIdByTeamId,
+    };
+    if (payload.mode === 'create') {
+        return {
+            ...common,
+            mode: 'create',
+            cardRows: suggestedOnly.map(({ card, uniqueId }) => ({
+                cardKind: toCardKind(card.card_type),
+                cardOptionId: aiCfoState_1.CARDS_CREATION_DEFAULT_CARD_OPTION_ID,
+                id: uniqueId,
+                label: card.card_name,
+                recommendedLimit: card.credit_limit > 0 ? card.credit_limit : undefined,
+                suggestedOwnerUserId: normalizeOwnerId(card.owner_id),
+            })),
+        };
+    }
+    return {
+        ...common,
+        mode: 'review',
+        teamRows: suggestedOnly.map(({ card, uniqueId }) => ({
+            avgMonthlySpend: CURRENCY_FORMATTER.format(card.avg_spend),
+            cardKind: toCardKind(card.card_type),
+            id: uniqueId,
+            label: card.card_name,
+            recommendedLimit: CURRENCY_FORMATTER.format(card.credit_limit),
+            recommendedLimitCadence: 'Monthly',
+        })),
+    };
+};
+const CURRENCY_FORMATTER = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+    maximumFractionDigits: 0,
+});
+/**
+ * Normalize the controller's `owner_id` into `string | undefined`. The
+ * BE may emit either `null` or `""` to signal "no owner picked"; both
+ * collapse to `undefined` so downstream resolvers don't try to look up
+ * a user with an empty id.
+ */
+const normalizeOwnerId = (ownerId) => ownerId != null && ownerId !== '' ? ownerId : undefined;
+const KIND_RANK = {
+    vendor: 0,
+    category: 1,
+    department: 2,
+};
+const toCardKind = (cardType) => {
+    if (cardType === 'department') {
+        return 'class';
+    }
+    if (cardType === 'category') {
+        return 'category';
+    }
+    return 'vendor';
+};
+/**
+ * Stamp each suggested card with a stable unique id derived from its
+ * `card_name_id`. If two cards in the same payload share the same
+ * `card_name_id` (which happens in the current sample payload where
+ * `card_name_id` is the literal `"vendor_uuid"`), fall back to a
+ * synthesized id `${kind}__${card_name_id}__${index}` so RHF row keying
+ * stays unique.
+ */
+const withSynthesizedIds = (cards) => {
+    const seen = new Set();
+    return cards.map((card, index) => {
+        const preferred = card.card_name_id;
+        if (preferred != null && preferred !== '' && !seen.has(preferred)) {
+            seen.add(preferred);
+            return { card, uniqueId: preferred };
+        }
+        const synthesized = `${card.card_type}__${preferred ?? 'unknown'}__${index}`;
+        seen.add(synthesized);
+        return { card, uniqueId: synthesized };
+    });
+};
+const toCardPolicyDraftPolicy = (payload, index) => ({
+    id: `draft-${index}`,
+    name: payload.name,
+    description: payload.description ?? '',
+    mode: payload.mode,
+    allowedEntity: {
+        categoryCodes: payload.allowed_entity?.category_codes ?? [],
+        merchantNames: payload.allowed_entity?.merchant_names ?? [],
+    },
+    blockedEntity: {
+        categoryCodes: payload.blocked_entity?.category_codes ?? [],
+        merchantNames: payload.blocked_entity?.merchant_names ?? [],
+    },
+    applyToCards: payload.apply_to_cards ?? [],
+    requiredReceiptThreshold: payload.required_receipt_threshold ?? 0,
+    spendLimits: {
+        transaction: payload.spend_limits?.transaction ?? 0,
+    },
+});
+const toCardPolicyStep5Review = (payload) => ({
+    draftPolicies: (payload.draft_policies ?? []).map(toCardPolicyDraftPolicy),
+    groupingSource: payload.grouping_source ?? 'none',
+    prompt: payload.prompt ?? '',
+});
+const toCardPolicyWizardPlan = (payload) => ({
+    step5Review: toCardPolicyStep5Review(payload.step_5_review),
+});
+const toCardPolicyUploadSource = (payload) => ({
+    confidenceScore: payload.confidence_score,
+    fileName: payload.file_name,
+    lowConfidenceFields: payload.low_confidence_fields ?? [],
+});
+const toCardPolicyInitialData = (payload) => {
+    if (payload.mode === 'upload') {
+        return {
+            policyKind: 'upload',
+            wizardPlan: payload.wizard_plan != null
+                ? toCardPolicyWizardPlan(payload.wizard_plan)
+                : undefined,
+            source: payload.source != null
+                ? toCardPolicyUploadSource(payload.source)
+                : undefined,
+        };
+    }
+    return {
+        policyKind: payload.mode,
+        wizardPlan: toCardPolicyWizardPlan(payload.wizard_plan),
+    };
+};
 const toAiCfoVisualizationData = (data) => {
     if ('x' in data && 'y' in data) {
         // Normalize y to always be an array
@@ -458,10 +666,118 @@ const aiCfo = (0, toolkit_1.createSlice)({
                 session.questionAnswers.push(qa);
             }
         },
+        /**
+         * Patch the `card_policy` interactive-form payload for a specific
+         * answer in a chat session to merge in the wizard plan + upload
+         * source metadata returned by
+         * `POST /cards/1.0/ai-cfo/policy-recommendation-from-upload`.
+         *
+         * Dispatched by the recommendation epic after a successful response;
+         * the wizard re-renders Steps 2 + 3 of the upload variant once the
+         * payload becomes a populated `CardPolicyInitialData` with
+         * `policyKind: "upload"` + `wizardPlan` + `source`.
+         *
+         * No-op when the target answer / chat session / form payload is
+         * missing or isn't an upload-mode card-policy interactive form —
+         * the bridge epic is best-effort and silently drops in edge cases
+         * (e.g. the user closed the chat before recommendation returned).
+         */
+        updateAiCfoAnswerCardPolicyWizardPlan(draft, action) {
+            const { answerId, chatSessionId, source, wizardPlan } = action.payload;
+            const session = draft.aiCfoByChatSessionId[chatSessionId];
+            if (session == null) {
+                return;
+            }
+            const qa = session.questionAnswers.find((entry) => entry.questionAnswerId === answerId);
+            if (qa == null) {
+                return;
+            }
+            for (const response of Object.values(qa.responses)) {
+                const visualization = response?.content.visualization;
+                if (visualization == null ||
+                    visualization.type !== 'interactive_form') {
+                    continue;
+                }
+                const data = visualization.data;
+                if (data.formType !== 'card_policy' ||
+                    data.payload.policyKind !== 'upload') {
+                    continue;
+                }
+                data.payload = {
+                    ...data.payload,
+                    wizardPlan,
+                    source: source ?? data.payload.source,
+                };
+            }
+        },
+        /**
+         * Append a client-synthesized answer bubble to a chat session. Used by
+         * the AI CFO cards/policy create flow to render a "Creating…" placeholder
+         * in the drawer while the underlying mutation runs.
+         *
+         * The caller is responsible for generating a stable `id` (so the same
+         * bubble can later be updated in place via `updateSyntheticAiCfoAnswer`
+         * once the mutation completes) and a `createdAt` timestamp so the
+         * renderer can interleave synthetic bubbles with streamed Q&A pairs in
+         * chronological order.
+         */
+        appendSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id, kind, createdAt, entityIds, sourceQuestionAnswerId, } = action.payload;
+            if (draft.syntheticAnswersByChatSessionId[chatSessionId] == null) {
+                draft.syntheticAnswersByChatSessionId[chatSessionId] = [];
+            }
+            draft.syntheticAnswersByChatSessionId[chatSessionId].push({
+                id,
+                kind,
+                entityIds: entityIds ?? [],
+                createdAt,
+                sourceQuestionAnswerId,
+            });
+        },
+        /**
+         * Update an existing synthetic answer bubble in place. Typically called
+         * when the create mutation completes: the screen transitions the bubble
+         * from `creating_*` to `created_*` and populates `entityIds` with the
+         * newly created cards / policy templates.
+         *
+         * No-op when the target bubble is missing (e.g. the session was cleared
+         * before the mutation returned).
+         */
+        updateSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id, kind, entityIds } = action.payload;
+            const list = draft.syntheticAnswersByChatSessionId[chatSessionId];
+            if (list == null) {
+                return;
+            }
+            const entry = list.find((item) => item.id === id);
+            if (entry == null) {
+                return;
+            }
+            entry.kind = kind;
+            if (entityIds != null) {
+                entry.entityIds = entityIds;
+            }
+        },
+        /**
+         * Remove a single synthetic answer bubble (e.g. when the user manually
+         * dismisses it or the mutation errors out and we want to fall back to
+         * an inline error snackbar).
+         */
+        removeSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id } = action.payload;
+            const list = draft.syntheticAnswersByChatSessionId[chatSessionId];
+            if (list == null) {
+                return;
+            }
+            draft.syntheticAnswersByChatSessionId[chatSessionId] = list.filter((item) => item.id !== id);
+        },
+        clearSyntheticAiCfoAnswers(draft, action) {
+            delete draft.syntheticAnswersByChatSessionId[action.payload];
+        },
         clearSession(draft, action) {
             const sessionId = action.payload;
             delete draft.aiCfoByChatSessionId[sessionId];
-            // Clear partial Q&A if it belongs to the cleared session
+            delete draft.syntheticAnswersByChatSessionId[sessionId];
             if (draft.partialQuestionAnswers?.[sessionId] != null) {
                 draft.partialQuestionAnswers[sessionId] = undefined;
             }
@@ -469,6 +785,7 @@ const aiCfo = (0, toolkit_1.createSlice)({
         clearAiCfo(draft) {
             draft.aiCfoByChatSessionId = {};
             draft.partialQuestionAnswers = {};
+            draft.syntheticAnswersByChatSessionId = {};
         },
         deleteQuestion(draft, action) {
             const { chatSessionId, questionAnswerId } = action.payload;
@@ -481,6 +798,12 @@ const aiCfo = (0, toolkit_1.createSlice)({
             if (idx !== -1) {
                 session.questionAnswers.splice(idx, 1);
             }
+            // Drop synthetic bubbles whose sourceQuestionAnswerId is the deleted Q/A; otherwise "Creating…" / "Created" tiles outlive their Q/A.
+            const syntheticAnswers = draft.syntheticAnswersByChatSessionId[chatSessionId];
+            if (syntheticAnswers != null) {
+                draft.syntheticAnswersByChatSessionId[chatSessionId] =
+                    syntheticAnswers.filter((answer) => answer.sourceQuestionAnswerId !== questionAnswerId);
+            }
         },
     },
 });
@@ -493,5 +816,5 @@ const toChatSession = (chatSessionPayload) => {
         createdAt: (0, zeniDayJS_1.date)(created_at),
     };
 };
-_a = aiCfo.actions, exports.setNewSession = _a.setNewSession, exports.clearSession = _a.clearSession, exports.setSessions = _a.setSessions, exports.setChatHistory = _a.setChatHistory, exports.upsertAnswerPayload = _a.upsertAnswerPayload, exports.upsertOrAddQuestionAnswerPayload = _a.upsertOrAddQuestionAnswerPayload, exports.addQuestionPayload = _a.addQuestionPayload, exports.clearAiCfo = _a.clearAiCfo, exports.deleteQuestion = _a.deleteQuestion;
+_a = aiCfo.actions, exports.setNewSession = _a.setNewSession, exports.clearSession = _a.clearSession, exports.setSessions = _a.setSessions, exports.setChatHistory = _a.setChatHistory, exports.upsertAnswerPayload = _a.upsertAnswerPayload, exports.upsertOrAddQuestionAnswerPayload = _a.upsertOrAddQuestionAnswerPayload, exports.addQuestionPayload = _a.addQuestionPayload, exports.clearAiCfo = _a.clearAiCfo, exports.deleteQuestion = _a.deleteQuestion, exports.updateAiCfoAnswerCardPolicyWizardPlan = _a.updateAiCfoAnswerCardPolicyWizardPlan, exports.appendSyntheticAiCfoAnswer = _a.appendSyntheticAiCfoAnswer, exports.updateSyntheticAiCfoAnswer = _a.updateSyntheticAiCfoAnswer, exports.removeSyntheticAiCfoAnswer = _a.removeSyntheticAiCfoAnswer, exports.clearSyntheticAiCfoAnswers = _a.clearSyntheticAiCfoAnswers;
 exports.default = aiCfo.reducer;

package/lib/entity/aiCfo/aiCfoSelector.d.ts

@@ -1,13 +1,25 @@
 import { ID } from '../../commonStateTypes/common';
-import { AiCfoQuestionWithAnswer, AiCfoState, ChatSession } from './aiCfoState';
+import { AiCfoQuestionWithAnswer, AiCfoState, ChatSession, SyntheticAiCfoAnswer } from './aiCfoState';
 export declare function getAllQuestionAnswersForChatSession(state: AiCfoState, chatSessionId: ID): AiCfoQuestionWithAnswer[];
 export declare function getQuestionAnswerByIdForChatSession(state: AiCfoState, chatSessionId: ID, questionAnswerId: ID): AiCfoQuestionWithAnswer | undefined;
 export declare function getAllQuestionsForChatSession(state: AiCfoState, chatSessionId: ID): string[];
 export interface AiCfoSelectorView {
     allSessionsWithOrderedQuestionAnswers: ChatSessionWithOrderedQuestionAnswers[];
+    syntheticAnswersByChatSessionId: Record<ID, SyntheticAiCfoAnswer[]>;
 }
 export interface ChatSessionWithOrderedQuestionAnswers {
     chatSession: ChatSession;
     questionAnswers: AiCfoQuestionWithAnswer[];
 }
 export declare function getAiCfoSelectorView(state: AiCfoState): AiCfoSelectorView;
+export declare function getSyntheticAiCfoAnswersForChatSession(state: AiCfoState, chatSessionId: ID): SyntheticAiCfoAnswer[];
+/**
+ * Look up the synthetic answer bubble (if any) whose source AI CFO Q/A
+ * is `questionAnswerId`. Used by the in-place renderer to swap a Q/A's
+ * answer bubble with the "Creating…" / "Created" tile.
+ *
+ * Returns `undefined` when no synthetic bubble has been dispatched for
+ * the answer yet (i.e. the user hasn't submitted the interactive form),
+ * or when the chat session has no synthetic entries at all.
+ */
+export declare function getSyntheticAiCfoAnswerByQuestionAnswerId(state: AiCfoState, chatSessionId: ID, questionAnswerId: ID): SyntheticAiCfoAnswer | undefined;

package/lib/entity/aiCfo/aiCfoSelector.js

@@ -4,6 +4,8 @@ exports.getAllQuestionAnswersForChatSession = getAllQuestionAnswersForChatSessio
 exports.getQuestionAnswerByIdForChatSession = getQuestionAnswerByIdForChatSession;
 exports.getAllQuestionsForChatSession = getAllQuestionsForChatSession;
 exports.getAiCfoSelectorView = getAiCfoSelectorView;
+exports.getSyntheticAiCfoAnswersForChatSession = getSyntheticAiCfoAnswersForChatSession;
+exports.getSyntheticAiCfoAnswerByQuestionAnswerId = getSyntheticAiCfoAnswerByQuestionAnswerId;
 function getAllQuestionAnswersForChatSession(state, chatSessionId) {
     const arr = state.aiCfoByChatSessionId[chatSessionId]?.questionAnswers ?? [];
     return arr
@@ -38,5 +40,30 @@ function getAiCfoSelectorView(state) {
             : [],
     }))
         .sort((a, b) => b.chatSession.createdAt.valueOf() - a.chatSession.createdAt.valueOf());
-    return { allSessionsWithOrderedQuestionAnswers };
+    return {
+        allSessionsWithOrderedQuestionAnswers,
+        syntheticAnswersByChatSessionId: state.syntheticAnswersByChatSessionId ?? {},
+    };
+}
+function getSyntheticAiCfoAnswersForChatSession(state, chatSessionId) {
+    const arr = state.syntheticAnswersByChatSessionId?.[chatSessionId] ?? [];
+    return arr
+        .slice()
+        .sort((a, b) => a.createdAt.valueOf() - b.createdAt.valueOf());
+}
+/**
+ * Look up the synthetic answer bubble (if any) whose source AI CFO Q/A
+ * is `questionAnswerId`. Used by the in-place renderer to swap a Q/A's
+ * answer bubble with the "Creating…" / "Created" tile.
+ *
+ * Returns `undefined` when no synthetic bubble has been dispatched for
+ * the answer yet (i.e. the user hasn't submitted the interactive form),
+ * or when the chat session has no synthetic entries at all.
+ */
+function getSyntheticAiCfoAnswerByQuestionAnswerId(state, chatSessionId, questionAnswerId) {
+    const arr = state.syntheticAnswersByChatSessionId?.[chatSessionId];
+    if (arr == null) {
+        return undefined;
+    }
+    return arr.find((answer) => answer.sourceQuestionAnswerId === questionAnswerId);
 }