@autobe/agent 0.17.1 → 0.18.0

package/lib/orchestrate/interface/structures/IAutoBeInterfaceOperationsReviewApplication.d.ts

@@ -0,0 +1,96 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+/**
+ * Application interface for reviewing and validating API operations.
+ *
+ * Provides functionality to systematically review generated API operations
+ * against business requirements, technical specifications, and OpenAPI
+ * standards. The review process ensures each operation meets quality criteria
+ * before proceeding to implementation.
+ */
+export interface IAutoBeInterfaceOperationsReviewApplication {
+    /**
+     * Reviews a batch of API operations for quality and correctness.
+     *
+     * Validates each operation's request/response schemas, authentication
+     * handling, error responses, and documentation completeness. Operations are
+     * marked as passed or failed based on compliance with enterprise standards.
+     *
+     * @param input Collection of operations to review with their validation
+     *   results
+     */
+    reviewOperations(input: IAutoBeInterfaceOperationsReviewApplication.IProps): void;
+}
+export declare namespace IAutoBeInterfaceOperationsReviewApplication {
+    /**
+     * Properties for API operation review and improvement process.
+     *
+     * Contains both the input operations to be reviewed and the outputs generated
+     * by the Interface Operations Review Agent, which will be published as part
+     * of the AutoBeInterfaceOperationsReviewEvent.
+     */
+    interface IProps {
+        /**
+         * Comprehensive review analysis with prioritized findings.
+         *
+         * Systematic assessment organized by severity levels (CRITICAL, HIGH,
+         * MEDIUM, LOW):
+         *
+         * - **Security Analysis**: Authentication boundary violations, exposed
+         *   passwords/tokens, unauthorized data access patterns, SQL injection
+         *   risks
+         * - **Logic Validation**: Return type consistency (list operations returning
+         *   arrays, single retrieval returning single items), HTTP method semantics
+         *   alignment, parameter usage verification
+         * - **Schema Compliance**: Field existence in Prisma schema, type accuracy,
+         *   relationship validity, required field handling
+         * - **Quality Assessment**: Documentation completeness, naming conventions,
+         *   error handling patterns, pagination standards
+         *
+         * Each finding includes specific examples, current vs expected behavior,
+         * and concrete fix recommendations. Critical security issues and logical
+         * contradictions are highlighted for immediate attention.
+         */
+        review: string;
+        /**
+         * Prioritized action plan for identified issues.
+         *
+         * Structured improvement strategy categorized by severity:
+         *
+         * - **Immediate Actions (CRITICAL)**: Security vulnerabilities that must be
+         *   fixed before production (password exposure, missing authorization,
+         *   authentication bypass risks)
+         * - **Required Fixes (HIGH)**: Functional issues affecting API correctness
+         *   (wrong return types, missing required fields, schema mismatches)
+         * - **Recommended Improvements (MEDIUM)**: Quality enhancements for better
+         *   API design (validation rules, format specifications, consistency)
+         * - **Optional Enhancements (LOW)**: Documentation and usability improvements
+         *
+         * If all operations pass review without issues, contains: "No improvements
+         * required. All operations meet AutoBE standards."
+         *
+         * Each action item includes the specific operation path, the exact change
+         * needed, and the rationale for the modification.
+         */
+        plan: string;
+        /**
+         * Production-ready operations with all critical issues resolved.
+         *
+         * Final API operations after systematic enhancement:
+         *
+         * - **Security Fixes Applied**: All authentication boundaries enforced,
+         *   sensitive data removed from responses, proper authorization
+         *   implemented
+         * - **Logic Corrections Made**: Return types match operation intent, HTTP
+         *   methods align with semantics, parameters properly utilized
+         * - **Schema Alignment Verified**: All fields exist in Prisma schema, types
+         *   correctly mapped, relationships properly defined
+         * - **Quality Improvements Added**: Enhanced documentation, format
+         *   specifications, validation rules, consistent naming patterns
+         *
+         * If no issues were found during review, this contains the exact original
+         * operations unchanged. These operations are validated and ready for schema
+         * generation and subsequent implementation phases.
+         */
+        content: AutoBeOpenApi.IOperation[];
+    }
+}

