@autobe/agent 0.28.1 → 0.29.0

package/src/orchestrate/prisma/{orchestratePrismaSchemas.ts → orchestratePrismaSchema.ts}

@@ -1,5 +1,5 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBePrisma } from "@autobe/interface";
+import { AutoBeEventSource, AutoBePrisma } from "@autobe/interface";
 import { AutoBePrismaSchemaEvent } from "@autobe/interface/src/events/AutoBePrismaSchemaEvent";
 import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
@@ -10,10 +10,11 @@ import { v7 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformPrismaSchemaHistories } from "./histories/transformPrismaSchemaHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformPrismaSchemaHistory } from "./histories/transformPrismaSchemaHistory";
 import { IAutoBePrismaSchemaApplication } from "./structures/IAutoBePrismaSchemaApplication";
 
-export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
+export async function orchestratePrismaSchema<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   instruction: string,
   componentList: AutoBePrisma.IComponent[],
@@ -24,6 +25,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
     .reduce((x, y) => x + y, 0);
   const completed: IPointer<number> = { value: 0 };
   return await executeCachedBatch(
+    ctx,
     componentList.map((component) => async (promptCacheKey) => {
       const otherTables: string[] = componentList
         .filter((y) => component !== y)
@@ -56,61 +58,71 @@ async function process<Model extends ILlmSchema.Model>(
     promptCacheKey: string;
   },
 ): Promise<AutoBePrismaSchemaEvent> {
-  const pointer: IPointer<IAutoBePrismaSchemaApplication.IProps | null> = {
-    value: null,
-  };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "prismaSchema",
-    histories: transformPrismaSchemaHistories({
-      analysis:
-        ctx
-          .state()
-          .analyze?.files.map((file) => ({ [file.filename]: file.content }))
-          .reduce((acc, cur) => {
-            return Object.assign(acc, cur);
-          }, {}) ?? {},
-      targetComponent: props.component,
-      otherTables: props.otherTables,
-      instruction: props.instruction,
-    }),
-    controller: createController(ctx, {
-      targetComponent: props.component,
-      otherTables: props.otherTables,
-      build: (next) => {
-        pointer.value = next;
-      },
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    message: "Make prisma schema file please",
+  const preliminary: AutoBePreliminaryController<"analysisFiles"> =
+    new AutoBePreliminaryController({
+      application: typia.json.application<IAutoBePrismaSchemaApplication>(),
+      source: SOURCE,
+      kinds: ["analysisFiles"],
+      state: ctx.state(),
+    });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBePrismaSchemaApplication.IComplete | null> = {
+      value: null,
+    };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
+      controller: createController(ctx, {
+        preliminary,
+        targetComponent: props.component,
+        otherTables: props.otherTables,
+        build: (next) => {
+          pointer.value = next;
+        },
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformPrismaSchemaHistory({
+        analysis:
+          ctx
+            .state()
+            .analyze?.files.map((file) => ({ [file.filename]: file.content }))
+            .reduce((acc, cur) => {
+              return Object.assign(acc, cur);
+            }, {}) ?? {},
+        targetComponent: props.component,
+        otherTables: props.otherTables,
+        instruction: props.instruction,
+      }),
+    });
+    if (pointer.value !== null)
+      return out(result)({
+        type: SOURCE,
+        id: v7(),
+        created_at: props.start.toISOString(),
+        plan: pointer.value.plan,
+        models: pointer.value.models,
+        file: {
+          filename: props.component.filename,
+          namespace: props.component.namespace,
+          models: pointer.value.models,
+        },
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        completed: (props.completed.value += props.component.tables.length),
+        total: props.total,
+        step: ctx.state().analyze?.step ?? 0,
+      } satisfies AutoBePrismaSchemaEvent);
+    return out(result)(null);
   });
-  if (pointer.value === null)
-    throw new Error("Unreachable code: Prisma Schema not generated");
-  return {
-    type: "prismaSchema",
-    id: v7(),
-    created_at: props.start.toISOString(),
-    plan: pointer.value.plan,
-    models: pointer.value.models,
-    file: {
-      filename: props.component.filename,
-      namespace: props.component.namespace,
-      models: pointer.value.models,
-    },
-    metric,
-    tokenUsage,
-    completed: (props.completed.value += props.component.tables.length),
-    total: props.total,
-    step: ctx.state().analyze?.step ?? 0,
-  } satisfies AutoBePrismaSchemaEvent;
 }
 
 function createController<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
+    preliminary: AutoBePreliminaryController<"analysisFiles">;
     targetComponent: AutoBePrisma.IComponent;
     otherTables: string[];
-    build: (next: IAutoBePrismaSchemaApplication.IProps) => void;
+    build: (next: IAutoBePrismaSchemaApplication.IComplete) => void;
   },
 ): IAgenticaController.IClass<Model> {
   assertSchemaModel(ctx.model);
@@ -119,10 +131,15 @@ function createController<Model extends ILlmSchema.Model>(
     input: unknown,
   ): IValidation<IAutoBePrismaSchemaApplication.IProps> => {
     const result: IValidation<IAutoBePrismaSchemaApplication.IProps> =
-      typia.validate<IAutoBePrismaSchemaApplication.IProps>(input);
+      defaultValidate(input);
     if (result.success === false) return result;
+    else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
 
-    const actual: AutoBePrisma.IModel[] = result.data.models;
+    const actual: AutoBePrisma.IModel[] = result.data.request.models;
     const expected: string[] = props.targetComponent.tables;
     const missed: string[] = expected.filter(
       (x) => actual.some((a) => a.name === x) === false,
@@ -142,8 +159,8 @@ function createController<Model extends ILlmSchema.Model>(
       data: result.data,
       errors: [
         {
-          path: "$input.models",
-          value: result.data.models,
+          path: "$input.request.models",
+          value: result.data.request.models,
           expected: `Array<AutoBePrisma.IModel>`,
           description: StringUtil.trim`
             You missed some tables from the current domain's component.
@@ -170,17 +187,21 @@ function createController<Model extends ILlmSchema.Model>(
     };
   };
   const application: ILlmApplication<Model> = collection[
-    ctx.model === "chatgpt" ? "chatgpt" : "claude"
+    ctx.model === "chatgpt"
+      ? "chatgpt"
+      : ctx.model === "gemini"
+        ? "gemini"
+        : "claude"
   ](
     validate,
   ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "Prisma Generator",
+    name: SOURCE,
     application,
     execute: {
-      makePrismaSchemaFile: (next) => {
-        props.build(next);
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
       },
     } satisfies IAutoBePrismaSchemaApplication,
   };
@@ -190,13 +211,19 @@ const collection = {
   chatgpt: (validate: Validator) =>
     typia.llm.application<IAutoBePrismaSchemaApplication, "chatgpt">({
       validate: {
-        makePrismaSchemaFile: validate,
+        process: validate,
       },
     }),
   claude: (validate: Validator) =>
     typia.llm.application<IAutoBePrismaSchemaApplication, "claude">({
       validate: {
-        makePrismaSchemaFile: validate,
+        process: validate,
+      },
+    }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaSchemaApplication, "gemini">({
+      validate: {
+        process: validate,
       },
     }),
 };
@@ -204,3 +231,8 @@ const collection = {
 type Validator = (
   input: unknown,
 ) => IValidation<IAutoBePrismaSchemaApplication.IProps>;
+
+const defaultValidate: Validator =
+  typia.createValidate<IAutoBePrismaSchemaApplication.IProps>();
+
+const SOURCE = "prismaSchema" satisfies AutoBeEventSource;

package/src/orchestrate/prisma/structures/IAutoBePrismaCorrectApplication.ts

@@ -1,111 +1,124 @@
 import { AutoBePrisma } from "@autobe/interface";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBePrismaCorrectApplication {
   /**
-   * Fixes validation errors in specific AutoBePrisma models while preserving
-   * ALL existing business logic and model descriptions.
-   *
-   * ## Core Rules
-   *
-   * 1. Fix ONLY validation errors in provided models - never remove business
-   *    descriptions
-   * 2. Apply minimal changes to error models only - preserve original design
-   *    intent
-   * 3. Return ONLY corrected models - unchanged models remain in original schema
-   * 4. Maintain referential integrity with unchanged models
-   *
-   * ## Targeted Scope
+   * Process schema correction task or preliminary data requests.
    *
-   * - Process ONLY models with validation errors from IError[] array
-   * - Exclude models without errors from processing and output
-   * - Minimize context usage by returning corrected models only
-   * - Preserve unchanged models in their original state
+   * Fixes validation errors in specific Prisma models while preserving all
+   * business logic and model descriptions. Returns ONLY corrected models.
    *
-   * ## Fix Strategy
-   *
-   * - Resolve validation errors within specific models only
-   * - Fix field duplications, invalid references, and type mismatches
-   * - Update cross-model references without modifying target models
-   * - Ensure naming conventions and index rules compliance in corrected models
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  correctPrismaSchemaFiles(props: IAutoBePrismaCorrectApplication.IProps): void;
+  process(props: IAutoBePrismaCorrectApplication.IProps): void;
 }
 export namespace IAutoBePrismaCorrectApplication {
   export interface IProps {
     /**
-     * Detailed execution plan for fixing `AutoBePrisma` validation errors in
-     * specific models.
+     * Think before you act.
+     *
+     * Before requesting preliminary data or completing your task, reflect on your
+     * current state and explain your reasoning:
+     *
+     * For preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):
+     * - What critical information is missing that you don't already have?
+     * - Why do you need it specifically right now?
+     * - Be brief - state the gap, don't list everything you have.
+     *
+     * For completion (complete):
+     * - What key assets did you acquire?
+     * - What did you accomplish?
+     * - Why is it sufficient to complete?
+     * - Summarize - don't enumerate every single item.
+     *
+     * This reflection helps you avoid duplicate requests and premature completion.
+     */
+    thinking: string;
+
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval
+     * (getAnalysisFiles, getPrismaSchemas) or final schema correction
+     * (complete). When preliminary returns empty array, that type is removed
+     * from the union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas;
+  }
+
+  /**
+   * Request to fix validation errors in Prisma models.
+   *
+   * Executes targeted error correction to resolve specific validation issues in
+   * affected models only. Applies minimal changes while preserving original
+   * design intent and business logic.
+   */
+  export interface IComplete {
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval or actual
+     * task execution. Value "complete" indicates this is the final task
+     * execution request.
+     */
+    type: "complete";
+
+    /**
+     * Detailed execution plan for fixing validation errors.
      *
-     * 🎯 Purpose: Enable systematic reasoning and step-by-step error resolution
-     * approach for targeted model validation issues
+     * Contains systematic reasoning and step-by-step error resolution approach
+     * for targeted model validation issues.
      *
-     * 📋 Required Planning Content:
+     * Required planning content:
      *
-     * 1. **Error Scope Analysis**
+     * 1. Error scope analysis:
      *
-     *    - List all validation errors from IAutoBePrismaValidation.IError[] array
-     *    - Extract unique table names from errors to identify affected models
+     *    - List all validation errors from IAutoBePrismaValidation.IError[]
+     *    - Extract unique table names to identify affected models
      *    - Categorize errors by type (field duplications, references, types,
      *         indexes)
-     *    - Identify which models need correction vs. which remain unchanged
-     * 2. **Targeted Fix Strategy**
+     *    - Identify which models need correction vs. remain unchanged
+     * 2. Targeted fix strategy:
      *
      *    - Focus ONLY on models mentioned in validation errors
      *    - Outline minimal changes needed for each affected model
-     *    - Plan cross-model reference updates (if any) without modifying non-error
-     *         models
+     *    - Plan cross-model reference updates without modifying non-error models
      *    - Ensure unchanged models maintain valid references to corrected models
-     * 3. **Model-Specific Fix Plan**
+     * 3. Model-specific fix plan:
      *
      *    - Model-by-model modification plan for ONLY affected models
      *    - Exact field additions, renames, or type corrections required
      *    - Reference updates within corrected models only
      *    - Index corrections limited to affected models
-     * 4. **Minimal Scope Validation**
+     * 4. Minimal scope validation:
      *
      *    - Confirm which models will be included in output (error models only)
      *    - List models that will remain unchanged in original schema
      *    - Identify cross-model dependencies without including unchanged models
      *    - Preserve all business logic within corrected models
-     * 5. **Targeted Impact Assessment**
+     * 5. Targeted impact assessment:
      *
      *    - Potential effects of fixes on unchanged models (reference validation)
      *    - Verification points for corrected models only
      *    - Ensure no new validation errors in targeted models
      *    - Confirm minimal output scope compliance
-     *
-     * 💡 Example Planning Structure:
-     *
-     *     ## Error Scope
-     *     - Target Models: shopping_customers, shopping_orders (2 models only)
-     *     - Unchanged Models: All others remain in original schema
-     *
-     *     ## Targeted Fixes
-     *     - shopping_customers: Remove duplicate 'email' field
-     *     - shopping_orders: Update targetModel reference to 'shopping_customers'
-     *
-     *     ## Output Scope
-     *     - Return: Only shopping_customers and shopping_orders models
-     *     - Preserve: All other models unchanged in original schema
-     *
-     *     ## Cross-Model Impact
-     *     - Verify: shopping_orders still references shopping_customers correctly
-     *     - No changes needed in other models referencing these
      */
     planning: string;
 
     /**
-     * ONLY the specific models that contain validation errors and need
-     * correction.
-     *
-     * 📥 Input Structure:
+     * Models with validation errors that need correction.
      *
-     * - Contains ONLY models mentioned in IAutoBePrismaValidation.IError[] array
-     * - Each model has specific validation errors that need targeted correction
-     * - Models not mentioned in errors are excluded from this input
-     * - Represents minimal scope for error correction
+     * Contains ONLY models mentioned in IAutoBePrismaValidation.IError[] array.
+     * Each model has specific validation errors requiring targeted correction.
+     * Models not mentioned in errors are excluded from this input.
      *
-     * 🔍 Expected Validation Issues (Model-Specific):
+     * Expected validation issues:
      *
      * - Duplicate field/relation names within these specific models
      * - Invalid foreign key references from these models to other models
@@ -113,7 +126,7 @@ export namespace IAutoBePrismaCorrectApplication {
      * - Invalid naming conventions within these specific models
      * - Type validation errors in fields of these models
      *
-     * 📝 Model Content Analysis (Targeted Scope):
+     * Model content analysis:
      *
      * - Complete field definitions for each error model only
      * - Relationships from these models (may reference unchanged models)
@@ -121,7 +134,7 @@ export namespace IAutoBePrismaCorrectApplication {
      * - Business descriptions specific to these models
      * - Cross-model references that need validation (read-only for targets)
      *
-     * ⚠️ Processing Notes (Focused Approach):
+     * Processing notes:
      *
      * - Input contains ONLY models with validation errors
      * - May reference other models not included in this input
@@ -130,14 +143,6 @@ export namespace IAutoBePrismaCorrectApplication {
      * - Output should return corrected versions of ONLY these input models
      * - All business logic and descriptions within these models must be preserved
      * - Corrections must not break references from unchanged models
-     *
-     * 🎯 Correction Scope:
-     *
-     * - Fix validation errors within these specific models
-     * - Update internal model structure (fields, relations, indexes)
-     * - Correct references to external models (without modifying targets)
-     * - Maintain compatibility with unchanged models in the full schema
-     * - Return corrected versions of ONLY these models
      */
     models: AutoBePrisma.IModel[];
   }

package/src/orchestrate/prisma/structures/IAutoBePrismaReviewApplication.ts

@@ -1,107 +1,132 @@
 import { AutoBePrisma } from "@autobe/interface";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBePrismaReviewApplication {
   /**
-   * Reviews and validates Prisma schema modifications to ensure compliance with
-   * database design best practices and business requirements.
+   * Process schema review task or preliminary data requests.
+   *
+   * Reviews generated Prisma models to validate normalization, relationships,
+   * indexes, and business alignment, producing necessary modifications.
    *
-   * 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.
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  reviewSchemaFile(props: IAutoBePrismaReviewApplication.IProps): void;
+  process(props: IAutoBePrismaReviewApplication.IProps): void;
 }
 export namespace IAutoBePrismaReviewApplication {
   export interface IProps {
     /**
-     * Comprehensive review analysis of the proposed schema modifications.
+     * Think before you act.
+     *
+     * Before requesting preliminary data or completing your task, reflect on your
+     * current state and explain your reasoning:
+     *
+     * For preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):
+     * - What critical information is missing that you don't already have?
+     * - Why do you need it specifically right now?
+     * - Be brief - state the gap, don't list everything you have.
+     *
+     * For completion (complete):
+     * - What key assets did you acquire?
+     * - What did you accomplish?
+     * - Why is it sufficient to complete?
+     * - Summarize - don't enumerate every single item.
+     *
+     * This reflection helps you avoid duplicate requests and premature completion.
+     */
+    thinking: string;
+
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval
+     * (getAnalysisFiles, getPrismaSchemas) or final schema review (complete).
+     * When preliminary returns empty array, that type is removed from the
+     * union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas;
+  }
+
+  /**
+   * Request to review and refine Prisma schema models.
+   *
+   * Executes comprehensive schema review to validate design quality and
+   * identify necessary improvements for normalization, relationships, and
+   * performance optimization.
+   */
+  export interface IComplete {
+    /**
+     * Type discriminator for the request.
      *
-     * 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.
+     * Determines which action to perform: preliminary data retrieval or actual
+     * task execution. Value "complete" indicates this is the final task
+     * execution request.
+     */
+    type: "complete";
+
+    /**
+     * Comprehensive review analysis of the schema.
      *
-     * **Review Dimensions:**
+     * Contains detailed evaluation of the schema design including:
      *
-     * - **Normalization Validation**: Confirms 3NF compliance and proper data
+     * - 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."
+     * - 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
+     *
+     * The review identifies potential issues and confirms adherence to best
+     * practices before final implementation.
      */
     review: string;
 
     /**
-     * Strategic database design plan that guided the schema creation.
+     * Strategic database design plan.
      *
-     * Contains the original planning document that outlines the database
-     * architecture strategy, including table structures, relationships,
+     * Contains the original planning document outlining 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
+     * Planning components:
      *
-     * **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"
+     * - 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
      */
     plan: string;
 
     /**
-     * Array of Prisma models that have been modified based on review feedback.
+     * Modified Prisma models 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:**
+     * Each model is a complete table definition with all fields, relationships,
+     * indexes, and documentation. These modifications merge with the original
+     * schema to produce the final implementation.
      *
-     * - **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
+     * Model requirements:
      *
-     * **Notes:**
+     * - 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
      *
-     * - 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
+     * Models not included remain unchanged from the original schema. All
+     * modifications must resolve issues identified in the review.
      */
     modifications: AutoBePrisma.IModel[];
   }