@autobe/agent 0.25.4 → 0.25.6

package/src/orchestrate/interface/histories/{transformInterfaceCommonPrerequisiteHistories.ts → transformInterfaceCommonHistories.ts}

@@ -3,7 +3,7 @@ import { v7 } from "uuid";
 
 import { AutoBeState } from "../../../context/AutoBeState";
 
-export const transformInterfaceCommonPrerequisiteHistories = (
+export const transformInterfaceCommonHistories = (
   state: AutoBeState,
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage

package/src/orchestrate/interface/histories/transformInterfaceComplementHistories.ts

@@ -41,15 +41,18 @@ export const transformInterfaceComplementHistories = (props: {
     text: StringUtil.trim`
       ## API Design Instructions
 
-      The following API-specific instructions were extracted by AI from
-      the user's utterances. These focus ONLY on API interface design aspects
+      The following API-specific instructions were extracted from
+      the user's requirements. These focus on API interface design aspects
       such as endpoint patterns, request/response formats, DTO schemas,
       and operation specifications.
 
-      Apply these instructions when completing the missing schema types.
-      Focus on ensuring the schemas align with the overall API design patterns
-      and data structure requirements. If the instructions are not relevant
-      to the specific schemas you need to create, you may ignore them.
+      Follow these instructions when completing missing schema types.
+      Carefully distinguish between:
+      - Suggestions or recommendations (consider these as guidance)
+      - Direct specifications or explicit commands (these must be followed exactly)
+      
+      When instructions contain direct specifications or explicit design decisions, 
+      follow them precisely even if you believe you have better alternatives.
 
       ${props.instruction}
 

package/src/orchestrate/interface/histories/transformInterfaceEndpointHistories.ts

@@ -30,15 +30,18 @@ export const transformInterfaceEndpointHistories = (props: {
     text: StringUtil.trim`
       ## API Design Instructions
 
-      The following API-specific instructions were extracted by AI from
-      the user's utterances. These focus ONLY on API interface design aspects
+      The following API-specific instructions were extracted from
+      the user's requirements. These focus on API interface design aspects
       such as endpoint patterns, request/response formats, DTO schemas,
       and operation specifications.
 
-      Apply these instructions when designing endpoints for the ${props.group.name} group.
-      Consider the specified URL patterns, HTTP methods, parameter structures,
-      and response formats. If the instructions are not relevant to this specific
-      endpoint group, you may ignore them.
+      Follow these instructions when designing endpoints for the ${props.group.name} group.
+      Carefully distinguish between:
+      - Suggestions or recommendations (consider these as guidance)
+      - Direct specifications or explicit commands (these must be followed exactly)
+      
+      When instructions contain direct specifications or explicit design decisions, 
+      follow them precisely even if you believe you have better alternatives.
 
       ${props.instruction}
 

package/src/orchestrate/interface/histories/transformInterfaceGroupHistories.ts

@@ -5,7 +5,7 @@ import { v7 } from "uuid";
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
 import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
-import { transformInterfaceCommonPrerequisiteHistories } from "./transformInterfaceCommonPrerequisiteHistories";
+import { transformInterfaceCommonHistories } from "./transformInterfaceCommonHistories";
 
 export const transformInterfaceGroupHistories = (props: {
   state: AutoBeState;
@@ -13,9 +13,7 @@ export const transformInterfaceGroupHistories = (props: {
 }): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
-  const prerequisite = transformInterfaceCommonPrerequisiteHistories(
-    props.state,
-  );
+  const prerequisite = transformInterfaceCommonHistories(props.state);
   if (prerequisite !== null) return prerequisite;
 
   return [
@@ -39,15 +37,18 @@ export const transformInterfaceGroupHistories = (props: {
       text: StringUtil.trim`
         ## API Design Instructions
 
-        The following API-specific instructions were extracted by AI from
-        the user's utterances. These focus ONLY on API interface design aspects
+        The following API-specific instructions were extracted from
+        the user's requirements. These focus on API interface design aspects
         such as endpoint patterns, request/response formats, DTO schemas,
         and operation specifications.
 
-        Apply these instructions when organizing API endpoints into logical groups.
-        Consider how to structure and categorize endpoints based on business domains,
-        resource types, or functional areas. If the instructions are not relevant
-        to endpoint grouping and organization, you may ignore them.
+        Follow these instructions when organizing API endpoints.
+        Carefully distinguish between:
+        - Suggestions or recommendations (consider these as guidance)
+        - Direct specifications or explicit commands (these must be followed exactly)
+        
+        When instructions contain direct specifications or explicit design decisions, 
+        follow them precisely even if you believe you have better alternatives.
 
         ${props.instruction}
       `,

package/src/orchestrate/interface/histories/transformInterfaceOperationHistories.ts

@@ -47,15 +47,18 @@ export const transformInterfaceOperationHistories = (props: {
       text: StringUtil.trim`
         ## API Design Instructions
 
-        The following API-specific instructions were extracted by AI from
-        the user's utterances. These focus ONLY on API interface design aspects
+        The following API-specific instructions were extracted from
+        the user's requirements. These focus on API interface design aspects
         such as endpoint patterns, request/response formats, DTO schemas,
         and operation specifications.
 
-        Apply these instructions when designing the detailed operation specifications
-        for each endpoint. Consider parameter types, request/response structures,
-        error handling, and API behavior patterns. If the instructions are not
-        relevant to the operations you need to implement, you may ignore them.
+        Follow these instructions when designing operation specifications. 
+        Carefully distinguish between:
+        - Suggestions or recommendations (consider these as guidance)
+        - Direct specifications or explicit commands (these must be followed exactly)
+        
+        When instructions contain direct specifications or explicit design decisions, 
+        follow them precisely even if you believe you have better alternatives.
 
         ${props.instruction}
 

package/src/orchestrate/interface/histories/transformInterfaceSchemaHistories.ts

@@ -28,15 +28,18 @@ export const transformInterfaceSchemaHistories = (props: {
     text: StringUtil.trim`
       ## API Design Instructions
 
-      The following API-specific instructions were extracted by AI from
-      the user's utterances. These focus ONLY on API interface design aspects
+      The following API-specific instructions were extracted from
+      the user's requirements. These focus on API interface design aspects
       such as endpoint patterns, request/response formats, DTO schemas,
       and operation specifications.
 
-      Apply these instructions when creating JSON schema components for the operations.
-      Focus on data structure design, field naming conventions, validation rules,
-      and type definitions. If the instructions are not relevant to the schema
-      components you need to create, you may ignore them.
+      Follow these instructions when creating JSON schema components. 
+      Carefully distinguish between:
+      - Suggestions or recommendations (consider these as guidance)
+      - Direct specifications or explicit commands (these must be followed exactly)
+      
+      When instructions contain direct specifications or explicit design decisions, 
+      follow them precisely even if you believe you have better alternatives.
 
       ${props.instruction}
 

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -17,7 +17,7 @@ import { HashMap, Pair } from "tstl";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { IAutoBeFacadeApplicationProps } from "../../context/IAutoBeFacadeApplicationProps";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { orchestrateInterfaceAuthorizations } from "./orchestrateInterfaceAuthorizations";
 import { orchestrateInterfaceComplement } from "./orchestrateInterfaceComplement";
@@ -32,7 +32,7 @@ import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
 export const orchestrateInterface =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
   async (
-    props: IAutoBeApplicationProps,
+    props: IAutoBeFacadeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceHistory> => {
     // PREDICATION
     const start: Date = new Date();

package/src/orchestrate/prisma/histories/transformPrismaComponentsHistories.ts

@@ -85,12 +85,17 @@ export const transformPrismaComponentsHistories = (
 
         ## Database Design Instructions
 
-        The following database-specific instructions were extracted by AI from
-        the user's utterances. These focus ONLY on database schema design aspects
+        The following database-specific instructions were extracted from
+        the user's requirements. These focus on database schema design aspects
         such as table structure, relationships, constraints, and indexing strategies.
 
-        Reference these instructions when designing namespace components and 
-        DB table names.
+        Follow these instructions when designing namespace components and DB table names. 
+        Carefully distinguish between:
+        - Suggestions or recommendations (consider these as guidance)
+        - Direct specifications or explicit commands (these must be followed exactly)
+        
+        When instructions contain direct specifications or explicit design decisions, 
+        follow them precisely even if you believe you have better alternatives.
 
         ${props.instruction}
       `,

package/src/orchestrate/prisma/histories/transformPrismaSchemaHistories.ts

@@ -39,13 +39,16 @@ export const transformPrismaSchemaHistories = (props: {
       text: StringUtil.trim`
         ## Database Design Instructions
 
-        The following database-specific instructions were extracted by AI from
-        the user's utterances. These focus ONLY on database schema design aspects
+        The following database-specific instructions were extracted from
+        the user's requirements. These focus on database schema design aspects
         such as table structure, relationships, constraints, and indexing strategies.
 
-        Reference these instructions when designing the DB schema for this specific
-        component. If the instruction is not related to the current domain or
-        component, you may ignore it.
+        Follow these instructions when designing the DB schema. Carefully distinguish between:
+        - Suggestions or recommendations (consider these as guidance)
+        - Direct specifications or explicit commands (these must be followed exactly)
+        
+        When instructions contain direct specifications or explicit design decisions, 
+        follow them precisely even if you believe you have better alternatives.
 
         ${props.instruction}
 

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -13,7 +13,7 @@ import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { IAutoBeFacadeApplicationProps } from "../../context/IAutoBeFacadeApplicationProps";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { orchestratePrismaComponents } from "./orchestratePrismaComponent";
 import { orchestratePrismaCorrect } from "./orchestratePrismaCorrect";
@@ -22,7 +22,7 @@ import { orchestratePrismaSchemas } from "./orchestratePrismaSchemas";
 
 export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  props: IAutoBeApplicationProps,
+  props: IAutoBeFacadeApplicationProps,
 ): Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory> => {
   // PREDICATION
   const start: Date = new Date();

package/src/orchestrate/realize/orchestRateRealizeCorrectCasting.ts

@@ -1,4 +1,5 @@
 import {
+  AutoBeOpenApi,
   AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeFunction,
@@ -6,7 +7,12 @@ import {
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
-import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
+import {
+  ILlmApplication,
+  ILlmController,
+  ILlmSchema,
+  IValidation,
+} from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
@@ -14,6 +20,7 @@ import { v7 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
+import { validateEmptyCode } from "../../utils/validateEmptyCode";
 import { IAutoBeCommonCorrectCastingApplication } from "../common/structures/IAutoBeCommonCorrectCastingApplication";
 import { transformRealizeCorrectCastingHistories } from "./histories/transformRealizeCorrectCastingHistories";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
@@ -113,13 +120,12 @@ const correct = async <Model extends ILlmSchema.Model>(
       const func: AutoBeRealizeFunction = functions.find(
         (f) => f.location === location,
       )!;
-
-      const scenario = scenarios.find((s) => s.location === func.location)!;
-
-      const operation = scenario.operation;
-      const authorization = authorizations.find(
-        (a) => a.role.name === operation.authorizationRole,
-      );
+      const scenario: IAutoBeRealizeScenarioResult = scenarios.find(
+        (s) => s.location === func.location,
+      )!;
+      const operation: AutoBeOpenApi.IOperation = scenario.operation;
+      const authorization: AutoBeRealizeAuthorization | undefined =
+        authorizations.find((a) => a.role.name === operation.authorizationRole);
 
       const pointer: IPointer<
         IAutoBeCommonCorrectCastingApplication.IProps | false | null
@@ -137,6 +143,7 @@ const correct = async <Model extends ILlmSchema.Model>(
         ]),
         controller: createController({
           model: ctx.model,
+          functionName: scenario.functionName,
           then: (next) => {
             pointer.value = next;
           },
@@ -373,13 +380,31 @@ const filterRelevantDiagnostics = (
 
 const createController = <Model extends ILlmSchema.Model>(props: {
   model: Model;
+  functionName: string;
   then: (next: IAutoBeCommonCorrectCastingApplication.IProps) => void;
   reject: () => void;
 }): ILlmController<Model> => {
   assertSchemaModel(props.model);
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeCommonCorrectCastingApplication.IProps> =
+      typia.validate<IAutoBeCommonCorrectCastingApplication.IProps>(input);
+    if (result.success === false) return result;
+    const errors: IValidation.IError[] = validateEmptyCode({
+      functionName: props.functionName,
+      draft: result.data.draft,
+      revise: result.data.revise,
+    });
+    return errors.length
+      ? {
+          success: false,
+          errors,
+          data: result.data,
+        }
+      : result;
+  };
   const application = collection[
     props.model === "chatgpt" ? "chatgpt" : "claude"
-  ] satisfies ILlmApplication<any> as any as ILlmApplication<Model>;
+  ](validate) satisfies ILlmApplication<any> as any as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "correctInvalidRequest",
@@ -396,12 +421,28 @@ const createController = <Model extends ILlmSchema.Model>(props: {
 };
 
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeCommonCorrectCastingApplication,
-    "chatgpt"
-  >(),
-  claude: typia.llm.application<
-    IAutoBeCommonCorrectCastingApplication,
-    "claude"
-  >(),
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeCommonCorrectCastingApplication, "chatgpt">({
+      validate: {
+        rewrite: validate,
+        reject: () => ({
+          success: true,
+          data: undefined,
+        }),
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeCommonCorrectCastingApplication, "claude">({
+      validate: {
+        rewrite: validate,
+        reject: () => ({
+          success: true,
+          data: undefined,
+        }),
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeCommonCorrectCastingApplication.IProps>;

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -13,7 +13,7 @@ import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { IAutoBeFacadeApplicationProps } from "../../context/IAutoBeFacadeApplicationProps";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
@@ -27,7 +27,7 @@ import { generateRealizeScenario } from "./utils/generateRealizeScenario";
 export const orchestrateRealize =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
   async (
-    props: IAutoBeApplicationProps,
+    props: IAutoBeFacadeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
     // PREDICATION
     const document: AutoBeOpenApi.IDocument | undefined =

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -5,7 +5,12 @@ import {
   AutoBeRealizeFunction,
 } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
-import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
+import {
+  ILlmApplication,
+  ILlmController,
+  ILlmSchema,
+  IValidation,
+} from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
@@ -13,6 +18,7 @@ import { v7 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
+import { validateEmptyCode } from "../../utils/validateEmptyCode";
 import { transformRealizeCorrectHistories } from "./histories/transformRealizeCorrectHistories";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeCorrectApplication";
@@ -70,9 +76,10 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     if (!location.startsWith("src/providers")) return;
 
     if (!diagnosticsByFile[location]) {
-      const func = functions.find((f) => f.location === location);
-
-      if (!func) {
+      const func: AutoBeRealizeFunction | undefined = functions.find(
+        (f) => f.location === location,
+      );
+      if (func === undefined) {
         return;
       }
 
@@ -195,6 +202,7 @@ async function step<Model extends ILlmSchema.Model>(
     source: "realizeCorrect",
     controller: createController({
       model: ctx.model,
+      functionName: props.scenario.functionName,
       build: (next) => {
         pointer.value = next;
       },
@@ -268,12 +276,33 @@ async function step<Model extends ILlmSchema.Model>(
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
+  functionName: string;
   build: (next: IAutoBeRealizeCorrectApplication.IProps) => void;
 }): ILlmController<Model> {
   assertSchemaModel(props.model);
+
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeRealizeCorrectApplication.IProps> =
+      typia.validate<IAutoBeRealizeCorrectApplication.IProps>(input);
+    if (result.success === false) return result;
+    const errors: IValidation.IError[] = validateEmptyCode({
+      functionName: props.functionName,
+      draft: result.data.draft,
+      revise: result.data.revise,
+    });
+    return errors.length
+      ? {
+          success: false,
+          errors,
+          data: result.data,
+        }
+      : result;
+  };
   const application: ILlmApplication<Model> = collection[
-    props.model
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
 
   return {
     protocol: "class",
@@ -287,14 +316,21 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 }
 
-const claude = typia.llm.application<
-  IAutoBeRealizeCorrectApplication,
-  "claude"
->();
 const collection = {
-  chatgpt: typia.llm.application<IAutoBeRealizeCorrectApplication, "chatgpt">(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeRealizeCorrectApplication, "chatgpt">({
+      validate: {
+        correct: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeRealizeCorrectApplication, "claude">({
+      validate: {
+        correct: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeRealizeCorrectApplication.IProps>;

package/src/orchestrate/realize/orchestrateRealizeWrite.ts

@@ -5,13 +5,19 @@ import {
   AutoBeRealizeWriteEvent,
 } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
-import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
+import {
+  ILlmApplication,
+  ILlmController,
+  ILlmSchema,
+  IValidation,
+} from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { validateEmptyCode } from "../../utils/validateEmptyCode";
 import { transformRealizeWriteHistories } from "./histories/transformRealizeWriteHistories";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { IAutoBeRealizeWriteApplication } from "./structures/IAutoBeRealizeWriteApplication";
@@ -45,6 +51,7 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
     }),
     controller: createController({
       model: ctx.model,
+      functionName: props.scenario.functionName,
       build: (next) => {
         pointer.value = next;
       },
@@ -102,13 +109,33 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
+  functionName: string;
   build: (next: IAutoBeRealizeWriteApplication.IProps) => void;
 }): ILlmController<Model> {
   assertSchemaModel(props.model);
 
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeRealizeWriteApplication.IProps> =
+      typia.validate<IAutoBeRealizeWriteApplication.IProps>(input);
+    if (result.success === false) return result;
+    const errors: IValidation.IError[] = validateEmptyCode({
+      functionName: props.functionName,
+      draft: result.data.draft,
+      revise: result.data.revise,
+    });
+    return errors.length
+      ? {
+          success: false,
+          errors,
+          data: result.data,
+        }
+      : result;
+  };
   const application: ILlmApplication<Model> = collection[
-    props.model
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
 
   return {
     protocol: "class",
@@ -122,14 +149,21 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 }
 
-const claude = typia.llm.application<
-  IAutoBeRealizeWriteApplication,
-  "claude"
->();
 const collection = {
-  chatgpt: typia.llm.application<IAutoBeRealizeWriteApplication, "chatgpt">(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeRealizeWriteApplication, "chatgpt">({
+      validate: {
+        write: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBeRealizeWriteApplication, "claude">({
+      validate: {
+        write: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeRealizeWriteApplication.IProps>;

package/src/orchestrate/test/histories/transformTestScenarioHistories.ts

@@ -53,16 +53,19 @@ export const transformTestScenarioHistories = (props: {
       text: StringUtil.trim`
         ## Instructions
 
-        The following e2e-test-specific instructions were extracted by AI from
+        The following e2e-test-specific instructions were extracted from
         the user's requirements and conversations. These instructions focus
         exclusively on test-related aspects such as test coverage priorities,
         specific edge cases to validate, business logic verification strategies,
         and critical user workflows that must be tested.
         
-        Apply these instructions when generating test scenarios to ensure the
-        tests align with the user's testing requirements and expectations.
-        If any instructions are not relevant to the target API operations,
-        you may ignore them.
+        Follow these instructions when generating test scenarios.
+        Carefully distinguish between:
+        - Suggestions or recommendations (consider these as guidance)
+        - Direct specifications or explicit commands (these must be followed exactly)
+        
+        When instructions contain direct specifications or explicit design decisions, 
+        follow them precisely even if you believe you have better alternatives.
 
         ${props.instruction}
 

package/src/orchestrate/test/histories/transformTestScenarioReviewHistories.ts

@@ -43,16 +43,19 @@ export function transformTestScenarioReviewHistories(props: {
       text: StringUtil.trim`
         ## Instructions
 
-        The following e2e-test-specific instructions were extracted by AI from
+        The following e2e-test-specific instructions were extracted from
         the user's requirements and conversations. These instructions focus
         exclusively on test-related aspects such as test coverage priorities,
         specific edge cases to validate, business logic verification strategies,
         and critical user workflows that must be tested.
         
-        Apply these instructions when reviewing test scenarios to ensure the
-        tests align with the user's testing requirements and expectations.
-        If any instructions are not relevant to the target API operations,
-        you may ignore them.
+        Follow these instructions when reviewing test scenarios.
+        Carefully distinguish between:
+        - Suggestions or recommendations (consider these as guidance)
+        - Direct specifications or explicit commands (these must be followed exactly)
+        
+        When instructions contain direct specifications or explicit design decisions, 
+        follow them precisely even if you believe you have better alternatives.
 
         ${props.instruction}