package/lib/orchestrate/interface/structures/IAutobeInterfaceSchemasReviewApplication.d.ts

@@ -0,0 +1,91 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+export interface IAutoBeInterfaceSchemasReviewApplication {
+    /**
+     * Analyzes and improves OpenAPI schema definitions.
+     *
+     * This function receives schema definitions and performs comprehensive review
+     * and enhancement. It identifies issues, creates an improvement plan, and
+     * produces refined schemas that meet quality standards.
+     *
+     * The function populates three key outputs:
+     *
+     * - A detailed review of findings organized by severity
+     * - An actionable plan for improvements
+     * - Enhanced schemas with all issues resolved
+     *
+     * @param props Contains review findings, improvement plan, and enhanced
+     *   schemas
+     */
+    review: (props: IAutoBeInterfaceSchemasReviewApplication.IProps) => void;
+}
+export declare namespace IAutoBeInterfaceSchemasReviewApplication {
+    /**
+     * Schema review and enhancement parameters for the review function.
+     *
+     * When the review function is called, these properties must be populated to
+     * complete the schema validation and improvement process. The LLM uses this
+     * interface to understand what outputs are required.
+     */
+    interface IProps {
+        /**
+         * Issues and problems found during schema analysis.
+         *
+         * IMPORTANT: Only document problems that need fixing. Do NOT include:
+         *
+         * - Positive feedback about what's already correct
+         * - Compliments about well-structured schemas
+         * - Confirmation that certain aspects meet standards
+         *
+         * Focus exclusively on issues organized by severity:
+         *
+         * - CRITICAL: Security vulnerabilities (exposed passwords, missing auth
+         *   boundaries)
+         * - HIGH: Missing required variants, incorrect type mappings
+         * - MEDIUM: Missing format specifications, incomplete relationships
+         * - LOW: Documentation improvements, style consistency
+         *
+         * Each issue must include the specific schema name and what needs to be
+         * fixed. If there are no issues at all, simply state: "No issues found."
+         */
+        review: string;
+        /**
+         * Action plan for addressing identified issues.
+         *
+         * Must specify concrete fixes categorized by priority:
+         *
+         * - For perfect schemas: "No improvements required. All schemas meet AutoBE
+         *   standards."
+         * - For fixable issues: List each fix with operation path and exact change
+         * - For critical problems: Describe how schemas were recreated or corrected
+         *
+         * Never leave this empty. Always provide a clear plan even if no changes
+         * are needed. The plan documents what was done to produce the content
+         * field.
+         */
+        plan: string;
+        /**
+         * Final validated and enhanced schemas ready for production use.
+         *
+         * CRITICAL REQUIREMENTS:
+         *
+         * - MUST NEVER be an empty object {}
+         * - MUST contain valid OpenAPI schema definitions
+         * - MUST include all entities that were in the original input
+         * - If original schemas have critical issues, MUST contain fixed versions
+         * - If entity names are wrong, MUST contain renamed correct versions
+         * - If schemas are missing variants, MUST include the created variants
+         *
+         * FORBIDDEN:
+         *
+         * - Empty object {} will cause all schemas to be deleted
+         * - Returning undefined or null
+         * - Including explanations or excuses in schema descriptions
+         * - Leaving broken schemas unfixed
+         *
+         * When original schemas are beyond repair, recreate them properly based on
+         * entity names and context. This field becomes the final schemas used by
+         * the system, so it must always contain complete, valid schemas.
+         */
+        content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>;
+    }
+}

package/lib/orchestrate/internal/IProgress.d.ts

@@ -0,0 +1,4 @@
+export interface IProgress {
+    total: number;
+    completed: number;
+}

