@autobe/agent 0.27.0 → 0.28.1

package/lib/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/orchestrate/analyze/orchestrateAnalyzeWrite.js

@@ -87,7 +87,11 @@ const orchestrateAnalyzeWrite = (ctx, props) => __awaiter(void 0, void 0, void 0
 exports.orchestrateAnalyzeWrite = orchestrateAnalyzeWrite;
 function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
-    const application = collection[props.model];
+    const application = collection[props.model === "chatgpt"
+        ? "chatgpt"
+        : props.model === "gemini"
+            ? "gemini"
+            : "claude"];
     return {
         protocol: "class",
         name: "Planning",
@@ -99,81 +103,150 @@ function createController(props) {
         },
     };
 }
-const claude = {
-    model: "claude",
-    options: {
-        reference: true,
-        separate: null
-    },
-    functions: [
-        {
-            name: "write",
-            parameters: {
-                description: " - The properties containing the document plan and initial\ncontent\n\n------------------------------\n\nCurrent Type: {@link IAutoBeAnalyzeWriteApplication.IProps}",
-                type: "object",
-                properties: {
-                    plan: {
-                        description: "Step 1 (CoT: Plan Phase) - Document Planning Structure\n\nThe document planning structure that outlines what needs to be written.\n\nThis includes:\n\n- Document title and purpose\n- Table of contents structure\n- Key sections to be covered\n- Relationships with other documents\n- Target audience (backend developers)\n\nThe plan serves as a roadmap for the AI agent to ensure all necessary\ntopics are covered in the documentation process.\n\nExample plan structure:\n\n- Service overview with business model\n- User actors and authentication requirements\n- Functional requirements with EARS format\n- Non-functional requirements\n- Business requirements in natural language\n- User scenarios and use cases",
-                        type: "string"
+const collection = {
+    chatgpt: {
+        model: "chatgpt",
+        options: {
+            reference: true,
+            strict: false,
+            separate: null
+        },
+        functions: [
+            {
+                name: "write",
+                parameters: {
+                    description: " - The properties containing the document plan and initial\ncontent\n\n------------------------------\n\nCurrent Type: {@link IAutoBeAnalyzeWriteApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        plan: {
+                            description: "Step 1 (CoT: Plan Phase) - Document Planning Structure\n\nThe document planning structure that outlines what needs to be written.\n\nThis includes:\n\n- Document title and purpose\n- Table of contents structure\n- Key sections to be covered\n- Relationships with other documents\n- Target audience (backend developers)\n\nThe plan serves as a roadmap for the AI agent to ensure all necessary\ntopics are covered in the documentation process.\n\nExample plan structure:\n\n- Service overview with business model\n- User actors and authentication requirements\n- Functional requirements with EARS format\n- Non-functional requirements\n- Business requirements in natural language\n- User scenarios and use cases",
+                            type: "string"
+                        },
+                        content: {
+                            description: "Step 2 (CoT: Write Phase) - Complete Document Content\n\nThe complete, production-ready markdown document content to be saved.\n\nRequirements:\n\n- Minimum 5,000 characters for technical documents\n- Uses EARS format for all applicable requirements\n- Includes proper Mermaid diagram syntax (double quotes for labels)\n- Focuses on business requirements in natural language\n- PROHIBITED: Database schemas, ERD, API specifications",
+                            type: "string"
+                        }
                     },
-                    content: {
-                        description: "Step 2 (CoT: Write Phase) - Document Content Creation\n\nThe initial content or context for the document being written.\n\nThis may include:\n\n- User requirements and business goals\n- Existing documentation to build upon\n- Specific scenarios or use cases to document\n- Technical constraints or preferences\n- Related documents for reference\n\nThe content provides the raw material that the AI agent will transform\ninto structured, developer-ready documentation following the planning\nguidelines.\n\nThe AI agent will expand this content into comprehensive documentation\nthat:\n\n- Removes all ambiguity for backend developers\n- Provides specific, measurable requirements in natural language\n- Focuses on business logic and requirements, NOT technical implementation\n- STRICTLY PROHIBITED: Do NOT write database schemas, ERD, or API\n  specifications\n- Uses EARS format for all applicable requirements\n- Follows proper document linking conventions\n- Includes Mermaid diagrams with proper syntax (double quotes mandatory)",
-                        type: "string"
-                    }
+                    required: [
+                        "plan",
+                        "content"
+                    ],
+                    additionalProperties: false,
+                    $defs: {}
                 },
-                required: [
-                    "plan",
-                    "content"
-                ],
-                additionalProperties: false,
-                $defs: {}
-            },
-            description: "Creates or updates planning documentation based on the provided plan and\ncontent structure.\n\nThis function is called by the AI agent to write detailed planning\ndocuments that will be used by backend developers to understand what needs\nto be built, why it's being built, and how it should function.",
-            validate: (() => { const _io0 = input => "string" === typeof input.plan && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.plan || _report(_exceptionable, {
-                    path: _path + ".plan",
-                    expected: "string",
-                    value: input.plan
-                }), "string" === typeof input.content || _report(_exceptionable, {
-                    path: _path + ".content",
-                    expected: "string",
-                    value: input.content
-                })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
-                if (false === __is(input)) {
-                    errors = [];
-                    _report = __typia_transform__validateReport._validateReport(errors);
-                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                        path: _path + "",
-                        expected: "IAutoBeAnalyzeWriteApplication.IProps",
-                        value: input
-                    })) && _vo0(input, _path + "", true) || _report(true, {
-                        path: _path + "",
-                        expected: "IAutoBeAnalyzeWriteApplication.IProps",
-                        value: input
-                    }))(input, "$input", true);
-                    const success = 0 === errors.length;
-                    return success ? {
-                        success,
+                description: "Creates or updates planning documentation based on the provided plan and\ncontent structure.\n\nThis function is called by the AI agent to write detailed planning\ndocuments that will be used by backend developers to understand what needs\nto be built, why it's being built, and how it should function.",
+                validate: (() => { const _io0 = input => "string" === typeof input.plan && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.plan || _report(_exceptionable, {
+                        path: _path + ".plan",
+                        expected: "string",
+                        value: input.plan
+                    }), "string" === typeof input.content || _report(_exceptionable, {
+                        path: _path + ".content",
+                        expected: "string",
+                        value: input.content
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeAnalyzeWriteApplication.IProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeAnalyzeWriteApplication.IProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
+                    }
+                    return {
+                        success: true,
                         data: input
-                    } : {
-                        success,
-                        errors,
+                    };
+                }; })()
+            }
+        ]
+    },
+    claude: {
+        model: "claude",
+        options: {
+            reference: true,
+            separate: null
+        },
+        functions: [
+            {
+                name: "write",
+                parameters: {
+                    description: " - The properties containing the document plan and initial\ncontent\n\n------------------------------\n\nCurrent Type: {@link IAutoBeAnalyzeWriteApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        plan: {
+                            description: "Step 1 (CoT: Plan Phase) - Document Planning Structure\n\nThe document planning structure that outlines what needs to be written.\n\nThis includes:\n\n- Document title and purpose\n- Table of contents structure\n- Key sections to be covered\n- Relationships with other documents\n- Target audience (backend developers)\n\nThe plan serves as a roadmap for the AI agent to ensure all necessary\ntopics are covered in the documentation process.\n\nExample plan structure:\n\n- Service overview with business model\n- User actors and authentication requirements\n- Functional requirements with EARS format\n- Non-functional requirements\n- Business requirements in natural language\n- User scenarios and use cases",
+                            type: "string"
+                        },
+                        content: {
+                            description: "Step 2 (CoT: Write Phase) - Complete Document Content\n\nThe complete, production-ready markdown document content to be saved.\n\nRequirements:\n\n- Minimum 5,000 characters for technical documents\n- Uses EARS format for all applicable requirements\n- Includes proper Mermaid diagram syntax (double quotes for labels)\n- Focuses on business requirements in natural language\n- PROHIBITED: Database schemas, ERD, API specifications",
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "plan",
+                        "content"
+                    ],
+                    additionalProperties: false,
+                    $defs: {}
+                },
+                description: "Creates or updates planning documentation based on the provided plan and\ncontent structure.\n\nThis function is called by the AI agent to write detailed planning\ndocuments that will be used by backend developers to understand what needs\nto be built, why it's being built, and how it should function.",
+                validate: (() => { const _io0 = input => "string" === typeof input.plan && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.plan || _report(_exceptionable, {
+                        path: _path + ".plan",
+                        expected: "string",
+                        value: input.plan
+                    }), "string" === typeof input.content || _report(_exceptionable, {
+                        path: _path + ".content",
+                        expected: "string",
+                        value: input.content
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeAnalyzeWriteApplication.IProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeAnalyzeWriteApplication.IProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
+                    }
+                    return {
+                        success: true,
                         data: input
                     };
-                }
-                return {
-                    success: true,
-                    data: input
-                };
-            }; })()
-        }
-    ]
-};
-const collection = {
-    chatgpt: {
-        model: "chatgpt",
+                }; })()
+            }
+        ]
+    },
+    gemini: {
+        model: "gemini",
         options: {
             reference: true,
-            strict: false,
             separate: null
         },
         functions: [
@@ -188,7 +261,7 @@ const collection = {
                             type: "string"
                         },
                         content: {
-                            description: "Step 2 (CoT: Write Phase) - Document Content Creation\n\nThe initial content or context for the document being written.\n\nThis may include:\n\n- User requirements and business goals\n- Existing documentation to build upon\n- Specific scenarios or use cases to document\n- Technical constraints or preferences\n- Related documents for reference\n\nThe content provides the raw material that the AI agent will transform\ninto structured, developer-ready documentation following the planning\nguidelines.\n\nThe AI agent will expand this content into comprehensive documentation\nthat:\n\n- Removes all ambiguity for backend developers\n- Provides specific, measurable requirements in natural language\n- Focuses on business logic and requirements, NOT technical implementation\n- STRICTLY PROHIBITED: Do NOT write database schemas, ERD, or API\n  specifications\n- Uses EARS format for all applicable requirements\n- Follows proper document linking conventions\n- Includes Mermaid diagrams with proper syntax (double quotes mandatory)",
+                            description: "Step 2 (CoT: Write Phase) - Complete Document Content\n\nThe complete, production-ready markdown document content to be saved.\n\nRequirements:\n\n- Minimum 5,000 characters for technical documents\n- Uses EARS format for all applicable requirements\n- Includes proper Mermaid diagram syntax (double quotes for labels)\n- Focuses on business requirements in natural language\n- PROHIBITED: Database schemas, ERD, API specifications",
                             type: "string"
                         }
                     },
@@ -239,9 +312,5 @@ const collection = {
             }
         ]
     },
