Release Notes: Quote editor redesign, Global Command Palette, and Verdant UI · August 26, 2026

New Features

• Quote Screen Redesign: The quote editor has been completely overhauled. Tabs (Lines, Info, Documents) have been moved to the top header alongside a new inline search bar, quote switcher, and a consolidated Actions menu.
• Collapsible Quote Sidebar: Quote sections are now managed in a collapsible left sidebar, allowing you to maximize screen space for the main pricing table while maintaining quick access to structural reordering.
• Hierarchical Quote Numbering: Quote sections and line items now automatically generate and display hierarchical numbering (e.g., 1.1, 1.2) for easier reference in discussions and proposals.
• Nested Quote Sections: Quote sections can now be nested deeply as sub-sections, and include inline buttons to quickly add new items or sub-groups directly at the bottom of their lists.
• Toggleable Totals Footer: You can now hide or show the sticky totals footer at the bottom of the quote screen via the Actions menu.
• Compact Record Headers: Parent-child views (like navigating into a specific quote from an engagement) now feature a streamlined, compact header that preserves vertical screen real estate.
• Dynamic Template Schemas: The document templating data schema engine now dynamically queries all custom properties across your organization’s entire collection list, eliminating legacy restrictions and allowing any collection to utilize custom data in document merges.
• Template Data Tables: Document, Engagement, and Quote Templates screens have been upgraded from legacy card lists to the new data tables with sortable columns and robust empty states.
• Enhanced Field Configuration: Engagement template fields now support stricter configurations, including multi-line text areas, whole number constraints for sliders, and explicit single/multi-select modes for Chip, Tag, and Object fields.
• Automated Table Security: Data tables across the platform now automatically enforce organization-level data filtering natively within the table component, enhancing security and reducing query complexity.
• Intelligent Sub-Agent Graph Matching: The interactive AI workflow graph now features hierarchical alias matching, accurately mapping deep sub-agent events to their parent pipeline steps during real-time streaming.
• Strict Template Field Validations: The backend now enforces strict data type validations and default value sanitation for all 10 engagement template field types (including bounds checks for sliders and boolean casting).
• Robust QA Critique Parsing: The AI QA Evaluator loop can now securely parse structured markdown pass/fail results in addition to standard JSON critiques, improving generation reliability when agents output markdown blocks.
• Safe ADK State Extraction: Added centralized utility functions (extract_state_dict and set_state_value) to safely read and write merged context dictionaries across ADK State, ToolContext, InvocationContext, and Session objects.
• Settings Sidebar: The Settings module now features a dedicated sub-navigation sidebar, replacing the legacy tabbed interface. This provides clean access to all organization configurations and includes a persistent “Back to app” button to exit.
• Advanced AI Graph Visualizations: The backend agent graph extraction API now supports polymorphic extraction for complex step wrappers, composite orchestrators, and QA Evaluator-Refiner loops. This allows the frontend interactive graph to visualize intricate multi-agent pipelines with exact transition routing.
• Parent-Child Screen Layouts: Parent-child views can now dynamically toggle tab bar and header visibility to support streamlined full-page modules like the new settings architecture.
• Global Command Palette: Rebuilt the top search bar into a powerful command palette. Press Cmd+K (Mac) or Ctrl+K (Windows) from anywhere to instantly search across all engagements, clients, documents, and notes. The palette supports full keyboard navigation and provides quick visual icons for different record types.
• Global Create Menu: The primary ‘Create Engagement’ button has been replaced with a dynamic, context-aware dropdown menu. It always allows you to create a new engagement but intelligently suggests creating quotes, resources, or notes depending on what page you are currently viewing.
• HTML QA Evaluator-Refiner Loop: The Document Templating AI now features a robust Evaluator-Refiner loop for HTML generation. It identifies rejected sections from QA feedback and iteratively regenerates only the failed parts.
• QA Circuit Breaker: To prevent infinite generation loops, the HTML QA pipeline now enforces a strict 3-attempt circuit breaker. If a template fails QA three times, the system safely bypasses finalization to preserve the draft for manual review.
• Verdant Design System: Applied the new Verdant Design System across the application. Data tables, status chips, form inputs, and popovers now feature refined spacing, borders, dynamic typography, and modern visual hierarchy.
• Inline Filter Menus: Data tables now feature redesigned, inline popover filter menus. You can search for specific fields and values within the filter dialog itself, and status indicator dots make visual scanning much faster.
• Organization Switcher: Switching between workspaces is now managed via a dedicated Organization Switcher built directly into the left sidebar, replacing the legacy profile menu routing.
• Profile Menu Redesign: The top navigation profile menu has been streamlined, offering clear actions for updating your profile name, accessing help and support resources, and signing out.
• Word to PDF Conversion: Document templates now natively convert uploaded Word reference documents to PDF internally during AI generation using Gotenberg with PyMuPDF fallbacks.
• AI Turn Detection & Auto-Supervisor: The core ADK agent workflow engine now provides native turn detection, automatically routing follow-up user feedback to an Auto-Supervisor planning step before executing the pipeline.
• Auto-Summary Terminal Step: The core AI agent workflow engine now automatically provides a terminal summary agent that consolidates database modifications into a structured Markdown report.
• Document Image Caching: The document templating AI now lazily generates and caches image samples from source documents, improving performance during multimodal analysis.
• AI Data Spec Feedback: The interactive AI supervisor now supports an explicit update_data_spec action, allowing you to ask the AI to change the base entity, data traversal, or data sources via conversational feedback.
• Spreadsheet List Properties: Data Dictionaries now support a List property type. You can define configurable sub-columns (Text, Number, Date, Boolean) to create repeatable rows of data.
• Inline Grid Editor: List properties render as an interactive, Excel-like spreadsheet grid directly on object forms. Users can add, duplicate, and delete rows, and edit cells inline with full keyboard support.
• Column Reordering: Administrators can drag and drop to reorder sub-columns when configuring a List property in the Data Dictionary.
• Universal Document Generation: The Generate Document button now appears dynamically on any record (like Project Plans, Accounts, or Contacts) when a matching template is configured, automatically hiding itself if no templates exist.
• Project Plan Exports: You can now generate PDF summaries directly from the Project Plan header controls.
• Visual Data Spec Builder: A new visual editor for configuring template Data Specs. It supports visual creation of base entities and data sources (Document, Reference, Subcollection, Alias) with built-in standard presets, alongside a raw JSON mode with real-time validation.
• Arbitrary Document Targets: Document generation is no longer hardcoded to engagements and quotes. You can now configure Data Specs to generate documents directly from Project Plans, Accounts, Contacts, or any other target collection.
• Data Spec Desktop Editor: The document template screen now features a segmented button on desktop and dedicated tabs on mobile to quickly switch between the HTML code editor, the visual Data Spec editor, and the HTML preview.
• Intelligent Schema Orchestration: A new Schema Orchestrator agent automatically analyzes document text and divides the generation workload across four specialized sub-agents: Custom Data, Quote Templates, Snippets, and Data Specs.
• Automated Data Spec Generation: A new Data Spec QA agent automatically structures template data sources, mapping root base entities and defining complex traversal paths (like cross-referencing project plans or accounts).
• Project Plan HTML Generation: The Document Templating AI is now explicitly trained to generate clean, semantic HTML tables for project plan items, milestones, and deliverables automatically when iterating over lists.
• HTML Editor UI: Removed the floating AI overlay from the document template HTML editor, streamlining the interface to favor the unified global AI generation dialog.
• Multi-Turn Supervisor Routing: The AI pipeline now explicitly intercepts follow-up user feedback and routes it through the Supervisor Agent to record intent before executing pipeline nodes.
• Target Object Documents: Document and Document Template schemas now support arbitrary target collections and target objects via dynamic data specifications, removing the hardcoded reliance on engagements and quotes.
• Unified AI Generation: Consolidated AI generation logic into a unified, reusable button and dialog system across Quote Templates, Engagement Templates, Data Dictionaries, Snippets, and Document Templates.
• Dynamic Workflow Graphs: The AI generation progress dialog now fetches agent workflow graph layouts dynamically via the backend, with intelligent fallbacks for specific template apps.
• Snippet AI Generation: You can now automatically generate or refine snippet content using a dedicated AI generation button directly on the snippet’s workspace.
• Snippet Custom Properties: You can now add and manage dynamic custom properties inline directly on snippet forms, instantly updating the underlying Data Dictionary.
• Snippet Deletion Protections: Deleting a snippet now prompts with a safety confirmation dialog to prevent accidental data loss.
• Agent Graph Visualization API: Added a new backend endpoint to export agent graph JSON (nodes and edges), supporting polymorphic visualization of ADK Workflows and multi-agent patterns.
• Strict Schema Safeguards: AI agents and manual configurations now strictly prevent the creation of custom data dictionary fields that duplicate out-of-the-box system fields. The system automatically rejects custom fields that replicate a parent object’s context (like adding an account to a quote) or duplicate data managed by a subcollection.
• Dart Schema Syncing: System schemas are now automatically extracted and synced directly from frontend data models, providing backend agents with complete visibility into built-in fields and entity relationships.
• Data Dictionary Merging: Added support for an overwrite flag in custom data dictionary payloads to safely merge new fields with existing ones instead of replacing them completely.
• Template Example Documents: You can now upload example reference files (PDF, DOC, DOCX, XLSX) directly to Engagement and Quote Templates. The AI generator uses these files to build accurate fields and pricing structures.
• Unified AI Template Generation: AI template generation now features a centralized UI across both engagement and quote templates. The new experience includes a persistent progress dialog, real-time status updates, and explicit cancellation support.
• Strict Data Dictionary Validation: The AI agents responsible for data dictionaries now strictly reject reserved system keys (like ref, org, and owner) and enforce explicit id and isRequired attributes during schema generation.
• Strict AI Subgroup Rules: The AI quote generator now enforces a rule preventing top-level sections from containing only a single subgroup, ensuring clean pricing structures.
• AI Quote Sections & Subgroups: The AI quote generator now automatically organizes line items into logical top-level sections. Additionally, it identifies items sharing a common prefix and intelligently groups them into nested subgroups.
• Line Item Classifications: Quote line items now enforce a strict classification type of either ‘Resource’ or ‘Material’ to simplify and standardize financial reporting.
• Nested Quote Sections: Quote templates and sections now support nested sub-sections via a parentId field, allowing for complex hierarchical pricing structures.
• Linear MCP Integration: Added a local Model Context Protocol (MCP) server package that enables AI agents to natively manage, search, and update issues across the Linear API.
• Advanced Quote Formulas: The quote template formula engine now supports additional math functions including round(), abs(), divmod(), and pow() for more complex pricing calculations.
• AI Sub-Agent Orchestration: The AI quote template agent now seamlessly delegates engagement template generation tasks to a specialized sub-agent workflow, improving generation accuracy and execution isolation.
• Repeatable List Fields: Engagement Templates now support list field types, allowing you to build forms with repeatable groups of nested child fields.
• Template Organization: Engagement Templates now support optional organization tags and external reference IDs to improve searchability and integration mapping.
• AI Context Parsing: Enhanced the internal AI context extraction utility to reliably parse complex nested state and metadata dictionaries during template generation.
• Local Agent Runner CLI: Added a run_agent_local.py script to run ADK agents locally against live Cloud Firestore using a simulated frontend request context. Use the --project parameter to explicitly target specific Google Cloud environments. This script now natively supports Windows environments (cmd.exe) with UTF-8 stdout encoding and dynamic gcloud token generation.
• AI Diagnostics CLI: Added get_transcript.py and get_raw_transcript.py scripts to fetch and debug AI agent session event streams directly from Vertex AI. The get_transcript.py script now securely fetches gcloud credentials, searches across multiple matching agent engines, and saves outputs to a local text file.
• Exact Document Section Extraction: The AI document templating Architect agent now strictly extracts exact section titles and sequences directly from the source document, preventing hallucinated generic sections.
• Automated Jinja Schema Fixes: The document templating pipeline now automatically converts dot notation to bracket access and flattens nested eager-crashing defaults (e.g., default(org['name'] | default(''))) to prevent rendering errors.
• Singular and Plural Data Aliases: Document merge payloads now support both singular and plural entity aliases (e.g., engagement and engagements, quote and quotes), making template variables more flexible.
• Strict Jinja Tag QA: The Document Templating QA process now rigorously evaluates every individual Jinja tag against a strict undefined environment to catch nested evaluation errors during rendering tests.
• List Property Table Generation: The Document Templating AI is now explicitly trained to generate semantic HTML tables with Jinja loops when iterating over custom List properties (like invoices or planned travel), rather than hardcoding static rows.
• Subcollection Dictionary Maps: Document merge payloads now provide subcollections as dictionary maps keyed by ID or name, requiring .values() iteration in Jinja2 templates.
• Template-Level Filtering: Subcollection data sources are now fetched in bulk without server-side where or order_by filters to avoid composite index overhead. All filtering and sorting must be performed directly in Jinja2 templates.
• Template Subcollection Safeguards: The Document Templating QA agents now strictly reject template logic that attempts to access non-existent nested item arrays on parent documents (like project_plan['items']) or directly sort dictionary maps.
• Universal Notes & Descendant Rollups: Notes are now a top-level entity and can be attached to any record in the system (Engagements, Accounts, Quotes, Project Plans). The Notes screen features a new “Include descendants” toggle that rolls up all notes from a record and its nested children into a single unified timeline.
• Root Note Data Architecture & Linking: Notes have been fully migrated from strict entity subcollections to a flattened, top-level root collection in Firestore. This allows notes to be linked to arbitrary target objects across the system, supporting high-performance cross-entity querying and descendant rollups.
• Semantic Note Search API: Added a new backend callable function (searchNotes) to perform semantic vector searches across note content and file summaries, utilizing Gemini embeddings and Firestore Vector Search. This API can filter results by specific target objects or roll up matches across all nested descendants.
• Files Empty State: The Files screen now features an intuitive empty state with a direct “Upload File” button to help you get started faster.
• Contextual Global Create Menu: The top-level ‘Create’ menu now deeply integrates with your active route and Settings tabs. It intelligently suggests actions like “Invite User”, “New Role”, or “New Price Rule” based on the exact screen you are viewing.
• AI File Extraction: Uploaded files (FileObject) now automatically extract full plain text content, generate AI summaries, and produce vector embeddings. This allows file contents to be searched and referenced by the institutional memory engine.
• Direct File Uploads: You can now upload, tag, and describe files directly from the Global Create Menu when viewing document or file contexts.
• Inline User Invites: Administrators can now invite new users via a streamlined dialog directly from the Global Create Menu without leaving their current workspace.
• Standalone Data Specifications: Data Specs are now fully independent, reusable entities managed in their own dedicated workspaces under Settings. They feature unique names, tags, and can be shared across multiple document templates with intelligent deduplication.
• Local Agent Runner Updates: The Management CLI script run_agent_local.py now enforces four strict mandatory parameters (Agent, Org ID, Record ID, and Prompt). It features real-time task log monitoring, automated root cause analysis support, and verifies post-run Firestore writes.
• Project Plan Custom Properties: Project Plans now fully support dynamic custom properties. You can add and manage custom data fields directly on the project plan form, seamlessly integrating with your Data Dictionaries.
• Visual Progress Bars: Added visual progress bars to the Project Plan detail form to instantly display the overall percentage of completion.
• Exact Tabular AI Extraction: AI generation of custom tabular list properties (like planned travel or invoice status) now strictly extracts and perfectly matches the exact column names and headers directly from your example document tables.
• Snippet Deduplication: Expanded snippet management to aggressively search and strictly deduplicate AI-generated snippets against your organization’s existing definitions based on semantic and token overlap.
• Fast PDF Rendering: Upgraded the internal Word-to-PDF converter to use high-speed in-memory PyMuPDF rendering with automatic Gotenberg fallbacks.
• Document Status Summaries: The Document Templating AI now recognizes and generates structured status summary callout cards, grids, and status badges when they appear in source documents.
• Visual Layout Feedback: The AI Supervisor now accurately routes conversational feedback regarding visual alignment, colors, and layout matching directly to HTML generation, preventing unintended data spec changes.
• Quote Item Reordering: Dragging and dropping quote line items across different sections now correctly preserves their isOptional status and custom tags.
• Jinja Loop Validation: The document templating pipeline now automatically identifies loop iteration variables (like {% for item in list %}) and strips erroneous ['customData'] accesses to prevent rendering crashes.
• Quote Numbering Hierarchy: Quote item numbering now intelligently sequences after nested subgroups. If a section contains subsections, the direct line items will pick up the numbering sequence where the subsections leave off. Canonical numbering is also preserved during filtered searches.
• Document AI Source Grounding: AI Developer agents are now strictly grounded in the exact source text of the specific section they are building. They are explicitly prohibited from hallucinating dashboard metrics, KPIs, or arbitrary widgets that do not appear in the source document.
• Visual QA User Feedback: The Document Templating multimodal Visual QA agent now actively evaluates user feedback. It verifies that the generated HTML specifically fulfills your requested layout and formatting instructions compared to the reference image, triggering a rejection if the layout still deviates.
• Quote Multi Group Wizard: A new full-screen bulk editor allows you to configure catalog items across multiple quote sections using tag groups, featuring a real-time combinatorial preview.
• QA Circuit Breaker: To prevent infinite generation loops, the HTML QA pipeline now enforces a strict 10-attempt circuit breaker. If a template fails QA ten times, the system safely bypasses finalization and commits the generated HTML as a draft with a QA warning for manual review.
• Standalone Data Spec Workspaces: Data specifications have been fully extracted from document templates into their own dedicated workspaces in Settings.
• Empty State Guidance: Added clear instructions and call-to-actions to empty lists, tables, and unpopulated screens across the platform to guide users on required next steps.
• Local Agent Runner CLI Updates: Added real-time AI tool call streaming, QA verdict printing, and automated verification of post-run Firestore writes (HTML, DataSpec, QA status) to the run_agent_local.py script.
• Surgical HTML Micro-Editing: The Document Templating AI now uses targeted search-and-replace patching instead of rewriting entire sections, preserving layout and scoped CSS.
• Tabular Data Extraction: AI now automatically extracts exact column names, headers, and data types directly from example document tables when generating List properties.
• Table Fidelity QA: The multimodal Visual QA agent strictly enforces table structure fidelity, rejecting generations that hallucinate different columns or miss status badge styling.
• Intelligent Snippet Reuse: The AI snippet generator now actively searches your organization for existing snippets and reuses them if a match is found, eliminating duplicates.
• OpenXML Style Extraction: Document template styling now extracts native OpenXML metadata (font colors, table shading) directly from Word documents for matched global CSS.

