@autobe/agent 0.28.1 → 0.29.1

package/src/orchestrate/interface/structures/IAutoBeInterfaceGroupApplication.ts

@@ -1,3 +1,4 @@
+import { AutoBeInterfaceGroup } from "@autobe/interface/src/histories/contents/AutoBeInterfaceGroup";
 import { tags } from "typia";
 
 export interface IAutoBeInterfaceGroupApplication {
@@ -6,8 +7,8 @@ export interface IAutoBeInterfaceGroupApplication {
    * Prisma schema structure.
    *
    * DO: Derive groups from Prisma schema organization (namespaces, file
-   * structure, table prefixes) rather than arbitrary business domains.
-   * DO: Create new groups only when existing schema structure cannot adequately
+   * structure, table prefixes) rather than arbitrary business domains. DO:
+   * Create new groups only when existing schema structure cannot adequately
    * cover all requirements.
    *
    * @param props Properties containing the groups to be created for API
@@ -21,88 +22,9 @@ export namespace IAutoBeInterfaceGroupApplication {
     /**
      * Array of API endpoint groups for organizing development.
      *
-     * DO: Organize groups around existing Prisma schema structure.
-     * DO: Provide complete coverage of all entities and requirements without
-     * overlap.
+     * DO: Organize groups around existing Prisma schema structure. DO: Provide
+     * complete coverage of all entities and requirements without overlap.
      */
-    groups: IGroup[] & tags.MinItems<1>;
-  }
-
-  /**
-   * Definition of a logical API endpoint group based on Prisma schema
-   * organization.
-   *
-   * **SCHEMA-BASED GROUP REQUIREMENTS:**
-   *
-   * DO: Derive groups from the Prisma schema structure rather than arbitrary
-   * business domain names.
-   * 
-   * This ensures consistency with the underlying data model and prevents
-   * misalignment between API organization and database structure.
-   *
-   * **Primary Group Sources (in order of priority):**
-   *
-   * 1. **Prisma Schema Namespaces**: Use namespace names (e.g., `namespace
-   *    Shopping` → "Shopping")
-   * 2. **Schema File Names**: Derive from file names (e.g., `shopping.prisma` →
-   *    "Shopping")
-   * 3. **Table Prefix Patterns**: Use consistent prefixes (e.g., `shopping_orders`
-   *    → "Shopping")
-   * 4. **Schema Comments/Annotations**: Follow organizational comments in schema
-   *
-   * **Group Creation Guidelines:**
-   *
-   * - Each group covers specific Prisma schema entities without overlap
-   * - Size groups appropriately for manageable endpoint generation cycles
-   * - Maintain clear boundaries based on schema organization
-   * - Ensure complete coverage of all database entities and requirements
-   * - Related database tables within the same schema area are grouped together
-   *
-   * **When to Create Schema-Independent Groups:**
-   *
-   * Only create groups that don't correspond to Prisma schema organization
-   * when:
-   *
-   * - Requirements include functionality not represented in any schema entity
-   * - Cross-cutting concerns span multiple schema areas
-   * - Integration operations don't map to specific database entities
-   * - System-level functionality requires dedicated API operations
-   *
-   * **Naming Standards:**
-   *
-   * - Use PascalCase format (e.g., "Shopping", "BBS", "UserManagement")
-   * - Names directly reflect Prisma schema structure
-   * - Keep names concise and schema-derived
-   * - Avoid arbitrary business domain names
-   * - Maintain consistency with schema organization
-   *
-   * **Quality Requirements:**
-   *
-   * - Groups collectively cover ALL entities and requirements
-   * - Each database entity belongs to exactly one group
-   * - Clear mapping to specific Prisma schema elements
-   * - Balance group sizes within schema constraints
-   * - Follow existing schema namespace or file structure patterns
-   */
-  export interface IGroup {
-    /**
-     * Unique identifier name derived from Prisma schema structure.
-     *
-     * DO: Correspond to schema namespaces, file names, table prefixes, or
-     * organizational annotations rather than arbitrary business domain names.
-     */
-    name: string & tags.MinLength<1>;
-
-    /**
-     * Concise description of the group's core purpose.
-     *
-     * **Requirements:**
-     * - Keep it brief and focused (50-200 characters)
-     * - State the main purpose and key entities
-     * - Avoid detailed explanations or mappings
-     *
-     * Example: "Handles shopping-related entities and operations"
-     */
-    description: string & tags.MinLength<1>;
+    groups: AutoBeInterfaceGroup[] & tags.MinItems<1>;
   }
 }

