@autobe/agent 0.28.0 → 0.29.0

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

@@ -1,36 +1,68 @@
 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 declare namespace IAutoBeInterfaceOperationsReviewApplication {
+export declare namespace IAutoBeInterfaceOperationReviewApplication {
+    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.
      */
-    interface IProps {
+    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.
          *
@@ -62,12 +94,10 @@ export declare namespace IAutoBeInterfaceOperationsReviewApplication {
         content: AutoBeOpenApi.IOperation[];
     }
     /**
-     * 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.
      */
     interface IThink {
         /**

package/lib/orchestrate/interface/structures/IAutoBeInterfaceOperationReviewApplication.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAutoBeInterfaceOperationReviewApplication.js.map

package/lib/orchestrate/interface/structures/IAutoBeInterfaceOperationReviewApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAutoBeInterfaceOperationReviewApplication.js","sourceRoot":"","sources":["../../../../src/orchestrate/interface/structures/IAutoBeInterfaceOperationReviewApplication.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,98 @@
+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 declare namespace IAutoBeInterfacePrerequisiteApplication {
+    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.
+     */
+    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.
+     */
+    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/lib/orchestrate/interface/structures/IAutoBeInterfacePrerequisiteApplication.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAutoBeInterfacePrerequisiteApplication.js.map

package/lib/orchestrate/interface/structures/IAutoBeInterfacePrerequisiteApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAutoBeInterfacePrerequisiteApplication.js","sourceRoot":"","sources":["../../../../src/orchestrate/interface/structures/IAutoBeInterfacePrerequisiteApplication.ts"],"names":[],"mappings":""}

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

@@ -1,28 +1,69 @@
 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 declare namespace IAutoBeInterfaceSchemaApplication {
     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.
+     */
+    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/lib/orchestrate/interface/structures/IAutoBeInterfaceSchemaContentReviewApplication.d.ts

@@ -1,36 +1,70 @@
 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.
+     * Process schema content review task or preliminary data requests.
      *
-     * 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.
+     * Reviews and validates DTO content completeness and consistency, ensuring
+     * DTOs accurately represent business entities with proper field completeness,
+     * type accuracy, and documentation quality.
      *
-     * The review process validates and corrects:
-     *
-     * - 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
-     *
-     * @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 declare namespace IAutoBeInterfaceSchemaContentReviewApplication {
+    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.
      */
-    interface IProps {
+    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;
         /**
@@ -54,6 +88,12 @@ export declare 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.
+     */
     interface IThink {
         /**
          * Content completeness and quality findings from the review process.

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

@@ -1,35 +1,68 @@
 import { AutoBeOpenApi } from "@autobe/interface";
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetInterfaceSchemas";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
 export interface IAutoBeInterfaceSchemaRelationReviewApplication {
     /**
-     * Reviews and validates DTO relations and structural patterns in OpenAPI
-     * schemas.
+     * Process schema relation review task or preliminary data requests.
      *
-     * This specialized relation review function focuses exclusively on data
-     * relations, foreign key transformations, and structural integrity. It
-     * ensures proper modeling of business domains while preventing circular
-     * references and enabling efficient code generation.
+     * Reviews and validates DTO relations and structural patterns, ensuring proper
+     * modeling of business domains with correct relation classifications, foreign
+     * key transformations, and structural integrity.
      *
-     * The review process validates and corrects:
-     *
-     * - Relation classifications (Composition vs Association vs Aggregation)
-     * - Foreign key to object transformations in response DTOs
-     * - Actor reversal violations (e.g., User containing articles array)
-     * - Inline object extractions to named types with $ref
-     * - IInvert pattern applications for alternative perspectives
-     *
-     * @param props Relation review results including violations found, fixes
-     *   applied, and modified schemas
+     * @param props Request containing either preliminary data request or complete
+     *   task
      */
-    review: (props: IAutoBeInterfaceSchemaRelationReviewApplication.IProps) => void;
+    process(props: IAutoBeInterfaceSchemaRelationReviewApplication.IProps): void;
 }
 export declare namespace IAutoBeInterfaceSchemaRelationReviewApplication {
+    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, getInterfaceSchemas) or final schema
+         * relation review (complete). When preliminary returns empty array, that
+         * type is removed from the union, physically preventing repeated calls.
+         */
+        request: IComplete | IAutoBePreliminaryGetAnalysisFiles | IAutoBePreliminaryGetPrismaSchemas | IAutoBePreliminaryGetInterfaceSchemas;
+    }
     /**
-     * Output structure for the relation review function.
+     * Request to review and validate schema relations.
      *
-     * Contains the relation analysis, structural fixes, and schemas modified for
-     * proper relations during the validation process.
+     * Executes relation review to ensure proper data relations, foreign key
+     * transformations, and structural integrity. Validates relation classifications,
+     * prevents circular references, and enables efficient code generation.
      */
-    interface IProps {
+    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";
         /** Relation analysis and structural planning information. */
         think: IThink;
         /**
@@ -52,6 +85,12 @@ export declare namespace IAutoBeInterfaceSchemaRelationReviewApplication {
          */
         content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
     }
+    /**
+     * Structured thinking process for schema relation review.
+     *
+     * Contains analytical review findings and improvement action plan organized
+     * for systematic enhancement of the schemas.
+     */
     interface IThink {
         /**
          * Relation and structural violation findings from the review process.

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

@@ -1,33 +1,69 @@
 import { AutoBeOpenApi } from "@autobe/interface";
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetInterfaceSchemas";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
 export interface IAutoBeInterfaceSchemaSecurityReviewApplication {
     /**
-     * Reviews and validates OpenAPI schema definitions for security compliance.
+     * Process schema security review task or preliminary data requests.
      *
-     * This specialized security review function focuses exclusively on
-     * authentication boundaries, data protection, and system integrity. It
-     * enforces strict security policies to prevent authentication bypass, data
-     * exposure, and unauthorized access.
+     * Reviews and validates OpenAPI schema definitions for security compliance,
+     * enforcing strict policies to prevent authentication bypass, data exposure,
+     * and unauthorized access.
      *
-     * The review process identifies and removes:
-     *
-     * - Authentication context fields in request DTOs (e.g., bbs_member_id)
-     * - Password and token fields in response DTOs
-     * - System-managed fields in request DTOs
-     * - Phantom fields that don't exist in Prisma schema
-     *
-     * @param props Security review results including violations found, fixes
-     *   applied, and modified schemas
+     * @param props Request containing either preliminary data request or complete
+     *   task
      */
-    review: (props: IAutoBeInterfaceSchemaSecurityReviewApplication.IProps) => void;
+    process(props: IAutoBeInterfaceSchemaSecurityReviewApplication.IProps): void;
 }
 export declare namespace IAutoBeInterfaceSchemaSecurityReviewApplication {
+    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, getInterfaceSchemas) or final schema
+         * security review (complete). When preliminary returns empty array, that
+         * type is removed from the union, physically preventing repeated calls.
+         */
+        request: IComplete | IAutoBePreliminaryGetAnalysisFiles | IAutoBePreliminaryGetPrismaSchemas | IAutoBePreliminaryGetInterfaceSchemas;
+    }
     /**
-     * Output structure for the security review function.
+     * Request to review and validate schema security.
      *
-     * Contains the security analysis, remediation actions, and schemas modified
-     * for security compliance during the validation process.
+     * Executes security review to ensure schemas comply with authentication
+     * boundaries, data protection, and system integrity policies. Identifies and
+     * removes authentication context, passwords, tokens, system-managed fields, and
+     * phantom fields.
      */
-    interface IProps {
+    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";
         /** Security analysis and remediation planning information. */
         think: IThink;
         /**
@@ -49,6 +85,12 @@ export declare namespace IAutoBeInterfaceSchemaSecurityReviewApplication {
          */
         content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
     }
+    /**
+     * Structured thinking process for schema security review.
+     *
+     * Contains analytical review findings and improvement action plan organized
+     * for systematic enhancement of the schemas.
+     */
     interface IThink {
         /**
          * Security violation findings from the review process.