-    claude,
-    llama: claude,
-    deepseek: claude,
-    "3.1": claude,
 };
 //# sourceMappingURL=orchestrateAnalyzeWrite.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"orchestrateAnalyzeWrite.js","sourceRoot":"","sources":["../../../src/orchestrate/analyze/orchestrateAnalyzeWrite.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kDAA0B;AAC1B,+BAA0B;AAG1B,uEAAoE;AACpE,+FAA4F;AAGrF,MAAM,uBAAuB,GAAG,CACrC,GAAyB,EACzB,KAKC,EACiC,EAAE;;IACpC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,KAAK,CAAC;IACjD,MAAM,OAAO,GAA2D;QACtE,KAAK,EAAE,IAAI;KACZ,CAAC;IACF,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;QAClD,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,KAAK,CAAC;QACrD,mBAAmB,EAAE,IAAI;QACzB,cAAc;QACd,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,EAAE,EAAE,IAAA,SAAE,GAAE;QACR,IAAI,kCACC,IAAI,KACP,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,GAC/B;QACD,UAAU;QACV,MAAM;QACN,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;AA3CW,QAAA,uBAAuB,2BA2ClC;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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kDAA0B;AAC1B,+BAA0B;AAG1B,uEAAoE;AACpE,+FAA4F;AAGrF,MAAM,uBAAuB,GAAG,CACrC,GAAyB,EACzB,KAKC,EACiC,EAAE;;IACpC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,KAAK,CAAC;IACjD,MAAM,OAAO,GAA2D;QACtE,KAAK,EAAE,IAAI;KACZ,CAAC;IACF,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;QAClD,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,KAAK,CAAC;QACrD,mBAAmB,EAAE,IAAI;QACzB,cAAc;QACd,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,EAAE,EAAE,IAAA,SAAE,GAAE;QACR,IAAI,kCACC,IAAI,KACP,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,GAC/B;QACD,UAAU;QACV,MAAM;QACN,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;AA3CW,QAAA,uBAAuB,2BA2ClC;AAEF,SAAS,gBAAgB,CAAiC,KAGzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,KAAK,SAAS;QACvB,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ;YACxB,CAAC,CAAC,QAAQ;YACV,CAAC,CAAC,QAAQ,CACqD,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,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoE;IAC3E,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAmE;IACzE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAmE;CAC1E,CAAC"}

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