package/lib/orchestrate/prisma/histories/transformPrismaReviewHistories.d.ts

@@ -0,0 +1,8 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBePrisma } from "@autobe/interface";
+export declare const transformPrismaReviewHistories: (props: {
+    analysis: Record<string, string>;
+    application: AutoBePrisma.IApplication;
+    schemas: Record<string, string>;
+    component: AutoBePrisma.IComponent;
+}) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/prisma/histories/transformPrismaSchemaHistories.d.ts

@@ -1,3 +1,3 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBePrisma } from "@autobe/interface";
-export declare const transformPrismaSchemaHistories: (requirementAnalysisReport: Record<string, string>, targetComponent: AutoBePrisma.IComponent, otherComponents: AutoBePrisma.IComponent[]) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;
+export declare const transformPrismaSchemaHistories: (requirementAnalysisReport: Record<string, string>, targetComponent: AutoBePrisma.IComponent, otherTables: string[]) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/prisma/orchestratePrismaComponent.d.ts

@@ -2,4 +2,4 @@ import { AutoBeAssistantMessageHistory } from "@autobe/interface";
 import { AutoBePrismaComponentsEvent } from "@autobe/interface/src/events/AutoBePrismaComponentsEvent";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestratePrismaComponents<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, content?: string): Promise<AutoBeAssistantMessageHistory | AutoBePrismaComponentsEvent>;
+export declare function orchestratePrismaComponents<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, message?: string): Promise<AutoBeAssistantMessageHistory | AutoBePrismaComponentsEvent>;

package/lib/orchestrate/prisma/orchestratePrismaReview.d.ts

@@ -0,0 +1,5 @@
+import { AutoBePrisma } from "@autobe/interface";
+import { AutoBePrismaReviewEvent } from "@autobe/interface/src/events/AutoBePrismaReviewEvent";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestratePrismaReview<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, application: AutoBePrisma.IApplication, schemas: Record<string, string>, componentList: AutoBePrisma.IComponent[]): Promise<AutoBePrismaReviewEvent[]>;

package/lib/orchestrate/prisma/orchestratePrismaSchemas.d.ts

@@ -2,4 +2,4 @@ import { AutoBePrisma } from "@autobe/interface";
 import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, components: AutoBePrisma.IComponent[]): Promise<AutoBePrismaSchemasEvent[]>;
+export declare function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, componentList: AutoBePrisma.IComponent[]): Promise<AutoBePrismaSchemasEvent[]>;

package/lib/orchestrate/prisma/structures/IAutoBePrismaComponentApplication.d.ts

@@ -1,4 +1,5 @@
 import { AutoBePrisma } from "@autobe/interface";
+import { tags } from "typia";
 export interface IAutoBePrismaComponentApplication {
     /**
      * Organizes database tables into domain-based components for Prisma schema
@@ -115,6 +116,6 @@ export declare namespace IAutoBePrismaComponentApplication {
          * - Filename numbering indicates dependency order for schema generation
          * - Namespace is used for documentation organization and domain grouping
          */
-        components: AutoBePrisma.IComponent[];
+        components: AutoBePrisma.IComponent[] & tags.MinItems<1>;
     }
 }

package/lib/orchestrate/prisma/structures/IAutoBePrismaReviewApplication.d.ts

