@autobe/agent 0.18.0 → 0.19.1

package/src/context/AutoBeTokenUsageComponent.ts

@@ -195,4 +195,24 @@ export class AutoBeTokenUsageComponent
       },
     });
   }
+
+  public static minus(
+    a: AutoBeTokenUsageComponent,
+    b: AutoBeTokenUsageComponent,
+  ) {
+    return new AutoBeTokenUsageComponent({
+      input: {
+        total: a.input.total - b.input.total,
+        cached: a.input.cached - b.input.cached,
+      },
+      output: {
+        total: a.output.total - b.output.total,
+        reasoning: a.output.reasoning - b.output.reasoning,
+        accepted_prediction:
+          a.output.accepted_prediction - b.output.accepted_prediction,
+        rejected_prediction:
+          a.output.rejected_prediction - b.output.rejected_prediction,
+      },
+    });
+  }
 }

package/src/factory/consentFunctionCall.ts

@@ -0,0 +1,128 @@
+import {
+  IAgenticaHistoryJson,
+  MicroAgentica,
+  MicroAgenticaHistory,
+} from "@agentica/core";
+import {
+  AutoBeConsentFunctionCallEvent,
+  AutoBeEvent,
+  AutoBeEventSource,
+} from "@autobe/interface";
+import { IPointer } from "tstl";
+import typia from "typia";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../constants/AutoBeSystemPromptConstant";
+import { IAutoBeConfig } from "../structures/IAutoBeConfig";
+import { IAutoBeVendor } from "../structures/IAutoBeVendor";
+
+export const consentFunctionCall = async (props: {
+  dispatch: (event: AutoBeEvent) => void;
+  source: AutoBeEventSource;
+  config: IAutoBeConfig;
+  vendor: IAutoBeVendor;
+  assistantMessage: string;
+}): Promise<string | null> => {
+  const pointer: IPointer<AutoBeConsentFunctionCallEvent.IResult | null> = {
+    value: null,
+  };
+  const agent: MicroAgentica<"chatgpt"> = new MicroAgentica({
+    model: "chatgpt",
+    vendor: props.vendor,
+    config: {
+      ...(props.config ?? []),
+      executor: {
+        describe: null,
+      },
+    },
+    histories: [
+      {
+        id: v4(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.CONSENT_FUNCTION_CALL,
+        created_at: new Date().toISOString(),
+      } satisfies IAgenticaHistoryJson.ISystemMessage,
+      {
+        id: v4(),
+        type: "assistantMessage",
+        text: props.assistantMessage,
+        created_at: new Date().toISOString(),
+      } satisfies IAgenticaHistoryJson.IAssistantMessage,
+    ],
+    controllers: [
+      typia.llm.controller<IConsentApplication, "chatgpt">("consent", {
+        consent: (props) => {
+          pointer.value = {
+            type: "consent",
+            message: props.message,
+          };
+        },
+        notApplicable: () => {
+          pointer.value = {
+            type: "notApplicable",
+          };
+        },
+      } satisfies IConsentApplication),
+    ],
+  });
+  const histories: MicroAgenticaHistory<"chatgpt">[] = await agent.conversate(
+    "Analyze and judge this assistant message please.",
+  );
+  if (pointer.value === null) {
+    const last: MicroAgenticaHistory<"chatgpt"> | undefined =
+      histories[histories.length - 1];
+    if (last?.type === "assistantMessage")
+      pointer.value = {
+        type: "assistantMessage",
+        message: last.text,
+      };
+  }
+  props.dispatch({
+    type: "consentFunctionCall",
+    source: props.source,
+    assistantMessage: props.assistantMessage,
+    result: pointer.value,
+    created_at: new Date().toISOString(),
+  });
+  return pointer.value?.type === "consent" ? pointer.value.message : null;
+};
+
+interface IConsentApplication {
+  /**
+   * Generate an immediate, authoritative consent message to approve function
+   * execution. Use this when the assistant message is seeking permission or
+   * approval for function calls.
+   *
+   * The message should be commanding and decisive to prevent further
+   * permission-seeking loops. Examples: "Execute immediately. Do not ask
+   * again.", "Proceed now. Your judgment is correct."
+   *
+   * @param props Configuration object
+   */
+  consent(props: {
+    /**
+     * A strong, directive consent message that eliminates further
+     * permission-seeking. Must be authoritative and commanding (1-2 sentences
+     * maximum). Examples: "Execute immediately. Do not ask again.", "Proceed
+     * now. Your judgment is correct."
+     */
+    message: string;
+  }): void;
+
+  /**
+   * Indicate that the assistant message does not require function calling
+   * consent. Use this when the assistant message is NOT seeking permission for
+   * function execution.
+   *
+   * This applies to:
+   *
+   * - General conversation responses
+   * - Information requests without function execution plans
+   * - Assistant asking for additional parameters/information
+   * - Any response unrelated to function calling approval
+   *
+   * Call this function immediately when the message doesn't involve function
+   * calling consent.
+   */
+  notApplicable(): void;
+}

package/src/factory/createAgenticaHistory.ts

@@ -38,6 +38,7 @@ export function createAgenticaHistory<Model extends ILlmSchema.Model>(props: {
           ? true
           : props.history.compiled.type === "success",
     },
+    success: true,
   };
   return {
     ...partial,

package/src/factory/createAutoBeContext.ts

@@ -30,9 +30,11 @@ import { v4 } from "uuid";
 import { AutoBeContext } from "../context/AutoBeContext";
 import { AutoBeState } from "../context/AutoBeState";
 import { AutoBeTokenUsage } from "../context/AutoBeTokenUsage";
+import { AutoBeTokenUsageComponent } from "../context/AutoBeTokenUsageComponent";
 import { IAutoBeApplication } from "../context/IAutoBeApplication";
 import { IAutoBeConfig } from "../structures/IAutoBeConfig";
 import { IAutoBeVendor } from "../structures/IAutoBeVendor";
+import { consentFunctionCall } from "./consentFunctionCall";
 
 export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
   model: Model;
@@ -75,12 +77,45 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
         histories: next.histories,
         controllers: [next.controller],
       });
