@zeniai/web-components 4.3.60 → 4.3.62-beta0ND

package/dist/components/aiCfo/components/AiCfoCombobox.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+/**
+ * A type-to-filter picker.
+ *
+ * Replaces `<input list>` + `<datalist>`: the native control cannot be styled,
+ * renders in the OS's own popup rather than the app's, and positions itself
+ * over whatever sits below the field. Everything here is app chrome.
+ *
+ * The component owns only the open/highlight state. The typed text lives with
+ * the caller, which is what lets a caller resolve it to an id (or reject it) on
+ * its own terms — a picker that also owned the value would have to know what
+ * the value meant.
+ */
+export interface AiCfoComboboxProps {
+    id: string;
+    /** Rendered as-is; already filtered options are not expected. */
+    options: string[];
+    query: string;
+    placeholder?: string;
+    onQueryChange: (query: string) => void;
+    onBlur?: () => void;
+}
+declare const AiCfoCombobox: React.FC<AiCfoComboboxProps>;
+export default AiCfoCombobox;

package/dist/components/aiCfo/components/AiCfoRoutineDetail.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { Routine, RoutineRun, SchedulableSkill } from './helpers/aiCfoRoutines';
+export interface AiCfoRoutineDetailProps {
+    historyError: boolean;
+    historyLoading: boolean;
+    /** The routine being shown. */
+    routine: Routine;
+    /** True while a Run-now is in flight for this routine. */
+    running: boolean;
+    runs: RoutineRun[];
+    /** Used to name the skill this runs, rather than showing a raw macro id. */
+    skills: SchedulableSkill[];
+    /**
+     * What this routine will run, if the host has loaded it.
+     *
+     * Not on `Routine`: the list endpoint returns schedules, and the text lives
+     * behind the skill-detail fetch. Absent simply hides the card rather than
+     * showing an empty one.
+     */
+    instructions?: string;
+    onBack: () => void;
+    onDelete: () => void;
+    onEdit: () => void;
+    onOpenRun: (run: RoutineRun) => void;
+    onRun: () => void;
+    onSetEnabled: (enabled: boolean) => void;
+}
+declare const AiCfoRoutineDetail: React.FC<AiCfoRoutineDetailProps>;
+export default AiCfoRoutineDetail;

package/dist/components/aiCfo/components/AiCfoRoutineEditor.d.ts

@@ -0,0 +1,46 @@
+import { default as React } from 'react';
+import { Routine, RoutineEditorDraft, SchedulableSkill } from './helpers/aiCfoRoutines';
+export interface AiCfoRoutineEditorProps {
+    editing: Routine | undefined;
+    saveError: boolean;
+    saving: boolean;
+    /**
+     * Skills this user can schedule. Empty hides the skill option entirely rather
+     * than offering a picker with nothing in it — a new user's only real choice
+     * is a one-off, and an empty dropdown reads as something being broken.
+     */
+    skills: SchedulableSkill[];
+    /**
+     * The routine being edited. Absent means this is a new one.
+     *
+     * The host MUST mount this with `key={editing?.scheduleId ?? "new"}`. Every
+     * field seeds from `editing` once, so without the key, opening B after
+     * cancelling A shows A's schedule and saves it onto B.
+     */
+    /**
+     * Instructions to start a NEW routine from, from the list page's composer.
+     *
+     * Also switches the source to the one-off branch: someone who described what
+     * they want has already said it is not a saved skill.
+     */
+    draftPrompt?: string;
+    /**
+     * The instructions behind the skill last requested via `onLoadSkillInstructions`.
+     *
+     * Carries its own `macroId` because this is the same detail slice the skills
+     * browser fills: without the check, opening a skill there and then opening
+     * this editor would seed the box from whatever that slice happened to hold.
+     */
+    skillInstructions?: {
+        instructions: string;
+        macroId: string;
+    };
+    skillInstructionsError?: boolean;
+    skillInstructionsLoading?: boolean;
+    onCancel: () => void;
+    onSave: (draft: RoutineEditorDraft) => void;
+    /** Absent withholds the "start from a skill" picker rather than offering one that cannot load. */
+    onLoadSkillInstructions?: (macroId: string) => void;
+}
+declare const AiCfoRoutineEditor: React.FC<AiCfoRoutineEditorProps>;
+export default AiCfoRoutineEditor;

package/dist/components/aiCfo/components/AiCfoRoutineRunsPanel.d.ts