@@ -0,0 +1,105 @@
+import { AutoBePrisma } from "@autobe/interface";
+export interface IAutoBePrismaReviewApplication {
+    /**
+     * Reviews and validates Prisma schema modifications to ensure compliance with
+     * database design best practices and business requirements.
+     *
+     * Performs comprehensive validation of proposed schema changes including
+     * normalization compliance, relationship integrity, performance optimization,
+     * and business logic alignment. The review process ensures all modifications
+     * maintain data consistency and follow enterprise-level database standards.
+     */
+    reviewSchemaFile(props: IAutoBePrismaReviewApplication.IProps): void;
+}
+export declare namespace IAutoBePrismaReviewApplication {
+    interface IProps {
+        /**
+         * Comprehensive review analysis of the proposed schema modifications.
+         *
+         * Contains the AI agent's detailed evaluation of the schema changes,
+         * including validation of normalization compliance, relationship integrity,
+         * index optimization, and business requirement alignment. The review
+         * identifies potential issues and confirms adherence to best practices.
+         *
+         * **Review Dimensions:**
+         *
+         * - **Normalization Validation**: Confirms 3NF compliance and proper data
+         *   structure
+         * - **Relationship Integrity**: Validates foreign key references and
+         *   cardinality
+         * - **Performance Optimization**: Reviews indexing strategy and query
+         *   patterns
+         * - **Business Logic Alignment**: Ensures schema supports all use cases
+         * - **Naming Conventions**: Verifies consistent naming patterns
+         * - **Data Type Consistency**: Confirms appropriate field types
+         * - **Temporal Field Handling**: Validates audit trail implementation
+         *
+         * **Example:**
+         *
+         *     "After reviewing the schema modifications:
+         *     1. All tables properly implement UUID primary keys
+         *     2. Foreign key relationships correctly reference existing models
+         *     3. Composite indexes optimize for common query patterns
+         *     4. Snapshot tables include proper temporal fields
+         *     5. Materialized views (mv_) contain appropriate denormalization
+         *     The schema follows all best practices and is ready for implementation."
+         */
+        review: string;
+        /**
+         * Strategic database design plan that guided the schema creation.
+         *
+         * Contains the original planning document that outlines the database
+         * architecture strategy, including table structures, relationships,
+         * normalization approach, and business requirement mapping. This plan
+         * serves as the blueprint for validating the implemented schema.
+         *
+         * **Planning Components:**
+         *
+         * - **Business Requirements**: Mapping of business needs to database
+         *   structures
+         * - **Table Design**: Entity definitions and attribute specifications
+         * - **Relationship Strategy**: Cardinality and referential integrity planning
+         * - **Normalization Approach**: Application of 1NF, 2NF, 3NF principles
+         * - **Performance Considerations**: Index strategy and query optimization
+         * - **Snapshot Architecture**: Temporal data handling and audit requirements
+         * - **Materialized Views**: Denormalization strategy for performance
+         *
+         * **Example:**
+         *
+         *     "Database Design Strategy:
+         *     Component: Sales Domain
+         *     Tables: shopping_sales, shopping_sale_snapshots, shopping_sale_units
+         *
+         *     Design Approach:
+         *     - Normalize product catalog to 3NF for data integrity
+         *     - Implement snapshot pattern for price history tracking
+         *     - Create composite indexes for product search queries
+         *     - Use materialized views for sales analytics dashboards"
+         */
+        plan: string;
+        /**
+         * Array of Prisma models that have been modified based on review feedback.
+         *
+         * Contains ONLY the models that required changes, not the entire schema.
+         * Each model represents a complete table definition with all fields,
+         * relationships, indexes, and documentation. These modifications will be
+         * applied to the models to produce the final implementation.
+         *
+         * **Model Requirements:**
+         *
+         * - **Complete Models**: Each entry must be a complete model definition
+         * - **Targeted Changes**: Only includes models that need modifications
+         * - **AST Compliance**: Follows AutoBePrisma.IModel interface structure
+         * - **Relationship Integrity**: All foreign keys reference valid models
+         * - **Index Optimization**: Strategic indexes without redundancy
+         * - **Documentation**: Comprehensive English descriptions
+         *
+         * **Notes:**
+         *
+         * - Models not included in this array remain unchanged from the models
+         * - The final schema merges these modifications with the original models
+         * - All modifications must resolve issues identified in the review
+         */
+        modifications: AutoBePrisma.IModel[];
+    }
+}

package/lib/orchestrate/prisma/structures/IAutoBePrismaSchemaApplication.d.ts

@@ -1,4 +1,5 @@
 import { AutoBePrisma } from "@autobe/interface";