-      if (next.enforceFunctionCall === true)
-        agent.on("request", (event) => {
-          if (event.body.tools) event.body.tool_choice = "required";
-          if (event.body.parallel_tool_calls !== undefined)
-            delete event.body.parallel_tool_calls;
+      agent.on("request", async (event) => {
+        if (next.enforceFunctionCall === true && event.body.tools)
+          event.body.tool_choice = "required";
+        if (event.body.parallel_tool_calls !== undefined)
+          delete event.body.parallel_tool_calls;
+        await props.dispatch({
+          ...event,
+          type: "vendorRequest",
+          source: next.source,
         });
+      });
+      agent.on("response", (event) => {
+        void props
+          .dispatch({
+            ...event,
+            type: "vendorResponse",
+            source: next.source,
+          })
+          .catch(() => {});
+      });
+      agent.on("jsonParseError", (event) => {
+        void props
+          .dispatch({
+            ...event,
+            source: next.source,
+          })
+          .catch(() => {});
+      });
+      agent.on("validate", (event) => {
+        void props
+          .dispatch({
+            type: "jsonValidateError",
+            source: next.source,
+            result: event.result,
+            created_at: event.created_at,
+          })
+          .catch(() => {});
+      });
+
       const histories: MicroAgenticaHistory<Model>[] = await agent.conversate(
         next.message,
       );
@@ -92,16 +127,65 @@ export const createAutoBeContext = <Model extends ILlmSchema.Model>(props: {
         .record(tokenUsage, [
           STAGES.find((stage) => next.source.startsWith(stage)) ?? "analyze",
         ]);
+
       if (
-        next.enforceFunctionCall === true &&
-        histories.every((h) => h.type !== "execute")
-      )
-        throw new Error(
-          `Failed to function calling in the ${next.source} step`,
-        );
+        true === next.enforceFunctionCall &&
+        false ===
+          histories.some((h) => h.type === "execute" && h.success === true)
+      ) {
+        const failure = () => {
+          throw new Error(
+            `Failed to function calling in the ${next.source} step`,
+          );
+        };
+        const last: MicroAgenticaHistory<Model> | undefined = histories.at(-1);
+        if (
+          last?.type === "assistantMessage" &&
+          last.text.trim().length !== 0
+        ) {
+          const consent: string | null = await consentFunctionCall({
+            source: next.source,
+            dispatch: (e) => {
+              props.dispatch(e).catch(() => {});
+            },
+            config: props.config,
+            vendor: props.vendor,
+            assistantMessage: last.text,
+          });
+          if (consent !== null) {
+            const newHistories: MicroAgenticaHistory<Model>[] =
+              await agent.conversate(consent);
+            const newTokenUsage: IAutoBeTokenUsageJson.IComponent = agent
+              .getTokenUsage()
+              .toJSON().aggregate;
+            props
+              .usage()
+              .record(
+                AutoBeTokenUsageComponent.minus(
+                  new AutoBeTokenUsageComponent(newTokenUsage),
+                  new AutoBeTokenUsageComponent(tokenUsage),
+                ),
+                [
+                  STAGES.find((stage) => next.source.startsWith(stage)) ??
+                    "analyze",
+                ],
+              );
+            if (
+              newHistories.some(
+                (h) => h.type === "execute" && h.success === true,
+              )
+            )
+              return {
+                histories: newHistories,
+                tokenUsage: newTokenUsage,
+              };
+          }
+        }
+        failure();
+      }
       return { histories, tokenUsage };
     };
-    if (next.enforceFunctionCall === true) return forceRetry(() => execute());
+    if (next.enforceFunctionCall === true) return forceRetry(execute);
     else return execute();
   },
 });