@@ -0,0 +1,42 @@
+import { default as React } from 'react';
+import { RoutineRun } from './helpers/aiCfoRoutines';
+/**
+ * The routine's past runs, beside its conversation.
+ *
+ * A routine's runs all append to ONE thread, so scrolling is the only way to
+ * find the run you came for. This lists them, newest first, and says which are
+ * unread — the same question the rail badge raises, answered where the answers
+ * actually are.
+ */
+export interface AiCfoRoutineRunsPanelProps {
+    error: boolean;
+    /**
+     * True while the runs are being fetched OR before the fetch has begun.
+     *
+     * Both, because an empty list with nothing in flight rendered "No runs yet."
+     * on a routine that had runs — the panel answered before it had asked.
+     */
+    loading: boolean;
+    routineName: string;
+    runs: RoutineRun[];
+    /** The cadence sentence, so the panel says what this thing does unprompted. */
+    schedule: string;
+    /** The routine's timezone, so run times read as the routine's own. */
+    tzName: string | null;
+    /** Runs newer than this many are marked unread. 0 means none are. */
+    unreadCount: number;
+    /**
+     * The conversation currently on screen, so its run reads as the one being
+     * looked at. Null on the routine's own page, where no run is open.
+     */
+    openSessionId?: string | null;
+    /** The skill this runs, when it runs one. Absent for a written prompt. */
+    skillName?: string;
+    onOpenRun: (run: RoutineRun) => void;
+    /** Opens the routine's own page, where it is configured and edited. */
+    onOpenRoutine?: () => void;
+    /** Absent renders the skill as text rather than a link that goes nowhere. */
+    onOpenSkill?: () => void;
+}
+declare const AiCfoRoutineRunsPanel: React.FC<AiCfoRoutineRunsPanelProps>;
+export default AiCfoRoutineRunsPanel;

package/dist/components/aiCfo/components/AiCfoRoutinesBrowser.d.ts

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+import { Routine } from './helpers/aiCfoRoutines';
+export interface AiCfoRoutinesBrowserProps {
+    /** False withholds "New routine" — the server states the cap, not the client. */
+    canCreate: boolean;
+    listError: boolean;
+    /**
+     * The list is being fetched. Distinct from "no routines": opening the tab
+     * triggers the fetch, so without this an empty list reads as "you have none"
+     * for the whole round trip.
+     */
+    listLoading: boolean;
+    /** The server's cap, for the message when it is reached. */
+    maxRoutines: number;
+    routines: Routine[];
+    /**
+     * Open one routine.
+     *
+     * Everything a routine can DO — run, pause, edit, delete, its run history —
+     * lives on that page. The list stayed readable while it had two controls; at
+     * six it was a wall of identical text links with no hierarchy.
+     */
+    /**
+     * Required: every row renders as a button with a chevron, so a list
+     * mounted without this looks navigable and silently does nothing — and
+     * opening a routine is the only thing this list does.
+     */
+    onOpen: (routine: Routine) => void;
+    /** Absent withholds the control rather than rendering one the API refuses. */
+    onCreate?: () => void;
+    /**
+     * Start a routine from a description.
+     *
+     * Opens the editor with the text as the instructions — it does NOT infer a
+     * schedule from the sentence. The cadence is one control away and getting it
+     * wrong silently is worse than asking.
+     */
+    onDraft?: (instructions: string) => void;
+}
+declare const AiCfoRoutinesBrowser: React.FC<AiCfoRoutinesBrowserProps>;
+export default AiCfoRoutinesBrowser;

package/dist/components/aiCfo/components/AiCfoScrollArea.d.ts

@@ -1,5 +1,16 @@
 /** Shared height for the scroll area fade gradient. */
 export declare const AI_CFO_SCROLL_GRADIENT_HEIGHT: string;