+import { tags } from "typia";
 export interface IAutoBePrismaSchemaApplication {
     /**
      * Generates comprehensive Prisma schema files based on detailed requirements
@@ -17,7 +18,7 @@ export interface IAutoBePrismaSchemaApplication {
 export declare namespace IAutoBePrismaSchemaApplication {
     interface IProps {
         /**
-         * Step 1: Strategic database design analysis and planning.
+         * Strategic database design analysis and planning.
          *
          * AI analyzes the target component and business requirements to formulate a
          * comprehensive database design strategy. This planning phase is crucial
@@ -43,167 +44,56 @@ export declare namespace IAutoBePrismaSchemaApplication {
          *
          * Workflow: Component analysis → Strategic planning → Design rationale
          */
-        thinking: string;
+        plan: string;
         /**
-         * Step 2: Initial Prisma schema code implementation.
+         * Production-ready Prisma schema models generated based on the strategic
+         * plan.
          *
-         * AI generates the first working version of the Prisma schema based on the
-         * strategic plan. This draft must be syntactically correct Prisma Schema
-         * Language (PSL) code that implements all planned tables, relationships,
-         * and constraints. The schema should follow Prisma conventions while
-         * incorporating enterprise patterns like snapshot tables and materialized
-         * views.
+         * Contains a structured Abstract Syntax Tree (AST) representation of all
+         * database tables for the target component. Each model implements the
+         * planned table structure, relationships, indexes, and constraints using
+         * the AutoBePrisma.IModel interface. These models are designed to be
+         * production-ready from the initial generation, following all best
+         * practices and normalization principles.
          *
          * **Implementation Requirements:**
          *
-         * - **Exact Table Names**: Use EXACT names from targetComponent.tables (NO
-         *   CHANGES)
-         * - **Valid PSL Syntax**: Proper model blocks, field definitions, and
-         *   directives
-         * - **Primary Keys**: Always UUID type with `@id` directive
-         * - **Foreign Keys**: UUID type following {target_model}_id naming pattern
-         * - **Data Types**: uuid, string, int, double, datetime, boolean, uri (no
-         *   pre-calculated fields)
-         * - **Relationships**: Proper `@relation` directives for 1:1, 1:N, M:N
-         *   patterns
-         * - **Descriptions**: Follow format with requirements mapping and business
-         *   purpose
-         * - **NO Prohibited Fields**: No totals, cached values, aggregates in regular
-         *   tables
-         *
-         * Workflow: Strategic plan → PSL implementation → Functional schema code
-         */
-        draft: string;
-        /**
-         * Step 3: Schema code review and quality assessment.
-         *
-         * AI performs a thorough review of the draft schema implementation,
-         * examining multiple quality dimensions to ensure production readiness.
-         * This review process identifies issues, suggests improvements, and
-         * validates compliance with best practices.
-         *
-         * **Review Dimensions:**
-         *
-         * **Syntax & Compilation:**
-         *
-         * - Prisma schema syntax errors and invalid directives
-         * - Model naming matches targetComponent.tables EXACTLY
-         * - Field type appropriateness (uuid for keys, no calculated fields)
-         * - Relationship definition correctness (`@relation` syntax)
-         *
-         * **Database Design Quality:**
-         *
-         * - **Normalization Compliance**:
-         *
-         *   - 1NF: Atomic values, no repeating groups
-         *   - 2NF: No partial dependencies on composite keys
-         *   - 3NF: No transitive dependencies
-         * - **Prohibited Fields Check**: No pre-calculated totals, cached values, or
-         *   aggregates in regular tables
-         * - **Snapshot Pattern**: Proper implementation for audit trails
-         * - **Junction Tables**: Correct naming ({table1}_{table2}) and structure
-         *
-         * **Index Strategy Validation:**
-         *
-         * - NO single foreign key indexes (Prisma auto-creates these)
-         * - Composite indexes for query patterns
-         * - Unique indexes for business constraints
-         * - GIN indexes for full-text search fields
-         *
-         * **Description Quality:**
-         *
-         * - Models include: requirement mapping, business purpose, relationships,
-         *   behaviors
-         * - Fields include: requirement aspect, business meaning, normalization
-         *   rationale
-         *
-         * Workflow: Draft schema → Systematic analysis → Specific improvements
-         */
-        review: string;
-        /**
-         * Step 4: Final production-ready Prisma schema code.
-         *
-         * AI produces the final, polished version of the Prisma schema
-         * incorporating all review feedback. This code represents the completed
-         * schema implementation, ready for database migration and production
-         * deployment. All identified issues must be resolved, and the schema must
-         * meet enterprise-grade quality standards.
-         *
-         * **Final Schema Characteristics:**
-         *
-         * - **Complete Coverage**: All targetComponent.tables implemented with exact
-         *   names
-         * - **Zero Errors**: Valid PSL syntax, no compilation warnings
-         * - **Proper Relationships**: All foreign keys reference existing tables
-         *   correctly
-         * - **Optimized Indexes**: Strategic indexes without redundant foreign key
-         *   indexes
-         * - **Full Normalization**: Strict 3NF compliance, denormalization only in
-         *   mv_ tables
-         * - **Enterprise Documentation**: Complete descriptions with business context
-         * - **Audit Support**: Proper snapshot patterns and temporal fields
-         *   (created_at, updated_at, deleted_at)
-         * - **Type Safety**: Consistent use of UUID for all keys, appropriate field
-         *   types
-         *
-         * Workflow: Review feedback → Schema refinement → Production-ready PSL code
-         */
-        final: string;
-        /**
-         * Step 5: Structured AST representation of the Prisma schema models.
-         *
-         * AI transforms the final Prisma schema code into a structured Abstract
-         * Syntax Tree (AST) representation using the AutoBePrisma.IModel interface.
-         * This involves critical reinterpretation and reclassification of the final
-         * code to conform to AST constraints.
-         *
-         * **CRITICAL: Reinterpretation & Post-Processing Required**
-         *
-         * The AI-generated final code may not directly map to valid AST structures
-         * due to:
-         *
-         * - Complex Prisma directives that need decomposition
-         * - Field attributes that require reclassification
-         * - Implicit relationships that need explicit AST representation
-         * - Schema-level constructs that must be distributed to models
-         *
-         * **Required Post-Processing Steps:**
-         *
-         * 1. **Field Reclassification**: Separate fields into primary, foreign, and
-         *    plain categories
-         * 2. **Relationship Extraction**: Convert `@relation` directives to IRelation
-         *    structures
-         * 3. **Index Decomposition**: Parse `@@index`, `@@unique` into appropriate
-         *    index arrays
-         * 4. **Type Normalization**: Map Prisma types to AST type enum values
-         * 5. **Constraint Resolution**: Convert schema constraints to AST properties
-         *
-         * **AST Structure Requirements:**
-         *
-         * - **Model Array**: Each table from targetComponent.tables as IModel
-         * - **Primary Field**: Always UUID type with name "id"
-         * - **Foreign Fields**: Proper IRelation configurations for all relationships
-         * - **Plain Fields**: Business fields with correct types (no calculated
-         *   fields)
+         * - **Model Count**: Exactly matches targetComponent.tables.length (plus any
+         *   junction tables)
+         * - **Table Names**: EXACT names from targetComponent.tables - no
+         *   modifications allowed
+         * - **Primary Keys**: Always UUID type with field name "id"
+         * - **Foreign Keys**: Proper IRelation configurations for all relationships
+         * - **Business Fields**: Only raw data fields - no calculated or derived
+         *   values
+         * - **Data Types**: Limited to: uuid, string, int, double, datetime, boolean,
+         *   uri
+         * - **Relationships**: Correct patterns for 1:1, 1:N, and M:N relationships
          * - **Indexes**:
          *
          *   - UniqueIndexes: Business constraints and composite unique keys
-         *   - PlainIndexes: Query optimization (no single foreign key indexes)
-         *   - GinIndexes: Full-text search on string fields
-         * - **Material Flag**: true only for mv_ prefixed tables
-         *
-         * **Relationship Patterns in AST:**
-         *
-         * - 1:1: Foreign field with unique: true
-         * - 1:N: Foreign field with unique: false
-         * - M:N: Separate junction table model with composite indexes
-         *
-         * Workflow: Final PSL code → Reinterpretation → AST transformation →
-         * Structured models
+         *   - PlainIndexes: Multi-column query optimization (never single FK indexes)
+         *   - GinIndexes: Full-text search on appropriate string fields
+         * - **Materialized Views**: Tables prefixed with "mv_" have material flag set
+         *   to true
+         * - **Documentation**: Comprehensive English descriptions with business
+         *   context
+         *
+         * **Quality Standards:**
+         *
+         * - **Normalization**: Strict adherence to 3NF (Third Normal Form)
+         * - **No Denormalization**: Except in materialized views (mv_ tables)
+         * - **Referential Integrity**: All foreign keys reference valid existing
+         *   tables
+         * - **Temporal Fields**: Consistent created_at, updated_at, deleted_at
+         *   patterns
+         * - **Snapshot Support**: Proper historical data preservation where needed
+         * - **Performance Ready**: Optimized index strategy for expected query
+         *   patterns
          *
-         * This structured representation serves as the ultimate deliverable for
-         * programmatic schema generation and manipulation.
+         * The generated models will undergo review by a separate specialized agent
+         * to ensure compliance with all requirements and best practices.
          */
-        models: AutoBePrisma.IModel[];
+        models: AutoBePrisma.IModel[] & tags.MinItems<1>;
     }
 }