Fixes & Improvements

• Item Optional State: Redesigned the optional badge for quote line items to display as a clean chip instead of just an icon, and it now only reveals itself on hover if the item is not currently optional, reducing visual clutter.
• Delete Confirmations: Added explicit safety confirmation dialogs before deleting quote items or sections to prevent accidental loss of complex pricing data.
• Form Styling: Replaced standard dropdowns with cleaner popup menus for selecting line item types and improved the styling and layout of quote inline inputs.
• Editor Programmatic Sync: Enhanced the document template HTML editor with strict programmatic sync flags, ensuring automated template updates do not trigger conflicting manual save events.
• Dynamic Data Dictionaries: The document template data schema engine now dynamically queries all custom properties across your organization’s entire collection list, eliminating legacy restrictions and allowing any collection to utilize custom data in document merges.
• Backend Initialization: Upgraded Firebase and Firestore client initialization logic across backend functions to reliably handle default app instances and Google Cloud project fallbacks.
• Diagnostic Logging: Integrated comprehensive structured developer logging across core frontend form builders, data spec editors, and backend document templating utilities to streamline system troubleshooting.
• AI State Context: Fixed an issue in the Document Templating HTML workflow where concurrent section generation could encounter state collisions by safely isolating sub-agent context dictionaries.
• Diagnostics Logging: Migrated standard print statements to structured developer logs across core Firestore object and form components for improved client-side debugging.
• AI Initialization Errors: Added an explicit error dialog to display diagnostic information if the AI generation pipeline fails to initialize before the workflow stream begins.
• Code Quality: Removed redundant test scripts and cleaned up unused dependencies across the quote generation and catalog backend functions.
• AI Graph Architecture: Upgraded the internal frontend workflow graph visualization to use strictly typed node, edge, and connection architectures, extracting parsing logic for improved testing and maintainability.
• Polymorphic Graph Extraction: Enhanced the backend agent graph extraction API to seamlessly parse nodes and edges from function steps, StepWrapperNode pipelines, and composite evaluator-refiner loops.
• Relaxed Pydantic Validation: All Data Spec configuration schemas now use extra="ignore" to gracefully ignore hallucinated extra properties during AI generation instead of throwing validation errors.
• Editor Sync Guards: Implemented strict anti-race condition guards (handshake principle) on the HTML code and Data Spec editors to prevent incoming stale server saves from overwriting your local edits.
• AI Dialog State Sync: The system now explicitly cancels active debounce saves when opening AI generation dialogs to prevent conflicting state updates.
• Code Quality: Cleaned up and removed redundant, auto-generated docstrings across multiple backend Cloud Functions.
• AI Diagnostics Tooling: Added a suite of new internal developer Python scripts (analyze_session.py, fetch_direct_session.py, inspect_invocation_deep.py) for deeply diagnosing Vertex AI Reasoning Engine event streams and session state.
• Module Renaming: Relocated the internal generate_graph.py script from functions to scripts for better repository organization.
• AI State Pre-fetching: The schema orchestrator agent now prioritizes active user prompts on follow-up turns over stale initial requests to ensure accurate context propagation.
• Supervisor Decision Extraction: The AI supervisor agent can now reliably extract decision outputs from arbitrary JSON payloads, custom metadata, and nested ADK event parts.
• PDF Page Extraction Fallbacks: Section page index extraction now intelligently maps general terms like “complete document” or “cover” to the first page if a direct match isn’t found.
• Word Document Parsing Fallback: Added a robust native XML fallback parser to reliably extract text and tables from Word documents if standard libraries encounter errors.
• Binary File Handling: The file extraction utility now correctly detects binary files (like PDFs or ZIPs) and returns a clean warning instead of attempting to parse unreadable text.
• Document Text Hydration: The document templating pipeline now guarantees deterministic loading of document text from the template’s example file link if the session context text is missing or binary.
• Frontend Sync Guards: Implemented strict anti-race condition guards (handshake principle) on the data spec editors to prevent incoming stale server saves from overwriting your local edits.
• Data Dictionary System Sync: The actual sync_all_custom_fields backend utility now dynamically builds its target list from the system schema registry rather than relying on hardcoded collections, ensuring full organizational coverage.
• Frontend Automated Checks: Added GitHub Actions workflows for automated code analysis and testing on the frontend repository. Upgraded the CI/CD pipeline to use standard Flutter actions for improved build caching and reliability.
• AI Assistant Controls: The interactive ‘Ask Gemini’ feedback box now includes a dedicated clear button to quickly reset your text input and dismiss the overlay.
• Strict Schema Fallbacks: Document templating AI Developer agents are explicitly instructed to use safe Jinja defaults or existence checks for unregistered properties, preventing generation crashes.
• AI Snippet Mapping Rules: The AI document templating workflow now strictly maps any HTML content and long text to AI snippets. It enforces full content coverage by mapping every major section without summarizing or omitting content. Short static wording (like header labels) is explicitly not mapped to snippets.
• Task Progress Tracking: Added a new % Done column to the project plan grid. Entering a value from 1 to 100 automatically drives task lifecycle statuses.
• AI Models: Upgraded the backend AI agents across the platform to Gemini 3.6 Flash to optimize reasoning, schema mapping, and asset extraction stability.
• AI Schema Extraction: Added standardized Dart doc comments across all data models to enable AI schema extraction and advanced AST parsing for intelligent workflows.
• Dynamic Template Data Specs: Document templates now support dynamic data_spec definitions. The backend uses these specs to dynamically map data sources (like quotes or custom objects) for document generation and stores them directly on the template document.
• Snippet Fallback Auto-Stripping: The document templating pipeline now automatically detects and strips complex Jinja {% if snippets[...] %} fallback chains, simplifying them to single clean tags (e.g., {{ snippets['Name'] }}).
• Template Schema Matching: When retrieving Jinja tags for a template, the backend now cross-references firestore_system_schemas.json to provide schema matching and field descriptions for built-in fields.
• AI QA Pre-checks: The HTML QA workflow now performs local, deterministic pre-evaluations (Jinja syntax, data spec schema validation, and mock rendering) before engaging the LLM, significantly accelerating the QA cycle.
• Resilient AI Authentication: Upgraded backend Google Auth transport requests with a resilient HTTP adapter, adding automatic retries with exponential backoff to prevent transient network errors from crashing AI agents.
• Document Hydration: Improved backend document merging logic to properly format and serialize subcollection data for JSON injection when a specific value field is not provided.
• System Schema Resolution: The schema lookup utility now intelligently resolves singular, plural, and class-name variations, improving AI schema extraction reliability.
• Backend Architecture: Cleaned up legacy metadata extraction agents, centralizing their logic into the new, robust schema orchestration pipeline.
• Agent Deployments: CI/CD deployment pipelines now automatically copy all sibling agent packages into the deployment container, ensuring sub-agent imports resolve correctly during runtime.
• Document Template Editor: Removed the inline floating AI assistant (“Ask Gemini”) from the raw HTML code editor.
• Agent Engine Deployments: CI/CD pipelines now automatically copy sibling agent packages into the deployment container, ensuring sub-agent imports function properly during runtime.
• Backend Architecture: Standardized Python module resolution paths across all document templating AI agents by explicitly injecting project and function root directories into the system path, preventing execution failures across local and deployed environments.
• CI/CD Reliability: Upgraded Firebase deployment GitHub Actions to use Node 20 and npx to prevent global dependency conflicts.
• Backend Issue Routing: Renamed internal backend issue lead agents to standardize linear integration pathways.
• Template Details Layout: Added a toggle to expand or collapse template details (like example document links) on quote and engagement templates to maximize screen space.
• AI Quote Subgroups: The AI quote template generator now strictly prevents creating a top-level section with only a single subgroup, automatically dissolving it to keep the pricing structure clean.
• Pydantic Schema Validation: Fixed a bug where Pydantic treated required list fields as optional, preventing empty fields from bypassing schema generation. Corrected QA pattern edge routing to prevent ASGI StopIteration crashes.
• Quote Template Persistence: Improved backend synchronization when saving quote templates to automatically detect and clear out stale section and line item subcollections, preventing orphaned data records.
• Quote Template AI: Fixed an issue where the AI generator could lose the original quote template ID during modifications, ensuring updates correctly overwrite the existing template instead of creating duplicates.
• Template Serialization: Upgraded backend template saving utilities to use exclude_unset serialization, robustly handling complex nested dictionary payloads and preventing undefined data structures from corrupting database writes.
• Engagement Template Ownership: Fixed an issue where updating an engagement template could unintentionally overwrite its original organization and owner assignments.
• AI Agent Stability: Fixed a parameter resolution issue in the QA agent pattern by explicitly passing keyword arguments for GenAI content parts, and added a safe dictionary payload fallback to prevent stream crashes.
• AI QA Loop Execution: The Evaluator agent now programmatically triggers loop escalation upon successful validation, bypassing unnecessary LLM iterations to advance directly to the commit step for faster generation.
• AI QA Output Parsing: Upgraded the QA agent pattern with robust markdown fence stripping and backward event scanning to reliably extract and persist generated drafts.
• AI QA Output Parsing: The Evaluator agent now parses QACritique JSON outputs directly from the callback context (including model_response_event and llm_response), improving the reliability of programmatic loop escalation during document generation.
• Backend Architecture: The automated OKF (Organizational Knowledge File) generator script now extracts full multi-line docstrings for Python functions and natively indexes 45 frontend Dart data models to generate structured codebase specifications for internal AI agents.
• AI QA Tool Execution: Replaced LLM-driven commit steps with a deterministic database execution node, guaranteeing verified payloads are reliably saved without relying on AI tool calling.
• AI QA Loop Refinement: The internal AI QA loop now propagates a detailed diagnostic payload to the refiner agent, improving its ability to surgically correct identified generation issues.
• AI Agent Summaries: AI generation summaries now correctly extract domain drafts instead of QA evaluation metadata, ensuring accurate post-generation overviews.
• Engagement Template AI: Fixed an issue where the AI generator could lose the original template ID during generation, ensuring updates correctly overwrite the existing configuration instead of creating orphaned templates.
• Engagement Template AI Adherence: The Engagement Template AI generator now explicitly injects user instructions directly into its base prompt context, ensuring generated templates more strictly adhere to user requests.
• Engagement Template AI Reliability: The generator now gracefully sanitizes null values returned by LLMs for template field properties (like options and tags), preventing parsing crashes.
• AI Template State Recovery: Enhanced the Engagement and Quote Template generation agents to reliably recover missing fields or items from context state if the primary payload is incomplete or missing.
• AI Streaming Connections: The backend streaming engine now correctly identifies clean reasoning engine completions, preventing false connection interruption errors and improving stability.
• Engagement Template Data: The backend now automatically normalizes list-based field options into structured dictionary maps before saving to Firestore, preventing schema structure inconsistencies.
• AI Prompt Adherence: QA and Refiner agents now explicitly cross-reference the original user request against the current draft, ensuring modifications accurately follow your instructions without drifting.
• AI Workflow Termination: All AI workflows, including Document Templating and general QA agent patterns, now use explicit end nodes to cleanly terminate sub-workflows and prevent hanging execution states.
• AI Data Serialization: Enhanced backend data formatting to safely parse complex date types and gracefully handle database document references across environments, preventing JSON serialization errors in AI prompts.
• Core Backend Architecture: Decoupled the central servantium_core library from Firebase-specific runtime dependencies, enabling flexible execution across local and agent environments.
• AI Agent Resolution: Enhanced Engagement and Quote template AI agents to support dynamic ID resolution across multiple casing conventions (e.g., templateId, id, quote_template_id), improving payload parsing reliability.
• AI State Persistence: The AI QA loop now explicitly persists the latest draft states from Generator and Refiner agents, ensuring reliable fallbacks if validation fails.
• AI Schema Types: The Engagement Template AI is now strictly instructed to use exact case-sensitive field types (Text, Chip, Tag, Object, Slider, Formula, Boolean) to prevent hallucinated types.
• AI Session Polling: Enhanced backend session fetching to safely handle iteration exceptions, preventing stream crashes when interacting with existing Vertex AI reasoning engines.
• AI Schema Routing: Fixed an internal state routing typo that could prevent the AI supervisor from successfully applying updates to Data Dictionaries.
• Backend Architecture: Modularized the all_collections, capacities, and resource_plan background triggers into a dedicated directory structures to improve maintainability and cleaner trigger management.
• Project Plan State: Replaced the future-based loading mechanism for project plan items with a real time data stream, resolving manual refresh requirements and ensuring local patch synchronization.
• Jinja Syntax Verification: Enhanced Jinja tag resolution to accurately surface evaluation errors to users and gracefully handle JSON serialization of complex data types.
• Data Serialization: The backend now automatically converts Pydantic models to standard Python dictionaries when saving template fields and quote items, preventing schema serialization errors.
• AI Template QA Tests: Fixed an issue where the document templating QA agent omitted quote data during rendering tests, ensuring templates with quote specific merge fields are validated accurately.
• Missing Snippet Fallbacks: If the AI cannot find a matching snippet in the schema, it now generates the semantic HTML narrative text directly in the template and actively strips out hallucinated snippet tags.
• Backend Architecture: Refactored shared AI template generation utilities and Firestore commit helpers into a centralized servantium_core.template_utils module for improved maintainability.
• Automated Checks: Added GitHub Actions workflows for automated code analysis and testing on the frontend repository.
• Agent Version Resolution: The backend AI streaming engine now automatically connects to the most recently deployed Vertex AI Agent Engine if multiple instances exist, preventing stale version conflicts.
• AI Agent Stability: Enhanced backend AI session management with robust retry backoff and StopIteration handling to prevent streaming crashes during heavy loads or missing sessions.
• Backend Observability: Added comprehensive internal logging and traceback capture to document and engagement template utilities to improve error diagnosis.
• Dependency Management: Pinned pycairo version to resolve backend environment compatibility issues.
• AI Workflow Resumption: AI workflow end nodes now return a completed status on empty inputs and support rerunning on resume to ensure reliable termination states.
• AI Agent Architecture: The internal QA agent pattern now properly awaits asynchronous evaluator executions, improving workflow stability.
• Deployment Scripts: The database migration script runner now explicitly ignores hidden directories and Python cache folders to prevent execution errors.
• AI QA Workflow Resumption: The AI QA evaluator nodes now explicitly support rerunning on resume, ensuring multi-agent QA loops recover gracefully from execution interruptions.
• AI Workflow Routing: Fixed an internal state routing issue in the QA agent workflow pattern to ensure reliable termination.
• Backend Schema Validation: Updated data models for Engagement Templates, Quote Templates, and Data Dictionaries to strictly require field definitions, improving data integrity.
• Engagement Template Storage: The backend now automatically strips unused default configuration keys from template fields to optimize database storage and safely preserves existing metadata during updates.
• AI Agent Orchestration: Improved backend AI workflow routing to reliably handle internal event construction and empty fallback states, preventing execution hangs.
• AI Agent Evaluation: Integrated automated ADK agent evaluations (google-agents-cli) into backend CI/CD pipelines to run graded trace evaluations before QA and production deployments.
• AI Evaluation Tooling: Added a generate_eval_traces.py script to run inference over evaluation datasets and construct trace files for automated agent grading.
• Backend Architecture: Modularized the Engagement Template AI agent by extracting validation and Firestore commit nodes into a dedicated tools.py module.
• AI Agent Context Resolution: Upgraded backend state resolution helpers to safely extract context dictionaries from various agent invocation contexts during engagement template generation.
• Data Dictionary Generation: The AI data dictionary tool now intelligently merges new properties with existing fields during generation, preventing accidental data loss, and correctly registers the isRequired attribute.
• System Orgs: Data dictionary queries and saves now gracefully fallback to demo environments if an organization ID is omitted during internal AI tasks.
• Local Agent Runner: The local testing script now supports simulating snippet generation contexts and automatically audits agent requirements.txt files for mandatory container dependencies.
• Snippet Payload Parsing: The AI snippet configuration tools now seamlessly parse raw JSON string inputs and automatically fallback to session state, preventing schema validation crashes.
• Template ID Resolution: The template lookup utility now strictly ignores invalid placeholder IDs (like null, undefined, or {...}) to prevent database query errors.
• Local Agent Runner: The run_agent_local.py management CLI script now natively supports Windows environments (cmd.exe) with UTF-8 stdout encoding and dynamic gcloud token generation.
• Template Syntax Validation: The QA process now strictly rejects generated HTML that contains duplicate section layouts (such as multiple cover pages) or snippet fallback chains.
• Example Document Hydration: The document templating AI now automatically hydrates the example document link from the active Firestore template into the agent context if it is missing.
• Fallback Section Extraction: Added a fallback section extractor that parses TOC and headings from raw document text if the Architect agent fails to output a valid structured outline.
• Targeted Page OCR: The system now attempts to find specific PDF page indices where a section name appears to target visual QA and OCR, improving accuracy for localized sections.
• Sequential Agent Workflows: Rebuilt the GenericAgentPattern and HTML sub-workflows to natively use the ADK SequentialAgent class, streamlining multi-agent pipeline execution.
• Template Tool Context Injection: Built-in backend template utilities now prioritize the unified session state over legacy run configs for improved contextual reliability during agent operations.
• App Infrastructure: Upgraded the Flutter SDK to version 3.41.0 and updated core PDF rendering libraries (pdfrx, pdfium) for improved cross-platform stability.
• CI/CD Deployments: Optimized backend Agent Engine deployment payloads by automatically stripping redundant cache files and nested agent directories to reduce container sizes.
• AI Dialog Stability: Fixed an issue where the template generation instruction dialog could lose organizational context by securely wrapping it in a global state provider.
• Template Generation UI: Improved error handling and cleanup logic for the AI template generation progress dialog to ensure reliable state resets.
• Missing Properties: The Missing Information dialog now correctly resolves data dictionary schemas for arbitrary collection names.
• AI Schema Validation: Internal AI schema validation tools now seamlessly parse raw JSON string payloads for enhanced reliability.
• Lifecycle UI: Polished the lifecycle formula rule list with sleeker icons and improved spacing.
• Project Plan UI: The Calculate Critical Path button is now automatically disabled while the plan is actively saving to prevent concurrent calculations.
• AI Payload Sanitization: The backend now isolates heavy binary payloads (like extracted PDF bytes and image caches) into ephemeral memory, actively stripping them from AI session states before saving to Google Cloud. This prevents 400 Payload Exceeded crashes during complex document generation.
• Vertex AI Session Reliability: Centralized backend patching ensures robust exponential backoffs and safe StopIteration handling across all ADK agent streaming sessions.
• Data Dictionary Syncing: Refactored data dictionary synchronization to allow direct snapshot processing without mocking Cloud Function events, improving reliability during bulk custom field syncs.
• In-Memory Template Staging: The document templating AI now stages generated HTML directly in the active session context instead of writing sequentially to the database, ensuring atomic commits to Firestore only at workflow completion.
• Local Agent Runner CLI: The script now automatically parses and prints detailed QA verdicts and feedback summaries directly in the terminal.
• File Download Validation: Added strict validation to file downloads. The system now immediately alerts you with an error banner if a file URL contains an unsupported scheme.
• HTML QA Function Node: The Document Templating HTML QA agent now executes directly as a function node, eliminating caching layers and accelerating deterministic pre-checks.
• Quote Item Reordering: Fixed an issue where dragging and dropping a quote line item to a new section could sometimes lose its isOptional state or custom tags.
• Quote Org Syncing: Resolved a bug where quote section items could fail to resync properly when switching between organizations in the same session.
• Tabular Column Verification: Custom Data evaluators now mandate matching exact columns to source documents to prevent hallucinated structures.