@@ -1,24 +1,11 @@
 export interface IAutoBeAnalyzeReviewApplication {
     /**
-     * Enhances planning documentation to meet all quality standards and requirements.
+     * Enhances and finalizes planning documentation.
      *
-     * This function receives a document and outputs an improved version directly.
-     * The output IS the enhanced document itself, NOT review comments or feedback.
+     * Receives a draft document and outputs the improved version. The output is
+     * the enhanced document itself, not review comments.
      *
-     * The enhancement process includes:
-     * - Expanding sections that are too brief
-     * - Converting vague statements to specific EARS format requirements
-     * - Fixing Mermaid diagram syntax errors
-     * - Adding missing business processes and workflows
-     * - Ensuring proper document structure and completeness
-     *
-     * 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
+     * @param props - Document content, plan, and review criteria
      */
     review(props: IAutoBeAnalyzeReviewApplication.IProps): void;
 }
@@ -47,8 +34,10 @@ export declare namespace IAutoBeAnalyzeReviewApplication {
          * - 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
+         * - DO NOT: Accept documents containing database schemas or API
+         *   specifications
+         * - DO: Describe business model and authentication requirements in natural
+         *   language
          */
         review: string;
         /**
@@ -68,43 +57,19 @@ export declare namespace IAutoBeAnalyzeReviewApplication {
          */
         plan: string;
         /**
-         * Step 3 (CoT: Content Phase) - Complete Document Content
-         *
-         * The actual markdown document content that incorporates review feedback.
-         *
-         * 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)
-         * - The result of applying review criteria to the original plan
-         * - A production-ready document for immediate deployment
-         * - Complete business requirements ready for developers
-         *
-         * The enhancer should treat this as the actual document content:
+         * Step 3 (CoT: Content Phase) - Document Content (INPUT → OUTPUT)
          *
-         * - Length and completeness (minimum 2,000 characters, more for technical
-         *   docs)
-         * - All sections from the plan are fully written
-         * - No vague or abstract statements
-         * - Proper use of EARS format for requirements
-         * - Correct Mermaid diagram syntax (double quotes mandatory)
-         * - Appropriate level of detail for backend implementation
-         * - Proper document linking (descriptive text, not raw filenames)
+         * INPUT: The document written by Write Agent (may have issues) OUTPUT: The
+         * enhanced, complete markdown document to be saved
          *
-         * The enhancer outputs the document itself:
+         * Enhancement requirements:
          *
-         * - If content is provided, it represents the actual document
-         * - The enhancer outputs the enhanced version AS the document itself
-         * - No meta-commentary or review feedback should be in the output
-         * - The output becomes the saved .md file directly
+         * - Fix Mermaid syntax errors (add quotes, fix arrows)
+         * - Convert vague statements to EARS format
+         * - Expand sections that are too brief
+         * - Add missing business processes
          *
-         * Example of what this field contains:
-         * "# Service Overview\n## Vision\nThe service provides..." (actual document)
-         * NOT: "This document should cover service overview..." (review comment)
+         * Output must be the actual document content (not review comments).
          */
         content: string;
     }

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

