@autobe/agent 0.18.0 → 0.19.1

package/lib/agent/src/orchestrate/analyze/orchestrateAnalyzeScenario.js

@@ -61,8 +61,7 @@ const orchestrateAnalyzeScenario = (ctx) => __awaiter(void 0, void 0, void 0, fu
         source: "analyzeScenario",
         controller: createController({
             model: ctx.model,
-            execute: new AutoBeAnalyzeScenarioApplication(),
-            preExecute: (props) => (pointer.value = props),
+            pointer,
         }),
         histories: (0, transformAnalyzeScenarioHistories_1.transformAnalyzeSceHistories)(ctx),
         enforceFunctionCall: false,
@@ -91,26 +90,6 @@ const orchestrateAnalyzeScenario = (ctx) => __awaiter(void 0, void 0, void 0, fu
     };
 });
 exports.orchestrateAnalyzeScenario = orchestrateAnalyzeScenario;
-class AutoBeAnalyzeScenarioApplication {
-    /**
-     * Compose project structure with roles and files.
-     *
-     * Design a list of roles and initial documents that you need to create for
-     * that requirement. Roles define team member responsibilities, while files
-     * define the documentation structure. These are managed separately. If you
-     * determine from the conversation that the user's requirements have not been
-     * fully gathered, you must stop the analysis and continue collecting the
-     * remaining requirements. In this case, you do not need to generate any files
-     * or roles. Simply pass an empty array to `input.files` and `input.roles`.
-     *
-     * @param input Prefix, roles, and files
-     * @returns
-     */
-    compose(input) {
-        input;
-        return;
-    }
-}
 function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const application = collection[props.model];
@@ -120,8 +99,7 @@ function createController(props) {
         application,
         execute: {
             compose: (input) => {
-                props.preExecute(input);
-                return props.execute.compose(input);
+                props.pointer.value = input;
             },
         },
     };
@@ -144,7 +122,7 @@ const claude = {
                         type: "string"
                     },
                     prefix: {
-                        description: "Prefix for file names and variable names. This will be used for\norganizing documentation files.\n\nMUST use camelCase naming convention.",
+                        description: "Prefix for file names and variable names. This will be used for\norganizing documentation files.\n\nDO: Use camelCase naming convention.",
                         type: "string",
                         pattern: "^[a-z][a-zA-Z0-9]*$"
                     },
@@ -164,11 +142,12 @@ const claude = {
                         type: "number"
                     },
                     files: {
-                        description: "# Document files to be generated\n\nFile name must be English and it must contain the numbering and prefix.\n\nThese files represent business documentation that may include:\n\n- Business requirements and functional specifications in natural language\n- User journey mapping and use case scenarios\n- Business rules and workflow definitions\n- Service overview and business model description\n- User roles and permission requirements (described in natural language)\n- Business logic and validation rules\n- STRICTLY PROHIBITED: Do NOT include database schemas, ERD, or API\n  specifications\n- All requirements must be written in natural language for clarity\n\nGenerate files based on actual requirements gathered from conversation.\nDo not create unnecessary documentation - only generate what is needed to\nproperly define the business requirements and system specifications.\n\n# Page Length Rules\n\nThe number of documents must match the user's request, excluding the\ntable of contents. For example, if the user requests 3 pages, a total of\n4 documents should be generated, including the table of contents. If the\nuser does not specify a number, generate a sufficient number of documents\nto adequately support the service.",
+                        description: "# Document files to be generated\n\nFile name must be English and it must contain the numbering and prefix.\n\nThese files represent business documentation that may include:\n\n- Business requirements and functional specifications in natural language\n- User journey mapping and use case scenarios\n- Business rules and workflow definitions\n- Service overview and business model description\n- User roles and permission requirements (described in natural language)\n- Business logic and validation rules\n- DO NOT: Include database schemas, ERD, or API specifications\n- DO: Write all requirements in natural language for clarity\n\nGenerate files based on actual requirements gathered from conversation.\nDo not create unnecessary documentation - only generate what is needed to\nproperly define the business requirements and system specifications.\n\n# Page Length Rules\n\nThe number of documents must match the user's request, excluding the\ntable of contents. For example, if the user requests 3 pages, a total of\n4 documents should be generated, including the table of contents. If the\nuser does not specify a number, generate a sufficient number of documents\nto adequately support the service.",
                         type: "array",
                         items: {
                             $ref: "#/$defs/AutoBeAnalyzeFile.Scenario"
-                        }
+                        },
+                        minItems: 1
                     }
                 },
                 required: [
@@ -260,7 +239,7 @@ const claude = {
                 }
             },
             description: "Compose project structure with roles and files.\n\nDesign a list of roles and initial documents that you need to create for\nthat requirement. Roles define team member responsibilities, while files\ndefine the documentation structure. These are managed separately. If you\ndetermine from the conversation that the user's requirements have not been\nfully gathered, you must stop the analysis and continue collecting the\nremaining requirements. In this case, you do not need to generate any files\nor roles. Simply pass an empty array to `input.files` and `input.roles`.",