package/lib/orchestrate/realize/histories/transformRealizeAuthorization.d.ts

@@ -0,0 +1,5 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeRole } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare const transformRealizeAuthorizationHistories: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, role: AutoBeAnalyzeRole) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/histories/transformRealizeAuthorizationCorrectHistories.d.ts

@@ -0,0 +1,5 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare const transformRealizeAuthorizationCorrectHistories: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, auth: AutoBeRealizeAuthorization, templateFiles: Record<string, string>, diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[]) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/histories/transformRealizeCoderHistories.d.ts

@@ -0,0 +1,7 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenario } from "../orchestrateRealizeScenario";
+import { IAutoBeRealizeCompile } from "../structures/IAutoBeRealizeCompile";
+export declare const transformRealizeCoderHistories: (state: AutoBeState, previousCodes: IAutoBeRealizeCompile.Success[], props: IAutoBeRealizeScenario, artifacts: IAutoBeTestScenarioArtifacts, previous: string | null, diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[], authorization?: AutoBeRealizeAuthorization) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/histories/transformRealizeCorrectHistories.d.ts

@@ -0,0 +1,13 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+export declare function transformRealizeCorrectHistories(props: {
+    state: AutoBeState;
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    artifacts: IAutoBeTestScenarioArtifacts;
+    authorization: AutoBeRealizeAuthorization | null;
+    code: string;
+    diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+}): Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/histories/transformRealizeWriteHistories.d.ts

@@ -0,0 +1,11 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+export declare const transformRealizeWriteHistories: (props: {
+    state: AutoBeState;
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    artifacts: IAutoBeTestScenarioArtifacts;
+    authorization: AutoBeRealizeAuthorization | null;
+}) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/internal/compile.d.ts

@@ -0,0 +1,7 @@
+import { AutoBeRealizeAuthorization, AutoBeRealizeValidateEvent, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare function compile<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
+    authorizations: AutoBeRealizeAuthorization[];
+    providers: Record<string, string>;
+}): Promise<IAutoBeTypeScriptCompileResult.ISuccess | AutoBeRealizeValidateEvent>;