@@ -3,18 +3,12 @@ import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/Auto
 import { tags } from "typia";
 export interface IAutoBeAnalyzeScenarioApplication {
     /**
-     * Compose project structure with actors and files.
+     * Composes project structure with actors and documentation files.
      *
-     * Design a list of actors and initial documents that you need to create for
-     * that requirement. Actors define user types and their 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 actors. Simply pass an empty array to `input.files` and `input.actors`.
+     * Determines the list of user actors and documents to generate based on
+     * requirements. If requirements are incomplete, returns empty arrays.
      *
-     * @param input Prefix, actors, and files
-     * @returns
+     * @param input - Project prefix, actors, and file list
      */
     compose(input: IAutoBeAnalyzeScenarioApplication.IProps): void;
 }
@@ -29,7 +23,15 @@ export declare namespace IAutoBeAnalyzeScenarioApplication {
          * DO: Use camelCase naming convention.
          */
         prefix: string & CamelCasePattern;
-        /** Actors to be assigned for the project */
+        /**
+         * Actors to be assigned for the project.
+         *
+         * Each actor has:
+         *
+         * - `name`: Actor identifier (camelCase)
+         * - `kind`: "guest" | "member" | "admin"
+         * - `description`: Actor's permissions and capabilities
+         */
         actors: AutoBeAnalyzeActor[];
         /**
          * Language for document content. When specified by the user, this takes
@@ -46,12 +48,14 @@ export declare namespace IAutoBeAnalyzeScenarioApplication {
          */
         page: number;
         /**
-         * # Document files to be generated
-         *
-         * File name must be English and it must contain the numbering and prefix.
+         * Array of document metadata objects defining files to be generated.
          *
-         * These files represent business documentation that may include:
+         * Each array element is an AutoBeAnalyzeFile.Scenario object containing:
+         * - filename: The output file name (e.g., "01-service-overview.md")
+         * - reason: Why this document is being created
+         * - documentType, outline, constraints, etc.: Metadata guiding content generation
          *
+         * These documents represent business-focused planning documentation:
          * - Business requirements and functional specifications in natural language
          * - User journey mapping and use case scenarios
          * - Business rules and workflow definitions
@@ -61,17 +65,16 @@ export declare namespace IAutoBeAnalyzeScenarioApplication {
          * - 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.
+         * Generate metadata objects based on actual requirements gathered from conversation.
          * Do not create unnecessary documentation - only generate what is needed to
          * properly define the business requirements and system specifications.
          *
-         * # Page Length Rules
+         * # Array Length Rules
          *
-         * The number of documents must match the user's request, excluding the
-         * table of contents. For example, if the user requests 3 pages, a total of
-         * 4 documents should be generated, including the table of contents. If the
-         * user does not specify a number, generate a sufficient number of documents
-         * to adequately support the service.
+         * The array length must match the user's requested page count plus one for ToC.
+         * For example: user requests 3 pages → generate 4 objects (1 ToC + 3 content).
+         * If user does not specify a number, generate sufficient objects to adequately
+         * document the service (typically 11+ objects including ToC).
          */
         files: Array<AutoBeAnalyzeFile.Scenario> & tags.MinItems<1>;
     }

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeWriteApplication.d.ts