+/**
+ * The conversation and whatever sits beside it.
+ *
+ * A row so a side panel takes width from the chat rather than overlaying it —
+ * an overlay would cover the answer the panel exists to help you find. Takes
+ * over the height AiCfoScrollWrapper used to claim directly, and passes it on.
+ */
+export declare const ChatWithPanel: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
 export declare const AiCfoScrollWrapper: import('@emotion/styled').StyledComponent<{
     theme?: import('@emotion/react').Theme;
     as?: React.ElementType;

package/dist/components/aiCfo/components/helpers/aiCfoRoutines.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Imported from `@zeniai/client-epic-state` once #3360 publishes. Declared here
+ * meanwhile because that import does not fail today — it degrades silently, so
+ * every guarantee below would be unchecked.
+ */
+export type RoutineRecurrence = "daily" | "weekly" | "monthly";
+export type RoutineStatus = "succeeded" | "failed" | "timeout";
+export interface Routine {
+    consecutiveFailures: number;
+    dayOfMonth: number | null;
+    enabled: boolean;
+    hour: number;
+    isAdHoc: boolean;
+    lastRunAt: string | null;
+    lastStatus: RoutineStatus | null;
+    /** '' when the skill behind this routine was deleted. */
+    macroId: string;
+    minute: number;
+    name: string;
+    nextRunAt: string | null;
+    pinnedVersion: number | null;
+    /** Null when this client does not recognise the server's cadence. */
+    recurrence: RoutineRecurrence | null;
+    scheduleId: string;
+    sessionId: string | null;
+    tzName: string | null;
+    /** Runs whose answer has not been opened. Drives the "N new" badge. */
+    unreadRuns: number;
+    weekday: number | null;
+}
+/** Mirrors `RoutineDraft`; imported from the package once #3360 publishes. */
+export interface RoutineEditorDraft {
+    hour: number;
+    minute: number;
+    name: string;
+    recurrence: RoutineRecurrence;
+    tzName: string;
+    dayOfMonth?: number;
+    macroId?: string;
+    prompt?: string;
+    weekday?: number;
+}
+/**
+ * Just the cadence fields, so the editor can describe a draft it has not saved
+ * yet. `Routine` satisfies this structurally, which keeps one implementation of
+ * the sentence behind both the list row and the editor's summary line.
+ */
+export interface RoutineSchedule {
+    dayOfMonth: number | null;
+    hour: number;
+    minute: number;
+    recurrence: RoutineRecurrence | null;
+    weekday: number | null;
+}
+/** Mirrors `RoutineRunStatus`; imported from the package once #3360 publishes. */
+export type RoutineRunStatus = "claimed" | "running" | "succeeded" | "failed" | "timeout";
+/** Mirrors `RoutineRun`; imported from the package once #3360 publishes. */
+export interface RoutineRun {
+    attempt: number;
+    /** Why it failed. The only place a failed run explains itself. */
+    error: string | null;
+    finishedAt: string | null;
+    isManual: boolean;
+    /** The message this run produced. Null opens the thread instead. */
+    questionAnswerId: string | null;
+    runId: string;
+    scheduledFor: string | null;
+    /**
+     * This run's own conversation.
+     *
+     * Each run gets one, so a follow-up about one report stays with that report.
+     * Null on runs from before that was true, and on a run that has not started
+     * — neither has a thread to open.
+     */
+    sessionId: string | null;
+    startedAt: string | null;
+    /** Null when this client does not recognise the server's status. */
+    status: RoutineRunStatus | null;
+}
+/** Whether a run is still going, and so has no outcome to report yet. */
+export declare const isRunInFlight: (run: RoutineRun) => boolean;
+/**
+ * When a run happened, in the routine's own timezone.
+ *
+ * `finishedAt` first, then `startedAt`, then the occurrence it belongs to: a
+ * run in flight has no finish, and a claimed one has no start, but every run
+ * has something honest to show.
+ */
+export declare const runTimestamp: (run: RoutineRun) => string | null;
+/** A skill the user may schedule, as the editor's picker needs it. */
+export interface SchedulableSkill {
+    macroId: string;
+    name: string;
+}
+/**
+ * Whether this client can honestly describe — and therefore edit — the schedule.
+ *
+ * One predicate feeding the label, the hint AND the Edit control, because when
+ * those disagree the user gets an editor for a routine the app just said it did
+ * not understand, and saving rewrites the schedule to whatever the form
+ * defaulted to. Range checks are part of it: a weekday of 7 or an hour of 24
+ * otherwise renders a confident, wrong sentence instead of the honest fallback.
+ */
+export declare const isDescribable: (routine: RoutineSchedule) => boolean;
+/**
+ * A routine's time of day, in its own timezone.
+ *
+ * Formatted from the stored hour/minute rather than a Date, because the
+ * routine's timezone is not the viewer's: constructing a Date would render 9am
+ * Pacific as whatever that is locally.
+ */
+export declare const formatTime: (hour: number, minute: number) => string;
+/** An hour, for a picker. */
+export declare const formatHour: (hour: number) => string;
+/** The human sentence for a routine's cadence, or an honest admission. */
+export declare const describeSchedule: (routine: RoutineSchedule) => string;
+/**
+ * A date rendered in the ROUTINE's timezone, not the viewer's.
+ *
+ * `formatIsoDateShort` converts to the browser's zone, which put "Next Sep 8"
+ * (a Tuesday) under "Every Monday at 9:00am (America/Los_Angeles)" for a viewer
+ * in Tokyo. Everything else here avoids Date for that reason; these dates have
+ * to as well, or the row contradicts itself.
+ */
+export declare const formatDateInZone: (iso: string | null, tzName: string | null) => string | null;
+/** Whether a timezone string is one the platform actually knows. */
+export declare const isValidTimezone: (tzName: string) => boolean;
+/**
+ * A timezone's current UTC offset, e.g. "GMT+5:30", for the schedule summary.
+ *
+ * Offsets shift with DST, so this is what the zone reads TODAY — enough to
+ * confirm you picked the right zone, which is all the summary claims.
+ */
+export declare const formatZoneOffset: (tzName: string) => string | null;
+/**
+ * Every timezone the platform knows, for the picker's suggestions.
+ *
+ * Empty on a browser without `Intl.supportedValuesOf` — the field stays a plain
+ * text input there, which still works because the value is validated anyway.
+ */
+export declare const timezoneOptions: () => string[];
+/**
+ * The last-run sentence, which must never claim success for a failed run.
+ *
+ * Lives here rather than in the list, because the detail page had its own copy
+ * that hardcoded the success string — so a routine the list correctly showed as
+ * failed reported "Last run 3 Sep" on the page you opened to find out why.
+ */
+export declare const describeLastRun: (routine: RoutineSchedule & {
+    lastRunAt: string | null;
+    lastStatus: RoutineStatus | null;
+    tzName: string | null;
+}) => string;
+/** Whether the routine's last run went wrong, for the status colour. */
+export declare const lastRunFailed: (routine: {
+    lastStatus: RoutineStatus | null;
+}) => boolean;
+/**
+ * The cadence in one or two words, for a rail row.
+ *
+ * `describeSchedule` gives the full sentence a page can afford; a rail row
+ * cannot. "Custom" for a cadence this client does not recognise, matching
+ * everywhere else that refuses to guess one.
+ */
+export declare const shortCadence: (routine: {
+    recurrence: RoutineRecurrence | null;
+}) => string;
+/**
+ * The prefix chat gives a routine's own conversation.
+ *
+ * Mirrors `_ROUTINE_SESSION_PREFIX` in chat's services/routine_runner.py. A
+ * routine's runs all append to one session, and that session comes back in the
+ * ordinary session list, so without this the rail listed every routine twice —
+ * once under Routines and again under Chat history.
+ */
+export declare const ROUTINE_SESSION_PREFIX = "routine_";
+export declare const isRoutineSession: (chatSessionId: string | null | undefined) => boolean;
+/** Mirrors `_SESSION_ID_SEPARATOR` in chat's services/routine_runner.py. */
+export declare const ROUTINE_SESSION_SEPARATOR = "__";
+/**
+ * The routine a run's conversation belongs to, or null.
+ *
+ * `routine_<scheduleId>__<runUuid>`. Kept here rather than in each caller so
+ * the rail and the screen cannot drift on how a session id is read — they both
+ * answer "which routine is open" and have to agree.
+ */
+export declare const routineIdFromSession: (chatSessionId: string | null | undefined) => string | null;
+/**
+ * When a run happened, to the minute.
+ *
+ * Runs need the time and scheduled dates do not: a routine can run more than
+ * once a day — pressing Run does exactly that — and two rows both reading
+ * "Sep 3, 2026" gave no way to tell which run was which. A next-run date takes
+ * `formatDateInZone` instead, because the cadence line beside it already says
+ * the time.
+ */
+export declare const formatRunTime: (iso: string | null, tzName: string | null) => string | null;

package/dist/components/aiCfo/stories/hooks/useAiCfoStreamingState.d.ts

@@ -27,6 +27,7 @@ export declare const useAiCfoStreamingState: ({ initialAiCfoView, currentChatSes
             };
             agentId?: import('@zeniai/client-epic-state').ID;
             aiCfoSidePanelHostPageKey?: string;
+            isRoutinesBrowserOpen?: boolean;
             isSkillsBrowserOpen?: boolean;
             lastContextMessage?: string;
             lastContextStatus?: import('@zeniai/client-epic-state/view/aiCfoView/aiCfoViewPayload').ContextStatus;

package/dist/components/appDrawerContent/AiCfoMenuContent.d.ts

@@ -1,14 +1,42 @@
 import { AiCfoViewSelector } from '@zeniai/client-epic-state';
 import { AiCfoMenu, InvoicingMenu, MenuListItem, Menu as MenuType, SettingsMenu } from './MenuButton';
 export declare const aiCfoMenuList: MenuListItem[];
+/** Just what the rail row needs; the full type lives with the Routines page. */
+export interface RailRoutine {
+    /** One or two words — "Daily", "Custom". Shown when nothing is unread. */
+    cadence: string;
+    name: string;
+    scheduleId: string;
+    /**
+     * The latest run's conversation, or null before the routine has run.
+     *
+     * Reported by the server rather than derived from the schedule id: runs each
+     * open their own conversation, so a derived id names one that was never
+     * created and the rail lands on an empty thread.
+     */
+    sessionId: string | null;
+    unreadRuns: number;
+}
 export interface Props {
     selectedMenu: MenuType | SettingsMenu | AiCfoMenu | InvoicingMenu;
     aiCfoView?: AiCfoViewSelector;
     isMobile?: boolean;
+    /** Listed under the Routines entry, newest first, as the server ordered them. */
+    routines?: RailRoutine[];
     /** Absent/false hides the Skills entry entirely — the server decides. */
+    /**
+     * Absent/false hides the Routines entry. Gated on the SAME server flag as
+     * Skills: a routine runs a skill, so a tenant without skills has nothing to
+     * schedule and an entry leading to a permanently empty list.
+     */
+    routinesEnabled?: boolean;
+    /** Which routine's page is open, so the rail marks it like any other row. */
+    selectedRoutineId?: string;
     skillsEnabled?: boolean;
     onClick: (_menu: MenuListItem) => void;
     onDeleteChatSession?: (chatSessionId: string) => void;
+    /** Absent hides the list rather than rendering rows that go nowhere. */
+    onRoutineSelect?: (scheduleId: string, sessionId: string | null) => void;
     updateCurrentChatSessionId?: (chatSessionId: string) => void;
 }
-export default function AiCfoMenuContent({ selectedMenu, aiCfoView, isMobile, skillsEnabled, onClick, onDeleteChatSession, updateCurrentChatSessionId, }: Readonly<Props>): import("react/jsx-runtime").JSX.Element;
+export default function AiCfoMenuContent({ selectedMenu, aiCfoView, isMobile, routinesEnabled, routines, selectedRoutineId, skillsEnabled, onClick, onRoutineSelect, onDeleteChatSession, updateCurrentChatSessionId, }: Readonly<Props>): import("react/jsx-runtime").JSX.Element;

package/dist/components/appDrawerContent/AppDrawerContent.d.ts

@@ -1,6 +1,7 @@
 import { AiCfoViewSelector, CurrentTenant, FetchStateAndError, ID, LoggedInUser, MonthEndCloseChecksView, MonthYearPeriod, RewardsPlanData, TenantBaseView } from '@zeniai/client-epic-state';
 import { DisableMode } from '../formElements/common/common';
 import { AiCfoMenu, InvoicingMenu, Menu, MenuListItem, SettingsMenu } from './MenuButton';
+import { RailRoutine } from './AiCfoMenuContent';
 export interface Props {
     aiCfoView: AiCfoViewSelector;
     currentTenantId: ID;
@@ -36,7 +37,12 @@ export interface Props {
         count: number;
         fetchStatus: FetchStateAndError;
     };
+    /** Forwarded to the AI CFO rail: the Scheduled list under Routines. */
+    routines?: RailRoutine[];
     /** Forwarded to the AI CFO rail: absent/false hides the Skills entry. */
+    /** Gates the Routines rail entry. Its OWN server flag, not the skills one. */
+    routinesEnabled?: boolean;
+    selectedRoutineId?: string;
     skillsEnabled?: boolean;
     thanksGivingAnimationEnabled?: boolean;
     handleLogOutClick: () => void;
@@ -50,7 +56,8 @@ export interface Props {
     onCalendarOpen?: (isOpen: boolean) => void;
     onDeleteChatSession?: (chatSessionId: string) => void;
     onPeriodChange?: (period: MonthYearPeriod) => void;
+    onRoutineSelect?: (scheduleId: string, sessionId: string | null) => void;
     onZeniLogoClick?: () => void;
     updateCurrentChatSessionId?: (chatSessionId: string) => void;
 }
-export default function AppDrawerContent({ currentTenantId, tenants, isVendorsTabVisible, isZeniAccountEnabled, isTreasuryEnabled, isChargeCardEnabled, rewardsConfiguration, selectedMenu, isTenantDropdownDisabled, isSettings, isInvoicing, isAiCfo, isAiCfoAccessEnabled, skillsEnabled, isNotificationsTabVisible, isSettingsFeatureEnabled, signedInUser, aiCfoView, currentTenant, christmasAnimationEnabled, expenseAutomationEnabledCompanies: _expenseAutomationEnabledCompanies, halloweenAnimationEnabled, newYearAnimationEnabled, thanksGivingAnimationEnabled, notificationCountDetails, isExpenseAutomationEnabledForUser, isTaskManagerAccessEnabled, onNotificationIconClick, handleLogOutClick, handleMenuChange, onZeniLogoClick, handleBackClick, handleCockpitClick, handleMyProfileClick, handleReferralsClick, handleTenantSelect, monthEndCloseChecksView, onCalendarOpen, onDeleteChatSession, onPeriodChange, updateCurrentChatSessionId, }: Readonly<Props>): import("react/jsx-runtime").JSX.Element;
+export default function AppDrawerContent({ currentTenantId, tenants, isVendorsTabVisible, isZeniAccountEnabled, isTreasuryEnabled, isChargeCardEnabled, rewardsConfiguration, selectedMenu, isTenantDropdownDisabled, isSettings, isInvoicing, isAiCfo, isAiCfoAccessEnabled, routinesEnabled, routines, selectedRoutineId, onRoutineSelect, skillsEnabled, isNotificationsTabVisible, isSettingsFeatureEnabled, signedInUser, aiCfoView, currentTenant, christmasAnimationEnabled, expenseAutomationEnabledCompanies: _expenseAutomationEnabledCompanies, halloweenAnimationEnabled, newYearAnimationEnabled, thanksGivingAnimationEnabled, notificationCountDetails, isExpenseAutomationEnabledForUser, isTaskManagerAccessEnabled, onNotificationIconClick, handleLogOutClick, handleMenuChange, onZeniLogoClick, handleBackClick, handleCockpitClick, handleMyProfileClick, handleReferralsClick, handleTenantSelect, monthEndCloseChecksView, onCalendarOpen, onDeleteChatSession, onPeriodChange, updateCurrentChatSessionId, }: Readonly<Props>): import("react/jsx-runtime").JSX.Element;

package/dist/components/appDrawerContent/MenuButton.d.ts

@@ -49,6 +49,7 @@ export declare const MENU_TITLE_MAP: {
     reports: string;
     rewards: string;
     settings: string;
+    routines: string;
     skills: string;
     transaction_categorization: string;
     treasury: string;
@@ -72,9 +73,9 @@ export declare const ALL_SETTINGS_MENU_OPTIONS: readonly ["accounting", "approva
 export declare const toSettingsMenuOptionType: (v: string) => "my_profile" | "accounting" | "billing" | "company_details" | "integrations" | "notifications" | "approval_rules" | "bank_connections" | "business_verification" | "my_bank_connections";
 export declare const toSettingsMenuOptionTypeStrict: (v: string) => "my_profile" | "accounting" | "billing" | "company_details" | "integrations" | "notifications" | "approval_rules" | "bank_connections" | "business_verification" | "my_bank_connections" | undefined;
 export type SettingsMenu = (typeof ALL_SETTINGS_MENU_OPTIONS)[number];
-export declare const ALL_AI_CFO_MENU_OPTIONS: readonly ["new_chat", "explore", "skills", "search_chats"];
-export declare const toAiCfoMenuOptionType: (v: string) => "skills" | "new_chat" | "explore" | "search_chats";
-export declare const toAiCfoMenuOptionTypeStrict: (v: string) => "skills" | "new_chat" | "explore" | "search_chats" | undefined;
+export declare const ALL_AI_CFO_MENU_OPTIONS: readonly ["new_chat", "explore", "skills", "routines", "search_chats"];
+export declare const toAiCfoMenuOptionType: (v: string) => "skills" | "routines" | "new_chat" | "explore" | "search_chats";
+export declare const toAiCfoMenuOptionTypeStrict: (v: string) => "skills" | "routines" | "new_chat" | "explore" | "search_chats" | undefined;
 export type AiCfoMenu = (typeof ALL_AI_CFO_MENU_OPTIONS)[number];
 export declare const ALL_INVOICING_MENU_OPTIONS: readonly ["invoicing_overview", "invoicing_analytics", "invoicing_customers", "invoicing_subscriptions", "invoicing_invoices", "invoicing_payments", "invoicing_credits", "invoicing_discounts", "invoicing_dunning", "invoicing_reports", "invoicing_catalog", "invoicing_settings", "invoicing_settings_payment_destination", "invoicing_settings_branding", "invoicing_settings_integrations", "invoicing_settings_dunning", "invoicing_settings_quickbooks", "invoicing_integrations", "invoicing_data_import", "invoicing_audit_log"];
 export declare const toInvoicingMenuOptionType: (v: string) => "invoicing_overview" | "invoicing_analytics" | "invoicing_customers" | "invoicing_subscriptions" | "invoicing_invoices" | "invoicing_payments" | "invoicing_credits" | "invoicing_discounts" | "invoicing_dunning" | "invoicing_reports" | "invoicing_catalog" | "invoicing_settings" | "invoicing_settings_payment_destination" | "invoicing_settings_branding" | "invoicing_settings_integrations" | "invoicing_settings_dunning" | "invoicing_settings_quickbooks" | "invoicing_integrations" | "invoicing_data_import" | "invoicing_audit_log";

package/dist/components/appDrawerContent/MenuList.d.ts

@@ -1,4 +1,5 @@
 import { AiCfoViewSelector, CurrentTenant, LoggedInUser, MonthEndCloseChecksView, MonthYearPeriod, RewardsPlanData } from '@zeniai/client-epic-state';
+import { RailRoutine } from './AiCfoMenuContent';
 import { AiCfoMenu, InvoicingMenu, Menu, MenuListItem, SettingsMenu } from './MenuButton';
 export declare const COMMAND_CENTER_SUBMENU_TYPES: readonly ["transaction_categorization", "je_schedules", "missing_receipts", "flux_analysis", "reconciliation"];
 export declare const INVOICING_SETTINGS_SUBMENU_TYPES: readonly ["invoicing_settings_branding", "invoicing_settings_integrations", "invoicing_settings_dunning", "invoicing_settings_quickbooks"];
@@ -31,6 +32,11 @@ interface Props {
     currentTenant?: CurrentTenant;
     isTaskManagerAccessEnabled?: boolean;
     monthEndCloseChecksView?: MonthEndCloseChecksView;
+    /** Forwarded to the AI CFO rail: the Scheduled list under Routines. */
+    routines?: RailRoutine[];
+    /** Forwarded to the AI CFO rail: absent/false hides the Routines entry. */
+    routinesEnabled?: boolean;
+    selectedRoutineId?: string;
     /** Forwarded to the AI CFO rail: absent/false hides the Skills entry. */
     skillsEnabled?: boolean;
     style?: React.CSSProperties;
@@ -39,7 +45,8 @@ interface Props {
     onCalendarOpen?: (isOpen: boolean) => void;
     onDeleteChatSession?: (chatSessionId: string) => void;
     onPeriodChange?: (period: MonthYearPeriod) => void;
+    onRoutineSelect?: (scheduleId: string, sessionId: string | null) => void;
     updateCurrentChatSessionId?: (chatSessionId: string) => void;
 }
-export default function MenuList({ selectedMenu, currentTenant, isVendorsTabVisible, isSetting, isInvoicing, isAiCfo, isAiCfoAccessEnabled, skillsEnabled, isZeniAccountEnabled, isChargeCardEnabled, isTreasuryEnabled, rewardsConfiguration, className, style, isNotificationsTabVisible, isTaskManagerAccessEnabled, isExpenseAutomationEnabledForUser, aiCfoView, additionalMessage, monthEndCloseChecksView, onCalendarOpen, onPeriodChange, onSelectionChanged, onDeleteChatSession, updateCurrentChatSessionId, onBackClick, }: Readonly<Props>): import("react/jsx-runtime").JSX.Element;
+export default function MenuList({ selectedMenu, currentTenant, isVendorsTabVisible, isSetting, isInvoicing, isAiCfo, isAiCfoAccessEnabled, routinesEnabled, routines, selectedRoutineId, onRoutineSelect, skillsEnabled, isZeniAccountEnabled, isChargeCardEnabled, isTreasuryEnabled, rewardsConfiguration, className, style, isNotificationsTabVisible, isTaskManagerAccessEnabled, isExpenseAutomationEnabledForUser, aiCfoView, additionalMessage, monthEndCloseChecksView, onCalendarOpen, onPeriodChange, onSelectionChanged, onDeleteChatSession, updateCurrentChatSessionId, onBackClick, }: Readonly<Props>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/appDrawerContent/appDrawerContent.helpers.d.ts

@@ -4,6 +4,11 @@ export declare const isBillPayTabVisible: (currentTenant: TenantView, globalInfo
 export declare const isReimbursementTabVisible: (currentTenant: TenantView, globalInfo: GlobalInfo) => boolean;
 export declare const isZeniAccountsTabVisible: (isZeniAccountEnabled: boolean, globalInfo: GlobalInfo) => boolean;
 export declare const isTreasuryTabVisible: (isTreasuryEnabled: boolean, globalInfo: GlobalInfo) => boolean;
+/**
+ * Invoicing is restricted to a company's super admins and Zeni's own internal
+ * roles — `hasAdminLevelAccess` covers exactly those two. The Statsig gate
+ * still has to be on; this narrows who sees the tab once it is.
+ */
 export declare const isInvoicingTabVisible: (isInvoicingFeatureEnabled: boolean, globalInfo: GlobalInfo) => boolean;
 export declare const isCardsTabVisible: (currentTenant: TenantView, isCardsModuleGateEnabled: boolean, globalInfo: GlobalInfo, isCardsHidden?: boolean) => boolean;
 export declare const isZeniFinopsRoles: (globalInfo: GlobalInfo | undefined) => boolean;

package/dist/components/settingsPage/Notifications/NotificationSettingsPage.d.ts

@@ -7,7 +7,7 @@ export declare const uniqueName: (formId: ID) => `${string}_form`;
 /**
  * Props
  */
-export interface TaskNotificationsSectionData {
+export interface NotificationControlsSectionData {
     isZeniUser: boolean;
     preferences: NotificationPreferences;
     registry: NotificationRegistry;
@@ -15,11 +15,18 @@ export interface TaskNotificationsSectionData {
     onSetGroupFrequency: (groupId: string, frequency: NotificationFrequency) => void;
     onToggleEventChannel: (eventId: string, channel: NotificationChannel, enabled: boolean) => void;
 }
+/**
+ * @deprecated Use `NotificationControlsSectionData`. Kept so consumers keep
+ * compiling while they migrate; the shape is identical.
+ */
+export type TaskNotificationsSectionData = NotificationControlsSectionData;
 export interface NotificationSettingsPageProps {
     notificationSettingsView: NotificationSettingsSelectorView;
     signedInUser: LoggedInUser;
+    commentingNotifications?: NotificationControlsSectionData;
+    isCommentingNotificationsDirty?: boolean;
     isTaskNotificationsDirty?: boolean;
-    taskNotifications?: TaskNotificationsSectionData;
+    taskNotifications?: NotificationControlsSectionData;
     onCancel: () => void;
     onClickMenuIcon: () => void;
     onFormDataChange: (formData: NotificationSettingsLocalData) => void;

package/dist/components/settingsPage/Notifications/{taskNotifications/TaskNotificationsSection.d.ts → notificationControls/NotificationControlsSection.d.ts}

@@ -1,10 +1,12 @@
 import { NotificationChannel, NotificationFrequency, NotificationPreferences, NotificationRegistry } from '@zeniai/client-epic-state';
-export interface TaskNotificationsSectionProps {
+export interface NotificationControlsSectionProps {
+    formPrefix: string;
     isZeniUser: boolean;
     preferences: NotificationPreferences;
     registry: NotificationRegistry;
+    title: string;
     onSetGroupChannelMaster: (groupId: string, channel: NotificationChannel, enabled: boolean) => void;
     onSetGroupFrequency: (groupId: string, frequency: NotificationFrequency) => void;
     onToggleEventChannel: (eventId: string, channel: NotificationChannel, enabled: boolean) => void;
 }
-export declare const TaskNotificationsSection: ({ isZeniUser, registry, preferences, onToggleEventChannel, onSetGroupChannelMaster, onSetGroupFrequency, }: TaskNotificationsSectionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const NotificationControlsSection: ({ title, formPrefix, isZeniUser, registry, preferences, onToggleEventChannel, onSetGroupChannelMaster, onSetGroupFrequency, }: NotificationControlsSectionProps) => import("react/jsx-runtime").JSX.Element;