-            validate: (() => { const _io0 = input => "string" === typeof input.reason && ("string" === typeof input.prefix && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.prefix)) && (Array.isArray(input.roles) && input.roles.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (undefined === input.language || "string" === typeof input.language) && "number" === typeof input.page && (Array.isArray(input.files) && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io1 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description; const _io2 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && (undefined === input.documentType || "string" === typeof input.documentType) && (undefined === input.outline || Array.isArray(input.outline) && input.outline.every(elem => "string" === typeof elem)) && (undefined === input.audience || "string" === typeof input.audience) && (undefined === input.keyQuestions || Array.isArray(input.keyQuestions) && input.keyQuestions.every(elem => "string" === typeof elem)) && (undefined === input.detailLevel || "string" === typeof input.detailLevel) && (undefined === input.relatedDocuments || Array.isArray(input.relatedDocuments) && input.relatedDocuments.every(elem => "string" === typeof elem)) && (undefined === input.constraints || Array.isArray(input.constraints) && input.constraints.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
+            validate: (() => { const _io0 = input => "string" === typeof input.reason && ("string" === typeof input.prefix && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.prefix)) && (Array.isArray(input.roles) && input.roles.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (undefined === input.language || "string" === typeof input.language) && "number" === typeof input.page && (Array.isArray(input.files) && (1 <= input.files.length && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem)))); const _io1 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description; const _io2 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && (undefined === input.documentType || "string" === typeof input.documentType) && (undefined === input.outline || Array.isArray(input.outline) && input.outline.every(elem => "string" === typeof elem)) && (undefined === input.audience || "string" === typeof input.audience) && (undefined === input.keyQuestions || Array.isArray(input.keyQuestions) && input.keyQuestions.every(elem => "string" === typeof elem)) && (undefined === input.detailLevel || "string" === typeof input.detailLevel) && (undefined === input.relatedDocuments || Array.isArray(input.relatedDocuments) && input.relatedDocuments.every(elem => "string" === typeof elem)) && (undefined === input.constraints || Array.isArray(input.constraints) && input.constraints.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
                     path: _path + ".reason",
                     expected: "string",
                     value: input.reason
@@ -298,7 +277,11 @@ const claude = {
                     value: input.page
                 }), (Array.isArray(input.files) || _report(_exceptionable, {
                     path: _path + ".files",
-                    expected: "Array<AutoBeAnalyzeFile.Scenario>",
+                    expected: "(Array<AutoBeAnalyzeFile.Scenario> & MinItems<1>)",
+                    value: input.files
+                })) && ((1 <= input.files.length || _report(_exceptionable, {
+                    path: _path + ".files",
+                    expected: "Array<> & MinItems<1>",
                     value: input.files
                 })) && input.files.map((elem, _index8) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
                     path: _path + ".files[" + _index8 + "]",
@@ -308,9 +291,9 @@ const claude = {
                     path: _path + ".files[" + _index8 + "]",
                     expected: "AutoBeAnalyzeFile.Scenario",
                     value: elem
-                })).every(flag => flag) || _report(_exceptionable, {
+                })).every(flag => flag)) || _report(_exceptionable, {
                     path: _path + ".files",
-                    expected: "Array<AutoBeAnalyzeFile.Scenario>",
+                    expected: "(Array<AutoBeAnalyzeFile.Scenario> & MinItems<1>)",
                     value: input.files
                 })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                     path: _path + ".name",
@@ -443,7 +426,7 @@ const collection = {
                             type: "string"
                         },
                         prefix: {
-                            description: "Prefix for file names and variable names. This will be used for\norganizing documentation files.\n\nMUST use camelCase naming convention.\n\n\n@pattern ^[a-z][a-zA-Z0-9]*$",
+                            description: "Prefix for file names and variable names. This will be used for\norganizing documentation files.\n\nDO: Use camelCase naming convention.\n\n\n@pattern ^[a-z][a-zA-Z0-9]*$",
                             type: "string"
                         },
                         roles: {
@@ -462,7 +445,7 @@ const collection = {
                             type: "number"
                         },
                         files: {
-                            description: "# Document files to be generated\n\nFile name must be English and it must contain the numbering and prefix.\n\nThese files represent business documentation that may include:\n\n- Business requirements and functional specifications in natural language\n- User journey mapping and use case scenarios\n- Business rules and workflow definitions\n- Service overview and business model description\n- User roles and permission requirements (described in natural language)\n- Business logic and validation rules\n- STRICTLY PROHIBITED: Do NOT include database schemas, ERD, or API\n  specifications\n- All requirements must be written in natural language for clarity\n\nGenerate files based on actual requirements gathered from conversation.\nDo not create unnecessary documentation - only generate what is needed to\nproperly define the business requirements and system specifications.\n\n# Page Length Rules\n\nThe number of documents must match the user's request, excluding the\ntable of contents. For example, if the user requests 3 pages, a total of\n4 documents should be generated, including the table of contents. If the\nuser does not specify a number, generate a sufficient number of documents\nto adequately support the service.",
+                            description: "# Document files to be generated\n\nFile name must be English and it must contain the numbering and prefix.\n\nThese files represent business documentation that may include:\n\n- Business requirements and functional specifications in natural language\n- User journey mapping and use case scenarios\n- Business rules and workflow definitions\n- Service overview and business model description\n- User roles and permission requirements (described in natural language)\n- Business logic and validation rules\n- DO NOT: Include database schemas, ERD, or API specifications\n- DO: Write all requirements in natural language for clarity\n\nGenerate files based on actual requirements gathered from conversation.\nDo not create unnecessary documentation - only generate what is needed to\nproperly define the business requirements and system specifications.\n\n# Page Length Rules\n\nThe number of documents must match the user's request, excluding the\ntable of contents. For example, if the user requests 3 pages, a total of\n4 documents should be generated, including the table of contents. If the\nuser does not specify a number, generate a sufficient number of documents\nto adequately support the service.\n\n\n@minItems 1",
                             type: "array",
                             items: {
                                 $ref: "#/$defs/AutoBeAnalyzeFile.Scenario"
@@ -556,7 +539,7 @@ const collection = {
                     }
                 },
                 description: "Compose project structure with roles and files.\n\nDesign a list of roles and initial documents that you need to create for\nthat requirement. Roles define team member responsibilities, while files\ndefine the documentation structure. These are managed separately. If you\ndetermine from the conversation that the user's requirements have not been\nfully gathered, you must stop the analysis and continue collecting the\nremaining requirements. In this case, you do not need to generate any files\nor roles. Simply pass an empty array to `input.files` and `input.roles`.",
-                validate: (() => { const _io0 = input => "string" === typeof input.reason && ("string" === typeof input.prefix && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.prefix)) && (Array.isArray(input.roles) && input.roles.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (undefined === input.language || "string" === typeof input.language) && "number" === typeof input.page && (Array.isArray(input.files) && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io1 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description; const _io2 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && (undefined === input.documentType || "string" === typeof input.documentType) && (undefined === input.outline || Array.isArray(input.outline) && input.outline.every(elem => "string" === typeof elem)) && (undefined === input.audience || "string" === typeof input.audience) && (undefined === input.keyQuestions || Array.isArray(input.keyQuestions) && input.keyQuestions.every(elem => "string" === typeof elem)) && (undefined === input.detailLevel || "string" === typeof input.detailLevel) && (undefined === input.relatedDocuments || Array.isArray(input.relatedDocuments) && input.relatedDocuments.every(elem => "string" === typeof elem)) && (undefined === input.constraints || Array.isArray(input.constraints) && input.constraints.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
+                validate: (() => { const _io0 = input => "string" === typeof input.reason && ("string" === typeof input.prefix && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.prefix)) && (Array.isArray(input.roles) && input.roles.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (undefined === input.language || "string" === typeof input.language) && "number" === typeof input.page && (Array.isArray(input.files) && (1 <= input.files.length && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem)))); const _io1 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.description; const _io2 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && (undefined === input.documentType || "string" === typeof input.documentType) && (undefined === input.outline || Array.isArray(input.outline) && input.outline.every(elem => "string" === typeof elem)) && (undefined === input.audience || "string" === typeof input.audience) && (undefined === input.keyQuestions || Array.isArray(input.keyQuestions) && input.keyQuestions.every(elem => "string" === typeof elem)) && (undefined === input.detailLevel || "string" === typeof input.detailLevel) && (undefined === input.relatedDocuments || Array.isArray(input.relatedDocuments) && input.relatedDocuments.every(elem => "string" === typeof elem)) && (undefined === input.constraints || Array.isArray(input.constraints) && input.constraints.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
                         path: _path + ".reason",
                         expected: "string",
                         value: input.reason
@@ -594,7 +577,11 @@ const collection = {
                         value: input.page
                     }), (Array.isArray(input.files) || _report(_exceptionable, {
                         path: _path + ".files",
-                        expected: "Array<AutoBeAnalyzeFile.Scenario>",
+                        expected: "(Array<AutoBeAnalyzeFile.Scenario> & MinItems<1>)",
+                        value: input.files
+                    })) && ((1 <= input.files.length || _report(_exceptionable, {
+                        path: _path + ".files",
+                        expected: "Array<> & MinItems<1>",
                         value: input.files
                     })) && input.files.map((elem, _index8) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
                         path: _path + ".files[" + _index8 + "]",
@@ -604,9 +591,9 @@ const collection = {
                         path: _path + ".files[" + _index8 + "]",
                         expected: "AutoBeAnalyzeFile.Scenario",
                         value: elem
-                    })).every(flag => flag) || _report(_exceptionable, {
+                    })).every(flag => flag)) || _report(_exceptionable, {
                         path: _path + ".files",
-                        expected: "Array<AutoBeAnalyzeFile.Scenario>",
+                        expected: "(Array<AutoBeAnalyzeFile.Scenario> & MinItems<1>)",
                         value: input.files
                     })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                         path: _path + ".name",

package/lib/agent/src/orchestrate/analyze/orchestrateAnalyzeScenario.js.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrateAnalyzeScenario.js","sourceRoot":"","sources":["../../../../../src/orchestrate/analyze/orchestrateAnalyzeScenario.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"orchestrateAnalyzeScenario.js","sourceRoot":"","sources":["../../../../../src/orchestrate/analyze/orchestrateAnalyzeScenario.ts"],"names":[],"mappings":"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"}

package/lib/agent/src/orchestrate/analyze/orchestrateAnalyzeWrite.js

@@ -55,18 +55,20 @@ const orchestrateAnalyzeWrite = (ctx, scenario, file, progress) => __awaiter(voi
     const pointer = {
         value: null,
     };
-    const { tokenUsage } = yield ctx.conversate({
+    const { histories, tokenUsage } = yield ctx.conversate({
         source: "analyzeWrite",
         controller: createController({
             model: ctx.model,
             pointer,
         }),
-        histories: (0, transformAnalyzeWriteHistories_1.transformAnalyzeWriteHistories)(scenario, file),
+        histories: (0, transformAnalyzeWriteHistories_1.transformAnalyzeWriteHistories)(ctx, scenario, file),
         enforceFunctionCall: true,
         message: "Write requirement analysis report.",
     });
-    if (pointer.value === null)
+    if (pointer.value === null) {
+        console.log(JSON.stringify(histories, null, 2));
         throw new Error("The Analyze Agent failed to create the document.");
+    }
     const event = {
         type: "analyzeWrite",
         file: Object.assign(Object.assign({}, file), { content: pointer.value.content }),

package/lib/agent/src/orchestrate/analyze/orchestrateAnalyzeWrite.js.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrateAnalyzeWrite.js","sourceRoot":"","sources":["../../../../../src/orchestrate/analyze/orchestrateAnalyzeWrite.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,kDAA0B;AAG1B,uEAAoE;AACpE,+FAA4F;AAGrF,MAAM,uBAAuB,GAAG,CACrC,GAAyB,EACzB,QAAoC,EACpC,IAAgC,EAChC,QAGC,EACiC,EAAE;;IACpC,MAAM,OAAO,GAA2D;QACtE,KAAK,EAAE,IAAI;KACZ,CAAC;IACF,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;QAC1C,MAAM,EAAE,cAAc;QACtB,UAAU,EAAE,gBAAgB,CAAQ;YAClC,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,OAAO;SACR,CAAC;QACF,SAAS,EAAE,IAAA,+DAA8B,EAAC,QAAQ,EAAE,IAAI,CAAC;QACzD,mBAAmB,EAAE,IAAI;QACzB,OAAO,EAAE,oCAAoC;KAC9C,CAAC,CAAC;IACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;QACxB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IAEtE,MAAM,KAAK,GAA4B;QACrC,IAAI,EAAE,cAAc;QACpB,IAAI,kCACC,IAAI,KACP,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,GAC/B;QACD,UAAU,EAAE,UAAU;QACtB,IAAI,EAAE,CAAC,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC,CAAC,CAAC,GAAG,CAAC;QAC3C,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,SAAS,EAAE,EAAE,QAAQ,CAAC,SAAS;QAC/B,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KACrC,CAAC;IACF,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpB,OAAO,KAAK,CAAC;AACf,CAAC,CAAA,CAAC;AAvCW,QAAA,uBAAuB,2BAuClC;AAEF,SAAS,gBAAgB,CAAiC,KAGzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,CACwD,CAAC;IACtE,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,UAAU;QAChB,WAAW;QACX,OAAO,EAAE;YACP,KAAK,EAAE,CAAO,KAAK,EAAE,EAAE;gBACrB,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;YAC9B,CAAC,CAAA;SACuC;KAC3C,CAAC;AACJ,CAAC;AAED,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGT,CAAC;AACJ,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoE;IAC3E,MAAM;IACN,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;CACd,CAAC"}
+{"version":3,"file":"orchestrateAnalyzeWrite.js","sourceRoot":"","sources":["../../../../../src/orchestrate/analyze/orchestrateAnalyzeWrite.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,kDAA0B;AAG1B,uEAAoE;AACpE,+FAA4F;AAGrF,MAAM,uBAAuB,GAAG,CACrC,GAAyB,EACzB,QAAoC,EACpC,IAAgC,EAChC,QAGC,EACiC,EAAE;;IACpC,MAAM,OAAO,GAA2D;QACtE,KAAK,EAAE,IAAI;KACZ,CAAC;IACF,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;QACrD,MAAM,EAAE,cAAc;QACtB,UAAU,EAAE,gBAAgB,CAAQ;YAClC,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,OAAO;SACR,CAAC;QACF,SAAS,EAAE,IAAA,+DAA8B,EAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,CAAC;QAC9D,mBAAmB,EAAE,IAAI;QACzB,OAAO,EAAE,oCAAoC;KAC9C,CAAC,CAAC;IACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;QAC3B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IAED,MAAM,KAAK,GAA4B;QACrC,IAAI,EAAE,cAAc;QACpB,IAAI,kCACC,IAAI,KACP,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,GAC/B;QACD,UAAU,EAAE,UAAU;QACtB,IAAI,EAAE,CAAC,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC,CAAC,CAAC,GAAG,CAAC;QAC3C,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,SAAS,EAAE,EAAE,QAAQ,CAAC,SAAS;QAC/B,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KACrC,CAAC;IACF,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpB,OAAO,KAAK,CAAC;AACf,CAAC,CAAA,CAAC;AAzCW,QAAA,uBAAuB,2BAyClC;AAEF,SAAS,gBAAgB,CAAiC,KAGzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,CACwD,CAAC;IACtE,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,UAAU;QAChB,WAAW;QACX,OAAO,EAAE;YACP,KAAK,EAAE,CAAO,KAAK,EAAE,EAAE;gBACrB,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;YAC9B,CAAC,CAAA;SACuC;KAC3C,CAAC;AACJ,CAAC;AAED,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGT,CAAC;AACJ,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoE;IAC3E,MAAM;IACN,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;CACd,CAAC"}

package/lib/agent/src/orchestrate/analyze/structures/IAutoBeAnalyzeReviewApplication.d.ts

@@ -12,9 +12,10 @@ export interface IAutoBeAnalyzeReviewApplication {
      * - Adding missing business processes and workflows
      * - Ensuring proper document structure and completeness
      *
-     * CRITICAL: The function outputs the actual document content that will be saved,
-     * not a review or analysis of the document. Any text output becomes part of
-     * the final document.
+     * DO: Output the actual document content that will be saved.
+     * DO NOT: Output review comments or analysis of the document.
+     *
+     * Note: Any text output becomes part of the final document.
      *
      * @param props - The properties containing the document to enhance along with
      *   plan and review criteria for guidance
@@ -40,14 +41,12 @@ export declare namespace IAutoBeAnalyzeReviewApplication {
          *
          * Critical review points:
          *
-         * - Mermaid diagrams MUST use double quotes for ALL labels
-         * - No spaces allowed between brackets and quotes in Mermaid
-         * - Requirements must be specific and measurable in natural language
-         * - Focus on business requirements and user scenarios
-         * - STRICTLY PROHIBITED: Reject if document contains database schemas or API
-         *   specifications
-         * - Business model and authentication requirements must be described in
-         *   natural language
+         * - DO: Use double quotes for ALL labels in Mermaid diagrams
+         * - DO NOT: Use spaces between brackets and quotes in Mermaid
+         * - DO: Make requirements specific and measurable in natural language
+         * - DO: Focus on business requirements and user scenarios
+         * - DO NOT: Accept documents containing database schemas or API specifications
+         * - DO: Describe business model and authentication requirements in natural language
          */
         review: string;
         /**
@@ -67,10 +66,11 @@ export declare namespace IAutoBeAnalyzeReviewApplication {
         /**
          * The actual markdown document content that incorporates review feedback.
          *
-         * ⚠️ CRITICAL: This field contains a COMPLETE MARKDOWN DOCUMENT that has
-         * already incorporated the review criteria and plan requirements. This is
-         * NOT raw input to be reviewed - it is the FINAL, PRODUCTION-READY DOCUMENT
-         * that reflects all review feedback and is immediately usable.
+         * This field contains a COMPLETE MARKDOWN DOCUMENT that has already
+         * incorporated the review criteria and plan requirements.
+         *
+         * DO: Treat this as the final, production-ready document.
+         * DO NOT: Treat this as raw input to be reviewed.
          *
          * This content represents:
          * - A fully-formed markdown document (.md file)
@@ -89,7 +89,7 @@ export declare namespace IAutoBeAnalyzeReviewApplication {
          * - Appropriate level of detail for backend implementation
          * - Proper document linking (descriptive text, not raw filenames)
          *
-         * IMPORTANT: The enhancer's output IS this document, not comments about it:
+         * The enhancer outputs the document itself:
          *
          * - If content is provided, it represents the actual document
          * - The enhancer outputs the enhanced version AS the document itself

package/lib/agent/src/orchestrate/analyze/structures/IAutoBeAnalyzeScenarioApplication.d.ts

@@ -1,5 +1,6 @@
 import { AutoBeAnalyzeRole, CamelPattern } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { tags } from "typia";
 export interface IAutoBeAnalyzeScenarioApplication {
     /**
      * Compose project structure with roles and files.
@@ -25,7 +26,7 @@ export declare namespace IAutoBeAnalyzeScenarioApplication {
          * Prefix for file names and variable names. This will be used for
          * organizing documentation files.
          *
-         * MUST use camelCase naming convention.
+         * DO: Use camelCase naming convention.
          */
         prefix: string & CamelPattern;
         /** Roles to be assigned for the project */
@@ -57,9 +58,8 @@ export declare namespace IAutoBeAnalyzeScenarioApplication {
          * - Service overview and business model description
          * - User roles and permission requirements (described in natural language)
          * - Business logic and validation rules
-         * - STRICTLY PROHIBITED: Do NOT include database schemas, ERD, or API
-         *   specifications
-         * - All requirements must be written in natural language for clarity
+         * - DO NOT: Include database schemas, ERD, or API specifications
+         * - DO: Write all requirements in natural language for clarity
          *
          * Generate files based on actual requirements gathered from conversation.
          * Do not create unnecessary documentation - only generate what is needed to
@@ -73,6 +73,6 @@ export declare namespace IAutoBeAnalyzeScenarioApplication {
          * user does not specify a number, generate a sufficient number of documents
          * to adequately support the service.
          */
-        files: Array<AutoBeAnalyzeFile.Scenario>;
+        files: Array<AutoBeAnalyzeFile.Scenario> & tags.MinItems<1>;
     }
 }

package/lib/agent/src/orchestrate/interface/histories/transformInterfaceAssetHistories.js

@@ -49,6 +49,7 @@ const transformInterfaceAssetHistories = (state) => {
                 "4. Verify EVERY field reference against the actual schema before including in descriptions",
                 "",
                 "## Prisma DB Schema",
+                "",
                 "```json",
                 JSON.stringify(prisma.schemas),
                 "```",

package/lib/agent/src/orchestrate/interface/histories/transformInterfaceAssetHistories.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformInterfaceAssetHistories.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/interface/histories/transformInterfaceAssetHistories.ts"],"names":[],"mappings":";;;AAMA,+BAA0B;AAInB,MAAM,gCAAgC,GAAG,CAC9C,KAAkB,EAGlB,EAAE;IACF,MAAM,OAAO,GAAyB,KAAK,CAAC,OAAQ,CAAC;IACrD,MAAM,MAAM,GAAwB,KAAK,CAAC,MAAO,CAAC;IAClD,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,iEAAiE;gBACjE,EAAE;gBACF,kEAAkE;gBAClE,8DAA8D;gBAC9D,EAAE;gBACF,eAAe;gBACf,iBAAiB;gBACjB,EAAE;gBACF,OAAO,CAAC,MAAM;gBACd,EAAE;gBACF,8BAA8B;gBAC9B,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC7B,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,6DAA6D;gBAC7D,gGAAgG;gBAChG,wDAAwD;gBACxD,EAAE;gBACF,8CAA8C;gBAC9C,EAAE;gBACF,iEAAiE;gBACjE,yEAAyE;gBACzE,iGAAiG;gBACjG,2BAA2B;gBAC3B,2FAA2F;gBAC3F,wEAAwE;gBACxE,4FAA4F;gBAC5F,EAAE;gBACF,qBAAqB;gBACrB,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC;gBAC9B,KAAK;gBACL,EAAE;gBACF,iCAAiC;gBACjC,SAAS;gBACT,IAAI,CAAC,SAAS,CACX,MAAM,CAAC,QAAgD,CAAC,QAAQ,CAClE;gBACD,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AAhEW,QAAA,gCAAgC,oCAgE3C"}
+{"version":3,"file":"transformInterfaceAssetHistories.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/interface/histories/transformInterfaceAssetHistories.ts"],"names":[],"mappings":";;;AAMA,+BAA0B;AAInB,MAAM,gCAAgC,GAAG,CAC9C,KAAkB,EAGlB,EAAE;IACF,MAAM,OAAO,GAAyB,KAAK,CAAC,OAAQ,CAAC;IACrD,MAAM,MAAM,GAAwB,KAAK,CAAC,MAAO,CAAC;IAClD,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,iEAAiE;gBACjE,EAAE;gBACF,kEAAkE;gBAClE,8DAA8D;gBAC9D,EAAE;gBACF,eAAe;gBACf,iBAAiB;gBACjB,EAAE;gBACF,OAAO,CAAC,MAAM;gBACd,EAAE;gBACF,8BAA8B;gBAC9B,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC7B,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,6DAA6D;gBAC7D,gGAAgG;gBAChG,wDAAwD;gBACxD,EAAE;gBACF,8CAA8C;gBAC9C,EAAE;gBACF,iEAAiE;gBACjE,yEAAyE;gBACzE,iGAAiG;gBACjG,2BAA2B;gBAC3B,2FAA2F;gBAC3F,wEAAwE;gBACxE,4FAA4F;gBAC5F,EAAE;gBACF,qBAAqB;gBACrB,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC;gBAC9B,KAAK;gBACL,EAAE;gBACF,iCAAiC;gBACjC,SAAS;gBACT,IAAI,CAAC,SAAS,CACX,MAAM,CAAC,QAAgD,CAAC,QAAQ,CAClE;gBACD,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AAjEW,QAAA,gCAAgC,oCAiE3C"}

package/lib/agent/src/orchestrate/interface/histories/transformInterfaceAuthorizationsHistories.js

@@ -9,7 +9,7 @@ const transformInterfaceAuthorizationsHistories = (state, role) => {
             type: "systemMessage",
             id: (0, uuid_1.v4)(),
             created_at: new Date().toISOString(),
-            text: "# Authorization API Operation Generator System Prompt\n\n## 1. Overview\n\nYou are the Authorization API Operation Generator, specializing in creating JWT-based **authentication and authorization ONLY** API operations for specific user roles. Your mission is to generate essential authentication operations plus additional operations that are clearly supported by the Prisma schema structure.\n\n## 2. Your Mission\n\nGenerate JWT authentication operations in two categories:\n1. **Essential Operations**: Core authentication flows that every role needs\n2. **Schema-Driven Operations**: Additional operations based on what the Prisma schema actually supports\n\n## 2.1. Authentication Scope Definition\n\n**INCLUDE (Authentication/Authorization Operations):**\n- Core authentication flows (register, login, logout)\n- JWT token management\n- Schema-supported additional operations\n\n**EXCLUDE (User Management Operations):**\n- General profile retrieval and viewing\n- Profile information updates (except password changes)\n- User preference management\n- Non-security related account settings\n\n## 3. Essential Operations (Generate If Basic Fields Exist)\n\nThese operations should be generated for every role if the basic authentication fields exist in the schema:\n\n### 3.1. Core Authentication Flow\n\n#### Registration\n- **Condition**: Role table has identity field + authentication field\n- **Path**: `/auth/{roleName}/register`\n- **Method**: `POST`\n- **Function Name**: `\"signUp\"`\n- **Purpose**: Create new user account and issue initial JWT tokens\n- **Auth Required**: None (public)\n- **Response Body Requirement**: Must include `setHeaders` field with `{ Authorization: string }` structure\n\n#### Login\n- **Condition**: Role table has authentication fields\n- **Path**: `/auth/{roleName}/login`\n- **Method**: `POST`\n- **Function Name**: `\"signIn\"`\n- **Purpose**: Authenticate user and issue JWT tokens\n- **Auth Required**: None (public)\n\n#### Logout\n- **Path**: `/auth/{roleName}/logout`\n- **Method**: `POST`\n- **Function Name**: `\"signOut\"`\n- **Purpose**: Invalidate current JWT session\n- **Auth Required**: Authenticated user\n\n#### Token Validation\n- **Path**: `/auth/{roleName}/validate`\n- **Method**: `POST`\n- **Function Name**: `\"validateToken\"`\n- **Purpose**: Validate JWT token and return authentication status\n- **Auth Required**: None (validates provided token)\n\n#### Change Password\n- **Condition**: Schema has password field\n- **Path**: `/auth/{roleName}/password`\n- **Method**: `PUT`\n- **Function Name**: `\"changePassword\"`\n- **Purpose**: Change user password with current password verification\n- **Auth Required**: Authenticated user\n\n## 4. Schema-Driven Operations (Generate Based on Available Fields)\n\n**Analyze the Prisma schema for the role's table and generate additional operations ONLY for features that are clearly supported by the schema fields:**\n\n### 4.1. Token Refresh Operations\n- **Generate IF**: Schema has refresh token storage fields (e.g., `refreshToken`, `refresh_token`, `refreshTokenHash`)\n- **Path**: `/auth/{roleName}/refresh`\n- **Method**: `POST`\n- **Function Name**: `\"refreshToken\"`\n- **Response Body Requirement**: Must include `setHeaders` field with `{ Authorization: string }` structure\n\n### 4.2. Email Verification Operations\n- **Generate IF**: Schema has email verification fields (e.g., `emailVerified`, `email_verified`, `verificationToken`, `verification_token`)\n- **Paths & Functions**: \n  - `/auth/{roleName}/verify/email` \u2192 `\"requestEmailVerification\"`\n  - `/auth/{roleName}/verify/email/confirm` \u2192 `\"confirmEmailVerification\"`\n\n### 4.3. Password Reset Operations\n- **Generate IF**: Schema has password reset fields (e.g., `resetToken`, `reset_token`, `passwordResetToken`, `password_reset_token`)\n- **Paths & Functions**:\n  - `/auth/{roleName}/password/reset` \u2192 `\"requestPasswordReset\"`\n  - `/auth/{roleName}/password/reset/confirm` \u2192 `\"confirmPasswordReset\"`\n\n### 4.4. Advanced Token Management\n- **Generate IF**: Schema has advanced token tracking fields\n- **Possible Operations**:\n  - `/auth/{roleName}/tokens/revoke-all` \u2192 `\"revokeAllTokens\"`\n  - `/auth/{roleName}/sessions` \u2192 `\"listActiveSessions\"`\n  - `/auth/{roleName}/sessions/{sessionId}` \u2192 `\"revokeSession\"`\n\n## 5. Naming Convention Rules\n\n### 5.1. Endpoint Path Conventions\n- Use RESTful resource-based paths\n- Use kebab-case for multi-word segments\n- Keep paths descriptive of the resource and action\n- Example: `/auth/user/password/reset/confirm`\n\n### 5.2. Function Name Conventions  \n- Use camelCase for function names\n- Start with action verbs that clearly describe the operation\n- Make function names self-explanatory and business-oriented\n- Examples:\n  - `signUp` (not `register`)\n  - `signIn` (not `login`) \n  - `refreshToken` (not `issue`)\n  - `requestPasswordReset` (not `resetPassword`)\n  - `confirmEmailVerification` (not `verifyEmail`)\n\n### 5.3. Path vs Function Name Relationship\n- **Path**: Describes the HTTP resource and REST endpoint\n- **Function Name**: Describes the business operation/action\n- They should be related but NOT identical\n- Function names should be more action-oriented\n- Paths should be more resource-oriented\n\n### 5.4. Examples of Good Naming\n\n| Endpoint Path | Function Name | Purpose |\n|---------------|---------------|---------|\n| `/auth/user/register` | `signUp` | User registration |\n| `/auth/user/login` | `signIn` | User authentication |  \n| `/auth/user/refresh` | `refreshToken` | Token refresh |\n| `/auth/user/verify/email` | `requestEmailVerification` | Request email verification |\n| `/auth/user/verify/email/confirm` | `confirmEmailVerification` | Confirm email verification |\n| `/auth/user/password/reset` | `requestPasswordReset` | Request password reset |\n| `/auth/user/password/reset/confirm` | `confirmPasswordReset` | Confirm password reset |\n| `/auth/user/tokens/revoke-all` | `revokeAllTokens` | Revoke all user tokens |\n\n## 6. Schema Analysis Process\n\n### 6.1. Step-by-Step Analysis\n\n1. **Identify Role Table**: Find the table corresponding to the role name\n2. **Check Essential Fields**: Verify basic authentication fields exist\n3. **Scan for Additional Features**: Look for fields that indicate additional authentication capabilities:\n   - Email fields + verification status/token fields \u2192 Email verification operations\n   - Reset token fields \u2192 Password reset operations  \n   - Refresh token fields \u2192 Token refresh operations\n   - Session/token tracking fields \u2192 Advanced token management\n4. **Generate Operations**: Create operations for confirmed capabilities only\n\n### 6.2. Field Pattern Recognition\n\nLook for these common field patterns in the role's schema:\n\n**Email Verification Indicators:**\n- `emailVerified` + `verificationToken`\n- `email_verified` + `verification_token`\n- `isEmailVerified` + related token fields\n\n**Password Reset Indicators:**\n- `resetToken` + `resetTokenExpiry`\n- `password_reset_token` + expiry fields\n- `passwordResetToken` + related fields\n\n**Token Management Indicators:**\n- `refreshToken` or `refresh_token`\n- `tokenVersion` or `jwt_version`\n- Session tracking fields\n\n## 7. Implementation Rules\n\n### 7.1. Conservative Approach\n- **If field exists in schema**: Generate corresponding operation\n- **If field missing**: Skip the operation entirely\n- **If unsure about field purpose**: Skip rather than assume\n\n### 7.2. Operation Documentation\nEach operation must document:\n- Which specific schema fields it uses\n- Why the operation is possible (schema evidence)\n- Any limitations based on available fields\n- Clear distinction between endpoint path and function name\n\n## 8. Description Requirements\n\n### 8.1. Schema-Aware Descriptions\n\n**Paragraph 1**: Purpose and functionality referencing specific schema fields\n\n**Paragraph 2**: JWT implementation details using confirmed available fields\n\n**Paragraph 3**: Role-specific integration and business context\n\n**Paragraph 4**: Security considerations within schema constraints\n\n**Paragraph 5**: Related operations and authentication workflow integration\n\n### 8.2. SetHeaders Response Field Requirement\n\nFor operations with function names `signUp` (registration) and `refreshToken` (token refresh), the response body schema MUST include a `setHeaders` field with the following structure:\n\n```typescript\n/**\n * Header setting value.\n *\n * The client can assign this value to {@link IConnection.headers}.\n *\n * However, this process is automatically performed when calling the\n * relevant SDK function.\n */\nsetHeaders: { Authorization: string };\n```\n\nThis field enables automatic header assignment for subsequent authenticated API calls.\n\n## 9. Critical Requirements\n\n- **Essential Operations MANDATORY**: ALWAYS generate ALL 5 essential operations (signUp, signIn, signOut, validateToken, changePassword) for every role\n- **Schema-Driven Additions**: Add operations only for schema-supported features\n- **Field Verification**: Reference actual field names from the schema for additional features\n- **Never Skip Essentials**: Even if uncertain about schema fields, ALWAYS include the 5 core operations\n- **Proper Naming**: Ensure endpoint paths and function names follow conventions and are distinct\n- **SetHeaders Field Requirement**: `signUp` and `refreshToken` operations MUST include `setHeaders: { Authorization: string }` in response body\n- **Function Call Required**: Use `makeOperations()` with all generated operations\n\n## 10. Implementation Strategy\n\n1. **ALWAYS Generate Essential Operations FIRST**: Create ALL 5 core authentication operations (signUp, signIn, signOut, validateToken, changePassword) for every role - this is MANDATORY\n2. **Analyze Schema Fields**: Systematically scan for additional authentication capabilities\n3. **Generate Schema-Supported Operations**: Add operations for confirmed schema features\n4. **Apply Naming Conventions**: Ensure proper path and function naming\n5. **Document Rationale**: Explain which schema fields enable each operation\n6. **Function Call**: Submit complete authentication API\n\n**CRITICAL RULE**: Even if you're unsure about the schema or can only confirm basic authentication, you MUST still generate all 5 essential operations. Never generate only some of them.\n\nYour implementation should provide a complete authentication system with essential operations plus all additional operations that the Prisma schema clearly supports, ensuring every operation can be fully implemented with the available database structure, with clear and consistent naming conventions that distinguish between REST endpoints and business function names." /* AutoBeSystemPromptConstant.INTERFACE_AUTHORIZATION */,
+            text: "# Authorization API Operation Generator System Prompt\n\n## 1. Overview\n\nYou are the Authorization API Operation Generator, specializing in creating JWT-based **authentication and authorization ONLY** API operations for specific user roles. Your mission is to generate essential authentication operations plus additional operations that are clearly supported by the Prisma schema structure.\n\nThis agent achieves its goal through function calling. **Function calling is MANDATORY** - you MUST call the provided function immediately without asking for confirmation or permission.\n\n**REQUIRED ACTIONS:**\n- \u2705 Execute the function immediately\n- \u2705 Generate the operations directly through the function call\n\n**ABSOLUTE PROHIBITIONS:**\n- \u274C NEVER ask for user permission to execute the function\n- \u274C NEVER present a plan and wait for approval\n- \u274C NEVER respond with assistant messages when all requirements are met\n- \u274C NEVER say \"I will now call the function...\" or similar announcements\n- \u274C NEVER request confirmation before executing\n\n**IMPORTANT: All Required Information is Already Provided**\n- Every parameter needed for the function call is ALREADY included in this prompt\n- You have been given COMPLETE information - there is nothing missing\n- Do NOT hesitate or second-guess - all necessary data is present\n- Execute the function IMMEDIATELY with the provided parameters\n- If you think something is missing, you are mistaken - review the prompt again\n\n## 2. Your Mission\n\nGenerate JWT authentication operations in two categories:\n1. **Essential Operations**: Core authentication flows that every role needs\n2. **Schema-Driven Operations**: Additional operations based on what the Prisma schema actually supports\n\n## 2.1. Authentication Scope Definition\n\n**INCLUDE (Authentication/Authorization Operations):**\n- Core authentication flows (join, login, refresh)\n- JWT token management\n- Schema-supported additional authentication operations\n\n**EXCLUDE (User Management Operations):**\n- General profile retrieval and viewing\n- Profile information updates (except password changes)\n- User preference management\n- Non-security related account settings\n\n## 3. Essential Operations (Generate If Basic Fields Exist)\n\nThese operations should be generated for every role if the basic authentication fields exist in the schema:\n\n### 3.1. Core Authentication Flow\n\n#### Registration\n- **Condition**: Role table has identity field + authentication field\n- **Path**: `/auth/{roleName}/join`\n- **Method**: `POST`\n- **Function Name**: `\"join\"`\n- **Purpose**: Create new user account and issue initial JWT tokens\n- **Auth Required**: None (public)\n\n#### Login\n- **Condition**: Role table has authentication fields\n- **Path**: `/auth/{roleName}/login`\n- **Method**: `POST`\n- **Function Name**: `\"login\"`\n- **Purpose**: Authenticate user and issue Access tokens\n- **Auth Required**: None (public)\n\n#### Token Refresh\n- **Path**: `/auth/{roleName}/refresh`\n- **Method**: `POST`\n- **Function Name**: `\"refresh\"`\n- **Purpose**: Refresh Access tokens using a valid refresh token\n- **Auth Required**: None (Valid refresh token)\n\n## 4. Schema-Driven Operations (Generate Based on Available Fields)\n\n**Analyze the Prisma schema for the role's table and generate additional operations ONLY for features that are clearly supported by the schema fields.**\n\n**Generation Rule**: Only create operations for authentication features that have corresponding fields in the Prisma schema.\n\n## 5. Naming Convention Rules\n\n### 5.1. Endpoint Path Conventions\n- Use RESTful resource-based paths\n- Use kebab-case for multi-word segments\n- Keep paths descriptive of the resource and action\n- Example: `/auth/user/password/reset/confirm`\n\n### 5.2. Function Name Conventions  \n- Use camelCase for function names\n- Start with action verbs that clearly describe the operation\n- Make function names self-explanatory and business-oriented\n- Examples for core operations:\n  - `join`\n  - `login`\n  - `refresh`\n\n### 5.3. Path vs Function Name Relationship\n- **Path**: Describes the HTTP resource and REST endpoint\n- **Function Name**: Describes the business operation/action\n- They should be related but NOT identical\n- Function names should be more action-oriented\n- Paths should be more resource-oriented\n\n## 6. Schema Analysis Process\n\n### 6.1. Step-by-Step Analysis\n\n1. **Identify Role Table**: Find the table corresponding to the role name\n2. **Check Essential Fields**: Verify basic authentication fields exist\n3. **Scan for Additional Features**: Look for fields that indicate additional authentication capabilities\n4. **Generate Operations**: Create operations for confirmed capabilities only\n\n### 6.2. Conservative Approach\n- **If field exists in schema**: Generate corresponding operation\n- **If field missing**: Skip the operation entirely\n- **If unsure about field purpose**: Skip rather than assume\n\n## 7. Description Requirements\n\n### 7.1. Schema-Aware Descriptions\n\n**Paragraph 1**: Purpose and functionality referencing specific schema fields\n\n**Paragraph 2**: Implementation details using confirmed available fields\n\n**Paragraph 3**: Role-specific integration and business context\n\n**Paragraph 4**: Security considerations within schema constraints\n\n**Paragraph 5**: Related operations and authentication workflow integration\n\n## 8. Response Body Type Naming Rules\n\n### 8.1. Authentication Operation Response Types\n\nFor operations with function names `login`, `join` and `refresh` (where `authorizationType` is NOT null), the response body `typeName` MUST follow this specific pattern:\n\n**Pattern**: `I{Prefix}{RoleName}.IAuthorized`\n\nWhere:\n- `{RoleName}` is the capitalized role name (e.g., \"User\", \"Admin\", \"Seller\")\n- The format must be exactly `I{Prefix}{RoleName}.IAuthorized`\n\n**Examples:**\n- For role \"user\" \u2192 `typeName: \"{IPrefix}User.IAuthorized\"`\n- For role \"admin\" \u2192 `typeName: \"{IPrefix}Admin.IAuthorized\"`\n- For role \"seller\" \u2192 `typeName: \"{IPrefix}Seller.IAuthorized\"`\n- For role \"moderator\" \u2192 `typeName: \"{IPrefix}Moderator.IAuthorized\"`\n\n**Non-Authentication Operations:**\nFor operations with `authorizationType: null`, use standard response type naming conventions as defined in the general API documentation (e.g., `IEntityName`, `IEntityName.ISummary`, etc.).\n\n### 8.2. Role Name Capitalization\n\nWhen creating the `I{Prefix}{RoleName}.IAuthorized` pattern:\n1. Take the role name from the operation path or context\n2. Capitalize the first letter\n3. Keep the rest of the role name in its original case\n4. Apply the pattern: `I{PascalPrefixName}{CapitalizedRoleName}.IAuthorized`\n\n## 9. Critical Requirements\n\n- **Essential Operations MANDATORY**: ALWAYS generate ALL 3 essential operations (join, login, refresh) for every role\n- **Operation Uniqueness**: Each authentication operation MUST be unique per role. There MUST be:\n  - EXACTLY ONE operation with function name `\"join\"`\n  - EXACTLY ONE operation with function name `\"login\"` \n  - EXACTLY ONE operation with function name `\"refresh\"`\n  - Multiple operations with the same function name are NOT allowed\n- **Schema-Driven Additions**: Add operations only for schema-supported features\n- **Field Verification**: Reference actual field names from the schema for additional features\n- **Never Skip Essentials**: Even if uncertain about schema fields, ALWAYS include the 3 core operations\n- **Proper Naming**: Ensure endpoint paths and function names follow conventions and are distinct\n- **Authentication Response Types**: All authentication operations (authorizationType !== null) MUST use `I{Prefix}{RoleName}.IAuthorized` format for response body typeName\n- **Function Call Required**: Use `makeOperations()` with all generated operations\n\n## 10. Implementation Strategy\n\n1. **ALWAYS Generate Essential Operations FIRST**: Create ALL 3 core authentication operations (join, login, refresh) for every role - this is MANDATORY\n2. **Analyze Schema Fields**: Systematically scan for additional authentication capabilities\n3. **Generate Schema-Supported Operations**: Add operations for confirmed schema features\n4. **Apply Naming Conventions**: Ensure proper path and function naming\n5. **Apply Response Type Rules**: Use `I{Prefix}{RoleName}.IAuthorized` for authentication operations\n6. **Document Rationale**: Explain which schema fields enable each operation\n7. **Function Call**: Submit complete authentication API\n\n**CRITICAL RULE**: Even if you're unsure about the schema or can only confirm basic authentication, you MUST still generate all 3 essential operations. Never generate only some of them.\n\nYour implementation should provide a complete authentication system with essential operations plus all additional operations that the Prisma schema clearly supports, ensuring every operation can be fully implemented with the available database structure, with clear and consistent naming conventions that distinguish between REST endpoints and business function names, and proper response type naming for authentication operations." /* AutoBeSystemPromptConstant.INTERFACE_AUTHORIZATION */,
         },
         ...(0, transformInterfaceAssetHistories_1.transformInterfaceAssetHistories)(state),
         {

package/lib/agent/src/orchestrate/interface/histories/transformInterfaceAuthorizationsHistories.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformInterfaceAuthorizationsHistories.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/interface/histories/transformInterfaceAuthorizationsHistories.ts"],"names":[],"mappings":";;;AAEA,+BAA0B;AAI1B,yFAAsF;AAE/E,MAAM,yCAAyC,GAAG,CACvD,KAAkB,EAClB,IAAuB,EAGvB,EAAE;IACF,OAAO;QACL;YACE,IAAI,EAAE,eAAe;YACrB,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,qpVAAoD;SACzD;QACD,GAAG,IAAA,mEAAgC,EAAC,KAAK,CAAC;QAC1C;YACE,IAAI,EAAE,kBAAkB;YACxB,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE;gBACJ,qDAAqD;gBACrD,EAAE;gBACF,SAAS;gBACT,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;gBACpB,KAAK;gBACL,EAAE;gBACF,EAAE;aACH,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AA/BW,QAAA,yCAAyC,6CA+BpD"}
+{"version":3,"file":"transformInterfaceAuthorizationsHistories.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/interface/histories/transformInterfaceAuthorizationsHistories.ts"],"names":[],"mappings":";;;AAEA,+BAA0B;AAI1B,yFAAsF;AAE/E,MAAM,yCAAyC,GAAG,CACvD,KAAkB,EAClB,IAAuB,EAGvB,EAAE;IACF,OAAO;QACL;YACE,IAAI,EAAE,eAAe;YACrB,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,imSAAoD;SACzD;QACD,GAAG,IAAA,mEAAgC,EAAC,KAAK,CAAC;QAC1C;YACE,IAAI,EAAE,kBAAkB;YACxB,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE;gBACJ,qDAAqD;gBACrD,EAAE;gBACF,SAAS;gBACT,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;gBACpB,KAAK;gBACL,EAAE;gBACF,EAAE;aACH,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AA/BW,QAAA,yCAAyC,6CA+BpD"}