@@ -41,33 +41,17 @@ export declare namespace IAutoBeAnalyzeWriteApplication {
          */
         plan: string;
         /**
-         * Step 2 (CoT: Write Phase) - Document Content Creation
+         * Step 2 (CoT: Write Phase) - Complete Document Content
          *
-         * The initial content or context for the document being written.
+         * The complete, production-ready markdown document content to be saved.
          *
-         * This may include:
+         * Requirements:
          *
-         * - User requirements and business goals
-         * - Existing documentation to build upon
-         * - Specific scenarios or use cases to document
-         * - Technical constraints or preferences
-         * - Related documents for reference
-         *
-         * The content provides the raw material that the AI agent will transform
-         * into structured, developer-ready documentation following the planning
-         * guidelines.
-         *
-         * The AI agent will expand this content into comprehensive documentation
-         * that:
-         *
-         * - Removes all ambiguity for backend developers
-         * - Provides specific, measurable requirements in natural language
-         * - Focuses on business logic and requirements, NOT technical implementation
-         * - STRICTLY PROHIBITED: Do NOT write database schemas, ERD, or API
-         *   specifications
+         * - Minimum 5,000 characters for technical documents
          * - Uses EARS format for all applicable requirements
-         * - Follows proper document linking conventions
-         * - Includes Mermaid diagrams with proper syntax (double quotes mandatory)
+         * - Includes proper Mermaid diagram syntax (double quotes for labels)
+         * - Focuses on business requirements in natural language
+         * - PROHIBITED: Database schemas, ERD, API specifications
          */
         content: string;
     }