package/src/orchestrate/interface/structures/IAutoBeInterfaceOperationApplication.ts

@@ -1,25 +1,77 @@
 import { AutoBeOpenApi, CamelCasePattern } from "@autobe/interface";
 import { tags } from "typia";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBeInterfaceOperationApplication {
   /**
-   * Generate detailed API operations from path/method combinations.
-   *
-   * This function creates complete API operations following REST principles and
-   * quality standards. Each generated operation includes specification, path,
-   * method, detailed multi-paragraph description, concise summary, parameters,
-   * and appropriate request/response bodies.
+   * Process operation generation task or preliminary data requests.
    *
-   * The function processes as many operations as possible in a single call,
-   * with progress tracking to ensure iterative completion of all required
-   * endpoints.
+   * Creates complete API operations following REST principles and quality
+   * standards. Processes operations with progress tracking to ensure iterative
+   * completion.
    *
-   * @param props Properties containing the operations to generate.
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  makeOperations(props: IAutoBeInterfaceOperationApplication.IProps): void;
+  process(props: IAutoBeInterfaceOperationApplication.IProps): void;
 }
 export namespace IAutoBeInterfaceOperationApplication {
   export interface IProps {
+    /**
+     * 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 operation generation
+     * (complete). When preliminary returns empty array, that type is removed
+     * from the union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas;
+  }
+
+  /**
+   * Request to generate detailed API operations.
+   *
+   * Executes operation generation to create complete API operations following
+   * REST principles and quality standards. Each operation includes specification,
+   * path, method, detailed description, summary, parameters, and request/response
+   * bodies.
+   */
+  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";
+
     /**
      * Array of API operations to generate.
      *
@@ -367,8 +419,8 @@ export namespace IAutoBeInterfaceOperationApplication {
      *
      * - ❌ BAD: Separate GET endpoints for admin, member, moderator to view the
      *   same public data
-     * - ✅ GOOD: Single public endpoint `[]` with actor-based filtering in business
-     *   logic
+     * - ✅ GOOD: Single public endpoint `[]` with actor-based filtering in
+     *   business logic
      *
      * **DO NOT enumerate all possible actors when the Prisma schema uses a
      * single User table:**

package/src/orchestrate/interface/structures/{IAutoBeInterfaceOperationsReviewApplication.ts → IAutoBeInterfaceOperationReviewApplication.ts}

@@ -1,40 +1,77 @@
 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 outputs a structured thinking process with
- * analytical findings and actionable improvements, along with the final
- * enhanced operations ready for implementation.
- */
-export interface IAutoBeInterfaceOperationsReviewApplication {
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
+export interface IAutoBeInterfaceOperationReviewApplication {
   /**
-   * Reviews a batch of API operations for quality and correctness.
+   * Process operation review task or preliminary data requests.
    *
    * Analyzes operations for security vulnerabilities, schema compliance,
-   * logical consistency, and standard adherence. Outputs a structured thinking
-   * process containing review findings and improvement plans, plus the final
-   * production-ready operations with all critical issues resolved.
+   * logical consistency, and standard adherence. Outputs structured thinking
+   * process and production-ready operations.
    *
-   * @param input Properties containing the thinking process (review & plan) and
-   *   the enhanced operations content
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  reviewOperations(
-    input: IAutoBeInterfaceOperationsReviewApplication.IProps,
-  ): void;
+  process(props: IAutoBeInterfaceOperationReviewApplication.IProps): void;
 }
 
-export namespace IAutoBeInterfaceOperationsReviewApplication {
+export namespace IAutoBeInterfaceOperationReviewApplication {
+  export interface IProps {
+    /**
+     * 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 operation review
+     * (complete). When preliminary returns empty array, that type is removed
+     * from the union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas;
+  }
+
   /**
-   * Properties for API operation review and improvement process.
+   * Request to review and validate API operations.
    *
-   * 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 AutoBeInterfaceOperationReviewEvent.
+   * Executes systematic operation review for quality and correctness, analyzing
+   * security vulnerabilities, schema compliance, logical consistency, and
+   * standard adherence. Outputs structured thinking process and enhanced
+   * operations.
    */
-  export interface IProps {
+  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";
+
     /**
      * Comprehensive thinking process for API operation review.
      *
@@ -68,12 +105,10 @@ export namespace IAutoBeInterfaceOperationsReviewApplication {
   }
 
   /**
-   * Structured thinking process for comprehensive API operation review.
+   * Structured thinking process for operation review.
    *
-   * Combines analytical review findings with actionable improvement planning to
-   * guide the systematic enhancement of API operations. This thinking structure
-   * ensures all aspects of API quality are evaluated and addressed before
-   * producing the final operations.
+   * Contains analytical review findings and improvement action plan organized
+   * for systematic enhancement of the operations.
    */
   export interface IThink {
     /**

package/src/orchestrate/interface/structures/IAutoBeInterfacePrerequisiteApplication.ts

@@ -0,0 +1,111 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetInterfaceOperations } from "../../common/structures/IAutoBePreliminaryGetInterfaceOperations";
+import { IAutoBePreliminaryGetInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetInterfaceSchemas";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
+export interface IAutoBeInterfacePrerequisiteApplication {
+  /**
+   * Process prerequisite analysis task or preliminary data requests.
+   *
+   * Analyzes each operation's dependencies and returns complete list with
+   * required prerequisite chains based on resource relationships.
+   *
+   * @param props Request containing either preliminary data request or complete
+   *   task
+   */
+  process(props: IAutoBeInterfacePrerequisiteApplication.IProps): void;
+}
+
+export namespace IAutoBeInterfacePrerequisiteApplication {
+  export interface IProps {
+    /**
+     * 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, getInterfaceOperations,
+     * getInterfaceSchemas) or final prerequisite analysis (complete). When
+     * preliminary returns empty array, that type is removed from the union,
+     * physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas
+      | IAutoBePreliminaryGetInterfaceOperations
+      | IAutoBePreliminaryGetInterfaceSchemas;
+  }
+
+  /**
+   * Request to analyze and generate API operation prerequisites.
+   *
+   * Executes prerequisite analysis to determine which Available API Operations
+   * must be executed before each Target Operation based on resource creation
+   * dependencies and existence validations.
+   */
+  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";
+
+    /**
+     * Target operations requiring prerequisite analysis.
+     *
+     * Each operation will be analyzed for dependency requirements and returned
+     * with appropriate prerequisites from Available API Operations.
+     */
+    operations: IOperation[];
+  }
+
+  /**
+   * Operation with its analyzed prerequisite dependencies.
+   *
+   * Represents a single API operation and its complete prerequisite chain
+   * needed for successful execution.
+   */
+  export interface IOperation {
+    /**
+     * The API endpoint being analyzed.
+     *
+     * Identifies the specific operation (method + path) that needs
+     * prerequisites.
+     */
+    endpoint: AutoBeOpenApi.IEndpoint;
+
+    /**
+     * Required prerequisite operations.
+     *
+     * List of API operations that must be successfully executed before this
+     * operation can be performed. Based on resource creation dependencies and
+     * existence validations from the analysis.
+     */
+    prerequisites: AutoBeOpenApi.IPrerequisite[];
+  }
+}

package/src/orchestrate/interface/structures/IAutoBeInterfaceSchemaApplication.ts

@@ -1,29 +1,79 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetInterfaceOperations } from "../../common/structures/IAutoBePreliminaryGetInterfaceOperations";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBeInterfaceSchemaApplication {
   /**
-   * Generate OpenAPI components containing named schema types.
+   * Process schema generation task or preliminary data requests.
    *
-   * This method receives a complete set of schema components and integrates
-   * them into the final OpenAPI specification. It processes all entity schemas,
-   * their variants, and related type definitions to ensure a comprehensive and
+   * Generates OpenAPI components containing named schema types and integrates
+   * them into the final OpenAPI specification. Processes all entity schemas,
+   * their variants, and related type definitions to ensure comprehensive and
    * consistent API design.
    *
-   * The provided components should include schemas for all entities identified
-   * in the previous phases of API path/method definition and operation
-   * creation. This ensures that the final OpenAPI document has complete type
-   * coverage for all operations.
-   *
-   * DO: Follow established naming conventions (IEntityName,
-   * IEntityName.ICreate, etc.) DO: Document thoroughly with descriptions that
-   * reference the original Prisma schema comments.
-   *
-   * @param props Properties containing components to generate.
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  makeComponents(props: IAutoBeInterfaceSchemaApplication.IProps): void;
+  process(props: IAutoBeInterfaceSchemaApplication.IProps): void;
 }
+
 export namespace IAutoBeInterfaceSchemaApplication {
   export interface IProps {
+    /**
+     * 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, getInterfaceOperations) or final
+     * schema generation (complete). When preliminary returns empty array, that
+     * type is removed from the union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas
+      | IAutoBePreliminaryGetInterfaceOperations;
+  }
+
+  /**
+   * Request to generate OpenAPI schema components.
+   *
+   * Executes schema generation to create comprehensive type definitions for all
+   * entities in the system. Ensures complete type coverage for all operations in
+   * the OpenAPI specification.
+   */
+  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";
+
     /**
      * Complete set of schema components for the OpenAPI specification.
      *

package/src/orchestrate/interface/structures/IAutoBeInterfaceSchemaContentReviewApplication.ts

@@ -1,40 +1,81 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetInterfaceOperations } from "../../common/structures/IAutoBePreliminaryGetInterfaceOperations";
+import { IAutoBePreliminaryGetInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetInterfaceSchemas";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBeInterfaceSchemaContentReviewApplication {
   /**
-   * Reviews and validates DTO content completeness and consistency in OpenAPI
-   * schemas.
-   *
-   * This specialized content review function focuses exclusively on ensuring
-   * DTOs accurately and completely represent their business entities. It
-   * validates field completeness, type accuracy, required field settings, and
-   * documentation quality.
-   *
-   * The review process validates and corrects:
+   * Process schema content review task or preliminary data requests.
    *
-   * - Field completeness against Prisma schema
-   * - Data type accuracy (Prisma to OpenAPI type mappings)
-   * - Required field arrays matching Prisma nullability
-   * - Description quality and comprehensiveness
-   * - Consistency across DTO variants (IEntity, ICreate, IUpdate, ISummary)
-   * - Missing variant detection and creation
+   * Reviews and validates DTO content completeness and consistency, ensuring
+   * DTOs accurately represent business entities with proper field completeness,
+   * type accuracy, and documentation quality.
    *
-   * @param props Content review results including completeness issues found,
-   *   fixes applied, and modified schemas
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  review: (
-    props: IAutoBeInterfaceSchemaContentReviewApplication.IProps,
-  ) => void;
+  process(props: IAutoBeInterfaceSchemaContentReviewApplication.IProps): void;
 }
 
 export namespace IAutoBeInterfaceSchemaContentReviewApplication {
+  export interface IProps {
+    /**
+     * 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, getInterfaceOperations,
+     * getInterfaceSchemas) or final schema content review (complete). When
+     * preliminary returns empty array, that type is removed from the union,
+     * physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas
+      | IAutoBePreliminaryGetInterfaceOperations
+      | IAutoBePreliminaryGetInterfaceSchemas;
+  }
+
   /**
-   * Output structure for the content review function.
+   * Request to review and validate schema content.
    *
-   * Contains the content analysis, completeness fixes, and schemas modified for
-   * content quality during the validation process.
+   * Executes content review to ensure DTOs accurately and completely represent
+   * business entities. Validates field completeness, type accuracy, required
+   * fields, descriptions, variant consistency, and missing variants.
    */
-  export interface IProps {
+  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";
+
     /** Content analysis and completeness planning information. */
     think: IThink;
 
@@ -60,6 +101,12 @@ export namespace IAutoBeInterfaceSchemaContentReviewApplication {
     content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
   }
 
+  /**
+   * Structured thinking process for schema content review.
+   *
+   * Contains analytical review findings and improvement action plan organized
+   * for systematic enhancement of the schemas.
+   */
   export interface IThink {
     /**
      * Content completeness and quality findings from the review process.