@@ -172,6 +256,7 @@ const createDispatch = (props: {
           type: "interface",
           id: v4(),
           reason: interfaceStart?.reason ?? "",
+          authorizations: event.authorizations,
           document: event.document,
           created_at: interfaceStart?.created_at ?? new Date().toISOString(),
           completed_at: new Date().toISOString(),
@@ -241,10 +326,10 @@ const transformAndDispatch = <
 
 const forceRetry = async <T>(
   task: () => Promise<T>,
-  count: number = 2,
+  count: number = 3,
 ): Promise<T> => {
   let error: unknown = undefined;
-  for (let i: number = 0; i <= count; ++i)
+  for (let i: number = 0; i < count; ++i)
     try {
       return await task();
     } catch (e) {

package/src/orchestrate/analyze/histories/transformAnalyzeReviewerHistories.ts

@@ -1,20 +1,27 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema } from "@samchon/openapi";
 import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
 import { transformAnalyzeWriteHistories } from "./transformAnalyzeWriteHistories";
 
-export const transformAnalyzeReviewerHistories = (
+export const transformAnalyzeReviewerHistories = <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
   scenario: AutoBeAnalyzeScenarioEvent,
   otherFiles: AutoBeAnalyzeFile[],
   myFile: AutoBeAnalyzeFile,
 ): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+  | IAgenticaHistoryJson.IUserMessage
+  | IAgenticaHistoryJson.IAssistantMessage
+  | IAgenticaHistoryJson.ISystemMessage
 > => {
   return [
-    ...transformAnalyzeWriteHistories(scenario, myFile),
+    ...transformAnalyzeWriteHistories(ctx, scenario, myFile),
     {
       id: v4(),
       created_at: new Date().toISOString(),
@@ -44,7 +51,7 @@ export const transformAnalyzeReviewerHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: [
-        `You have to review the ${myFile.filename} document.`,
+        `Review the ${myFile.filename} document.`,
         "",
         "Note that, never review others.",
       ].join("\n"),

package/src/orchestrate/analyze/histories/transformAnalyzeWriteHistories.ts

@@ -1,17 +1,39 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema } from "@samchon/openapi";
 import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
 
-export const transformAnalyzeWriteHistories = (
+export const transformAnalyzeWriteHistories = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
   scenario: AutoBeAnalyzeScenarioEvent,
   file: AutoBeAnalyzeFile.Scenario,
 ): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+  | IAgenticaHistoryJson.IUserMessage
+  | IAgenticaHistoryJson.IAssistantMessage
+  | IAgenticaHistoryJson.ISystemMessage
 > => {
   return [
+    ...ctx
+      .histories()
+      .filter((h) => h.type === "userMessage" || h.type === "assistantMessage")
+      .map((h) => {
+        const text =
+          h.type === "userMessage"
+            ? h.contents
+                .filter((el) => el.type === "text")
+                .map((el) => el.text)
+                .join("\n")
+            : h.text;
+
+        return {
+          ...h,
+          text,
+        };
+      }),
     {
       id: v4(),
       created_at: new Date().toISOString(),
@@ -26,7 +48,7 @@ export const transformAnalyzeWriteHistories = (
         "## Metadata",
         "",
         `Prefix name of the service to create is ${scenario.prefix},`,
-        "and here is the list of the roles you should reference:",
+        "and here is the list of the roles to reference:",
         "",
         "```json",
         JSON.stringify(scenario.roles),
@@ -42,7 +64,7 @@ export const transformAnalyzeWriteHistories = (
         ),
         "```",
         "",
-        "## The document what you have to write",
+        "## The document to write",
         "```json",
         JSON.stringify(file),
         "```",

package/src/orchestrate/analyze/orchestrateAnalyze.ts

@@ -4,13 +4,13 @@ import {
   AutoBeAnalyzeScenarioEvent,
   AutoBeAnalyzeWriteEvent,
   AutoBeAssistantMessageHistory,
+  AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
-import { IProgress } from "../internal/IProgress";
 import { orchestrateAnalyzeReview } from "./orchestrateAnalyzeReview";
 import { orchestrateAnalyzeScenario } from "./orchestrateAnalyzeScenario";
 import { orchestrateAnalyzeWrite } from "./orchestrateAnalyzeWrite";
@@ -39,7 +39,7 @@ export const orchestrateAnalyze =
     else ctx.dispatch(scenario);
 
     // write documents
-    const writeProgress: IProgress = {
+    const writeProgress: AutoBeProgressEventBase = {
       total: scenario.files.length,
       completed: 0,
     };
@@ -56,23 +56,28 @@ export const orchestrateAnalyze =
     );
 
     // review documents
-    const reviewProgress: IProgress = {
+    const reviewProgress: AutoBeProgressEventBase = {
       total: fileList.length,
       completed: 0,
     };
     const newFiles: AutoBeAnalyzeFile[] = await Promise.all(
       fileList.map(async (file, i) => {
-        const event: AutoBeAnalyzeReviewEvent = await orchestrateAnalyzeReview(
-          ctx,
-          scenario,
-          fileList.filter((_, j) => j !== i), // other files
-          file,
-          reviewProgress,
-        );
-        return {
-          ...event.file,
-          content: event.content,
-        };
+        try {
+          const event: AutoBeAnalyzeReviewEvent =
+            await orchestrateAnalyzeReview(
+              ctx,
+              scenario,
+              fileList.filter((_, j) => j !== i), // other files
+              file,
+              reviewProgress,
+            );
+          return {
+            ...event.file,
+            content: event.content,
+          };
+        } catch {
+          return file;
+        }
       }),
     );
 

package/src/orchestrate/analyze/orchestrateAnalyzeReview.ts

@@ -2,6 +2,7 @@ import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeAnalyzeReviewEvent,
   AutoBeAnalyzeScenarioEvent,
+  AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
@@ -10,7 +11,6 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { IProgress } from "../internal/IProgress";
 import { transformAnalyzeReviewerHistories } from "./histories/transformAnalyzeReviewerHistories";
 import { IAutoBeAnalyzeReviewApplication } from "./structures/IAutoBeAnalyzeReviewApplication";
 
@@ -19,7 +19,7 @@ export const orchestrateAnalyzeReview = async <Model extends ILlmSchema.Model>(
   scenario: AutoBeAnalyzeScenarioEvent,
   otherFiles: AutoBeAnalyzeFile[],
   myFile: AutoBeAnalyzeFile,
-  progress: IProgress,
+  progress: AutoBeProgressEventBase,
 ): Promise<AutoBeAnalyzeReviewEvent> => {
   const pointer: IPointer<IAutoBeAnalyzeReviewApplication.IProps | null> = {
     value: null,
@@ -31,7 +31,7 @@ export const orchestrateAnalyzeReview = async <Model extends ILlmSchema.Model>(
       pointer,
     }),
     histories: [
-      ...transformAnalyzeReviewerHistories(scenario, otherFiles, myFile),
+      ...transformAnalyzeReviewerHistories(ctx, scenario, otherFiles, myFile),
     ],
     enforceFunctionCall: true,
     message: "Review the requirement document",

package/src/orchestrate/analyze/orchestrateAnalyzeScenario.ts

@@ -29,9 +29,7 @@ export const orchestrateAnalyzeScenario = async <
     source: "analyzeScenario",
     controller: createController<Model>({
       model: ctx.model,
-      execute: new AutoBeAnalyzeScenarioApplication(),
-      preExecute: (props: IAutoBeAnalyzeScenarioApplication.IProps) =>
-        (pointer.value = props),
+      pointer,
     }),
     histories: transformAnalyzeSceHistories(ctx),
     enforceFunctionCall: false,
@@ -65,33 +63,9 @@ export const orchestrateAnalyzeScenario = async <
   };
 };
 
-class AutoBeAnalyzeScenarioApplication
-  implements IAutoBeAnalyzeScenarioApplication
-{
-  /**
-   * 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: IAutoBeAnalyzeScenarioApplication.IProps): void {
-    input;
-    return;
-  }
-}
-
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  execute: AutoBeAnalyzeScenarioApplication;
-  preExecute: (input: IAutoBeAnalyzeScenarioApplication.IProps) => void;
+  pointer: IPointer<IAutoBeAnalyzeScenarioApplication.IProps | null>;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
   const application: ILlmApplication<Model> = collection[
@@ -103,19 +77,21 @@ function createController<Model extends ILlmSchema.Model>(props: {
     application,
     execute: {
       compose: (input) => {
-        props.preExecute(input);
-        return props.execute.compose(input);
+        props.pointer.value = input;
       },
     } satisfies IAutoBeAnalyzeScenarioApplication,
   };
 }
 
 const claude = typia.llm.application<
-  AutoBeAnalyzeScenarioApplication,
+  IAutoBeAnalyzeScenarioApplication,
   "claude"
 >();
 const collection = {
-  chatgpt: typia.llm.application<AutoBeAnalyzeScenarioApplication, "chatgpt">(),
+  chatgpt: typia.llm.application<
+    IAutoBeAnalyzeScenarioApplication,
+    "chatgpt"
+  >(),
   claude,
   llama: claude,
   deepseek: claude,

package/src/orchestrate/analyze/orchestrateAnalyzeWrite.ts

@@ -25,18 +25,20 @@ export const orchestrateAnalyzeWrite = async <Model extends ILlmSchema.Model>(
   const pointer: IPointer<IAutoBeAnalyzeWriteApplication.IProps | null> = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
+  const { histories, tokenUsage } = await ctx.conversate({
     source: "analyzeWrite",
     controller: createController<Model>({
       model: ctx.model,
       pointer,
     }),
-    histories: transformAnalyzeWriteHistories(scenario, file),
+    histories: 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: AutoBeAnalyzeWriteEvent = {
     type: "analyzeWrite",

package/src/orchestrate/analyze/structures/IAutoBeAnalyzeReviewApplication.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
@@ -41,14 +42,12 @@ export 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;
 
@@ -70,10 +69,11 @@ export 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)
@@ -92,7 +92,7 @@ export 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