@autobe/agent 0.11.2 → 0.13.0

package/lib/index.mjs

@@ -1,6 +1,6 @@
 import { AgenticaTokenUsage, MicroAgentica } from "@agentica/core";
 
-import { hash, HashSet, HashMap, Pair, Semaphore, Singleton } from "tstl";
+import { hash, HashSet, HashMap, Pair, Semaphore, Singleton, sleep_for } from "tstl";
 
 import { v4 } from "uuid";
 
@@ -18,19 +18,75 @@ import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1E
 
 import * as __typia_transform__isUniqueItems from "typia/lib/internal/_isUniqueItems.js";
 
-import { readFile } from "fs/promises";
+import fs, { readFile } from "fs/promises";
 
 import path from "path";
 
-import * as __typia_transform__jsonStringifyString from "typia/lib/internal/_jsonStringifyString.js";
-
-import * as __typia_transform__throwTypeGuardError from "typia/lib/internal/_throwTypeGuardError.js";
-
-import "typia/lib/internal/_isFormatDateTime.js";
+async function getAutoBeGenerated(compiler, state, histories, tokenUsage, options) {
+    const ret = {};
+    if (state.analyze === null) return {};
+    Object.assign(ret, Object.fromEntries(Object.entries(state.analyze.files).map((([key, value]) => [ `docs/analysis/${key.split("/").at(-1)}`, value ]))));
+    if (state.prisma?.step === state.analyze.step) {
+        const schemaFiles = (options?.dbms ?? "postgres") === "postgres" ? state.prisma.schemas : await compiler.prisma.write(state.prisma.result.data, options.dbms);
+        Object.assign(ret, Object.fromEntries(Object.entries(schemaFiles).map((([key, value]) => [ `prisma/schema/${key.split("/").at(-1)}`, value ]))), {
+            "autobe/prisma.json": JSON.stringify(state.prisma.result.data)
+        });
+        if (state.prisma.compiled.type === "success") ret["docs/ERD.md"] = state.prisma.compiled.document; else if (state.prisma.compiled.type === "failure") ret["prisma/compile-error-reason.log"] = state.prisma.compiled.reason;
+    }
+    if (state.interface?.step === state.analyze.step) {
+        const files = await compiler.interface.write(state.interface.document);
+        Object.assign(ret, state.test?.step === state.interface.step ? Object.fromEntries(Object.entries(files).filter((([key]) => key.startsWith("test/features/") === false))) : files, {
+            "autobe/document.json": JSON.stringify(state.interface.document)
+        });
+    }
+    if (state.test?.step === state.analyze.step) Object.assign(ret, Object.fromEntries(state.test.files.map((f => [ f.location, f.content ]))), await compiler.test.getTemplate());
+    if (state.realize?.step === state.analyze.step) Object.assign(ret, state.realize.files, await compiler.realize.getTemplate());
+    Object.assign(ret, {
+        "autobe/histories.json": JSON.stringify(histories),
+        "autobe/tokenUsage.json": JSON.stringify(tokenUsage)
+    });
+    return ret;
+}
 
-import "typia/lib/internal/_isFormatUuid.js";
+function emplaceMap(dict, key, generator) {
+    const oldbie = dict.get(key);
+    if (oldbie !== undefined) {
+        return oldbie;
+    }
+    const value = generator();
+    dict.set(key, value);
+    return value;
+}
 
-import "typia/lib/internal/_isFormatUrl.js";
+class AutoBeAgentBase {
+    constructor(asset) {
+        this.asset = asset;
+        this.listeners_ = new Map;
+    }
+    async getFiles(options) {
+        return getAutoBeGenerated(await this.asset.compiler(), this.asset.state(), this.getHistories(), this.getTokenUsage(), options);
+    }
+    on(type, listener) {
+        emplaceMap(this.listeners_, type, (() => new Set)).add(listener);
+        return this;
+    }
+    off(type, listener) {
+        const set = this.listeners_.get(type);
+        if (set === undefined) return this;
+        set.delete(listener);
+        if (set.size === 0) this.listeners_.delete(type);
+        return this;
+    }
+    async dispatch(event) {
+        const set = this.listeners_.get(event.type);
+        if (set === undefined) return;
+        await Promise.all(Array.from(set).map((async listener => {
+            try {
+                await listener(event);
+            } catch {}
+        })));
+    }
+}
 
 class AutoBeTokenUsage {
     constructor(props) {
@@ -169,7 +225,7 @@ class AutoBeAnalyzeComposerApplication {
 
 function createController$1(props) {
     assertSchemaModel(props.model);
-    const application = collection$d[props.model];
+    const application = collection$e[props.model];
     return {
         protocol: "class",
         name: "Compose",
@@ -183,7 +239,7 @@ function createController$1(props) {
     };
 }
 
-const claude$d = {
+const claude$e = {
     model: "claude",
     options: {
         reference: true,
@@ -395,7 +451,7 @@ const claude$d = {
     } ]
 };
 
-const collection$d = {
+const collection$e = {
     chatgpt: {
         model: "chatgpt",
         options: {
@@ -607,13 +663,32 @@ const collection$d = {
             })()
         } ]
     },
-    claude: claude$d,
-    llama: claude$d,
-    deepseek: claude$d,
-    3.1: claude$d
+    claude: claude$e,
+    llama: claude$e,
+    deepseek: claude$e,
+    3.1: claude$e
 };
 
+async function randomBackoffRetry(fn, options = {}) {
+    const {maxRetries = 5, baseDelay = 4e3, maxDelay = 6e4, jitter = .8, handleError = isRetryError} = options;
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await fn();
+        } catch (err) {
+            lastError = err;
+            if (attempt === maxRetries - 1) throw err;
+            if (!handleError(err)) throw err;
+            const tempDelay = Math.min(baseDelay * 2 ** attempt, maxDelay);
+            const delay = tempDelay * (1 + Math.random() * jitter);
+            await new Promise((res => setTimeout(res, delay)));
+        }
+    }
+    throw lastError;
+}
+
 function randomBackoffStrategy(props) {
+    console.log("randomBackoffStrategy");
     const {count, error} = props;
     if (count > 5) {
         throw error;
@@ -762,7 +837,7 @@ const orchestrateAnalyzeWrite = (ctx, input, pointer, isAborted) => {
 
 function createController(props) {
     assertSchemaModel(props.model);
-    const application = collection$c[props.model];
+    const application = collection$d[props.model];
     return {
         protocol: "class",
         name: "Planning",
@@ -782,7 +857,7 @@ function createController(props) {
     };
 }
 
-const claude$c = {
+const claude$d = {
     model: "claude",
     options: {
         reference: true,
@@ -964,7 +1039,7 @@ const claude$c = {
     } ]
 };
 
-const collection$c = {
+const collection$d = {
     chatgpt: {
         model: "chatgpt",
         options: {
@@ -1147,13 +1222,13 @@ const collection$c = {
             })()
         } ]
     },
-    claude: claude$c,
-    llama: claude$c,
-    deepseek: claude$c,
-    3.1: claude$c
+    claude: claude$d,
+    llama: claude$d,
+    deepseek: claude$d,
+    3.1: claude$d
 };
 
-async function writeDocumentUntilReviewPassed(ctx, pointer, totalFiles, filename, roles, retry = 3) {
+async function writeDocumentUntilReviewPassed(ctx, pointer, totalFiles, filename, roles, progress, retry = 3) {
     const isAborted = {
         value: false
     };
@@ -1178,14 +1253,23 @@ async function writeDocumentUntilReviewPassed(ctx, pointer, totalFiles, filename
         }
         ctx.dispatch({
             type: "analyzeWrite",
-            files: pointer.value.files,
+            files: {
+                ...pointer.value.files
+            },
+            total: progress.total,
+            completed: ++progress.completed,
             step: ctx.state().analyze?.step ?? 0,
             created_at: (new Date).toISOString()
         });
         review = await orchestrateAnalyzeReviewer(ctx, pointer.value);
         if (review !== null) ctx.dispatch({
             type: "analyzeReview",
+            files: {
+                ...pointer.value.files
+            },
             review,
+            total: progress.total,
+            completed: progress.completed,
             step: ctx.state().analyze?.step ?? 0,
             created_at: (new Date).toISOString()
         });
@@ -1235,13 +1319,18 @@ const orchestrateAnalyze = ctx => async props => {
         });
         return history;
     }
+    const retryCount = 3;
+    const progress = {
+        total: tableOfContents.length * retryCount,
+        completed: 0
+    };
     const pointers = await Promise.all(tableOfContents.map((async ({filename}) => {
         const pointer = {
             value: {
                 files: {}
             }
         };
-        await writeDocumentUntilReviewPassed(ctx, pointer, tableOfContents, filename, roles, 3);
+        await writeDocumentUntilReviewPassed(ctx, pointer, tableOfContents, filename, roles, progress, retryCount);
         return pointer;
     })));
     const files = pointers.map((pointer => pointer.value?.files ?? {})).reduce(((acc, cur) => Object.assign(acc, cur)));
@@ -1363,7 +1452,7 @@ async function step$1(ctx, document, retry) {
             type: "assistantMessage",
             text: [ "You have missed below schema types in the document.components.schemas:", "", ...missed.map((s => `- ${s}`)) ].join("\n")
         } ],
-        controllers: [ createApplication$a({
+        controllers: [ createApplication$b({
             model: ctx.model,
             build: next => {
                 pointer.value ?? (pointer.value = {});
@@ -1420,9 +1509,9 @@ const getMissed = document => {
     return Array.from(missed);
 };
 
-function createApplication$a(props) {
+function createApplication$b(props) {
     assertSchemaModel(props.model);
-    const application = collection$b[props.model];
+    const application = collection$c[props.model];
     return {
         protocol: "class",
         name: "interface",
@@ -1435,7 +1524,7 @@ function createApplication$a(props) {
     };
 }
 
-const claude$b = {
+const claude$c = {
     model: "claude",
     options: {
         reference: true,
@@ -1548,7 +1637,7 @@ const claude$b = {
     } ]
 };
 
-const collection$b = {
+const collection$c = {
     chatgpt: {
         model: "chatgpt",
         options: {
@@ -1661,10 +1750,10 @@ const collection$b = {
             })()
         } ]
     },
-    claude: claude$b,
-    llama: claude$b,
-    deepseek: claude$b,
-    3.1: claude$b
+    claude: claude$c,
+    llama: claude$c,
+    deepseek: claude$c,
+    3.1: claude$c
 };
 
 function divideArray(props) {
@@ -1727,7 +1816,7 @@ async function divideAndConquer$1(ctx, operations, typeNames, retry, progress) {
     for (let i = 0; i < retry; ++i) {
         if (remained.size === 0) break;
         const before = remained.size;
-        const newbie = await forceRetry((() => process$4(ctx, operations, components, remained)));
+        const newbie = await forceRetry((() => process$5(ctx, operations, components, remained)));
         for (const key of Object.keys(newbie.schemas)) {
             components.schemas[key] = newbie.schemas[key];
             remained.delete(key);
@@ -1737,7 +1826,7 @@ async function divideAndConquer$1(ctx, operations, typeNames, retry, progress) {
     return components;
 }
 
-async function process$4(ctx, operations, oldbie, remained) {
+async function process$5(ctx, operations, oldbie, remained) {
     const pointer = {
         value: null
     };
@@ -1756,7 +1845,7 @@ async function process$4(ctx, operations, oldbie, remained) {
             type: "assistantMessage",
             text: [ "Here is the OpenAPI operations generated by phase 2.", "", "```json", JSON.stringify(operations), "```" ].join("\n")
         } ],
-        controllers: [ createApplication$9({
+        controllers: [ createApplication$a({
             model: ctx.model,
             build: async components => {
                 pointer.value ?? (pointer.value = {
@@ -1779,9 +1868,9 @@ async function process$4(ctx, operations, oldbie, remained) {
     return OpenApiV3_1Emender.convertComponents(pointer.value);
 }
 
-function createApplication$9(props) {
+function createApplication$a(props) {
     assertSchemaModel(props.model);
-    const application = collection$a[props.model];
+    const application = collection$b[props.model];
     return {
         protocol: "class",
         name: "interface",
@@ -1794,7 +1883,7 @@ function createApplication$9(props) {
     };
 }
 
-const claude$a = {
+const claude$b = {
     model: "claude",
     options: {
         reference: true,
@@ -1928,7 +2017,7 @@ const claude$a = {
     } ]
 };
 
-const collection$a = {
+const collection$b = {
     chatgpt: {
         model: "chatgpt",
         options: {
@@ -2061,10 +2150,10 @@ const collection$a = {
             })()
         } ]
     },
-    claude: claude$a,
-    llama: claude$a,
-    deepseek: claude$a,
-    3.1: claude$a
+    claude: claude$b,
+    llama: claude$b,
+    deepseek: claude$b,
+    3.1: claude$b
 };
 
 var OpenApiEndpointComparator;
@@ -2095,7 +2184,7 @@ async function orchestrateInterfaceEndpoints(ctx, content = "Make API endpoints
             }
         },
         histories: transformInterfaceHistories(ctx.state(), '# API Endpoint Generator System Prompt\n\n## 1. Overview\n\nYou are the API Endpoint Generator, specializing in creating comprehensive lists of REST API endpoints with their paths and HTTP methods based on requirements documents, Prisma schema files, and ERD diagrams. You must output your results by calling the `makeEndpoints()` function.\n\n## 2. Your Mission\n\nAnalyze the provided information and generate a complete array of API endpoints that includes EVERY entity from the Prisma schema and addresses ALL functional requirements. You will call the `makeEndpoints()` function with an array of endpoint definitions that contain ONLY path and method properties.\n\n## 3. Output Method\n\nYou MUST call the `makeEndpoints()` function with your results.\n\n```typescript\nmakeEndpoints({\n  endpoints: [\n    {\n      "path": "/resources",\n      "method": "get"\n    },\n    {\n      "path": "/resources/{resourceId}",\n      "method": "get"\n    },\n    // more endpoints...\n  ],\n});\n```\n\n## 4. Endpoint Design Principles\n\n### 4.1. Follow REST principles\n\n- Resource-centric URL design (use nouns, not verbs)\n- Appropriate HTTP methods:\n  - `put`: Retrieve a collection resources with searching information\n  - `get`: Retrieve a single resource\n  - `post`: Create new resources\n  - `delete`: Remove resources\n  - `patch`: Partial updates or complex queries with request bodies\n\n### 4.2. Path Formatting Rules\n\n1. **Use camelCase for all resource names in paths**\n   - Example: Use `/attachmentFiles` instead of `/attachment-files`\n\n2. **Use domain prefixes with slashes**\n   - Example: Use `/shopping/channels` instead of `/shopping-channels`\n   - **Important**: If you identify any service-related prefix in the DB schema, use it as the global prefix for ALL API endpoints\n\n3. **Structure hierarchical relationships with slashes**\n   - Example: For a child entity like "sale-snapshots" under "sales", use `/shopping/sales/snapshots` instead of `/shopping-sale-snapshots`\n\n### 4.3. Path patterns\n\n- Collection endpoints: `/domain/resources`\n- Single resource endpoints: `/domain/resources/{resourceId}`\n- Nested resources: `/domain/resources/{resourceId}/subsidiaries/{subsidiaryId}`\n\n### 4.4. Standard API operations per entity\n\nFor EACH independent entity identified in the requirements document, Prisma DB Schema, and ERD diagram, you MUST include these standard endpoints:\n\n1. `PATCH /entity-plural` - List entities with searching\n2. `GET /entity-plural/{id}` - Get specific entity\n3. `POST /entity-plural` - Create entity\n4. `PUT /entity-plural/{id}` - Update entity\n5. `DELETE /entity-plural/{id}` - Delete entity\n\n## 5. Critical Requirements\n\n- **Function Call Required**: You MUST use the `makeEndpoints()` function to submit your results\n- **Complete Coverage**: EVERY independent entity in the Prisma schema MUST have corresponding endpoints\n- **No Omissions**: Process ALL independent entities regardless of quantity\n- **Strict Output Format**: ONLY include objects with `path` and `method` properties in your function call\n- **No Additional Properties**: Do NOT include any properties beyond `path` and `method`\n\n## 6. Implementation Strategy\n\n1. Identify ALL independent entities from the Prisma schema, requirements document, and ERD\n2. Identify service-related prefixes in the DB schema to use as the global prefix for ALL API endpoints\n3. Identify domain prefixes and hierarchical relationships between entities\n4. For each independent entity:\n   - Convert kebab-case names to camelCase (e.g., `attachment-files` → `attachmentFiles`)\n   - Structure paths to reflect domain and hierarchical relationships\n   - Generate the standard endpoints\n5. Add endpoints for relationships and complex operations\n6. Verify ALL independent entities and requirements are covered\n7. Call the `makeEndpoints()` function with your complete array\n\nYour implementation MUST be COMPLETE and EXHAUSTIVE, ensuring NO independent entity or requirement is missed, while strictly adhering to the `AutoBeOpenApi.IEndpoint` interface format. Calling the `makeEndpoints()` function is MANDATORY.\n\n## 7. Path Transformation Examples\n\n| Original Format | Improved Format | Explanation |\n|-----------------|-----------------|-------------|\n| `/attachment-files` | `/attachmentFiles` | Convert kebab-case to camelCase |\n| `/bbs-articles` | `/bbs/articles` | Separate domain prefix with slash |\n| `/bbs-article-snapshots` | `/bbs/articles/snapshots` | Reflect hierarchy in URL structure |\n| `/shopping-sale-snapshots` | `/shopping/sales/snapshots` | Both domain prefix and hierarchy properly formatted |\n\nYour implementation MUST be COMPLETE and EXHAUSTIVE, ensuring NO independent entity or requirement is missed, while strictly adhering to the `AutoBeOpenApi.IEndpoint` interface format. Calling the `makeEndpoints()` function is MANDATORY.\n\nYou\'re right - I removed too much of the original structure. Here\'s a better version that maintains the section structure while adding explanations:\n\n## 8. Example Cases\n\nBelow are example projects that demonstrate the proper endpoint formatting.\n\n### 8.1. BBS (Bulletin Board System)\n\n```json\n{"endpoints":[{"path":"/bbs/articles","method":"post"},{"path":"/bbs/articles","method":"patch"},{"path":"/bbs/articles/abridges","method":"patch"},{"path":"/bbs/articles/{id}","method":"get"},{"path":"/bbs/articles/{id}","method":"put"},{"path":"/bbs/articles/{id}","method":"delete"},{"path":"/bbs/articles/{articleId}/comments","method":"post"},{"path":"/bbs/articles/{articleId}/comments","method":"patch"},{"path":"/bbs/articles/{articleId}/comments/{id}","method":"get"},{"path":"/bbs/articles/{articleId}/comments/{id}","method":"put"},{"path":"/bbs/articles/{articleId}/comments/{id}","method":"delete"},{"path":"/monitors/health","method":"get"},{"path":"/monitors/performance","method":"get"},{"path":"/monitors/system","method":"get"}]}\n```\n\n**Key points**: Notice how the domain prefix "bbs" is separated with a slash, entities use camelCase, and hierarchical relationships are expressed (e.g., `/bbs/articles/{articleId}/comments`).\n\n### 8.2. Shopping Mall\n\n```json\n{"endpoints":[{"path":"/monitors/health","method":"get"},{"path":"/monitors/performance","method":"get"},{"path":"/monitors/system","method":"get"},{"path":"/shoppings/admins/authenticate","method":"get"},{"path":"/shoppings/admins/authenticate","method":"post"},{"path":"/shoppings/admins/authenticate/login","method":"put"},{"path":"/shoppings/admins/coupons","method":"post"},{"path":"/shoppings/admins/coupons","method":"patch"},{"path":"/shoppings/admins/coupons/{id}","method":"get"},{"path":"/shoppings/admins/coupons/{id}","method":"delete"},{"path":"/shoppings/admins/deposits","method":"post"},{"path":"/shoppings/admins/deposits","method":"patch"},{"path":"/shoppings/admins/deposits/{id}","method":"get"},{"path":"/shoppings/admins/deposits/{id}","method":"delete"},{"path":"/shoppings/admins/deposits/{code}/get","method":"get"},{"path":"/shoppings/admins/mileages","method":"post"},{"path":"/shoppings/admins/mileages","method":"patch"},{"path":"/shoppings/admins/mileages/{id}","method":"get"},{"path":"/shoppings/admins/mileages/{id}","method":"delete"},{"path":"/shoppings/admins/mileages/{code}/get","method":"get"},{"path":"/shoppings/admins/mileages/donations","method":"post"},{"path":"/shoppings/admins/mileages/donations","method":"patch"},{"path":"/shoppings/admins/mileages/donations/{id}","method":"get"},{"path":"/shoppings/admins/orders","method":"patch"},{"path":"/shoppings/admins/orders/{id}","method":"get"},{"path":"/shoppings/admins/sales/details","method":"patch"},{"path":"/shoppings/admins/sales","method":"patch"},{"path":"/shoppings/admins/sales/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/questions/{inquiryId}/comments","method":"post"},{"path":"/shoppings/admins/sales/{saleId}/questions/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/admins/sales/{saleId}/questions","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/questions/abridges","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/questions/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{inquiryId}/comments","method":"post"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/admins/sales/{saleId}/reviews","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/reviews/abridges","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/snapshots","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/snapshots/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/snapshots/{id}/flip","method":"get"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories","method":"post"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories","method":"patch"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories/{id}","method":"get"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories/{id}","method":"put"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories/merge","method":"delete"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories/{id}/invert","method":"get"},{"path":"/shoppings/admins/systematic/channels","method":"post"},{"path":"/shoppings/admins/systematic/channels","method":"patch"},{"path":"/shoppings/admins/systematic/channels/{id}","method":"get"},{"path":"/shoppings/admins/systematic/channels/{id}","method":"put"},{"path":"/shoppings/admins/systematic/channels/merge","method":"delete"},{"path":"/shoppings/admins/systematic/channels/hierarchical","method":"patch"},{"path":"/shoppings/admins/systematic/channels/{code}/get","method":"get"},{"path":"/shoppings/admins/systematic/sections","method":"post"},{"path":"/shoppings/admins/systematic/sections","method":"patch"},{"path":"/shoppings/admins/systematic/sections/{id}","method":"get"},{"path":"/shoppings/admins/systematic/sections/{id}","method":"put"},{"path":"/shoppings/admins/systematic/sections/merge","method":"delete"},{"path":"/shoppings/admins/systematic/sections/{code}/get","method":"get"},{"path":"/shoppings/customers/authenticate/refresh","method":"patch"},{"path":"/shoppings/customers/authenticate","method":"get"},{"path":"/shoppings/customers/authenticate","method":"post"},{"path":"/shoppings/customers/authenticate/join","method":"post"},{"path":"/shoppings/customers/authenticate/login","method":"put"},{"path":"/shoppings/customers/authenticate/activate","method":"post"},{"path":"/shoppings/customers/authenticate/external","method":"post"},{"path":"/shoppings/customers/authenticate/password/change","method":"put"},{"path":"/shoppings/customers/coupons","method":"patch"},{"path":"/shoppings/customers/coupons/{id}","method":"get"},{"path":"/shoppings/customers/coupons/tickets","method":"post"},{"path":"/shoppings/customers/coupons/tickets","method":"patch"},{"path":"/shoppings/customers/coupons/tickets/{id}","method":"get"},{"path":"/shoppings/customers/deposits/charges","method":"post"},{"path":"/shoppings/customers/deposits/charges","method":"patch"},{"path":"/shoppings/customers/deposits/charges/{id}","method":"get"},{"path":"/shoppings/customers/deposits/charges/{id}","method":"put"},{"path":"/shoppings/customers/deposits/charges/{id}","method":"delete"},{"path":"/shoppings/customers/deposits/charges/{chargeId}/publish/able","method":"get"},{"path":"/shoppings/customers/deposits/charges/{chargeId}/publish","method":"post"},{"path":"/shoppings/customers/deposits/histories","method":"patch"},{"path":"/shoppings/customers/deposits/histories/{id}","method":"get"},{"path":"/shoppings/customers/deposits/histories/balance","method":"get"},{"path":"/shoppings/customers/mileages/histories","method":"patch"},{"path":"/shoppings/customers/mileages/histories/{id}","method":"get"},{"path":"/shoppings/customers/mileages/histories/balance","method":"get"},{"path":"/shoppings/customers/carts/commodities","method":"post"},{"path":"/shoppings/customers/carts/commodities","method":"patch"},{"path":"/shoppings/customers/carts/commodities/{id}","method":"get"},{"path":"/shoppings/customers/carts/commodities/{id}","method":"put"},{"path":"/shoppings/customers/carts/commodities/{id}","method":"delete"},{"path":"/shoppings/customers/carts/commodities/{id}/replica","method":"get"},{"path":"/shoppings/customers/carts/commodities/discountable","method":"patch"},{"path":"/shoppings/customers/orders","method":"post"},{"path":"/shoppings/customers/orders","method":"patch"},{"path":"/shoppings/customers/orders/direct","method":"post"},{"path":"/shoppings/customers/orders/{id}","method":"get"},{"path":"/shoppings/customers/orders/{id}","method":"delete"},{"path":"/shoppings/customers/orders/{id}/price","method":"get"},{"path":"/shoppings/customers/orders/{id}/discountable","method":"patch"},{"path":"/shoppings/customers/orders/{id}/discount","method":"put"},{"path":"/shoppings/customers/orders/{orderId}/goods/{id}/confirm","method":"put"},{"path":"/shoppings/customers/orders/{orderId}/publish/able","method":"get"},{"path":"/shoppings/customers/orders/{orderId}/publish","method":"post"},{"path":"/shoppings/customers/orders/{orderId}/publish","method":"delete"},{"path":"/shoppings/customers/sales/details","method":"patch"},{"path":"/shoppings/customers/sales","method":"patch"},{"path":"/shoppings/customers/sales/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/questions/{inquiryId}/comments","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/questions/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/customers/sales/{saleId}/questions","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/questions","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/questions/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/questions/{id}","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/questions/abridges","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{inquiryId}/comments","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/customers/sales/{saleId}/reviews","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/reviews","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{id}","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/reviews/abridges","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/snapshots","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/snapshots/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/snapshots/{id}/flip","method":"get"},{"path":"/shoppings/customers/systematic/channels/{channelCode}/categories","method":"patch"},{"path":"/shoppings/customers/systematic/channels/{channelCode}/categories/{id}","method":"get"},{"path":"/shoppings/customers/systematic/channels/{channelCode}/categories/{id}/invert","method":"get"},{"path":"/shoppings/customers/systematic/channels","method":"patch"},{"path":"/shoppings/customers/systematic/channels/hierarchical","method":"patch"},{"path":"/shoppings/customers/systematic/channels/{id}","method":"get"},{"path":"/shoppings/customers/systematic/channels/{code}/get","method":"get"},{"path":"/shoppings/customers/systematic/sections","method":"patch"},{"path":"/shoppings/customers/systematic/sections/{id}","method":"get"},{"path":"/shoppings/customers/systematic/sections/{code}/get","method":"get"},{"path":"/shoppings/sellers/authenticate","method":"get"},{"path":"/shoppings/sellers/authenticate","method":"post"},{"path":"/shoppings/sellers/authenticate/login","method":"put"},{"path":"/shoppings/sellers/deliveries","method":"post"},{"path":"/shoppings/sellers/deliveries","method":"patch"},{"path":"/shoppings/sellers/deliveries/{id}","method":"get"},{"path":"/shoppings/sellers/deliveries/incompletes","method":"patch"},{"path":"/shoppings/sellers/deliveries/{deliveryId}/journeys","method":"post"},{"path":"/shoppings/sellers/deliveries/{deliveryId}/journeys/{id}/complete","method":"put"},{"path":"/shoppings/sellers/deliveries/{deliveryId}/journeys/{id}","method":"delete"},{"path":"/shoppings/sellers/deliveries/{deliveryId}/shippers","method":"post"},{"path":"/shoppings/sellers/coupons","method":"post"},{"path":"/shoppings/sellers/coupons","method":"patch"},{"path":"/shoppings/sellers/coupons/{id}","method":"get"},{"path":"/shoppings/sellers/coupons/{id}","method":"delete"},{"path":"/shoppings/sellers/orders","method":"patch"},{"path":"/shoppings/sellers/orders/{id}","method":"get"},{"path":"/shoppings/sellers/sales","method":"post"},{"path":"/shoppings/sellers/sales","method":"patch"},{"path":"/shoppings/sellers/sales/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{id}","method":"put"},{"path":"/shoppings/sellers/sales/{id}/open","method":"put"},{"path":"/shoppings/sellers/sales/{id}/replica","method":"post"},{"path":"/shoppings/sellers/sales/{id}/pause","method":"delete"},{"path":"/shoppings/sellers/sales/{id}/suspend","method":"delete"},{"path":"/shoppings/sellers/sales/{id}/restore","method":"put"},{"path":"/shoppings/sellers/sales/details","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{questionId}/answer","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{questionId}/answer","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{inquiryId}/comments","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/questions","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/questions/abridges","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{reviewId}/answer","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{reviewId}/answer","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{inquiryId}/comments","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/reviews","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/abridges","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/snapshots/{id}/replica","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/snapshots","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/snapshots/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/snapshots/{id}/flip","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/units/{unitId}/stocks/{stockId}/supplements","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/units/{unitId}/stocks/{stockId}/supplements","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/units/{unitId}/stocks/{stockId}/supplements/{id}","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/units/{unitId}/stocks/{stockId}/supplements/{id}","method":"delete"},{"path":"/shoppings/sellers/systematic/channels/{channelCode}/categories","method":"patch"},{"path":"/shoppings/sellers/systematic/channels/{channelCode}/categories/{id}","method":"get"},{"path":"/shoppings/sellers/systematic/channels/{channelCode}/categories/{id}/invert","method":"get"},{"path":"/shoppings/sellers/systematic/channels","method":"patch"},{"path":"/shoppings/sellers/systematic/channels/hierarchical","method":"patch"},{"path":"/shoppings/sellers/systematic/channels/{id}","method":"get"},{"path":"/shoppings/sellers/systematic/channels/{code}/get","method":"get"},{"path":"/shoppings/sellers/systematic/sections","method":"patch"},{"path":"/shoppings/sellers/systematic/sections/{id}","method":"get"},{"path":"/shoppings/sellers/systematic/sections/{code}/get","method":"get"}]}\n```\n\n**Key points**: Observe how `/shopping` is used as domain prefix, hierarchical relationships are reflected in paths (e.g., `/shopping/sales/{saleId}/reviews/{reviewId}`), and consistent HTTP methods are applied across similar operations.'),
-        controllers: [ createApplication$8({
+        controllers: [ createApplication$9({
             model: ctx.model,
             build: endpoints => {
                 pointer.value ?? (pointer.value = endpoints);
@@ -2121,9 +2210,9 @@ async function orchestrateInterfaceEndpoints(ctx, content = "Make API endpoints
     };
 }
 
-function createApplication$8(props) {
+function createApplication$9(props) {
     assertSchemaModel(props.model);
-    const application = collection$9[props.model];
+    const application = collection$a[props.model];
     return {
         protocol: "class",
         name: "interface",
@@ -2136,7 +2225,7 @@ function createApplication$8(props) {
     };
 }
 
-const claude$9 = {
+const claude$a = {
     model: "claude",
     options: {
         reference: true,
@@ -2251,7 +2340,7 @@ const claude$9 = {
     } ]
 };
 
-const collection$9 = {
+const collection$a = {
     chatgpt: {
         model: "chatgpt",
         options: {
@@ -2358,10 +2447,10 @@ const collection$9 = {
             })()
         } ]
     },
-    claude: claude$9,
-    llama: claude$9,
-    deepseek: claude$9,
-    3.1: claude$9
+    claude: claude$a,
+    llama: claude$a,
+    deepseek: claude$a,
+    3.1: claude$a
 };
 
 async function orchestrateInterfaceOperations(ctx, endpoints, capacity = 12) {
@@ -2393,7 +2482,7 @@ async function divideAndConquer(ctx, endpoints, retry, progress) {
     for (let i = 0; i < retry; ++i) {
         if (remained.empty() === true || operations.size() >= endpoints.length) break;
         const before = operations.size();
-        const newbie = await forceRetry((() => process$3(ctx, Array.from(remained))));
+        const newbie = await forceRetry((() => process$4(ctx, Array.from(remained))));
         for (const item of newbie) {
             operations.set(item, item);
             remained.erase(item);
@@ -2403,7 +2492,7 @@ async function divideAndConquer(ctx, endpoints, retry, progress) {
     return operations.toJSON().map((it => it.second));
 }
 
-async function process$3(ctx, endpoints) {
+async function process$4(ctx, endpoints) {
     const pointer = {
         value: null
     };
@@ -2417,7 +2506,7 @@ async function process$3(ctx, endpoints) {
             }
         },
         histories: transformInterfaceHistories(ctx.state(), '# API Endpoint Generator System Prompt\n\n## 1. Overview\n\nYou are the API Endpoint Generator, specializing in creating comprehensive lists of REST API endpoints with their paths and HTTP methods based on requirements documents, Prisma schema files, and ERD diagrams. You must output your results by calling the `makeEndpoints()` function.\n\n## 2. Your Mission\n\nAnalyze the provided information and generate a complete array of API endpoints that includes EVERY entity from the Prisma schema and addresses ALL functional requirements. You will call the `makeEndpoints()` function with an array of endpoint definitions that contain ONLY path and method properties.\n\n## 3. Output Method\n\nYou MUST call the `makeEndpoints()` function with your results.\n\n```typescript\nmakeEndpoints({\n  endpoints: [\n    {\n      "path": "/resources",\n      "method": "get"\n    },\n    {\n      "path": "/resources/{resourceId}",\n      "method": "get"\n    },\n    // more endpoints...\n  ],\n});\n```\n\n## 4. Endpoint Design Principles\n\n### 4.1. Follow REST principles\n\n- Resource-centric URL design (use nouns, not verbs)\n- Appropriate HTTP methods:\n  - `put`: Retrieve a collection resources with searching information\n  - `get`: Retrieve a single resource\n  - `post`: Create new resources\n  - `delete`: Remove resources\n  - `patch`: Partial updates or complex queries with request bodies\n\n### 4.2. Path Formatting Rules\n\n1. **Use camelCase for all resource names in paths**\n   - Example: Use `/attachmentFiles` instead of `/attachment-files`\n\n2. **Use domain prefixes with slashes**\n   - Example: Use `/shopping/channels` instead of `/shopping-channels`\n   - **Important**: If you identify any service-related prefix in the DB schema, use it as the global prefix for ALL API endpoints\n\n3. **Structure hierarchical relationships with slashes**\n   - Example: For a child entity like "sale-snapshots" under "sales", use `/shopping/sales/snapshots` instead of `/shopping-sale-snapshots`\n\n### 4.3. Path patterns\n\n- Collection endpoints: `/domain/resources`\n- Single resource endpoints: `/domain/resources/{resourceId}`\n- Nested resources: `/domain/resources/{resourceId}/subsidiaries/{subsidiaryId}`\n\n### 4.4. Standard API operations per entity\n\nFor EACH independent entity identified in the requirements document, Prisma DB Schema, and ERD diagram, you MUST include these standard endpoints:\n\n1. `PATCH /entity-plural` - List entities with searching\n2. `GET /entity-plural/{id}` - Get specific entity\n3. `POST /entity-plural` - Create entity\n4. `PUT /entity-plural/{id}` - Update entity\n5. `DELETE /entity-plural/{id}` - Delete entity\n\n## 5. Critical Requirements\n\n- **Function Call Required**: You MUST use the `makeEndpoints()` function to submit your results\n- **Complete Coverage**: EVERY independent entity in the Prisma schema MUST have corresponding endpoints\n- **No Omissions**: Process ALL independent entities regardless of quantity\n- **Strict Output Format**: ONLY include objects with `path` and `method` properties in your function call\n- **No Additional Properties**: Do NOT include any properties beyond `path` and `method`\n\n## 6. Implementation Strategy\n\n1. Identify ALL independent entities from the Prisma schema, requirements document, and ERD\n2. Identify service-related prefixes in the DB schema to use as the global prefix for ALL API endpoints\n3. Identify domain prefixes and hierarchical relationships between entities\n4. For each independent entity:\n   - Convert kebab-case names to camelCase (e.g., `attachment-files` → `attachmentFiles`)\n   - Structure paths to reflect domain and hierarchical relationships\n   - Generate the standard endpoints\n5. Add endpoints for relationships and complex operations\n6. Verify ALL independent entities and requirements are covered\n7. Call the `makeEndpoints()` function with your complete array\n\nYour implementation MUST be COMPLETE and EXHAUSTIVE, ensuring NO independent entity or requirement is missed, while strictly adhering to the `AutoBeOpenApi.IEndpoint` interface format. Calling the `makeEndpoints()` function is MANDATORY.\n\n## 7. Path Transformation Examples\n\n| Original Format | Improved Format | Explanation |\n|-----------------|-----------------|-------------|\n| `/attachment-files` | `/attachmentFiles` | Convert kebab-case to camelCase |\n| `/bbs-articles` | `/bbs/articles` | Separate domain prefix with slash |\n| `/bbs-article-snapshots` | `/bbs/articles/snapshots` | Reflect hierarchy in URL structure |\n| `/shopping-sale-snapshots` | `/shopping/sales/snapshots` | Both domain prefix and hierarchy properly formatted |\n\nYour implementation MUST be COMPLETE and EXHAUSTIVE, ensuring NO independent entity or requirement is missed, while strictly adhering to the `AutoBeOpenApi.IEndpoint` interface format. Calling the `makeEndpoints()` function is MANDATORY.\n\nYou\'re right - I removed too much of the original structure. Here\'s a better version that maintains the section structure while adding explanations:\n\n## 8. Example Cases\n\nBelow are example projects that demonstrate the proper endpoint formatting.\n\n### 8.1. BBS (Bulletin Board System)\n\n```json\n{"endpoints":[{"path":"/bbs/articles","method":"post"},{"path":"/bbs/articles","method":"patch"},{"path":"/bbs/articles/abridges","method":"patch"},{"path":"/bbs/articles/{id}","method":"get"},{"path":"/bbs/articles/{id}","method":"put"},{"path":"/bbs/articles/{id}","method":"delete"},{"path":"/bbs/articles/{articleId}/comments","method":"post"},{"path":"/bbs/articles/{articleId}/comments","method":"patch"},{"path":"/bbs/articles/{articleId}/comments/{id}","method":"get"},{"path":"/bbs/articles/{articleId}/comments/{id}","method":"put"},{"path":"/bbs/articles/{articleId}/comments/{id}","method":"delete"},{"path":"/monitors/health","method":"get"},{"path":"/monitors/performance","method":"get"},{"path":"/monitors/system","method":"get"}]}\n```\n\n**Key points**: Notice how the domain prefix "bbs" is separated with a slash, entities use camelCase, and hierarchical relationships are expressed (e.g., `/bbs/articles/{articleId}/comments`).\n\n### 8.2. Shopping Mall\n\n```json\n{"endpoints":[{"path":"/monitors/health","method":"get"},{"path":"/monitors/performance","method":"get"},{"path":"/monitors/system","method":"get"},{"path":"/shoppings/admins/authenticate","method":"get"},{"path":"/shoppings/admins/authenticate","method":"post"},{"path":"/shoppings/admins/authenticate/login","method":"put"},{"path":"/shoppings/admins/coupons","method":"post"},{"path":"/shoppings/admins/coupons","method":"patch"},{"path":"/shoppings/admins/coupons/{id}","method":"get"},{"path":"/shoppings/admins/coupons/{id}","method":"delete"},{"path":"/shoppings/admins/deposits","method":"post"},{"path":"/shoppings/admins/deposits","method":"patch"},{"path":"/shoppings/admins/deposits/{id}","method":"get"},{"path":"/shoppings/admins/deposits/{id}","method":"delete"},{"path":"/shoppings/admins/deposits/{code}/get","method":"get"},{"path":"/shoppings/admins/mileages","method":"post"},{"path":"/shoppings/admins/mileages","method":"patch"},{"path":"/shoppings/admins/mileages/{id}","method":"get"},{"path":"/shoppings/admins/mileages/{id}","method":"delete"},{"path":"/shoppings/admins/mileages/{code}/get","method":"get"},{"path":"/shoppings/admins/mileages/donations","method":"post"},{"path":"/shoppings/admins/mileages/donations","method":"patch"},{"path":"/shoppings/admins/mileages/donations/{id}","method":"get"},{"path":"/shoppings/admins/orders","method":"patch"},{"path":"/shoppings/admins/orders/{id}","method":"get"},{"path":"/shoppings/admins/sales/details","method":"patch"},{"path":"/shoppings/admins/sales","method":"patch"},{"path":"/shoppings/admins/sales/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/questions/{inquiryId}/comments","method":"post"},{"path":"/shoppings/admins/sales/{saleId}/questions/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/admins/sales/{saleId}/questions","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/questions/abridges","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/questions/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{inquiryId}/comments","method":"post"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/admins/sales/{saleId}/reviews","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/reviews/abridges","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/reviews/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/snapshots","method":"patch"},{"path":"/shoppings/admins/sales/{saleId}/snapshots/{id}","method":"get"},{"path":"/shoppings/admins/sales/{saleId}/snapshots/{id}/flip","method":"get"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories","method":"post"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories","method":"patch"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories/{id}","method":"get"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories/{id}","method":"put"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories/merge","method":"delete"},{"path":"/shoppings/admins/systematic/channels/{channelCode}/categories/{id}/invert","method":"get"},{"path":"/shoppings/admins/systematic/channels","method":"post"},{"path":"/shoppings/admins/systematic/channels","method":"patch"},{"path":"/shoppings/admins/systematic/channels/{id}","method":"get"},{"path":"/shoppings/admins/systematic/channels/{id}","method":"put"},{"path":"/shoppings/admins/systematic/channels/merge","method":"delete"},{"path":"/shoppings/admins/systematic/channels/hierarchical","method":"patch"},{"path":"/shoppings/admins/systematic/channels/{code}/get","method":"get"},{"path":"/shoppings/admins/systematic/sections","method":"post"},{"path":"/shoppings/admins/systematic/sections","method":"patch"},{"path":"/shoppings/admins/systematic/sections/{id}","method":"get"},{"path":"/shoppings/admins/systematic/sections/{id}","method":"put"},{"path":"/shoppings/admins/systematic/sections/merge","method":"delete"},{"path":"/shoppings/admins/systematic/sections/{code}/get","method":"get"},{"path":"/shoppings/customers/authenticate/refresh","method":"patch"},{"path":"/shoppings/customers/authenticate","method":"get"},{"path":"/shoppings/customers/authenticate","method":"post"},{"path":"/shoppings/customers/authenticate/join","method":"post"},{"path":"/shoppings/customers/authenticate/login","method":"put"},{"path":"/shoppings/customers/authenticate/activate","method":"post"},{"path":"/shoppings/customers/authenticate/external","method":"post"},{"path":"/shoppings/customers/authenticate/password/change","method":"put"},{"path":"/shoppings/customers/coupons","method":"patch"},{"path":"/shoppings/customers/coupons/{id}","method":"get"},{"path":"/shoppings/customers/coupons/tickets","method":"post"},{"path":"/shoppings/customers/coupons/tickets","method":"patch"},{"path":"/shoppings/customers/coupons/tickets/{id}","method":"get"},{"path":"/shoppings/customers/deposits/charges","method":"post"},{"path":"/shoppings/customers/deposits/charges","method":"patch"},{"path":"/shoppings/customers/deposits/charges/{id}","method":"get"},{"path":"/shoppings/customers/deposits/charges/{id}","method":"put"},{"path":"/shoppings/customers/deposits/charges/{id}","method":"delete"},{"path":"/shoppings/customers/deposits/charges/{chargeId}/publish/able","method":"get"},{"path":"/shoppings/customers/deposits/charges/{chargeId}/publish","method":"post"},{"path":"/shoppings/customers/deposits/histories","method":"patch"},{"path":"/shoppings/customers/deposits/histories/{id}","method":"get"},{"path":"/shoppings/customers/deposits/histories/balance","method":"get"},{"path":"/shoppings/customers/mileages/histories","method":"patch"},{"path":"/shoppings/customers/mileages/histories/{id}","method":"get"},{"path":"/shoppings/customers/mileages/histories/balance","method":"get"},{"path":"/shoppings/customers/carts/commodities","method":"post"},{"path":"/shoppings/customers/carts/commodities","method":"patch"},{"path":"/shoppings/customers/carts/commodities/{id}","method":"get"},{"path":"/shoppings/customers/carts/commodities/{id}","method":"put"},{"path":"/shoppings/customers/carts/commodities/{id}","method":"delete"},{"path":"/shoppings/customers/carts/commodities/{id}/replica","method":"get"},{"path":"/shoppings/customers/carts/commodities/discountable","method":"patch"},{"path":"/shoppings/customers/orders","method":"post"},{"path":"/shoppings/customers/orders","method":"patch"},{"path":"/shoppings/customers/orders/direct","method":"post"},{"path":"/shoppings/customers/orders/{id}","method":"get"},{"path":"/shoppings/customers/orders/{id}","method":"delete"},{"path":"/shoppings/customers/orders/{id}/price","method":"get"},{"path":"/shoppings/customers/orders/{id}/discountable","method":"patch"},{"path":"/shoppings/customers/orders/{id}/discount","method":"put"},{"path":"/shoppings/customers/orders/{orderId}/goods/{id}/confirm","method":"put"},{"path":"/shoppings/customers/orders/{orderId}/publish/able","method":"get"},{"path":"/shoppings/customers/orders/{orderId}/publish","method":"post"},{"path":"/shoppings/customers/orders/{orderId}/publish","method":"delete"},{"path":"/shoppings/customers/sales/details","method":"patch"},{"path":"/shoppings/customers/sales","method":"patch"},{"path":"/shoppings/customers/sales/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/questions/{inquiryId}/comments","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/questions/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/customers/sales/{saleId}/questions","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/questions","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/questions/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/questions/{id}","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/questions/abridges","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{inquiryId}/comments","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/customers/sales/{saleId}/reviews","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/reviews","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/reviews/{id}","method":"post"},{"path":"/shoppings/customers/sales/{saleId}/reviews/abridges","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/snapshots","method":"patch"},{"path":"/shoppings/customers/sales/{saleId}/snapshots/{id}","method":"get"},{"path":"/shoppings/customers/sales/{saleId}/snapshots/{id}/flip","method":"get"},{"path":"/shoppings/customers/systematic/channels/{channelCode}/categories","method":"patch"},{"path":"/shoppings/customers/systematic/channels/{channelCode}/categories/{id}","method":"get"},{"path":"/shoppings/customers/systematic/channels/{channelCode}/categories/{id}/invert","method":"get"},{"path":"/shoppings/customers/systematic/channels","method":"patch"},{"path":"/shoppings/customers/systematic/channels/hierarchical","method":"patch"},{"path":"/shoppings/customers/systematic/channels/{id}","method":"get"},{"path":"/shoppings/customers/systematic/channels/{code}/get","method":"get"},{"path":"/shoppings/customers/systematic/sections","method":"patch"},{"path":"/shoppings/customers/systematic/sections/{id}","method":"get"},{"path":"/shoppings/customers/systematic/sections/{code}/get","method":"get"},{"path":"/shoppings/sellers/authenticate","method":"get"},{"path":"/shoppings/sellers/authenticate","method":"post"},{"path":"/shoppings/sellers/authenticate/login","method":"put"},{"path":"/shoppings/sellers/deliveries","method":"post"},{"path":"/shoppings/sellers/deliveries","method":"patch"},{"path":"/shoppings/sellers/deliveries/{id}","method":"get"},{"path":"/shoppings/sellers/deliveries/incompletes","method":"patch"},{"path":"/shoppings/sellers/deliveries/{deliveryId}/journeys","method":"post"},{"path":"/shoppings/sellers/deliveries/{deliveryId}/journeys/{id}/complete","method":"put"},{"path":"/shoppings/sellers/deliveries/{deliveryId}/journeys/{id}","method":"delete"},{"path":"/shoppings/sellers/deliveries/{deliveryId}/shippers","method":"post"},{"path":"/shoppings/sellers/coupons","method":"post"},{"path":"/shoppings/sellers/coupons","method":"patch"},{"path":"/shoppings/sellers/coupons/{id}","method":"get"},{"path":"/shoppings/sellers/coupons/{id}","method":"delete"},{"path":"/shoppings/sellers/orders","method":"patch"},{"path":"/shoppings/sellers/orders/{id}","method":"get"},{"path":"/shoppings/sellers/sales","method":"post"},{"path":"/shoppings/sellers/sales","method":"patch"},{"path":"/shoppings/sellers/sales/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{id}","method":"put"},{"path":"/shoppings/sellers/sales/{id}/open","method":"put"},{"path":"/shoppings/sellers/sales/{id}/replica","method":"post"},{"path":"/shoppings/sellers/sales/{id}/pause","method":"delete"},{"path":"/shoppings/sellers/sales/{id}/suspend","method":"delete"},{"path":"/shoppings/sellers/sales/{id}/restore","method":"put"},{"path":"/shoppings/sellers/sales/details","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{questionId}/answer","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{questionId}/answer","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{inquiryId}/comments","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/questions","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/questions/abridges","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/questions/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{reviewId}/answer","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{reviewId}/answer","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{inquiryId}/comments","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{inquiryId}/comments","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{inquiryId}/comments/{id}","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/reviews","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/abridges","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/reviews/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/snapshots/{id}/replica","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/snapshots","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/snapshots/{id}","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/snapshots/{id}/flip","method":"get"},{"path":"/shoppings/sellers/sales/{saleId}/units/{unitId}/stocks/{stockId}/supplements","method":"post"},{"path":"/shoppings/sellers/sales/{saleId}/units/{unitId}/stocks/{stockId}/supplements","method":"patch"},{"path":"/shoppings/sellers/sales/{saleId}/units/{unitId}/stocks/{stockId}/supplements/{id}","method":"put"},{"path":"/shoppings/sellers/sales/{saleId}/units/{unitId}/stocks/{stockId}/supplements/{id}","method":"delete"},{"path":"/shoppings/sellers/systematic/channels/{channelCode}/categories","method":"patch"},{"path":"/shoppings/sellers/systematic/channels/{channelCode}/categories/{id}","method":"get"},{"path":"/shoppings/sellers/systematic/channels/{channelCode}/categories/{id}/invert","method":"get"},{"path":"/shoppings/sellers/systematic/channels","method":"patch"},{"path":"/shoppings/sellers/systematic/channels/hierarchical","method":"patch"},{"path":"/shoppings/sellers/systematic/channels/{id}","method":"get"},{"path":"/shoppings/sellers/systematic/channels/{code}/get","method":"get"},{"path":"/shoppings/sellers/systematic/sections","method":"patch"},{"path":"/shoppings/sellers/systematic/sections/{id}","method":"get"},{"path":"/shoppings/sellers/systematic/sections/{code}/get","method":"get"}]}\n```\n\n**Key points**: Observe how `/shopping` is used as domain prefix, hierarchical relationships are reflected in paths (e.g., `/shopping/sales/{saleId}/reviews/{reviewId}`), and consistent HTTP methods are applied across similar operations.'),
-        controllers: [ createApplication$7({
+        controllers: [ createApplication$8({
             model: ctx.model,
             roles: ctx.state().analyze?.roles.map((it => it.name)) ?? null,
             build: endpoints => {
@@ -2435,9 +2524,9 @@ async function process$3(ctx, endpoints) {
     return pointer.value;
 }
 
-function createApplication$7(props) {
+function createApplication$8(props) {
     assertSchemaModel(props.model);
-    const application = collection$8[props.model];
+    const application = collection$9[props.model];
     application.functions[0].validate = next => {
         const result = (() => {
             const _io0 = input => Array.isArray(input.operations) && input.operations.every((elem => "object" === typeof elem && null !== elem && _io1(elem)));
@@ -2753,7 +2842,7 @@ function createApplication$7(props) {
     };
 }
 
-const claude$8 = {
+const claude$9 = {
     model: "claude",
     options: {
         reference: true,
@@ -3289,7 +3378,7 @@ const claude$8 = {
     } ]
 };
 
-const collection$8 = {
+const collection$9 = {
     chatgpt: {
         model: "chatgpt",
         options: {
@@ -3816,10 +3905,10 @@ const collection$8 = {
             })()
         } ]
     },
-    claude: claude$8,
-    llama: claude$8,
-    deepseek: claude$8,
-    3.1: claude$8
+    claude: claude$9,
+    llama: claude$9,
+    deepseek: claude$9,
+    3.1: claude$9
 };
 
 const orchestrateInterface = ctx => async props => {
@@ -3899,7 +3988,7 @@ async function orchestratePrismaComponents(ctx, content = "Please extract files
             }
         },
         histories: transformPrismaComponentsHistories(ctx.state(), prefix),
-        controllers: [ createApplication$6({
+        controllers: [ createApplication$7({
             model: ctx.model,
             build: next => {
                 pointer.value ?? (pointer.value = {
@@ -3929,9 +4018,9 @@ async function orchestratePrismaComponents(ctx, content = "Please extract files
     };
 }
 
-function createApplication$6(props) {
+function createApplication$7(props) {
     assertSchemaModel(props.model);
-    const application = collection$7[props.model];
+    const application = collection$8[props.model];
     return {
         protocol: "class",
         name: "Prisma Extract Files and Tables",
@@ -3944,7 +4033,7 @@ function createApplication$6(props) {
     };
 }
 
-const claude$7 = {
+const claude$8 = {
     model: "claude",
     options: {
         reference: true,
@@ -4083,7 +4172,7 @@ const claude$7 = {
     } ]
 };
 
-const collection$7 = {
+const collection$8 = {
     chatgpt: {
         model: "chatgpt",
         options: {
@@ -4221,10 +4310,10 @@ const collection$7 = {
             })()
         } ]
     },
-    claude: claude$7,
-    llama: claude$7,
-    deepseek: claude$7,
-    3.1: claude$7
+    claude: claude$8,
+    llama: claude$8,
+    deepseek: claude$8,
+    3.1: claude$8
 };
 
 const transformPrismaCorrectHistories = result => [ {
@@ -4288,7 +4377,7 @@ async function step(ctx, application, life) {
             }
         },
         histories: transformPrismaCorrectHistories(result),
-        controllers: [ createApplication$5({
+        controllers: [ createApplication$6({
             model: ctx.model,
             build: next => {
                 pointer.value = next;
@@ -4327,9 +4416,9 @@ async function step(ctx, application, life) {
     }, life - 1);
 }
 
-function createApplication$5(props) {
+function createApplication$6(props) {
     assertSchemaModel(props.model);
-    const application = collection$6[props.model];
+    const application = collection$7[props.model];
     return {
         protocol: "class",
         name: "Prisma Compiler",
@@ -4342,7 +4431,7 @@ function createApplication$5(props) {
     };
 }
 
-const claude$6 = {
+const claude$7 = {
     model: "claude",
     options: {
         reference: true,
@@ -4890,7 +4979,7 @@ const claude$6 = {
     } ]
 };
 
-const collection$6 = {
+const collection$7 = {
     chatgpt: {
         model: "chatgpt",
         options: {
@@ -5418,10 +5507,10 @@ const collection$6 = {
             })()
         } ]
     },
-    claude: claude$6,
-    llama: claude$6,
-    deepseek: claude$6,
-    3.1: claude$6
+    claude: claude$7,
+    llama: claude$7,
+    deepseek: claude$7,
+    3.1: claude$7
 };
 
 const transformPrismaSchemaHistories = (requirementAnalysisReport, targetComponent, otherComponents) => [ {
@@ -5454,7 +5543,7 @@ async function orchestratePrismaSchemas(ctx, components) {
     return await Promise.all(components.map((async comp => {
         const targetComponent = comp;
         const otherComponents = components.filter((y => comp !== y));
-        const result = await forceRetry((() => process$2(ctx, targetComponent, otherComponents)));
+        const result = await forceRetry((() => process$3(ctx, targetComponent, otherComponents)));
         const event = {
             type: "prismaSchemas",
             created_at: start.toISOString(),
@@ -5472,7 +5561,7 @@ async function orchestratePrismaSchemas(ctx, components) {
     })));
 }
 
-async function process$2(ctx, targetComponent, otherComponents) {
+async function process$3(ctx, targetComponent, otherComponents) {
     const pointer = {
         value: null
     };
@@ -5486,7 +5575,7 @@ async function process$2(ctx, targetComponent, otherComponents) {
             }
         },
         histories: transformPrismaSchemaHistories(ctx.state().analyze.files, targetComponent, otherComponents),
-        controllers: [ createApplication$4(ctx, {
+        controllers: [ createApplication$5(ctx, {
             targetComponent,
             otherComponents,
             build: next => {
@@ -5503,9 +5592,9 @@ async function process$2(ctx, targetComponent, otherComponents) {
     return pointer.value;
 }
 
-function createApplication$4(ctx, props) {
+function createApplication$5(ctx, props) {
     assertSchemaModel(ctx.model);
-    const application = collection$5[ctx.model];
+    const application = collection$6[ctx.model];
     return {
         protocol: "class",
         name: "Prisma Generator",
@@ -5518,7 +5607,7 @@ function createApplication$4(ctx, props) {
     };
 }
 
-const claude$5 = {
+const claude$6 = {
     model: "claude",
     options: {
         reference: true,
@@ -6104,7 +6193,7 @@ const claude$5 = {
     } ]
 };
 
-const collection$5 = {
+const collection$6 = {
     chatgpt: {
         model: "chatgpt",
         options: {
@@ -6670,10 +6759,10 @@ const collection$5 = {
             })()
         } ]
     },
-    claude: claude$5,
-    llama: claude$5,
-    deepseek: claude$5,
-    3.1: claude$5
+    claude: claude$6,
+    llama: claude$6,
+    deepseek: claude$6,
+    3.1: claude$6
 };
 
 const orchestratePrisma = ctx => async props => {
@@ -6723,44 +6812,543 @@ const orchestratePrisma = ctx => async props => {
     return history;
 };
 
-const FAILED = Symbol("FAILED");
+const transformRealizeDecoratorHistories = (ctx, role) => [ {
+    id: v4(),
+    created_at: (new Date).toISOString(),
+    type: "systemMessage",
+    text: '# NestJS Authentication Provider & Decorator Generation AI Agent  \n\nYou are a world-class NestJS expert and TypeScript developer. Your role is to automatically generate Provider functions and Decorators for JWT authentication based on given Role information and Prisma Schema.  \n\n## Core Mission  \n\nGenerate authentication Provider and Decorator code specialized for specific Roles based on Role information provided by users.  \n\n## Input Information  \n\n- **Role Name**: The authentication role to generate (e.g., admin, user, manager, etc.)  \n- **Prisma Schema**: Database table information.\n\n## Code Generation Rules  \n\n### 1. Provider Function Generation Rules  \n\n- Function name: `{role}Authorize` format (e.g., adminAuthorize, userAuthorize)  \n- Must use the `jwtAuthorize` function for JWT token verification  \n- Verify payload type and check if `payload.type` matches the correct role  \n- Query database using `MyGlobal.prisma.{tableName}` format to fetch **only the authorization model itself** - do not include relations or business logic models (no `include` statements for profile, etc.)  \n- Verify that the user actually exists in the database  \n- Function return type should be `{Role}Payload` interface  \n- Return the `payload` variable whenever feasible in provider functions.  \n- **Always check the Prisma schema for validation columns (e.g., `deleted_at`, status fields) within the authorization model and include them in the `where` clause to ensure the user is valid and active.**  \n\n### 2. Payload Interface Generation Rules  \n\n- Interface name: `{Role}Payload` format (e.g., AdminPayload, UserPayload)  \n- Required fields:  \n  - `id: string & tags.Format<"uuid">`: User ID (UUID format)  \n  - `type: "{role}"`: Discriminator for role identification  \n- Additional fields should be generated according to Role characteristics and "Prisma Schema"  \n\n### 3. Decorator Generation Rules  \n\n- Decorator name: `{Role}Auth` format (e.g., AdminAuth, UserAuth)  \n- Use SwaggerCustomizer to add bearer token security schema to API documentation  \n- Use createParamDecorator to implement actual authentication logic  \n- Use Singleton pattern to manage decorator instances  \n\n### 4. Code Style and Structure\n\n- Comply with TypeScript strict mode  \n- Utilize NestJS Exception classes (ForbiddenException, UnauthorizedException)  \n- Ensure type safety using typia tags  \n- Add appropriate JSDoc comments  \n\n## Reference Functions and Examples  \n\n### JWT Authentication Function  \n\n```typescript\n// path - src/authentications/jwtAuthorize.ts\nimport { ForbiddenException, UnauthorizedException } from "@nestjs/common";\nimport jwt from "jsonwebtoken";\n\nimport { MyGlobal } from "../MyGlobal";\n\nexport function jwtAuthorize(props: {\n  request: {\n    headers: { authorization?: string };\n  };\n}) {\n  if (!props.request.headers.authorization)\n    throw new ForbiddenException("No token value exists");\n  else if (\n    props.request.headers.authorization.startsWith(BEARER_PREFIX) === false\n  )\n    throw new UnauthorizedException("Invalid token");\n\n  // PARSE TOKEN\n  try {\n    const token: string = props.request.headers.authorization.substring(\n      BEARER_PREFIX.length,\n    );\n\n    const verified = jwt.verify(token, MyGlobal.env.JWT_SECRET_KEY);\n\n    return verified;\n  } catch {\n    throw new UnauthorizedException("Invalid token");\n  }\n}\n\nconst BEARER_PREFIX = "Bearer ";\n```  \n\n### Provider Function Example  \n\n```typescript\nimport { ForbiddenException } from "@nestjs/common";\n\nimport { MyGlobal } from "../MyGlobal";\nimport { jwtAuthorize } from "./jwtAuthorize";\nimport { AdminPayload } from "./types/AdminPayload";\n\nexport async function adminAuthorize(request: {\n  headers: {\n    authorization?: string;\n  };\n}): Promise<AdminPayload> {\n  const payload: AdminPayload = jwtAuthorize({ request }) as AdminPayload;\n\n  if (payload.type !== "admin") {\n    throw new ForbiddenException(`You\'re not ${payload.type}`);\n  }\n\n  const admin = await MyGlobal.prisma.admins.findFirst({\n    where: {\n      id: payload.id,\n      user: {\n        deleted_at: null,\n        is_banned: false,\n      },\n    },\n  });\n\n  if (admin === null) {\n    throw new ForbiddenException("You\'re not enrolled");\n  }\n\n  return payload;\n}\n```  \n\n### Decorator Example\n\n```typescript\nimport { SwaggerCustomizer } from "@nestia/core";\nimport { ExecutionContext, createParamDecorator } from "@nestjs/common";\nimport { Singleton } from "tstl";\n\nimport { adminAuthorize } from "../authentications/adminAuthorize";\n\nexport const AdminAuth =\n  (): ParameterDecorator =>\n  (\n    target: object,\n    propertyKey: string | symbol | undefined,\n    parameterIndex: number,\n  ): void => {\n    SwaggerCustomizer((props) => {\n      props.route.security ??= [];\n      props.route.security.push({\n        bearer: [],\n      });\n    })(target, propertyKey as string, undefined!);\n    singleton.get()(target, propertyKey, parameterIndex);\n  };\n\nconst singleton = new Singleton(() =>\n  createParamDecorator(async (_0: unknown, ctx: ExecutionContext) => {\n    const request = ctx.switchToHttp().getRequest();\n    return adminAuthorize(request);\n  })(),\n);\n```  \n\n### Decorator Type Example  \n\nIn case of the columns related to Date type like `created_at`, `updated_at`, `deleted_at`, must use the `string & tags.Format<\'date-time\'>` Type instead of Date type.  \n\n```typescript\nimport { tags } from "typia";\n\nexport interface AdminPayload {\n  /**\n   * Admin ID.\n   */\n  id: string & tags.Format<"uuid">;\n\n  /**\n   * Discriminator for the discriminated union type.\n   */\n  type: "admin";\n}\n```  \n\n## Output Format  \n\nYou must provide your response in a structured JSON format containing the following nested structure:  \n\n**provider**: An object containing the authentication Provider function configuration  \n\n- **name**: The name of the authentication Provider function in `{role}Authorize` format (e.g., adminAuthorize, userAuthorize). This function verifies JWT tokens and returns user information for the specified role.  \n- **code**: Complete TypeScript code for the authentication Provider function only. Must include JWT verification, role checking, database query logic, and proper import statements for the Payload interface.\n\n**decorator**: An object containing the authentication Decorator configuration  \n\n- **name**: The name of the Decorator to be generated in `{Role}Auth` format (e.g., AdminAuth, UserAuth). The decorator name used in Controller method parameters.  \n- **code**: Complete TypeScript code for the Decorator. Must include complete authentication decorator implementation using SwaggerCustomizer, createParamDecorator, and Singleton pattern.\n\n**decoratorType**: An object containing the Decorator Type configuration\n\n- **name**: The name of the Decorator Type in `{Role}Payload` format (e.g., AdminPayload, UserPayload). Used as the TypeScript type for the authenticated user data.\n- **code**: Complete TypeScript code for the Payload type interface. Must include proper field definitions with typia tags for type safety.\n\n## Work Process  \n\n1. Analyze the input Role name  \n2. Generate Provider function for the Role  \n3. Define Payload interface  \n4. Implement Decorator  \n5. Verify that all code follows example patterns  \n6. Generate response in specified format  \n\n## Quality Standards  \n\n- Ensure type safety  \n- Follow NestJS conventions  \n- Complete error handling  \n- Code reusability  \n- Complete documentation  \n\nWhen users provide Role information, generate complete and practical authentication code according to the above rules.'
+}, {
+    id: v4(),
+    created_at: (new Date).toISOString(),
+    type: "systemMessage",
+    text: [ "## Role", "", role, "", "## Prisma Schema", "", JSON.stringify(ctx.state().prisma?.schemas, null, 2), "" ].join("\n")
+} ];
 
-function pipe(a, ...fns) {
-    return fns.reduce(((prev, fn) => prev.then((result => {
-        if (result === FAILED) return FAILED;
-        return fn(result);
-    }))), Promise.resolve(a));
-}
+const transformRealizeDecoratorCorrectHistories = (ctx, result, templateFiles, diagnostics) => [ {
+    id: v4(),
+    created_at: (new Date).toISOString(),
+    type: "systemMessage",
+    text: '# TypeScript Compiler Feedback Correction System  \n\nYou are an expert TypeScript developer specializing in fixing compilation errors in NestJS authentication systems. Your task is to analyze TypeScript compilation diagnostics and correct the generated code to ensure it compiles successfully.  \n\n## Your Role  \n\nYou will receive:  \n\n1. **Generated TypeScript Code** - Authentication provider and decorator implementations  \n2. **Prisma Schema** - Available database table  \n3. **File Paths** - Project structure for import resolution  \n4. **Compile Errors** - TypeScript diagnostic information  \n\nYour goal is to fix all compilation errors while maintaining the original functionality and structure.  \n\n## Analysis Process  \n\nFollow this systematic approach to fix compilation errors:  \n\n### Step 1: Error Analysis  \n\n- Examine each diagnostic error carefully  \n- Identify the error type (import issues, type mismatches, missing properties, etc.)  \n- Note the file location and specific line/character positions  \n- Categorize errors by severity and interdependency  \n\n### Step 2: Context Understanding\n\n- Review the available Prisma client mappings to understand database schema  \n- Check file paths to ensure correct import statements  \n- Validate that all referenced types and interfaces exist  \n- Understand the relationship between provider and decorator implementations  \n\n### Step 3: Root Cause Identification\n\n- Determine if errors are due to:  \n  - Incorrect Prisma table names (use Prisma Schema mapping)  \n  - Wrong import paths (use provided file paths)  \n  - Missing type definitions  \n  - Incorrect function signatures  \n  - Incompatible TypeScript syntax  \n\n### Step 4: Systematic Correction  \n\n- Fix errors in dependency order (types before implementations)  \n- Ensure consistency between provider and decorator implementations  \n- Maintain original naming conventions and patterns  \n- Preserve all required functionality  \n\n## Common Error Types and Solutions  \n\n### Database Table Access Errors\n\n- **Problem**: `Property \'tableName\' does not exist on type \'PrismaClients\'`  \n- **Solution**: Check `Prisma Schema` mapping for correct table names  \n- **Example**: If error shows `admins` but model of prisma Schema shows `admin`, use `admin`  \n\n### Import Path Errors  \n\n- **Problem**: Module resolution failures  \n- **Solution**: Use provided file paths to construct correct relative imports  \n- **Example**: Adjust `./` vs `../` based on actual file structure  \n\n### Type Definition Errors  \n\n- **Problem**: Missing or incorrect type references  \n- **Solution**: Ensure all interfaces and types are properly defined and exported  \n- **Example**: Add missing `export` keywords or correct type names  \n\n### Function Signature Mismatches\n\n- **Problem**: Parameter types don\'t match expected signatures  \n- **Solution**: Align function parameters with NestJS and custom type requirements  \n- **Example**: Ensure JWT payload types match expected structure  \n\n## Code Correction Guidelines  \n\n### 1. Preserve Original Structure  \n\n- Keep the same function names and export patterns  \n- Maintain the provider-decorator relationship  \n- Preserve all required imports and dependencies  \n\n### 2. Database Integration  \n\n- Use exact table names from `Prisma Schema` mapping  \n- Ensure proper async/await patterns for database queries  \n- Maintain proper error handling for database operations  \n\n### 3. Type Safety\n\n- Ensure all types are properly imported and defined  \n- Use typia tags correctly for validation  \n- Maintain strict TypeScript compliance  \n\n### 4. NestJS Integration  \n\n- Preserve decorator patterns and parameter injection  \n- Maintain proper exception handling (ForbiddenException, UnauthorizedException)  \n- Ensure Swagger integration remains intact  \n\n## Output Format  \n\nProvide your corrected code in the following JSON format:  \n\n```json\n{\n  "provider": {\n    "name": "corrected_provider_name",\n    "code": "corrected_provider_code"\n  },\n  "decorator": {\n    "name": "corrected_decorator_name", \n    "code": "corrected_decorator_code"\n  }\n  "decoratorType": {\n    "name": "corrected_payload_type_name",\n    "code": "corrected_payload_type_code"\n  }\n}\n```  \n\n## Validation Checklist  \n\nBefore submitting your corrections, verify:  \n\n- [ ] All compilation errors are addressed  \n- [ ] Database table names match Prisma Schema mapping  \n- [ ] Import paths are correct based on file structure  \n- [ ] All types are properly defined and exported  \n- [ ] Function signatures match expected patterns  \n- [ ] Error handling is preserved  \n- [ ] Original functionality is maintained  \n- [ ] Code follows TypeScript best practices  \n\n## Response Process  \n\n1. **First**, analyze all errors and identify patterns  \n2. **Then**, explain your understanding of the issues  \n3. **Next**, describe your correction strategy  \n4. **Finally**, provide the corrected code in the specified JSON format  \n\nRemember: Focus on fixing compilation errors while preserving the original authentication logic and NestJS integration patterns.'
+}, {
+    id: v4(),
+    created_at: (new Date).toISOString(),
+    type: "assistantMessage",
+    text: [ "## Generated TypeScript Code", "", "```json", `${JSON.stringify(result, null, 2)}`, "```", "", "## Prisma Schema", "", "```json", `${JSON.stringify(ctx.state().prisma?.schemas, null, 2)}`, "```", "", "## File Paths", "", Object.keys(templateFiles).map((path => `- ${path}`)).join("\n"), "", "## Compile Errors", "", "Fix the compilation error in the provided code.", "", "```json", JSON.stringify(diagnostics, null, 2), "```" ].join("\n")
+} ];
 
-async function getTestScenarioArtifacts(ctx, scenario) {
-    const compiler = await ctx.compiler();
-    const document = filterDocument(scenario, ctx.state().interface.document);
-    const entries = Object.entries(await compiler.interface.write(document));
-    const filter = (prefix, exclude) => {
-        const result = entries.filter((([key]) => key.startsWith(prefix) === true));
-        return Object.fromEntries(exclude ? result.filter((([key]) => key.startsWith(exclude) === false)) : result);
+async function orchestrateRealizeDecorator(ctx) {
+    const roles = ctx.state().interface?.document.components.authorization?.map((auth => auth.name)) ?? [];
+    const decorators = [];
+    let completed = 0;
+    const templateFiles = {
+        "src/MyGlobal.ts": await fs.readFile(path.join(__dirname, "../../../../../internals/template/realize/src/MyGlobal.ts"), "utf-8"),
+        "src/authentications/jwtAuthorize.ts": await fs.readFile(path.join(__dirname, "../../../../../internals/template/realize/src/providers/jwtAuthorize.ts"), "utf-8")
     };
-    return {
-        document,
-        sdk: filter("src/api", "src/api/structures"),
-        dto: filter("src/api/structures"),
-        e2e: filter("test/features")
+    const files = {
+        ...templateFiles
     };
+    await Promise.all(roles.map((async role => {
+        const decorator = await process$2(ctx, role, templateFiles);
+        files[`src/decorators/${decorator.decorator.name}.ts`] = decorator.decorator.code;
+        files[`src/authentications/${decorator.provider.name}.ts`] = decorator.provider.code;
+        files[`src/authentications/types/${decorator.decoratorType.name}.ts`] = decorator.decoratorType.code;
+        decorators.push(decorator);
+        const events = {
+            type: "realizeDecorator",
+            created_at: (new Date).toISOString(),
+            files,
+            completed: ++completed,
+            total: roles.length,
+            step: ctx.state().test?.step ?? 0
+        };
+        ctx.dispatch(events);
+    })));
+    return decorators;
 }
 
-function filterDocument(scenario, document) {
-    const operations = document.operations.filter((op => scenario.endpoint.method === op.method && scenario.endpoint.path === op.path || scenario.dependencies.some((dp => dp.endpoint.method === op.method && dp.endpoint.path === op.path))));
-    const components = {
-        schemas: {}
+async function process$2(ctx, role, templateFiles) {
+    const pointer = {
+        value: null
     };
-    const visit = typeName => {
-        OpenApiTypeChecker.visit({
-            components: document.components,
-            schema: {
-                $ref: `#/components/schemas/${typeName}`
-            },
-            closure: s => {
-                if (OpenApiTypeChecker.isReference(s)) {
+    const agentica = new MicroAgentica({
+        model: ctx.model,
+        vendor: ctx.vendor,
+        config: {
+            ...ctx.config ?? {},
+            executor: {
+                describe: null
+            }
+        },
+        histories: transformRealizeDecoratorHistories(ctx, role),
+        controllers: [ createApplication$4({
+            model: ctx.model,
+            build: next => {
+                pointer.value = next;
+            }
+        }) ]
+    });
+    enforceToolCall(agentica);
+    await agentica.conversate("Create Authorization Provider and Decorator.").finally((() => {
+        const tokenUsage = agentica.getTokenUsage();
+        ctx.usage().record(tokenUsage, [ "realize" ]);
+    }));
+    if (pointer.value === null) throw new Error("Failed to create decorator.");
+    const compiled = ctx.state().prisma?.compiled;
+    const prismaClients = compiled?.type === "success" ? compiled.nodeModules : {};
+    return await correctDecorator(ctx, pointer.value, prismaClients, templateFiles);
+}
+
+async function correctDecorator(ctx, result, prismaClients, templateFiles, life = 4) {
+    const files = {
+        ...templateFiles,
+        ...prismaClients,
+        [`src/decorators/${result.decorator.name}.ts`]: result.decorator.code,
+        [`src/authentications/${result.provider.name}.ts`]: result.provider.code,
+        [`src/authentications/types/${result.decoratorType.name}.ts`]: result.decoratorType.code
+    };
+    const compiler = await ctx.compiler();
+    const compiled = await compiler.typescript.compile({
+        files
+    });
+    ctx.dispatch({
+        type: "realizeDecoratorValidate",
+        created_at: (new Date).toISOString(),
+        result: compiled,
+        files,
+        step: ctx.state().test?.step ?? 0
+    });
+    if (compiled.type === "success") {
+        return result;
+    } else if (compiled.type === "exception" || life === 0) {
+        return result;
+    }
+    const pointer = {
+        value: null
+    };
+    const agentica = new MicroAgentica({
+        model: ctx.model,
+        vendor: ctx.vendor,
+        config: {
+            ...ctx.config ?? {},
+            executor: {
+                describe: null
+            }
+        },
+        histories: transformRealizeDecoratorCorrectHistories(ctx, result, templateFiles, compiled.diagnostics),
+        controllers: [ createApplication$4({
+            model: ctx.model,
+            build: next => {
+                pointer.value = next;
+            }
+        }) ]
+    });
+    enforceToolCall(agentica);
+    await agentica.conversate("Please correct the decorator and the provider.").finally((() => {
+        const tokenUsage = agentica.getTokenUsage();
+        ctx.usage().record(tokenUsage, [ "realize" ]);
+    }));
+    if (pointer.value === null) throw new Error("Failed to correct decorator.");
+    const correctedFiles = {
+        ...files,
+        [`src/decorators/${pointer.value.decorator.name}.ts`]: pointer.value.decorator.code,
+        [`src/authentications/${pointer.value.provider.name}.ts`]: pointer.value.provider.code,
+        [`src/authentications/types/${pointer.value.decoratorType.name}.ts`]: pointer.value.decoratorType.code
+    };
+    ctx.dispatch({
+        type: "realizeDecoratorCorrect",
+        created_at: (new Date).toISOString(),
+        files: correctedFiles,
+        result: compiled,
+        step: ctx.state().test?.step ?? 0
+    });
+    return await correctDecorator(ctx, pointer.value, prismaClients, templateFiles, life - 1);
+}
+
+function createApplication$4(props) {
+    assertSchemaModel(props.model);
+    const application = collection$5[props.model];
+    return {
+        protocol: "class",
+        name: "Create Decorator",
+        application,
+        execute: {
+            createDecorator: next => {
+                props.build(next);
+            }
+        }
+    };
+}
+
+const claude$5 = {
+    model: "claude",
+    options: {
+        reference: true,
+        separate: null
+    },
+    functions: [ {
+        name: "createDecorator",
+        parameters: {
+            description: "Current Type: {@link IAutoBeRealizeDecoratorApplication.IProps}",
+            type: "object",
+            properties: {
+                provider: {
+                    description: "Authentication Provider function configuration containing the function\nname and implementation code. The Provider handles JWT token\nverification, role validation, and database queries to authenticate\nusers.",
+                    $ref: "#/$defs/IAutoBeRealizeDecoratorApplication.IProvider"
+                },
+                decorator: {
+                    description: "Authentication Decorator configuration containing the decorator name and\nimplementation code. The Decorator integrates with NestJS parameter\ndecorators to automatically inject authenticated user data into\nController methods.",
+                    $ref: "#/$defs/IAutoBeRealizeDecoratorApplication.IDecorator"
+                },
+                decoratorType: {
+                    description: "Authentication Decorator Type configuration containing the decorator type\nname and implementation code. The Decorator Type is used to define the\nstructure of the authenticated user data that will be injected into\nController methods when using the decorator. It serves as the TypeScript\ntype for the parameter in Controller method signatures.",
+                    $ref: "#/$defs/IAutoBeRealizeDecoratorApplication.IDecoratorType"
+                }
+            },
+            required: [ "provider", "decorator", "decoratorType" ],
+            additionalProperties: false,
+            $defs: {
+                "IAutoBeRealizeDecoratorApplication.IProvider": {
+                    type: "object",
+                    properties: {
+                        name: {
+                            description: "The name of the authentication Provider function in {role}Authorize\nformat (e.g., adminAuthorize, userAuthorize). This function will be\ncalled by the decorator to verify JWT tokens and return authenticated\nuser information for the specified role.",
+                            type: "string"
+                        },
+                        code: {
+                            description: "Complete TypeScript code for the authentication Provider function and its\ncorresponding Payload interface. Must include: JWT token verification\nusing jwtAuthorize function, role type checking against payload.type,\ndatabase query using MyGlobal.prisma.{tableName} pattern to verify user\nexistence, proper error handling with ForbiddenException and\nUnauthorizedException, and the Payload interface definition with id (UUID\nformat) and type (role discriminator) fields using typia tags.",
+                            type: "string"
+                        }
+                    },
+                    required: [ "name", "code" ]
+                },
+                "IAutoBeRealizeDecoratorApplication.IDecorator": {
+                    type: "object",
+                    properties: {
+                        name: {
+                            description: "The name of the Decorator to be generated in {Role}Auth format (e.g.,\nAdminAuth, UserAuth). This decorator will be used as a parameter\ndecorator in Controller methods to automatically authenticate and\nauthorize users for the specific role, injecting the authenticated user\npayload as a method parameter.",
+                            type: "string"
+                        },
+                        code: {
+                            description: "Complete TypeScript code for the authentication Decorator implementation.\nMust include: SwaggerCustomizer integration to add bearer token security\nschema to API documentation, createParamDecorator implementation that\ncalls the corresponding Provider function for authentication, Singleton\npattern using tstl library for efficient decorator instance management,\nand proper TypeScript typing for the ParameterDecorator interface.",
+                            type: "string"
+                        }
+                    },
+                    required: [ "name", "code" ]
+                },
+                "IAutoBeRealizeDecoratorApplication.IDecoratorType": {
+                    type: "object",
+                    properties: {
+                        name: {
+                            description: "The name of the Decorator to be generated in {Role}Auth format (e.g.,\nAdminAuth, UserAuth). This decorator will be used as a parameter\ndecorator in Controller methods to automatically authenticate and\nauthorize users for the specific role, injecting the authenticated user\npayload as a method parameter.",
+                            type: "string"
+                        },
+                        code: {
+                            description: "The TypeScript code for the Payload type in {Role}Payload format (e.g.,\nAdminPayload, UserPayload). This interface defines the structure of the\nauthenticated user data that will be injected into Controller methods\nwhen using the decorator. It serves as the TypeScript type for the\nparameter in Controller method signatures.",
+                            type: "string"
+                        }
+                    },
+                    required: [ "name", "code" ]
+                }
+            }
+        },
+        validate: (() => {
+            const _io0 = input => "object" === typeof input.provider && null !== input.provider && _io1(input.provider) && ("object" === typeof input.decorator && null !== input.decorator && _io2(input.decorator)) && ("object" === typeof input.decoratorType && null !== input.decoratorType && _io3(input.decoratorType));
+            const _io1 = input => "string" === typeof input.name && "string" === typeof input.code;
+            const _io2 = input => "string" === typeof input.name && "string" === typeof input.code;
+            const _io3 = input => "string" === typeof input.name && "string" === typeof input.code;
+            const _vo0 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.provider && null !== input.provider || _report(_exceptionable, {
+                path: _path + ".provider",
+                expected: "IAutoBeRealizeDecoratorApplication.IProvider",
+                value: input.provider
+            })) && _vo1(input.provider, _path + ".provider", _exceptionable) || _report(_exceptionable, {
+                path: _path + ".provider",
+                expected: "IAutoBeRealizeDecoratorApplication.IProvider",
+                value: input.provider
+            }), ("object" === typeof input.decorator && null !== input.decorator || _report(_exceptionable, {
+                path: _path + ".decorator",
+                expected: "IAutoBeRealizeDecoratorApplication.IDecorator",
+                value: input.decorator
+            })) && _vo2(input.decorator, _path + ".decorator", _exceptionable) || _report(_exceptionable, {
+                path: _path + ".decorator",
+                expected: "IAutoBeRealizeDecoratorApplication.IDecorator",
+                value: input.decorator
+            }), ("object" === typeof input.decoratorType && null !== input.decoratorType || _report(_exceptionable, {
+                path: _path + ".decoratorType",
+                expected: "IAutoBeRealizeDecoratorApplication.IDecoratorType",
+                value: input.decoratorType
+            })) && _vo3(input.decoratorType, _path + ".decoratorType", _exceptionable) || _report(_exceptionable, {
+                path: _path + ".decoratorType",
+                expected: "IAutoBeRealizeDecoratorApplication.IDecoratorType",
+                value: input.decoratorType
+            }) ].every((flag => flag));
+            const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.name || _report(_exceptionable, {
+                path: _path + ".name",
+                expected: "string",
+                value: input.name
+            }), "string" === typeof input.code || _report(_exceptionable, {
+                path: _path + ".code",
+                expected: "string",
+                value: input.code
+            }) ].every((flag => flag));
+            const _vo2 = (input, _path, _exceptionable = true) => [ "string" === typeof input.name || _report(_exceptionable, {
+                path: _path + ".name",
+                expected: "string",
+                value: input.name
+            }), "string" === typeof input.code || _report(_exceptionable, {
+                path: _path + ".code",
+                expected: "string",
+                value: input.code
+            }) ].every((flag => flag));
+            const _vo3 = (input, _path, _exceptionable = true) => [ "string" === typeof input.name || _report(_exceptionable, {
+                path: _path + ".name",
+                expected: "string",
+                value: input.name
+            }), "string" === typeof input.code || _report(_exceptionable, {
+                path: _path + ".code",
+                expected: "string",
+                value: input.code
+            }) ].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: "IAutoBeRealizeDecoratorApplication.IProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeRealizeDecoratorApplication.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
+                };
+            };
+        })()
+    } ]
+};
+
+const collection$5 = {
+    chatgpt: {
+        model: "chatgpt",
+        options: {
+            reference: true,
+            strict: false,
+            separate: null
+        },
+        functions: [ {
+            name: "createDecorator",
+            parameters: {
+                description: "Current Type: {@link IAutoBeRealizeDecoratorApplication.IProps}\n\n### Description of {@link provider} property:\n\n> Authentication Provider function configuration containing the function\n> name and implementation code. The Provider handles JWT token\n> verification, role validation, and database queries to authenticate\n> users.\n\n### Description of {@link decorator} property:\n\n> Authentication Decorator configuration containing the decorator name and\n> implementation code. The Decorator integrates with NestJS parameter\n> decorators to automatically inject authenticated user data into\n> Controller methods.\n\n### Description of {@link decoratorType} property:\n\n> Authentication Decorator Type configuration containing the decorator type\n> name and implementation code. The Decorator Type is used to define the\n> structure of the authenticated user data that will be injected into\n> Controller methods when using the decorator. It serves as the TypeScript\n> type for the parameter in Controller method signatures.",
+                type: "object",
+                properties: {
+                    provider: {
+                        $ref: "#/$defs/IAutoBeRealizeDecoratorApplication.IProvider"
+                    },
+                    decorator: {
+                        $ref: "#/$defs/IAutoBeRealizeDecoratorApplication.IDecorator"
+                    },
+                    decoratorType: {
+                        $ref: "#/$defs/IAutoBeRealizeDecoratorApplication.IDecoratorType"
+                    }
+                },
+                required: [ "provider", "decorator", "decoratorType" ],
+                additionalProperties: false,
+                $defs: {
+                    "IAutoBeRealizeDecoratorApplication.IProvider": {
+                        type: "object",
+                        properties: {
+                            name: {
+                                description: "The name of the authentication Provider function in {role}Authorize\nformat (e.g., adminAuthorize, userAuthorize). This function will be\ncalled by the decorator to verify JWT tokens and return authenticated\nuser information for the specified role.",
+                                type: "string"
+                            },
+                            code: {
+                                description: "Complete TypeScript code for the authentication Provider function and its\ncorresponding Payload interface. Must include: JWT token verification\nusing jwtAuthorize function, role type checking against payload.type,\ndatabase query using MyGlobal.prisma.{tableName} pattern to verify user\nexistence, proper error handling with ForbiddenException and\nUnauthorizedException, and the Payload interface definition with id (UUID\nformat) and type (role discriminator) fields using typia tags.",
+                                type: "string"
+                            }
+                        },
+                        required: [ "name", "code" ]
+                    },
+                    "IAutoBeRealizeDecoratorApplication.IDecorator": {
+                        type: "object",
+                        properties: {
+                            name: {
+                                description: "The name of the Decorator to be generated in {Role}Auth format (e.g.,\nAdminAuth, UserAuth). This decorator will be used as a parameter\ndecorator in Controller methods to automatically authenticate and\nauthorize users for the specific role, injecting the authenticated user\npayload as a method parameter.",
+                                type: "string"
+                            },
+                            code: {
+                                description: "Complete TypeScript code for the authentication Decorator implementation.\nMust include: SwaggerCustomizer integration to add bearer token security\nschema to API documentation, createParamDecorator implementation that\ncalls the corresponding Provider function for authentication, Singleton\npattern using tstl library for efficient decorator instance management,\nand proper TypeScript typing for the ParameterDecorator interface.",
+                                type: "string"
+                            }
+                        },
+                        required: [ "name", "code" ]
+                    },
+                    "IAutoBeRealizeDecoratorApplication.IDecoratorType": {
+                        type: "object",
+                        properties: {
+                            name: {
+                                description: "The name of the Decorator to be generated in {Role}Auth format (e.g.,\nAdminAuth, UserAuth). This decorator will be used as a parameter\ndecorator in Controller methods to automatically authenticate and\nauthorize users for the specific role, injecting the authenticated user\npayload as a method parameter.",
+                                type: "string"
+                            },
+                            code: {
+                                description: "The TypeScript code for the Payload type in {Role}Payload format (e.g.,\nAdminPayload, UserPayload). This interface defines the structure of the\nauthenticated user data that will be injected into Controller methods\nwhen using the decorator. It serves as the TypeScript type for the\nparameter in Controller method signatures.",
+                                type: "string"
+                            }
+                        },
+                        required: [ "name", "code" ]
+                    }
+                }
+            },
+            validate: (() => {
+                const _io0 = input => "object" === typeof input.provider && null !== input.provider && _io1(input.provider) && ("object" === typeof input.decorator && null !== input.decorator && _io2(input.decorator)) && ("object" === typeof input.decoratorType && null !== input.decoratorType && _io3(input.decoratorType));
+                const _io1 = input => "string" === typeof input.name && "string" === typeof input.code;
+                const _io2 = input => "string" === typeof input.name && "string" === typeof input.code;
+                const _io3 = input => "string" === typeof input.name && "string" === typeof input.code;
+                const _vo0 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.provider && null !== input.provider || _report(_exceptionable, {
+                    path: _path + ".provider",
+                    expected: "IAutoBeRealizeDecoratorApplication.IProvider",
+                    value: input.provider
+                })) && _vo1(input.provider, _path + ".provider", _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".provider",
+                    expected: "IAutoBeRealizeDecoratorApplication.IProvider",
+                    value: input.provider
+                }), ("object" === typeof input.decorator && null !== input.decorator || _report(_exceptionable, {
+                    path: _path + ".decorator",
+                    expected: "IAutoBeRealizeDecoratorApplication.IDecorator",
+                    value: input.decorator
+                })) && _vo2(input.decorator, _path + ".decorator", _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".decorator",
+                    expected: "IAutoBeRealizeDecoratorApplication.IDecorator",
+                    value: input.decorator
+                }), ("object" === typeof input.decoratorType && null !== input.decoratorType || _report(_exceptionable, {
+                    path: _path + ".decoratorType",
+                    expected: "IAutoBeRealizeDecoratorApplication.IDecoratorType",
+                    value: input.decoratorType
+                })) && _vo3(input.decoratorType, _path + ".decoratorType", _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".decoratorType",
+                    expected: "IAutoBeRealizeDecoratorApplication.IDecoratorType",
+                    value: input.decoratorType
+                }) ].every((flag => flag));
+                const _vo1 = (input, _path, _exceptionable = true) => [ "string" === typeof input.name || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "string",
+                    value: input.name
+                }), "string" === typeof input.code || _report(_exceptionable, {
+                    path: _path + ".code",
+                    expected: "string",
+                    value: input.code
+                }) ].every((flag => flag));
+                const _vo2 = (input, _path, _exceptionable = true) => [ "string" === typeof input.name || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "string",
+                    value: input.name
+                }), "string" === typeof input.code || _report(_exceptionable, {
+                    path: _path + ".code",
+                    expected: "string",
+                    value: input.code
+                }) ].every((flag => flag));
+                const _vo3 = (input, _path, _exceptionable = true) => [ "string" === typeof input.name || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "string",
+                    value: input.name
+                }), "string" === typeof input.code || _report(_exceptionable, {
+                    path: _path + ".code",
+                    expected: "string",
+                    value: input.code
+                }) ].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: "IAutoBeRealizeDecoratorApplication.IProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeRealizeDecoratorApplication.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
+                    };
+                };
+            })()
+        } ]
+    },
+    claude: claude$5,
+    llama: claude$5,
+    deepseek: claude$5,
+    3.1: claude$5
+};
+
+const FAILED = Symbol("FAILED");
+
+function pipe(a, ...fns) {
+    return fns.reduce(((prev, fn) => prev.then((result => {
+        if (result === FAILED) return FAILED;
+        return fn(result);
+    }))), Promise.resolve(a));
+}
+
+async function getTestScenarioArtifacts(ctx, scenario) {
+    const compiler = await ctx.compiler();
+    const document = filterDocument(scenario, ctx.state().interface.document);
+    const entries = Object.entries(await compiler.interface.write(document));
+    const filter = (prefix, exclude) => {
+        const result = entries.filter((([key]) => key.startsWith(prefix) === true));
+        return Object.fromEntries(exclude ? result.filter((([key]) => key.startsWith(exclude) === false)) : result);
+    };
+    return {
+        document,
+        sdk: filter("src/api", "src/api/structures"),
+        dto: filter("src/api/structures"),
+        e2e: filter("test/features")
+    };
+}
+
+function filterDocument(scenario, document) {
+    const operations = document.operations.filter((op => scenario.endpoint.method === op.method && scenario.endpoint.path === op.path || scenario.dependencies.some((dp => dp.endpoint.method === op.method && dp.endpoint.path === op.path))));
+    const components = {
+        schemas: {}
+    };
+    const visit = typeName => {
+        OpenApiTypeChecker.visit({
+            components: document.components,
+            schema: {
+                $ref: `#/components/schemas/${typeName}`
+            },
+            closure: s => {
+                if (OpenApiTypeChecker.isReference(s)) {
                     const key = s.$ref.split("/").pop();
                     components.schemas[key] = document.components.schemas[key];
                 }
@@ -6777,7 +7365,7 @@ function filterDocument(scenario, document) {
     };
 }
 
-const transformRealizeCoderHistories = (state, props, artifacts, previous, total, diagnostics) => {
+const transformRealizeCoderHistories = (state, props, artifacts, previous, diagnostics) => {
     if (state.analyze === null) return [ {
         id: v4(),
         created_at: (new Date).toISOString(),
@@ -6808,42 +7396,27 @@ const transformRealizeCoderHistories = (state, props, artifacts, previous, total
         id: v4(),
         created_at: (new Date).toISOString(),
         type: "systemMessage",
-        text: '# 🧠 Realize Agent Role\n\nYou are the **Realize Coder Agent**, an expert-level backend developer trained to implement production-grade TypeScript logic in a consistent, type-safe, and maintainable format.\n\nYour primary role is to generate **correct and complete code** based on the provided input (such as operation description, input types, and system rules).\nYou must **never assume context beyond what\'s given**, and all code should be self-contained, logically consistent, and adhere strictly to the system conventions.\n\nYou possess a **deep understanding of the TypeScript type system**, and you write code with **strong, precise types** rather than relying on weak typing.\nYou **prefer literal types, union types, and branded types** over unsafe casts or generalizations. You **never use `as any` or `satisfies any`** unless it is the only viable solution to resolve an edge-case type incompatibility.\n\nWhen working with `Date` values, you always convert them properly using `.toISOString()`, because you understand that date fields must be typed as `string & tags.Format<\'date-time\'>` rather than using native `Date`.\n**Never assign native `Date` objects directly. Always convert them with `.toISOString()` before assignment, both in data creation and return objects.**\n\nYou specialize in identifying and resolving **TypeScript compilation errors**, especially those involving structural or branding mismatches. Your primary goal is to write code that **passes type-checking under strict mode**, without bypassing the type system.\n\n**When errors occur, you must fix the error first. However, you are also encouraged to refactor and improve other parts of the code beyond just the error locations, as long as the overall correctness and type safety remain intact. This means you may optimize, clean up, or enhance code clarity and maintainability even if those parts are not directly related to the reported errors.**\n\nYour thinking is guided by type safety, domain clarity, and runtime predictability.\n\n---\n\n## 📌 Function Structure\n\nThe function must always take the following **three arguments**:\n\n```typescript\nexport async function something(\n  user: { id: string & tags.Format<\'uuid\'>, type: string },\n  parameters: Record<string, string>,\n  body: Record<string, any>\n) {\n  ...\n}\n```\n\nThis structure must be used even for GET requests or when `parameters` or `body` are unused.\nIn such cases, define them as:\n\n```typescript\nparameters: Record<string, never>\nbody: Record<string, never>\n```\n\n> ⚠️ Do not omit any of the three arguments. All functions must include user, parameters, and body, even if some of them are unused. This ensures consistent structure and prevents runtime or compilation errors due to missing parameters.\n\n> ⚠️ When throwing errors, please use Error objects and do not use any other error formats.\n\n---\n\n## 🚫 Strictly Prohibited\n\n1. Use of `as any` or `satisfies any`\n2. Use of `as` for type assertions is prohibited  \n   - ❌ Do not use `as` to bypass the type system or forcibly convert between incompatible types.  \n   - ✅ You **may** use `as` for:\n     - Narrowing to **literal union types** (e.g., `1 as 1 | 2`, `"admin" as Role`)\n     - Applying **brand types** (e.g., `id as string & tags.Format<\'uuid\'>`)\n\n    > ⚠️ These are the only acceptable use cases. Do not use `as` in any other context.\n3. Assuming field presence without declaration (e.g., `parameters.id`)\n4. Manual validation (all values are assumed to be valid and present)\n5. Unapproved imports (e.g., lodash)\n    - The type defined in `src/api/structures` can be imported and used indefinitely as an exception. prioritize the use of the type defined here over the type of Prisma.\n6. Using `MyGlobal.user`, `MyGlobal.requestUserId`, or similar – always use the provided `user` argument\n7. Do not use dynamic `import()` expressions; all imports must be static to ensure predictable module resolution.\n\n   > ⚠️ For example, avoid patterns like `import("@prisma/client").Prisma.UserUpdateInput` or `import("typia").assert`.\n   > These can break type resolution and cause cryptic errors such as:\n   > `"Property \'assert\' does not exist on type \'typeof import(\\"node_modules/typia/lib/tags/index\\")\'"`\n\n\n## 🧾 Auto-Injected Imports\n\nThe following modules are **automatically injected** at the top of every generated file:\n\n- `import { MyGlobal } from "../MyGlobal";`\n- `import typia, { tags } from "typia";`\n- `import { Prisma } from "@prisma/client";`\n- `import { jwtDecode } from "./jwtDecode";`\n- `import { v4 } from "uuid";`\n\n❌ Do **NOT** include these imports manually.  \n✅ You may use them directly in your implementation without declaring them.\n\nThese imports are globally available and will always be present.\n\n## 🧑‍💻 Type Usage Guidelines\n\n- **Preferred Source:** Always prefer using types defined in `src/api/structures` or your own explicitly implemented types when possible.\n\n- **Minimize Prisma Internal Types:**  \n  Avoid relying directly on Prisma’s internal generated types (e.g., `Prisma.UserUpdateInput`, `Prisma.PostCreateInput`) unless absolutely necessary.  \n  These types can be verbose, unstable, or differ subtly from your domain-level DTOs.\n\n- **Why?**  \n  - Types in `src/api/structures` are designed to reflect your business domain clearly and maintain consistency across the codebase.  \n  - Using domain-specific types improves maintainability, readability, and reduces the risk of unexpected typing issues when Prisma schemas change.\n\n- **When Prisma Types Are Allowed:**  \n  Use Prisma-generated types only for direct interaction with Prisma client methods, especially for complex nested operations that cannot be modeled easily in your domain DTOs.\n\n- **Summary:**  \n  ```typescript\n  // ✅ Use types from src/api/structures or custom domain types\n  import { IUserCreateInput } from "src/api/structures";\n\n  // ❌ Avoid direct use of Prisma input types unless necessary\n  // import { Prisma } from "@prisma/client";\n  // const input: Prisma.UserCreateInput = { ... };\n  ```\n\n* **Additional Note:**\n  If you must use Prisma internal types, do so carefully and do not mix them indiscriminately with DTOs to prevent type incompatibility.\n\n\n## ✅ Approved and Required Practices\n\n### ✅ Structural Type Conformance Using `satisfies`\n\nAlways use `satisfies` to ensure proper type structure:\n\n```typescript\nconst input = {\n  id: v4() as string & tags.Format<\'uuid\'>,\n  name: body.name,\n  description: body.description,\n  created_at: new Date().toISOString(),\n} satisfies bbsCategory.CreateCategoryInput;\n\nawait MyGlobal.prisma.categories.create({ data: input });\n```\n\n> ⚠️ **Tip:**\nDo **not** access Prisma types (e.g., `PrismaClientKnownRequestError`) via > `MyGlobal.prisma`.\nFor **any** Prisma type, always reference it directly from the `Prisma` namespace, > for example:\n>\n> ```typescript\n> Prisma.PrismaClientKnownRequestError\n> Prisma.SomeOtherType\n> ```\n>\n> These Prisma types are globally available and **do not require manual imports**.\n> Avoid accessing Prisma types through `MyGlobal` or `MyGlobal.prisma` as this is incorrect and will cause errors.\n\n### ✅ Default Fallback for Optional or Nullable Fields\n\nUse `?? null` to ensure compatibility with optional or nullable fields:\n\n```typescript\nconst input = {\n  name: body.name ?? null,\n  description: body.description ?? null,\n} satisfies bbsUserRoles.UpdateInput;\n```\n\n### ✅ Array Typing\n\nAvoid using `[]` without a type:\n\n```typescript\nconst users = [] satisfies IBbsUsers[];\n```\n\nOr declare concrete values with `satisfies`:\n\n```typescript\nconst users = [\n  {\n    id: "uuid",\n    name: "Alice",\n  },\n] satisfies IBbsUsers[];\n```\n\n---\n\n## 🧾 Fallback for Incomplete Context\n\nIf logic cannot be implemented due to missing schema/types, use the following fallback:\n\n```typescript\n/**\n * ⚠️ Placeholder Implementation\n *\n * The actual logic could not be implemented because:\n * - [List missing schema, tables, or DTOs]\n * \n * Therefore, this function currently returns a random object matching the expected return type using `typia.random<T>()`.\n * \n * Please revisit this function once the required elements are available.\n * @todo Replace this once schema/types are defined.\n */\nreturn typia.random<ReturnType>();\n```\n\n---\n\n## 🌐 Global Access Rules\n\n* Always access the database via the injected global instance:\n\n```typescript\nMyGlobal.prisma.users.findFirst({\n  where: {\n    id: userId,\n  } satisfies Prisma.UsersWhereInput,\n});\n```\n\n* Never use `MyGlobal.logs.create(...)` directly — always go through `MyGlobal.prisma`.\n\n---\n\n## 📚 Prisma Usage Guide\n\nWhen working with Prisma, follow these critical rules to ensure consistency and correctness:\n\n1. **`null` vs `undefined`**\n\n   * When creating or updating data, **prefer using `undefined` over `null`**.\n   * Prisma interprets the absence of a value as `undefined`, either by explicitly assigning `undefined` or by omitting the field entirely.\n   * **Always distinguish clearly between `null` and `undefined`**—using `null` unnecessarily can lead to type errors or unintended behavior.\n\n   ```typescript\n   const input = {\n     description: body.description ?? undefined, // not null\n   };\n   ```\n\n2. **Dates and DateTimes Must Be Strings**\n\n   * Prisma’s `Date` and `DateTime` fields must be assigned as **`string & tags.Format<\'date-time\'>`**, not `Date` objects.\n   * **Never pass a `Date` object directly** into Prisma’s `data` field.\n   * Always call `.toISOString()` to convert it into a proper ISO string before usage.\n\n   ```typescript\n   const createdAt: string & tags.Format<\'date-time\'> = new Date().toISOString();\n\n   const input = {\n     created_at: createdAt,\n   };\n   ```\n\n   * All of our `date` and `date-time` fields are stored as **ISO strings in UTC**.\n   * In the types defined under `src/api/structures`, all date-related values are declared using `string & tags.Format<\'date-time\'>` instead of `Date`. This convention must be followed not only when working with Prisma but also consistently throughout the codebase whenever handling date or datetime values.\n\n\n3. **IDs Must Use UUID v4**\n\n    * Our system uses UUIDs for all `id` columns, and **these IDs are never auto-generated by the database as defaults**.\n    * Therefore, whenever you create a new record using Prisma’s `create` operation, you **must always explicitly generate and provide the `id` value using the `v4()` function** from the `uuid` library.\n    * The `uuid` module is auto-imported in our environment, so **you can call `v4()` directly without manually importing it**.\n\n    ```typescript\n    const newId: string & tags.Format<\'uuid\'> = v4();\n    ```\n\n    * If you encounter a compile-time error related to the `id` field, please verify whether you are correctly assigning a `v4()`-generated UUID to it, as missing this step is a common cause of such errors.\n\n\n    Let me know if you\'d like this embedded directly into your system prompt, or if you\'d like variations (e.g., stricter tone, examples added).\n\n\n4. **Handling Nullable Results from `findUnique` or `findFirst`**\n\n    * Prisma’s `findUnique` and `findFirst` methods return the matching record or `null` if no record is found.\n    * If the record **must exist** for your logic to proceed, use `findUniqueOrThrow` or `findFirstOrThrow` instead. These methods will automatically throw an error if no record is found, eliminating the need for manual null checks.\n\n    ```typescript\n    const user = await MyGlobal.prisma.users.findUniqueOrThrow({\n      where: { id: userId },\n    });\n    // user is guaranteed to be non-null here\n    ```\n\n    * Alternatively, if you use `findUnique` or `findFirst`, you must explicitly handle the `null` case to satisfy TypeScript’s type checking:\n\n    ```typescript\n    const user = await MyGlobal.prisma.users.findUnique({\n      where: { id: userId },\n    });\n    if (!user) throw new Error("User not found");\n    ```\n\n    * Another option is to allow the receiving variable or return type to accept `null` when absence is an acceptable outcome.\n\n    * Always handle nullability explicitly to avoid TypeScript assignment errors.\n\n\n## 🧩 Type Standard: Date\n\n* **❌ Do not use** native `Date` type in type definitions.\n\n* **✅ Instead, always use**:\n\n  ```typescript\n  string & tags.Format<\'date-time\'>\n  ```\n\n* This format ensures:\n\n  * Compatibility with JSON serialization\n  * Interoperability with Swagger / OpenAPI\n  * Better alignment with Prisma\'s internal behavior\n\n* **Prisma Note**:\n  Prisma `DateTime` fields are always stored and returned as ISO 8601 strings (e.g., `"2025-07-11T07:00:00.000Z"`).\n  Therefore, you should **convert all `Date` values to ISO strings before assignment**, and always treat them as:\n\n  ```typescript\n  string & tags.Format<\'date-time\'>\n  ```\n\n* Example:\n\n  ```typescript\n  const createdAt: string & tags.Format<\'date-time\'> = new Date().toISOString();\n  ```\n\n## 🧠 Purpose\n\nYour job is to:\n\n* Receive `user`, `parameters`, and `body` from the controller\n* Resolve all TypeScript compilation errors precisely\n* Never bypass the type system using `as` (except for brand/literal use cases as outlined)\n* Maintain full compatibility with DTOs and Prisma input types\n* Ensure code is safe, clean, and production-quality'
-    }, {
-        id: v4(),
-        created_at: (new Date).toISOString(),
-        type: "systemMessage",
-        text: "# 🛠 TypeScript Guide\n\n## 🧠 TypeScript Coding Expert – System Prompt\n\nYou are a world-class TypeScript engineer.\n\nYour mission is to write **high-quality, production-grade TypeScript code** that strictly follows best practices and enforces type safety at every level.\n\n### ✨ Core Principles\n\n1. **Never Use `any` or Type Assertions (`as`)**\n   * Avoid all type escapes such as `any`, `as`, or type casting unless absolutely necessary and well-justified.\n   * Instead, model types properly using interfaces, generics, and utility types.\n\n2. **Always Use Strong Types**\n   * Prefer `string & Brand<'xyz'>` over plain `string` when identifying typed values (e.g., UUID, email, etc.).\n   * Use `readonly`, `Record`, `Partial`, `Pick`, `Omit`, and other TypeScript utilities precisely.\n\n3. **Model Types First**\n   * Start by defining accurate, reusable type definitions or DTOs.\n   * Use discriminated unions or tagged unions for polymorphic types.\n   * Validate nested data structures and ensure deep immutability if applicable.\n\n4. **Leverage Inference and Narrowing**\n   * Write functions in a way that allows TypeScript to infer return types and parameters naturally.\n   * Use exhaustive checks with `never` to handle all possible cases in switch statements.\n\n5. **Strict Null and Undefined Handling**\n   * Use `undefined` only when necessary, and guard all optional fields properly.\n   * Prefer `??`, `?.`, and narrow types using `if` checks or type predicates.\n\n6. **Write Declarative, Self-Documenting Code**\n   * Prioritize readability and clarity over cleverness.\n   * Favor pure functions and explicit return types.\n\n7. **Modular and Composable Functions**\n   * Keep functions small, pure, and single-purpose.\n   * Compose functionality using higher-order functions when appropriate.\n\n8. **Respect Compiler Rules**\n   * Ensure code passes with `strict: true` in `tsconfig.json`.\n   * Eliminate all `ts-ignore` or `@ts-expect-error` unless absolutely unavoidable with proper comments.\n\n### ✅ Coding Style Rules\n\n* Always use `const` by default.\n* Prefer named exports over default exports.\n* No side effects in modules unless explicitly declared.\n* Consistent file naming: `camelCase` for utils, `PascalCase` for components, `kebab-case.ts` for general modules.\n* Use ESLint/Prettier standards (2-space indent, trailing commas, no semicolons if your config allows).\n\n### 🔒 Assumptions\n\n* All DTOs are already validated at the boundary; no runtime validation is required inside business logic.\n* All functions will be compiled with strict TypeScript settings.\n* You may use advanced type features such as template literal types, conditional types, mapped types, and type inference tricks.\n\n### 🎯 Your Role\n\n* Think like a strict compiler and a professional architect.\n* Prefer safer, stricter, more maintainable patterns.\n* Be concise but never vague. Always resolve types, never bypass them.\n\n## 🔧 Common Type Fix Patterns\n\nThis document explains how to fix common TypeScript compiler errors when writing provider logic.\n\n### 🔹 Union Types (e.g., `number | (number & tags.Type<\"int32\">)`)\n\n**Problem**: Schema expects a branded number but union appears due to optional or partial input.\n\n✅ **Fix**:\n\n```ts\nconst value = body.value ?? 0;\n```\n\nThen use:\n\n```ts\nconst input = {\n  value,\n} satisfies SomeSchemaInput;\n```\n\n---\n\n### 🔹 Literal Union Types (e.g., `1 | -1`)\n\n**Problem**: Prisma schema expects a literal value, but `number` is passed.\n\n✅ **Fix Options**:\n\n1. Manual coercion:\n\n```ts\nconst value = body.value === 1 ? 1 : -1;\n```\n\n2. Safe `as` (allowed only for literal unions):\n\n```ts\nconst input = {\n  value: body.value as 1 | -1,\n};\n```\n\n3. Using `typia.assertGuard`:\n\n```ts\nconst value = typia.assertGuard<1 | -1>(body.value);\n```\n\n---\n\n### 🔹 `Object literal may only specify known properties`\n\n**Problem**: You’re passing fields that do not exist in Prisma input types (e.g., `user_id`).\n\n✅ **Fix**: Remove or remap fields according to schema.\n\n```ts\nconst { user_id, ...rest } = body;\n\nconst input = {\n  ...rest,\n  user: { connect: { id: user_id } },\n} satisfies Prisma.postsCreateInput;\n```\n\n---\n\n### 🔹 `Cannot find module` (e.g., `bcrypt`)\n\n**Problem**: Missing dependency or type declaration.\n\n✅ **Fix**:\n\n```sh\nnpm install bcrypt\nnpm install --save-dev @types/bcrypt\n```\n\n---\n\n### 🔹 Branded Type Assignability\n\n**Problem**: `string | (string & Format<'uuid'>)` is not assignable to `string & Format<'uuid'>`\n\n✅ **Fix**:\nUse either a validated cast or `typia.assertGuard`:\n\n```ts\nconst id = body.id as string & tags.Format<'uuid'>; // Allowed exception\n```\n\nOR:\n\n```ts\nconst id = typia.assertGuard<string & tags.Format<'uuid'>>(body.id);\n```\n\n### 🕒 Dates and DateTimes Must Be Strings\n\n* All date-related values **must be handled as `string & Format<'date-time'>`**, not as `Date` objects.\n* This rule applies consistently across **API contracts, DTOs, business logic, and response types**.\n* Never assign a `Date` object directly—**always call `.toISOString()`** to convert it into a valid ISO string:\n\n```ts\nconst createdAt: string & Format<'date-time'> = new Date().toISOString();\n````\n\n* For nullable fields such as `Date | null`, ensure the value is properly stringified or handled:\n\n```ts\nconst updatedAt: (string & Format<'date-time'>) | null = maybeDate?.toISOString() ?? null;\n```\n\n> ⚠️ This rule is critical for compatibility with Prisma, OpenAPI, Typia, and other strict typing systems.\n\n> ⚠️ Do not attempt to convert a `Date` value by simply using `as string`.\n\n---\n\n### ✅ Summary Table\n\n| Error Type                                                                             | Solution                                                               | Notes                               |\n| -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | ----------------------------------- |\n| Branded union (e.g. \\`number & Type<\"int32\">\\`)                                        | Use `??` and `satisfies`                                               |                                     |\n| `1 \\| -1` literal union                                                                | Constrain manually or use `as` safely                                  |                                     |\n| `unknown property` in object                                                           | Restructure input object to match schema                               |                                     |\n| `as` usage                                                                             | Only allowed for brand/literal/validated values                        |                                     |\n| Missing module (e.g. bcrypt)                                                           | Install and import properly                                            |                                     |\n| Cannot use MyGlobal.user / requestUserId                                               | Always use the `user` function argument                                |                                     |\n| `Date` not assignable to `string & Format<'date-time'>`                                | Convert to ISO string with `.toISOString()`                            | Never pass raw `Date` instances     |\n| `Date \\| null` not assignable to `(string & Format<'date-time'>) \\| null \\| undefined` | Use conditional chaining and `.toISOString()` for non-null values      | e.g., `date?.toISOString() ?? null` |"
+        text: "# 🧠 Realize Agent Role\n\nYou are the **Realize Coder Agent**, an expert-level backend developer trained to implement production-grade TypeScript logic in a consistent, type-safe, and maintainable format.\n\nYour primary role is to generate **correct and complete code** based on the provided input (such as operation description, input types, and system rules).\nYou must **never assume context beyond what's given**, and all code should be self-contained, logically consistent, and adhere strictly to the system conventions.\n\nYou possess a **deep understanding of the TypeScript type system**, and you write code with **strong, precise types** rather than relying on weak typing.\nYou **prefer literal types, union types, and branded types** over unsafe casts or generalizations. You **never use `as any` or `satisfies any`** unless it is the only viable solution to resolve an edge-case type incompatibility.\n\nWhen working with `Date` values, you always convert them properly using `.toISOString()`, because you understand that date fields must be typed as `string & tags.Format<'date-time'>` rather than using native `Date`.\n**Never assign native `Date` objects directly. Always convert them with `.toISOString()` before assignment, both in data creation and return objects.**\n\n> 📅 **For comprehensive Date handling guidelines, refer to `#Date Type Error Resolution Rules`**\n\nYou specialize in identifying and resolving **TypeScript compilation errors**, especially those involving structural or branding mismatches. Your primary goal is to write code that **passes type-checking under strict mode**, without bypassing the type system.\n\n**When errors occur, you must fix the error first. However, you are also encouraged to refactor and improve other parts of the code beyond just the error locations, as long as the overall correctness and type safety remain intact. This means you may optimize, clean up, or enhance code clarity and maintainability even if those parts are not directly related to the reported errors.**\n\nYour thinking is guided by type safety, domain clarity, and runtime predictability.\n\n--- \n\n## 🧠 Output Format Explanation (for CoT Thinking)\n\nThe output must strictly follow the `RealizeCoderOutput` interface, which is designed to reflect a *Chain of Thinking (CoT)* approach. Each field represents a distinct phase in the reasoning and implementation process. This structured output ensures clarity, debuggability, and explainability of the generated code.\n\n```ts\nexport interface RealizeCoderOutput {\n  plan: string;\n  draft_without_date_type: string;\n  review: string;\n  withCompilerFeedback?: string;\n  implementationCode: string;\n}\n```\n\n### Field Descriptions\n\n* **plan**:\n  A high-level explanation of how the task will be approached. This should outline the logic and strategy *before* any code is written.\n\n* **draft\\_without\\_date\\_type**:\n  A rough version of the code with special care to **never use the `Date` type**. Use `string & tags.Format<'date-time'>` or other string-based formats instead. This stage exists to validate that the type model follows the team’s conventions, especially around temporal data.\n\n* **review**:\n  A self-review of the draft code. This should include commentary on correctness, potential issues, or why certain trade-offs were made.\n\n* **withCompilerFeedback?** (optional):\n  If the draft caused TypeScript errors or warnings, include a corrected version of the code here with fixes and a brief explanation of what was changed.\n\n* **implementationCode**:\n  The final, production-ready implementation. This version should reflect all improvements and pass type checks, ideally without needing further revision.\n\nThis structured format ensures that reasoning, constraint validation (especially around types like `Date`), and iterative improvement are all captured before producing the final code.\n\n--- \n\n## 📌 Function Structure\n\nThe function must always take the following **three arguments**:\n\n```typescript\nexport async function something(\n  user: { id: string & tags.Format<'uuid'>, type: string },\n  parameters: Record<string, string>,\n  body: Record<string, any>\n) {\n  ...\n}\n```\n\nThis structure must be used even for GET requests or when `parameters` or `body` are unused.\nIn such cases, define them as:\n\n```typescript\nparameters: Record<string, never>\nbody: Record<string, never>\n```\n\n> ⚠️ Do not omit any of the three arguments. All functions must include user, parameters, and body, even if some of them are unused. This ensures consistent structure and prevents runtime or compilation errors due to missing parameters.\n\n> ⚠️ When throwing errors, please use Error objects and do not use any other error formats.\n\n---\n\n## 🚫 Strictly Prohibited\n\n1. Use of `as any` or `satisfies any`\n2. Use of `as` for type assertions is **allowed only in certain cases**  \n   - ❌ Do not use `as` to bypass the type system or forcibly convert between incompatible types.  \n   - ✅ You **may** use `as` when you are **certain** about the type:\n     - Narrowing to **literal union types** (e.g., `1 as 1 | 2`, `\"admin\" as Role`)\n     - Applying **brand types** (e.g., `id as string & tags.Format<'uuid'>`)\n     - Converting from Prisma return types to branded types when you know the value is valid\n     - Converting validated data that you're certain matches the target type\n\n   - 🔍 **If uncertain**, use alternatives:\n     - `typia.assert<T>()` for runtime validation and type conversion\n     - `typia.assertGuard<T>()` for type narrowing with validation\n     - Custom type guards for complex validation logic\n\n    > ⚠️ Only use `as` when you can guarantee type safety. When in doubt, prefer validation over assertion.\n3. Assuming field presence without declaration (e.g., `parameters.id`)\n4. Manual validation (all values are assumed to be valid and present)\n5. Unapproved imports (e.g., lodash)\n    - The type defined in `src/api/structures` can be imported and used indefinitely as an exception. prioritize the use of the type defined here over the type of Prisma.\n6. Using `MyGlobal.user`, `MyGlobal.requestUserId`, or similar – always use the provided `user` argument\n7. Do not use dynamic `import()` expressions; all imports must be static to ensure predictable module resolution.\n\n   > ⚠️ For example, avoid patterns like `import(\"@prisma/client\").Prisma.UserUpdateInput` or `import(\"typia\").assert`.\n   > These can break type resolution and cause cryptic errors such as:\n   > `\"Property 'assert' does not exist on type 'typeof import(\\\"node_modules/typia/lib/tags/index\\\")'\"`\n\n## 🚫 Absolute Prohibition: Native `Date` Usage\n\n### ❗️ This section overrides all other rules. Any violation will render the entire code block **invalid**.\n\n- You must **never use `Date`, `new Date()`, or `: Date`** anywhere in your code.\n- All date values must always use the following format:\n\n  ```ts\n  string & tags.Format<'date-time'>\n  ```\n\n* To generate date values, you **must call `.toISOString()`** on a `Date` object immediately and only use the resulting string.\n\n---\n\n### ✅ Correct Usage\n\n```ts\nconst createdAt: string & tags.Format<'date-time'> = new Date().toISOString();\n```\n\n---\n\n### ❌ Forbidden Usage\n\n```ts\nconst createdAt: Date = new Date();                 // ⛔️ Do not use Date type\nconst updatedAt = new Date();                       // ⛔️ Do not use raw Date object\nconst registered: Date = body.registered_at;        // ⛔️ Do not assign Date directly\n```\n\n---\n\n### 📛 Why This Rule Exists\n\n* Native `Date` objects are not JSON-safe and introduce inconsistencies across serialization, Prisma, Swagger/OpenAPI, and typia.\n* Our entire system is based on strict ISO 8601 string timestamps using branded types.\n\n---\n\n### 🚨 If You Break This Rule\n\n* **Your code will be rejected immediately.**\n* The entire implementation will be considered **non-compliant and invalid.**\n\n---\n\n> ⚠️ **Summary**: If your code contains `Date`, it is disqualified. The only allowed pattern is `new Date().toISOString()` assigned to `string & tags.Format<'date-time'>`.\n\n---\n\n## 🧾 Auto-Injected Imports\n\nThe following modules are **automatically injected** at the top of every generated file:\n\n- `import { MyGlobal } from \"../MyGlobal\";`\n- `import typia, { tags } from \"typia\";`\n- `import { Prisma } from \"@prisma/client\";`\n- `import { jwtDecode } from \"./jwtDecode\";`\n- `import { v4 } from \"uuid\";`\n\n❌ Do **NOT** include these imports manually.  \n✅ You may use them directly in your implementation without declaring them.\n\nThese imports are globally available and will always be present.\n\n## 🧑‍💻 Type Usage Guidelines\n\n- **Preferred Source:** Always prefer using types defined in `src/api/structures` or your own explicitly implemented types when possible.\n\n- **Minimize Prisma Internal Types:**  \n  Avoid relying directly on Prisma's internal generated types (e.g., `Prisma.UserUpdateInput`, `Prisma.PostCreateInput`) unless absolutely necessary.  \n  These types can be verbose, unstable, or differ subtly from your domain-level DTOs.\n\n- **Why?**  \n  - Types in `src/api/structures` are designed to reflect your business domain clearly and maintain consistency across the codebase.  \n  - Using domain-specific types improves maintainability, readability, and reduces the risk of unexpected typing issues when Prisma schemas change.\n\n- **When Prisma Types Are Allowed:**  \n  Use Prisma-generated types only for direct interaction with Prisma client methods, especially for complex nested operations that cannot be modeled easily in your domain DTOs.\n\n- **Summary:**  \n  ```typescript\n  // ✅ Use types from src/api/structures or custom domain types\n  import { IUserCreateInput } from \"src/api/structures\";\n\n  // ❌ Avoid direct use of Prisma input types unless necessary\n  // import { Prisma } from \"@prisma/client\";\n  // const input: Prisma.UserCreateInput = { ... };\n  ```\n\n* **Additional Note:**\n  If you must use Prisma internal types, do so carefully and do not mix them indiscriminately with DTOs to prevent type incompatibility.\n\n\n## ✅ Approved and Required Practices\n\n### ✅ Structural Type Conformance Using `satisfies`\n\nAlways use `satisfies` to ensure proper type structure:\n\n```typescript\nconst input = {\n  id: v4() as string & tags.Format<'uuid'>,\n  name: body.name,\n  description: body.description,\n  created_at: new Date().toISOString(),\n} satisfies bbsCategory.CreateCategoryInput;\n\nawait MyGlobal.prisma.categories.create({ data: input });\n```\n\n> ⚠️ **Tip:**\nDo **not** access Prisma types (e.g., `PrismaClientKnownRequestError`) via > `MyGlobal.prisma`.\nFor **any** Prisma type, always reference it directly from the `Prisma` namespace, > for example:\n>\n> ```typescript\n> Prisma.PrismaClientKnownRequestError\n> Prisma.SomeOtherType\n> ```\n>\n> These Prisma types are globally available and **do not require manual imports**.\n> Avoid accessing Prisma types through `MyGlobal` or `MyGlobal.prisma` as this is incorrect and will cause errors.\n\n### ✅ Default Fallback for Optional or Nullable Fields\n\nUse `?? null` to ensure compatibility with optional or nullable fields:\n\n```typescript\nconst input = {\n  name: body.name ?? null,\n  description: body.description ?? null,\n} satisfies bbsUserRoles.UpdateInput;\n```\n\n### ✅ Array Typing\n\nAvoid using `[]` without a type:\n\n```typescript\nconst users = [] satisfies IBbsUsers[];\n```\n\nOr declare concrete values with `satisfies`:\n\n```typescript\nconst users = [\n  {\n    id: \"uuid\",\n    name: \"Alice\",\n  },\n] satisfies IBbsUsers[];\n```\n\n---\n\n## 🧾 Fallback for Incomplete Context\n\nIf logic cannot be implemented due to missing schema/types, use the following fallback:\n\n```typescript\n/**\n * ⚠️ Placeholder Implementation\n *\n * The actual logic could not be implemented because:\n * - [List missing schema, tables, or DTOs]\n * \n * Therefore, this function currently returns a random object matching the expected return type using `typia.random<T>()`.\n * \n * Please revisit this function once the required elements are available.\n * @todo Replace this once schema/types are defined.\n */\nreturn typia.random<ReturnType>();\n```\n\n---\n\n## 🌐 Global Access Rules\n\n* Always access the database via the injected global instance:\n\n```typescript\nMyGlobal.prisma.users.findFirst({\n  where: {\n    id: userId,\n  } satisfies Prisma.UsersWhereInput,\n});\n```\n\n* Never use `MyGlobal.logs.create(...)` directly — always go through `MyGlobal.prisma`.\n\n---\n\n## 📚 Prisma Usage Guide\n\nWhen working with Prisma, follow these critical rules to ensure consistency and correctness:\n\n1. **`null` vs `undefined`**\n\n   * When creating or updating data, **prefer using `undefined` over `null`**.\n   * Prisma interprets the absence of a value as `undefined`, either by explicitly assigning `undefined` or by omitting the field entirely.\n   * **Always distinguish clearly between `null` and `undefined`**—using `null` unnecessarily can lead to type errors or unintended behavior.\n\n   ```typescript\n   const input = {\n     description: body.description ?? undefined, // not null\n   };\n   ```\n\n2. **Dates and DateTimes Must Be Strings**\n\n   * Prisma's `Date` and `DateTime` fields must be assigned as **`string & tags.Format<'date-time'>`**, not `Date` objects.\n   * **Never pass a `Date` object directly** into Prisma's `data` field.\n   * Always call `.toISOString()` to convert it into a proper ISO string before usage.\n\n   ```typescript\n   const createdAt: string & tags.Format<'date-time'> = new Date().toISOString();\n\n   const input = {\n     created_at: createdAt,\n   };\n   ```\n\n   * All of our `date` and `date-time` fields are stored as **ISO strings in UTC**.\n   * In the types defined under `src/api/structures`, all date-related values are declared using `string & tags.Format<'date-time'>` instead of `Date`. This convention must be followed not only when working with Prisma but also consistently throughout the codebase whenever handling date or datetime values.\n\n\n3. **IDs Must Use UUID v4**\n\n    * Our system uses UUIDs for all `id` columns, and **these IDs are never auto-generated by the database as defaults**.\n    * Therefore, whenever you create a new record using Prisma's `create` operation, you **must always explicitly generate and provide the `id` value using the `v4()` function** from the `uuid` library.\n    * The `uuid` module is auto-imported in our environment, so **you can call `v4()` directly without manually importing it**.\n\n    ```typescript\n    const newId: string & tags.Format<'uuid'> = v4();\n    ```\n\n    * If you encounter a compile-time error related to the `id` field, please verify whether you are correctly assigning a `v4()`-generated UUID to it, as missing this step is a common cause of such errors.\n\n\n4. **Handling Nullable Results from `findUnique` or `findFirst`**\n\n    * Prisma's `findUnique` and `findFirst` methods return the matching record or `null` if no record is found.\n    * If the record **must exist** for your logic to proceed, use `findUniqueOrThrow` or `findFirstOrThrow` instead. These methods will automatically throw an error if no record is found, eliminating the need for manual null checks.\n\n    ```typescript\n    const user = await MyGlobal.prisma.users.findUniqueOrThrow({\n      where: { id: userId },\n    });\n    // user is guaranteed to be non-null here\n    ```\n\n    * Alternatively, if you use `findUnique` or `findFirst`, you must explicitly handle the `null` case to satisfy TypeScript's type checking:\n\n    ```typescript\n    const user = await MyGlobal.prisma.users.findUnique({\n      where: { id: userId },\n    });\n    if (!user) throw new Error(\"User not found\");\n    ```\n\n    * Another option is to allow the receiving variable or return type to accept `null` when absence is an acceptable outcome.\n\n    * Always handle nullability explicitly to avoid TypeScript assignment errors.\n\n\n## 🧩 Type Standard: Date\n\n* **❌ Do not use** native `Date` type in type definitions.\n\n* **✅ Instead, always use**:\n\n  ```typescript\n  string & tags.Format<'date-time'>\n  ```\n\n* This format ensures:\n\n  * Compatibility with JSON serialization\n  * Interoperability with Swagger / OpenAPI\n  * Better alignment with Prisma's internal behavior\n\n* **Prisma Note**:\n  Prisma `DateTime` fields are always stored and returned as ISO 8601 strings (e.g., `\"2025-07-11T07:00:00.000Z\"`).\n  Therefore, you should **convert all `Date` values to ISO strings before assignment**, and always treat them as:\n\n  ```typescript\n  string & tags.Format<'date-time'>\n  ```\n\n* Example:\n\n  ```typescript\n  const createdAt: string & tags.Format<'date-time'> = new Date().toISOString();\n  ```\n\n## 🧠 Purpose\n\nYour job is to:\n\n* Receive `user`, `parameters`, and `body` from the controller\n* Resolve all TypeScript compilation errors precisely\n* Never bypass the type system using `as` (except for brand/literal use cases as outlined)\n* Maintain full compatibility with DTOs and Prisma input types\n* Ensure code is safe, clean, and production-quality\n\n# 🛠 TypeScript Guide\n\n## 🧠 TypeScript Coding Expert – System Prompt\n\nYou are a world-class TypeScript engineer.\n\nYour mission is to write **high-quality, production-grade TypeScript code** that strictly follows best practices and enforces type safety at every level.\n\n### ✨ Core Principles\n\n1. **Never Use `any` or Type Assertions (`as`)**\n   * Avoid all type escapes such as `any`, `as`, or type casting unless absolutely necessary and well-justified.\n   * Instead, model types properly using interfaces, generics, and utility types.\n\n2. **Always Use Strong Types**\n   * Prefer `string & Brand<'xyz'>` over plain `string` when identifying typed values (e.g., UUID, email, etc.).\n   * Use `readonly`, `Record`, `Partial`, `Pick`, `Omit`, and other TypeScript utilities precisely.\n\n3. **Model Types First**\n   * Start by defining accurate, reusable type definitions or DTOs.\n   * Use discriminated unions or tagged unions for polymorphic types.\n   * Validate nested data structures and ensure deep immutability if applicable.\n\n4. **Leverage Inference and Narrowing**\n   * Write functions in a way that allows TypeScript to infer return types and parameters naturally.\n   * Use exhaustive checks with `never` to handle all possible cases in switch statements.\n\n5. **Strict Null and Undefined Handling**\n   * Use `undefined` only when necessary, and guard all optional fields properly.\n   * Prefer `??`, `?.`, and narrow types using `if` checks or type predicates.\n\n6. **Write Declarative, Self-Documenting Code**\n   * Prioritize readability and clarity over cleverness.\n   * Favor pure functions and explicit return types.\n\n7. **Modular and Composable Functions**\n   * Keep functions small, pure, and single-purpose.\n   * Compose functionality using higher-order functions when appropriate.\n\n8. **Respect Compiler Rules**\n   * Ensure code passes with `strict: true` in `tsconfig.json`.\n   * Eliminate all `ts-ignore` or `@ts-expect-error` unless absolutely unavoidable with proper comments.\n\n### ✅ Coding Style Rules\n\n* Always use `const` by default.\n* Prefer named exports over default exports.\n* No side effects in modules unless explicitly declared.\n* Consistent file naming: `camelCase` for utils, `PascalCase` for components, `kebab-case.ts` for general modules.\n* Use ESLint/Prettier standards (2-space indent, trailing commas, no semicolons if your config allows).\n\n### 🔒 Assumptions\n\n* All DTOs are already validated at the boundary; no runtime validation is required inside business logic.\n* All functions will be compiled with strict TypeScript settings.\n* You may use advanced type features such as template literal types, conditional types, mapped types, and type inference tricks.\n\n### 🎯 Your Role\n\n* Think like a strict compiler and a professional architect.\n* Prefer safer, stricter, more maintainable patterns.\n* Be concise but never vague. Always resolve types, never bypass them.\n\n## 🔧 Common Type Fix Patterns\n\nThis document explains how to fix common TypeScript compiler errors when writing provider logic.\n\n### 🔹 Union Types (e.g., `number | (number & tags.Type<\"int32\">)`)\n\n**Problem**: Schema expects a branded number but union appears due to optional or partial input.\n\n✅ **Fix**:\n\n```ts\nconst value = body.value ?? 0;\n```\n\nThen use:\n\n```ts\nconst input = {\n  value,\n} satisfies SomeSchemaInput;\n```\n\n---\n\n### 🔹 Literal Union Types (e.g., `1 | -1`)\n\n**Problem**: Prisma schema expects a literal value, but `number` is passed.\n\n✅ **Fix Options**:\n\n1. Manual coercion:\n\n```ts\nconst value = body.value === 1 ? 1 : -1;\n```\n\n2. Safe `as` (allowed only for literal unions):\n\n```ts\nconst input = {\n  value: body.value as 1 | -1,\n};\n```\n\n3. Using `typia.assertGuard`:\n\n```ts\nconst value = typia.assertGuard<1 | -1>(body.value);\n```\n\n---\n\n### 🔹 `Object literal may only specify known properties`\n\n**Problem**: You're passing fields that do not exist in Prisma input types (e.g., `user_id`).\n\n✅ **Fix**: Remove or remap fields according to schema.\n\n```ts\nconst { user_id, ...rest } = body;\n\nconst input = {\n  ...rest,\n  user: { connect: { id: user_id } },\n} satisfies Prisma.postsCreateInput;\n```\n\n---\n\n### 🔹 `Cannot find module` (e.g., `bcrypt`)\n\n**Problem**: Missing dependency or type declaration.\n\n✅ **Fix**:\n\n```sh\nnpm install bcrypt\nnpm install --save-dev @types/bcrypt\n```\n\n---\n\n### 🔹 Branded Type Assignability\n\n**Problem**: `string | (string & Format<'uuid'>)` is not assignable to `string & Format<'uuid'>`\n\n✅ **Fix**:\nUse either a validated cast or `typia.assertGuard`:\n\n```ts\nconst id = body.id as string & tags.Format<'uuid'>; // Allowed exception\n```\n\nOR:\n\n```ts\nconst id = typia.assertGuard<string & tags.Format<'uuid'>>(body.id);\n```\n\n### 🕒 Dates and DateTimes Must Be Strings\n\n* All date-related values **must be handled as `string & Format<'date-time'>`**, not as `Date` objects.\n* This rule applies consistently across **API contracts, DTOs, business logic, and response types**.\n* Never assign a `Date` object directly—**always call `.toISOString()`** to convert it into a valid ISO string:\n\n```ts\nconst createdAt: string & Format<'date-time'> = new Date().toISOString();\n````\n\n* For nullable fields such as `Date | null`, ensure the value is properly stringified or handled:\n\n```ts\nconst updatedAt: (string & Format<'date-time'>) | null = maybeDate?.toISOString() ?? null;\n```\n\n> ⚠️ This rule is critical for compatibility with Prisma, OpenAPI, Typia, and other strict typing systems.\n\n> ⚠️ Do not attempt to convert a `Date` value by simply using `as string`.\n\n---\n\n### ✅ Summary Table\n\n| Error Type                                                                             | Solution                                                               | Notes                               |\n| -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | ----------------------------------- |\n| Branded union (e.g. \\`number & Type<\"int32\">\\`)                                        | Use `??` and `satisfies`                                               |                                     |\n| `1 \\| -1` literal union                                                                | Constrain manually or use `as` safely                                  |                                     |\n| `unknown property` in object                                                           | Restructure input object to match schema                               |                                     |\n| `as` usage                                                                             | Only allowed for brand/literal/validated values                        |                                     |\n| Missing module (e.g. bcrypt)                                                           | Install and import properly                                            |                                     |\n| Cannot use MyGlobal.user / requestUserId                                               | Always use the `user` function argument                                |                                     |\n| `Date` not assignable to `string & Format<'date-time'>`                                | Convert to ISO string with `.toISOString()`                            | Never pass raw `Date` instances     |\n| `Date \\| null` not assignable to `(string & Format<'date-time'>) \\| null \\| undefined` | Use conditional chaining and `.toISOString()` for non-null values      | e.g., `date?.toISOString() ?? null` |\n\n\n\n# Prisma Guide\n\n## 🔍 Prisma Update Input Type Safety Guide\n\nWhen implementing an update operation using `Prisma.update()`, you **must strictly follow these rules** to avoid `TS2322` or structural type errors.\n\nThis section guides you through **a checklist**, provides **clear rationale**, and includes **copyable safe patterns** for high accuracy and minimal confusion — for both human developers and LLMs.\n\n---\n\n### ✅ Why Type Errors Occur\n\nTypeScript error `TS2322` usually occurs because:\n\n1. You **manually defined** an object type for `data` instead of using the Prisma-generated input type.\n2. You **assigned `null`** to a field that is not nullable in the Prisma schema.\n3. You **used DTO types** (e.g., `IBbsUserRoles`) instead of the Prisma model update type.\n4. You **assigned values to optional fields** without checking ownership or value type.\n5. You **used dynamic imports** (e.g., `import(\"@prisma/client\")`) that bypass proper static typing.\n\n---\n\n### 📅 Always Transform DateTime Fields to ISO Strings After Select\n\n#### ✅ Why This Matters\n\nWhen using Prisma's `findFirst`, `findMany`, `create`, `update`, or `upsert`, any `DateTime` fields returned by Prisma are **native `Date` objects**, not strings.\nHowever, your DTOs (e.g., `IBbsArticle`, `IUserProfile`) and API contracts require all date fields to be:\n\n```ts\nstring & tags.Format<'date-time'> // ISO 8601 format\n```\n\nFailing to transform `Date` objects into strings will cause:\n\n* `TS2322` type mismatches\n* Serialization issues\n* Invalid API responses\n\n---\n\n#### ✅ What You Must Do\n\nAfter any `select` or result access, **immediately transform** all `Date` fields to ISO strings using `.toISOString()`.\n\n#### 🔧 Example (Safe Transformation)\n\n```ts\nconst record = await MyGlobal.prisma.users.findFirst({\n  where: { id },\n  select: {\n    id: true,\n    created_at: true, // Prisma will return `Date`\n  },\n});\n\nif (!record) throw new Error(\"User not found\");\n\nconst result = {\n  id: record.id,\n  created_at: record.created_at.toISOString() as string & tags.Format<\"date-time\">,\n};\n```\n\nalso, `update` method's return type include Date type properties.\n\n```ts\nconst updated = await MyGlobal.prisma.discussionboard_user.update({\n  where: { id: parameters.id },\n  data: updates,\n});\n\nupdated.created_at; // Date\n```\n\n---\n\n#### ❌ What NOT to Do\n\n```ts\n// ❌ This will cause a TS2322 error\nconst result: IUser = record; // record.created_at is Date, not string\n```\n\n---\n\n### 📌 Rule of Thumb\n\n> **Whenever you access a field of type `DateTime` from Prisma, you MUST immediately call `.toISOString()` and brand it. Never pass raw `Date` objects into DTOs or API responses.**\n\n---\n\n#### ✅ Where This Rule Applies\n\n* `prisma.model.findFirst()`, `findMany()`, `findUnique()`\n* `create()`, `update()`, `upsert()` with `select` or `include`\n* Any nested relation access (e.g., `user.profile.created_at`)\n* Anywhere Prisma returns data containing `DateTime` fields\n\n---\n\n### 💡 Pro Tip\n\nIf your object has many date fields, use a mapping function:\n\n```ts\nfunction toDTO(user: User & { created_at: Date; updated_at: Date }) {\n  return {\n    ...user,\n    created_at: user.created_at.toISOString() as string & tags.Format<\"date-time\">,\n    updated_at: user.updated_at.toISOString() as string & tags.Format<\"date-time\">,\n  };\n}\n```\n\n### ✅ Step-by-Step Checklist Before You Call `update()`\n\n#### ✅ 1. Always use Prisma's update input type\n\n**DO:**\n\n```ts\nimport { Prisma } from \"@prisma/client\";\n\nconst data: Prisma.User_rolesUpdateInput = {};\n```\n\n**DON'T:**\n\n```ts\nconst data: { name?: string | null } = {}; // ❌ will not match Prisma's input type\n```\n\n---\n\n#### ✅ 2. Use `?? undefined` to cleanly normalize nullable/optional inputs\n\nIf a field is `nullable`, use:\n\n```ts\ndata.description = body.description ?? undefined;\n```\n\nIf a field is **required** but **not provided**, **omit** it — do not assign `null`.\n\n---\n\n#### ✅ 3. Use `hasOwnProperty` to detect explicit field presence\n\n```ts\nif (Object.prototype.hasOwnProperty.call(body, \"name\")) {\n  data.name = body.name ?? undefined;\n}\n```\n\n> ⚠️ This is essential to distinguish between:\n>\n> * `{ name: undefined }` (intentional update)\n> * `{}` (field not provided at all)\n\n---\n\n#### ✅ 4. Never use DTO types (`IBbs...`) for `data`\n\nDTO types are for API input/output, **not internal DB operations**. Prisma input types (like `Prisma.User_rolesUpdateInput`) should always be used for database writes.\n\n---\n\n#### ✅ 5. Use TypeScript's narrowing, never bypass with `as`\n\nNever try:\n\n```ts\nconst data = {...} as any; // ❌ extremely dangerous\n```\n\nOnly acceptable `as` use:\n\n```ts\nconst uuid = v4() as string & tags.Format<'uuid'>;\n```\n\n---\n\n#### ✅ 6. Never use dynamic import for Prisma types\n\nDynamic imports like `import(\"@prisma/client\")`:\n\n```ts\nconst { Prisma } = await import(\"@prisma/client\"); // ❌ Do not use\n```\n\nshould **never** be used for type access. This **bypasses static type checking** and **breaks tooling support**. Always use static imports:\n\n```ts\nimport { Prisma } from \"@prisma/client\"; // ✅ Safe and typed\n```\n\n---\n\n### 💡 Copyable Safe Pattern\n\n```ts\nimport { Prisma } from \"@prisma/client\";\n\nconst data: Prisma.User_rolesUpdateInput = {};\nif (\"name\" in body) data.name = body.name ?? undefined;\nif (\"description\" in body) data.description = body.description ?? undefined;\n```\n\n---\n\n### ❌ Common Pitfalls and Fixes\n\n| ❌ Bad Practice                             | ✅ Fix                                   |\n| ------------------------------------------ | --------------------------------------- |\n| Manually define `data` as inline object    | Use `Prisma.ModelUpdateInput`           |\n| Assign `null` to non-nullable fields       | Use `?? undefined` or omit              |\n| Use DTOs like `IBbsUserRoles` for update   | Only use DTOs for API input/output      |\n| Assign `data = body` directly              | Extract and normalize fields explicitly |\n| Use `import(\"@prisma/client\")` dynamically | Use static `import { Prisma } ...`      |\n\n---\n\n### ✅ Rule of Thumb\n\n> **If you're passing `data` into Prisma, it must be type-compatible with `Prisma.ModelUpdateInput` — and must be built using statically imported types. No exceptions.**\n\n---\n\n### 📎 TL;DR for Agent or Developer\n\n1. Always use `Prisma.ModelUpdateInput` as the type.\n2. Use `?? undefined` to normalize input.\n3. Use `hasOwnProperty` to detect intent.\n4. Don't use `null` unless the schema allows it.\n5. Never use DTO types for `data`.\n6. **Never use `import(\"@prisma/client\")` dynamically — always use static import.**\n\n\n# 🔐 Browser-Compatible Native-First Rule\n\nYou must implement all functionality using **only browser-compatible native features** whenever possible.  \nAll logic must assume it will run in a browser environment — even if Node.js is also supported.\n\n> 🚫 Do **not** use Node.js-only modules like `'crypto'`, `'fs'`, `'path'`, etc.\n> ✅ Always use **Web-standard, browser-safe APIs**.\n\n---\n\n## ✅ Encryption Rule\n\nAll encryption and decryption must be implemented using the **Web Crypto API (`window.crypto.subtle`)**.\n\n**❌ Do not use:**\n- `crypto` (Node.js built-in)\n- `crypto-js`, `bcrypt`, `libsodium`, or any other third-party crypto libraries\n\n**✅ Only use:**\n- `window.crypto.subtle` and `window.crypto.getRandomValues`\n\n```ts\n// Example: AES-GCM encryption in the browser\nconst key = await crypto.subtle.generateKey(\n  { name: 'AES-GCM', length: 256 },\n  true,\n  ['encrypt', 'decrypt']\n);\n\nconst iv = crypto.getRandomValues(new Uint8Array(12));\n\nconst encoded = new TextEncoder().encode('hello world');\nconst encrypted = await crypto.subtle.encrypt(\n  { name: 'AES-GCM', iv },\n  key,\n  encoded\n);\n````\n\n---\n\n## ✅ General API Rule\n\nYou must avoid Node.js-specific or third-party libraries. All implementations must be fully functional in **browser environments**, using **web-standard APIs** only.\n\n| Use Case        | ❌ Do Not Use (Node.js / External)                 | ✅ Use Instead (Browser-safe)               |\n| --------------- | ------------------------------------------------- | ------------------------------------------ |\n| UUID Generation | `uuid` package, `crypto.randomUUID()` (Node only) | `crypto.randomUUID()` (browser supported)  |\n| HTTP Requests   | `axios`, `node-fetch`                             | `fetch`                                    |\n| Timing / Delay  | `sleep-promise`, `delay`                          | `setTimeout`, `await new Promise(...)`     |\n| Hashing         | `crypto.createHash()` (Node.js)                   | `crypto.subtle.digest()`                   |\n| Compression     | `zlib`, `adm-zip`, `archiver`                     | `CompressionStream`, `DecompressionStream` |\n| File Handling   | `fs`, `fs-extra`                                  | `File`, `Blob`, `FileReader`, `Streams`    |\n\n---\n\n## 🧷 Summary\n\n* ✅ Use only APIs that work natively in **browsers**.\n* 🚫 Do not use Node.js-only modules or platform-specific packages.\n* ❌ Avoid third-party libraries unless there's **no equivalent** browser-native solution.\n* 🧭 If your logic must run both in Node.js and the browser, **the browser must always be the lowest common denominator**—ensure everything works in the browser first.\n\n\n# Date Type Error Resolution Rules\n\nYou are specialized in fixing Date-related TypeScript compilation errors in the codebase. These errors typically occur when native `Date` objects are incorrectly assigned to fields that expect `string & tags.Format<'date-time'>`.\n\n## Common Date Type Errors\n\n### Error Pattern 1: Direct Date Assignment\n```\nType 'Date' is not assignable to type 'string & Format<\"date-time\">'\n```\n\n### Error Pattern 2: Date Object in Return Values  \n```\nType 'Date' is not assignable to type 'string & Format<\"date-time\">'\n```\n\n### Error Pattern 3: Nullable Date Assignment\n```\nType 'Date | null' is not assignable to type '(string & Format<\"date-time\">) | null | undefined'\n```\n\n### Error Pattern 4: Date Type Conversion Issues\n```\nConversion of type 'Date' to type 'string & Format<\"date-time\">' may be a mistake\n```\n\n### Error Pattern 5: Null to Date-Time String Conversion\n```\nConversion of type 'null' to type 'string & Format<\"date-time\">' may be a mistake\n```\n\n### Error Pattern 6: Field Property Existence Errors\n```\nObject literal may only specify known properties, and 'user_id' does not exist in type 'CreateInput'\nProperty 'field_name' does not exist on type 'UpdateInput'. Did you mean 'related_field'?\n```\n\n## Mandatory Resolution Rules\n\n### Rule 1: Never Use Native Date Objects\n**❌ NEVER do this:**\n```typescript\nconst data = {\n  created_at: new Date(),\n  updated_at: someDate,\n  deleted_at: record.deleted_at, // if record.deleted_at is Date\n};\n```\n\n**✅ ALWAYS do this:**\n```typescript\nconst data = {\n  created_at: new Date().toISOString(),\n  updated_at: someDate.toISOString(),\n  deleted_at: record.deleted_at?.toISOString() ?? null,\n};\n```\n\n### Rule 2: Convert All Date Fields in Data Objects\nWhen creating or updating records, ALL date fields must be converted:\n\n```typescript\n// Correct approach for create operations\nconst input = {\n  id: v4() as string & tags.Format<'uuid'>,\n  created_at: new Date().toISOString(),\n  updated_at: new Date().toISOString(),\n  deleted_at: body.deleted_at ? new Date(body.deleted_at).toISOString() : null,\n} satisfies SomeCreateInput;\n```\n\n### Rule 3: Convert Date Fields in Return Objects\nWhen returning data to API responses, ensure all date fields are strings:\n\n```typescript\n// Convert dates in return objects\nreturn {\n  id: record.id,\n  name: record.name,\n  created_at: record.created_at, // Already string from Prisma\n  updated_at: record.updated_at, // Already string from Prisma\n  processed_at: processedDate.toISOString(), // Convert if Date object\n};\n```\n\n### Rule 4: Handle Nullable Dates Properly\nFor optional or nullable date fields:\n\n```typescript\n// Handle nullable dates\nconst data = {\n  deleted_at: deletedDate ? deletedDate.toISOString() : null,\n  expired_at: expiryDate?.toISOString() ?? undefined,\n};\n```\n\n### Rule 5: Type All Date Variables Correctly\nAlways type date variables as strings, not Date objects:\n\n```typescript\n// Correct typing\nconst now: string & tags.Format<'date-time'> = new Date().toISOString();\nconst createdAt: string & tags.Format<'date-time'> = record.created_at;\n\n// ❌ Never do this\nconst now: Date = new Date();\n```\n\n### Rule 6: Handle Null Values in Date Assignments\nWhen dealing with null values that need to be converted to date strings:\n\n```typescript\n// ✅ Proper null handling for date fields\nconst data = {\n  deleted_at: deletedDate ? deletedDate.toISOString() : null,\n  expired_at: expiry ? new Date(expiry).toISOString() : undefined,\n};\n\n// ❌ Never assign null directly to date-time fields expecting strings\nconst data = {\n  deleted_at: null as string & tags.Format<'date-time'>, // Wrong!\n};\n```\n\n### Rule 7: Verify Field Existence Before Assignment\nAlways check if fields exist in the target type before assigning:\n\n```typescript\n// ✅ Check schema definition first, remove non-existent fields\nconst updateData = {\n  // removed user_id because it doesn't exist in UpdateInput\n  name: body.name,\n  updated_at: new Date().toISOString(),\n} satisfies SomeUpdateInput;\n\n// ❌ Don't force assign non-existent fields\nconst updateData = {\n  user_id: userId, // This field doesn't exist in the type!\n  name: body.name,\n};\n```\n\n### Rule 8: Handle Relational Field Names Correctly\nWhen you see \"Did you mean\" errors, use the suggested field name:\n\n```typescript\n// ❌ Wrong field name\nconst data = {\n  followed_user_id: userId,\n  reporting_user_id: reporterId,\n};\n\n// ✅ Use correct relational field names\nconst data = {\n  followed_user: { connect: { id: userId } },\n  reporting_user: { connect: { id: reporterId } },\n};\n```\n\n## 🔧 Automatic Fixes for Specific Error Patterns\n\n### Fix Pattern 1: Property Assignment Errors\nWhen you see errors like:\n```\nProperty 'created_at' does not exist on type 'UpdateInput'\nProperty 'updated_at' does not exist on type 'UpdateInput'  \nProperty 'deleted_at' does not exist on type 'UpdateInput'\n```\n\n**Resolution:**\n1. Check if the field actually exists in the type definition\n2. If it doesn't exist, remove the assignment\n3. If it exists but has wrong type, convert Date to string using `.toISOString()`\n\n### Fix Pattern 2: Object Literal Property Errors\nWhen you see:\n```\nObject literal may only specify known properties, and 'deleted_at' does not exist\n```\n\n**Resolution:**\n1. Verify the property exists in the target type\n2. If not, remove the property from the object literal\n3. If yes, ensure proper type conversion with `.toISOString()`\n\n### Fix Pattern 3: Return Type Mismatches\nWhen return objects have Date type mismatches:\n\n**Resolution:**\n```typescript\n// Convert all Date fields in responses\nreturn {\n  ...otherFields,\n  created_at: record.created_at, // Prisma already returns string\n  updated_at: record.updated_at, // Prisma already returns string\n  last_accessed: lastAccessTime.toISOString(), // Convert Date objects\n};\n```\n\n### Fix Pattern 4: Null Conversion Errors\nWhen you see:\n```\nConversion of type 'null' to type 'string & Format<\"date-time\">' may be a mistake\n```\n\n**Resolution:**\n```typescript\n// ✅ Proper null handling\nconst data = {\n  deleted_at: deletedDate ? deletedDate.toISOString() : null,\n  // OR use undefined if field is optional\n  expired_at: expiryDate?.toISOString() ?? undefined,\n};\n\n// ❌ Don't force convert null\nconst data = {\n  deleted_at: null as string & tags.Format<'date-time'>,\n};\n```\n\n### Fix Pattern 5: Field Name Mismatch Errors\nWhen you see \"Did you mean\" suggestions:\n```\nProperty 'followed_user_id' does not exist. Did you mean 'followed_user'?\nProperty 'reporting_user_id' does not exist. Did you mean 'reporting_user'?\n```\n\n**Resolution:**\n```typescript\n// ✅ Use relational connects instead of ID fields\nconst data = {\n  followed_user: { connect: { id: parameters.id } },\n  reporting_user: { connect: { id: user.id } },\n  report: { connect: { id: body.report_id } },\n};\n\n// ❌ Don't use direct ID assignments for relations\nconst data = {\n  followed_user_id: parameters.id,\n  reporting_user_id: user.id,\n};\n```\n\n## 🎯 TransformRealizeCoderHistories Integration\n\nWhen fixing Date-related errors in the TransformRealizeCoderHistories process:\n\n1. **Identify all Date-related compilation errors** in the error list\n2. **Apply systematic conversion** using `.toISOString()` for all Date assignments\n3. **Verify field existence** in target types before assignment\n4. **Remove non-existent fields** rather than forcing assignments\n5. **Maintain type safety** by using `satisfies` with proper types\n\n## Critical Reminders\n\n- **NEVER use `as any` or type assertions** to bypass Date type errors\n- **ALWAYS convert Date objects to ISO strings** before assignment\n- **Prisma DateTime fields are stored as ISO strings**, not Date objects\n- **All date fields in API structures use `string & tags.Format<'date-time'>`**\n- **Handle nullable dates with proper null checking** using `?.toISOString() ?? null`\n\nThis systematic approach ensures that all Date-related TypeScript errors are resolved correctly while maintaining type safety and consistency across the codebase.\n\n# Typia Guide\n\nWhen defining validation rules for input or response structures using `typia`, you **must** utilize `tags` exclusively through the `tags` namespace provided by the `typia` module. This ensures strict type safety, clarity, and compatibility with automated code generation and schema extraction.\nFor example, to use `tags.Format<'uuid'>`, you must reference it as `tags.Format`, not simply `Format`.\n\n## ✅ Correct Usage Examples\n\n```ts\nexport interface IUser {\n  username: string & tags.MinLength<3> & tags.MaxLength<20>;\n  email: string & tags.Format<\"email\">;\n  age: number & tags.Type<\"uint32\"> & tags.Minimum<18>;\n}\n```\n\n## ❌ Invalid Usage Examples\n\n```ts\nexport interface IUser {\n  username: string & MinLength<3> & MaxLength<20>;\n  email: string & Format<\"email\">;\n  age: number & Type<\"uint32\"> & Minimum<18>;\n}\n```\n\n---\n\n## 🛡️ `typia.assert` vs `typia.assertGuard`\n\n`typia` provides two main runtime validation utilities: `assert` and `assertGuard`.\nBoth serve to validate runtime data against a TypeScript type, but their **behavior and return types differ**, which can influence which one to use depending on your use case.\n\n### 🔍 `typia.assert<T>(input): T`\n\n* Validates that `input` conforms to type `T`.\n* If invalid, throws a detailed exception.\n* **Returns** the parsed and validated input as type `T`.\n* Ideal when you want **to validate and use the result immediately**.\n\n**Example:**\n\n```ts\nconst user = typia.assert<IUser>(input); // user is of type IUser\n```\n\n---\n\n### 🧪 `typia.assertGuard<T>(input): void`\n\n* Validates that `input` conforms to type `T`.\n* If invalid, throws an exception like `assert`.\n* **Does not return anything** (`void` return type).\n* Acts like a **type guard** for the input **within the scope**.\n* Useful when you want to narrow the type **for subsequent logic**, but **don't need to reassign the value**.\n\n**Example:**\n\n```ts\ntypia.assertGuard<IUser>(input); // input is now treated as IUser\n\n// input can be used safely as IUser here\nconsole.log(input.username);\n```\n\n### 📎 Appendix – `assert` vs `assertGuard`\n\n```ts\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise you want to know all the errors, {@link validate} is the way to go.\n * Also, if you want to automatically cast the parametric value to the type `T`\n * when no problem (perform the assertion guard of type).\n *\n * On the other and, if you don't want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare function assert<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise, you want to know all the errors, {@link validate} is the way to go.\n *\n * On the other and, if you don't want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare function assert<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Assertion guard of a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, nothing would be returned, but the input value\n * would be automatically casted to the type `T`. This is the concept of\n * \"Assertion Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise you want to know all the errors, {@link validate} is the way to go.\n * Also, if you want to returns the parametric value when no problem, you can use\n * {@link assert} function instead.\n *\n * On the other and, if you don't want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertGuardEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare function assertGuard<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Assertion guard of a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, nothing would be returned, but the input value\n * would be automatically casted to the type `T`. This is the concept of\n * \"Assertion Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise you want to know all the errors, {@link validate} is the way to go.\n * Also, if you want to returns the parametric value when no problem, you can use\n * {@link assert} function instead.\n *\n * On the other and, if you don't want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertGuardEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare function assertGuard<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n\n```\n\n### Handling Typia Assertion Errors for JsonSchemaPlugin Format Mismatches\n\n- These errors occur because a value typed as `number & Type<\"int32\">` is being assigned where `number & Type<\"int32\"> & typia.tags.JsonSchemaPlugin<{ format: \"uint32\" }>` is expected.\n- The root cause is a mismatch between signed (`int32`) and unsigned (`uint32`) integer formats.\n- To resolve these, use **typia.tags.assert** to explicitly assert or validate the value conforms to the expected `uint32` format.\n- Example:\n\n```ts\nconst value = getValue(); // type: number & tags.Type<\"int32\">\n\ntags.assert<number & tags.Type<\"int32\"> & tags.JsonSchemaPlugin<{ format: \"uint32\" }>>(value);\n\n// Now `value` is guaranteed to conform to the expected unsigned 32-bit integer type.\n```\n\n* Always use typia.tags' `assert` or related functions for runtime validation and to satisfy TypeScript's type checker.\n* This approach ensures type safety without compromising runtime correctness.\n\n---\n\n### ✅ Summary: Which Should I Use?\n\n| Use Case                             | Recommended API          |\n| ------------------------------------ | ------------------------ |\n| Validate and return typed value      | `typia.assert<T>()`      |\n| Narrow type without reassigning      | `typia.assertGuard<T>()` |\n| Use validated object directly        | `typia.assert<T>()`      |\n| Use input inside a conditional block | `typia.assertGuard<T>()` |\n\n> **Note:** Since `assertGuard` returns `void`, if you need **both type narrowing and a returned value**, `assert` is the better choice.\n\n---\n\n## 🏷️ Typia Tags Declaration – Explanation & Usage Guide\n\nYou can use the following tags from Typia to annotate your types for additional semantic meaning, validation constraints, or schema generation.\n\n| Tag                | Purpose                                                                                                                                                                         |\n| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `Constant`         | Enforces the value to be a specific constant. Useful for literal values.<br>→ `string & tags.Constant<'active'>`                                                                |\n| `ContentMediaType` | Specifies the media type of content (e.g., `application/json`, `text/plain`).                                                                                                   |\n| `Default`          | Declares a default value to be used when the field is not provided.<br>**Note:** This is a schema-level hint, not runtime logic.                                                |\n| `Example`          | Declares a single example value to help with documentation tools like Swagger.                                                                                                  |\n| `Examples`         | Declares multiple example values.                                                                                                                                               |\n| `ExclusiveMaximum` | Similar to `Maximum`, but the value must be **strictly less than** the given limit.                                                                                             |\n| `ExclusiveMinimum` | Similar to `Minimum`, but the value must be **strictly greater than** the given limit.                                                                                          |\n| `Format`           | Specifies a semantic format for a value, such as:<br>→ `email`, `uuid`, `date-time`, `url`, etc.<br>✅ Used heavily across our codebase.<br>e.g., `string & tags.Format<'uuid'>` |\n| `JsonSchemaPlugin` | Allows adding plugin-specific schema behaviors. Rarely needed.                                                                                                                  |\n| `Maximum`          | Specifies the maximum value (inclusive) for a number.<br>e.g., `number & tags.Maximum<100>`                                                                                     |\n| `MaxItems`         | Specifies the maximum number of elements in an array.                                                                                                                           |\n| `MaxLength`        | Specifies the maximum string length.<br>e.g., `string & tags.MaxLength<50>`                                                                                                     |\n| `Minimum`          | Specifies the minimum value (inclusive) for a number.                                                                                                                           |\n| `MinItems`         | Specifies the minimum number of array items.                                                                                                                                    |\n| `MinLength`        | Specifies the minimum string length.                                                                                                                                            |\n| `MultipleOf`       | The value must be a multiple of the given number.<br>e.g., `number & tags.MultipleOf<5>`                                                                                        |\n| `Pattern`          | Applies a regular expression pattern to a string.<br>e.g., `string & tags.Pattern<'^[a-z]+>`                                                                                  |\n| `Sequence`         | Used for sequential fields like auto-incrementing IDs.                                                                                                                          |\n| `TagBase`          | Internal utility tag – typically not used directly.                                                                                                                             |\n| `Type`             | Used to enforce a type name in JSON Schema generation.                                                                                                                          |\n| `UniqueItems`      | Ensures all elements in an array are unique.                                                                                                                                    |\n\n---\n\n### ✅ Examples\n\n```ts\ntype UserId = string & tags.Format<'uuid'>;\ntype LimitedString = string & tags.MinLength<5> & tags.MaxLength<20>;\ntype SmallNumber = number & tags.Minimum<1> & tags.Maximum<10>;\ntype ConstantStatus = string & tags.Constant<'active'>;\ntype Email = string & tags.Format<'email'>;\n```\n\n---\n\n### 🔒 Typia Tag Usage Notes\n\n* Tags are used at the **type level**, not runtime.\n* They are especially useful when:\n\n  * Generating OpenAPI / Swagger schemas\n  * Enforcing validation contracts across API boundaries\n  * Using `typia.assert`, `typia.validate`, or `typia.random`\n\n> ⚠️ **Never use these tags directly for logic branching in code.** They are strictly for static type and schema purposes."
     }, {
         id: v4(),
         created_at: (new Date).toISOString(),
         type: "systemMessage",
-        text: "# Prisma Guide\n\n## 🔍 Prisma Update Input Type Safety Guide\n\nWhen implementing an update operation using `Prisma.update()`, you **must strictly follow these rules** to avoid `TS2322` or structural type errors.\n\nThis section guides you through **a checklist**, provides **clear rationale**, and includes **copyable safe patterns** for high accuracy and minimal confusion — for both human developers and LLMs.\n\n---\n\n### ✅ Why Type Errors Occur\n\nTypeScript error `TS2322` usually occurs because:\n\n1. You **manually defined** an object type for `data` instead of using the Prisma-generated input type.\n2. You **assigned `null`** to a field that is not nullable in the Prisma schema.\n3. You **used DTO types** (e.g., `IBbsUserRoles`) instead of the Prisma model update type.\n4. You **assigned values to optional fields** without checking ownership or value type.\n\n---\n\n### ✅ Step-by-Step Checklist Before You Call `update()`\n\n#### ✅ 1. Always use Prisma's update input type\n\n**DO:**\n\n```ts\nconst data: Prisma.User_rolesUpdateInput = {};\n```\n\n**DON'T:**\n\n```ts\nconst data: { name?: string | null } = {}; // ❌ will not match Prisma's input type\n```\n\n---\n\n#### ✅ 2. Use `?? undefined` to cleanly normalize nullable/optional inputs\n\nIf a field is `nullable`, use:\n\n```ts\ndata.description = body.description ?? undefined;\n```\n\nIf a field is **required** but **not provided**, **omit** it — do not assign `null`.\n\n---\n\n#### ✅ 3. Use `hasOwnProperty` to detect explicit field presence\n\n```ts\nif (Object.prototype.hasOwnProperty.call(body, \"name\")) {\n  data.name = body.name ?? undefined;\n}\n```\n\n> ⚠️ This is essential to distinguish between:\n>\n> * `{ name: undefined }` (intentional update)\n> * `{}` (field not provided at all)\n\n---\n\n#### ✅ 4. Never use DTO types (`IBbs...`) for `data`\n\nDTO types are for API input/output, **not internal DB operations**. Prisma input types (like `Prisma.User_rolesUpdateInput`) should always be used for database writes.\n\n---\n\n#### ✅ 5. Use TypeScript’s narrowing, never bypass with `as`\n\nNever try:\n\n```ts\nconst data = {...} as any; // ❌ extremely dangerous\n```\n\nOnly acceptable `as` use:\n\n```ts\nconst uuid = v4() as string & tags.Format<'uuid'>;\n```\n\n---\n\n### 💡 Copyable Safe Pattern\n\n```ts\nconst data: Prisma.User_rolesUpdateInput = {};\nif (\"name\" in body) data.name = body.name ?? undefined;\nif (\"description\" in body) data.description = body.description ?? undefined;\n```\n\n> 🧠 This avoids errors by:\n>\n> * Using the exact type expected by Prisma\n> * Avoiding `null` on non-nullable fields\n> * Treating `undefined` as “do not update”\n\n---\n\n### ❌ Common Pitfalls and Fixes\n\n| ❌ Bad Practice                           | ✅ Fix                                   |\n| ---------------------------------------- | --------------------------------------- |\n| Manually define `data` as inline object  | Use `Prisma.ModelUpdateInput`           |\n| Assign `null` to non-nullable fields     | Use `?? undefined` or omit              |\n| Use DTOs like `IBbsUserRoles` for update | Only use DTOs for API input/output      |\n| Assign `data = body` directly            | Extract and normalize fields explicitly |\n\n---\n\n### ✅ Rule of Thumb\n\n> **If you're passing `data` into Prisma, it must be type-compatible with `Prisma.ModelUpdateInput` — no exceptions.**\n\n---\n\n### 📎 TL;DR for Agent or Developer\n\n1. Always use `Prisma.ModelUpdateInput` as the type.\n2. Use `?? undefined` to normalize input.\n3. Use `hasOwnProperty` to detect intent.\n4. Don’t use `null` unless the schema allows it.\n5. Never use DTO types for `data`."
-    }, {
-        id: v4(),
-        created_at: (new Date).toISOString(),
-        type: "systemMessage",
-        text: "## 🔐 Browser-Compatible Native-First Rule\n\nYou must implement all functionality using **only browser-compatible native features** whenever possible.  \nAll logic must assume it will run in a browser environment — even if Node.js is also supported.\n\n> 🚫 Do **not** use Node.js-only modules like `'crypto'`, `'fs'`, `'path'`, etc.\n> ✅ Always use **Web-standard, browser-safe APIs**.\n\n---\n\n### ✅ Encryption Rule\n\nAll encryption and decryption must be implemented using the **Web Crypto API (`window.crypto.subtle`)**.\n\n**❌ Do not use:**\n- `crypto` (Node.js built-in)\n- `crypto-js`, `bcrypt`, `libsodium`, or any other third-party crypto libraries\n\n**✅ Only use:**\n- `window.crypto.subtle` and `window.crypto.getRandomValues`\n\n```ts\n// Example: AES-GCM encryption in the browser\nconst key = await crypto.subtle.generateKey(\n  { name: 'AES-GCM', length: 256 },\n  true,\n  ['encrypt', 'decrypt']\n);\n\nconst iv = crypto.getRandomValues(new Uint8Array(12));\n\nconst encoded = new TextEncoder().encode('hello world');\nconst encrypted = await crypto.subtle.encrypt(\n  { name: 'AES-GCM', iv },\n  key,\n  encoded\n);\n````\n\n---\n\n### ✅ General API Rule\n\nYou must avoid Node.js-specific or third-party libraries. All implementations must be fully functional in **browser environments**, using **web-standard APIs** only.\n\n| Use Case        | ❌ Do Not Use (Node.js / External)                 | ✅ Use Instead (Browser-safe)               |\n| --------------- | ------------------------------------------------- | ------------------------------------------ |\n| UUID Generation | `uuid` package, `crypto.randomUUID()` (Node only) | `crypto.randomUUID()` (browser supported)  |\n| HTTP Requests   | `axios`, `node-fetch`                             | `fetch`                                    |\n| Timing / Delay  | `sleep-promise`, `delay`                          | `setTimeout`, `await new Promise(...)`     |\n| Hashing         | `crypto.createHash()` (Node.js)                   | `crypto.subtle.digest()`                   |\n| Compression     | `zlib`, `adm-zip`, `archiver`                     | `CompressionStream`, `DecompressionStream` |\n| File Handling   | `fs`, `fs-extra`                                  | `File`, `Blob`, `FileReader`, `Streams`    |\n\n---\n\n### 🧷 Summary\n\n* ✅ Use only APIs that work natively in **browsers**.\n* 🚫 Do not use Node.js-only modules or platform-specific packages.\n* ❌ Avoid third-party libraries unless there's **no equivalent** browser-native solution.\n* 🧭 If your logic must run both in Node.js and the browser, **the browser must always be the lowest common denominator**—ensure everything works in the browser first."
-    }, {
-        id: v4(),
-        created_at: (new Date).toISOString(),
-        type: "systemMessage",
-        text: '# Typia Guide\n\nWhen defining validation rules for input or response structures using `typia`, you **must** utilize `tags` exclusively through the `tags` namespace provided by the `typia` module. This ensures strict type safety, clarity, and compatibility with automated code generation and schema extraction.\nFor example, to use `tags.Format<\'uuid\'>`, you must reference it as `tags.Format`, not simply `Format`.\n\n## ✅ Correct Usage Examples\n\n```ts\nexport interface IUser {\n  username: string & tags.MinLength<3> & tags.MaxLength<20>;\n  email: string & tags.Format<"email">;\n  age: number & tags.Type<"uint32"> & tags.Minimum<18>;\n}\n```\n\n## ❌ Invalid Usage Examples\n\n```ts\nexport interface IUser {\n  username: string & MinLength<3> & MaxLength<20>;\n  email: string & Format<"email">;\n  age: number & Type<"uint32"> & Minimum<18>;\n}\n```\n\n---\n\n## 🛡️ `typia.assert` vs `typia.assertGuard`\n\n`typia` provides two main runtime validation utilities: `assert` and `assertGuard`.\nBoth serve to validate runtime data against a TypeScript type, but their **behavior and return types differ**, which can influence which one to use depending on your use case.\n\n### 🔍 `typia.assert<T>(input): T`\n\n* Validates that `input` conforms to type `T`.\n* If invalid, throws a detailed exception.\n* **Returns** the parsed and validated input as type `T`.\n* Ideal when you want **to validate and use the result immediately**.\n\n**Example:**\n\n```ts\nconst user = typia.assert<IUser>(input); // user is of type IUser\n```\n\n---\n\n### 🧪 `typia.assertGuard<T>(input): void`\n\n* Validates that `input` conforms to type `T`.\n* If invalid, throws an exception like `assert`.\n* **Does not return anything** (`void` return type).\n* Acts like a **type guard** for the input **within the scope**.\n* Useful when you want to narrow the type **for subsequent logic**, but **don\'t need to reassign the value**.\n\n**Example:**\n\n```ts\ntypia.assertGuard<IUser>(input); // input is now treated as IUser\n\n// input can be used safely as IUser here\nconsole.log(input.username);\n```\n\n### 📎 Appendix – `assert` vs `assertGuard`\n\n```ts\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise you want to know all the errors, {@link validate} is the way to go.\n * Also, if you want to automatically cast the parametric value to the type `T`\n * when no problem (perform the assertion guard of type).\n *\n * On the other and, if you don\'t want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare function assert<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise, you want to know all the errors, {@link validate} is the way to go.\n *\n * On the other and, if you don\'t want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare function assert<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Assertion guard of a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, nothing would be returned, but the input value\n * would be automatically casted to the type `T`. This is the concept of\n * "Assertion Guard" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise you want to know all the errors, {@link validate} is the way to go.\n * Also, if you want to returns the parametric value when no problem, you can use\n * {@link assert} function instead.\n *\n * On the other and, if you don\'t want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertGuardEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare function assertGuard<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Assertion guard of a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with detailed\n * reason, if the parametric value is not following the type `T`. Otherwise, the\n * value is following the type `T`, nothing would be returned, but the input value\n * would be automatically casted to the type `T`. This is the concept of\n * "Assertion Guard" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric value is\n * following the type `T` or not, you can choose the {@link is} function instead.\n * Otherwise you want to know all the errors, {@link validate} is the way to go.\n * Also, if you want to returns the parametric value when no problem, you can use\n * {@link assert} function instead.\n *\n * On the other and, if you don\'t want to allow any superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertGuardEquals} function instead.\n *\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @throws A {@link TypeGuardError} instance with detailed reason\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare function assertGuard<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n\n```\n\n### Handling Typia Assertion Errors for JsonSchemaPlugin Format Mismatches\n\n- These errors occur because a value typed as `number & Type<"int32">` is being assigned where `number & Type<"int32"> & typia.tags.JsonSchemaPlugin<{ format: "uint32" }>` is expected.\n- The root cause is a mismatch between signed (`int32`) and unsigned (`uint32`) integer formats.\n- To resolve these, use **typia.tags.assert** to explicitly assert or validate the value conforms to the expected `uint32` format.\n- Example:\n\n```ts\nconst value = getValue(); // type: number & tags.Type<"int32">\n\ntags.assert<number & tags.Type<"int32"> & tags.JsonSchemaPlugin<{ format: "uint32" }>>(value);\n\n// Now `value` is guaranteed to conform to the expected unsigned 32-bit integer type.\n```\n\n* Always use typia.tags’ `assert` or related functions for runtime validation and to satisfy TypeScript’s type checker.\n* This approach ensures type safety without compromising runtime correctness.\n\n---\n\n### ✅ Summary: Which Should I Use?\n\n| Use Case                             | Recommended API          |\n| ------------------------------------ | ------------------------ |\n| Validate and return typed value      | `typia.assert<T>()`      |\n| Narrow type without reassigning      | `typia.assertGuard<T>()` |\n| Use validated object directly        | `typia.assert<T>()`      |\n| Use input inside a conditional block | `typia.assertGuard<T>()` |\n\n> **Note:** Since `assertGuard` returns `void`, if you need **both type narrowing and a returned value**, `assert` is the better choice.\n\n---\n\n## 🏷️ Typia Tags Declaration – Explanation & Usage Guide\n\nYou can use the following tags from Typia to annotate your types for additional semantic meaning, validation constraints, or schema generation.\n\n| Tag                | Purpose                                                                                                                                                                         |\n| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `Constant`         | Enforces the value to be a specific constant. Useful for literal values.<br>→ `string & tags.Constant<\'active\'>`                                                                |\n| `ContentMediaType` | Specifies the media type of content (e.g., `application/json`, `text/plain`).                                                                                                   |\n| `Default`          | Declares a default value to be used when the field is not provided.<br>**Note:** This is a schema-level hint, not runtime logic.                                                |\n| `Example`          | Declares a single example value to help with documentation tools like Swagger.                                                                                                  |\n| `Examples`         | Declares multiple example values.                                                                                                                                               |\n| `ExclusiveMaximum` | Similar to `Maximum`, but the value must be **strictly less than** the given limit.                                                                                             |\n| `ExclusiveMinimum` | Similar to `Minimum`, but the value must be **strictly greater than** the given limit.                                                                                          |\n| `Format`           | Specifies a semantic format for a value, such as:<br>→ `email`, `uuid`, `date-time`, `url`, etc.<br>✅ Used heavily across our codebase.<br>e.g., `string & tags.Format<\'uuid\'>` |\n| `JsonSchemaPlugin` | Allows adding plugin-specific schema behaviors. Rarely needed.                                                                                                                  |\n| `Maximum`          | Specifies the maximum value (inclusive) for a number.<br>e.g., `number & tags.Maximum<100>`                                                                                     |\n| `MaxItems`         | Specifies the maximum number of elements in an array.                                                                                                                           |\n| `MaxLength`        | Specifies the maximum string length.<br>e.g., `string & tags.MaxLength<50>`                                                                                                     |\n| `Minimum`          | Specifies the minimum value (inclusive) for a number.                                                                                                                           |\n| `MinItems`         | Specifies the minimum number of array items.                                                                                                                                    |\n| `MinLength`        | Specifies the minimum string length.                                                                                                                                            |\n| `MultipleOf`       | The value must be a multiple of the given number.<br>e.g., `number & tags.MultipleOf<5>`                                                                                        |\n| `Pattern`          | Applies a regular expression pattern to a string.<br>e.g., `string & tags.Pattern<\'^[a-z]+$\'>`                                                                                  |\n| `Sequence`         | Used for sequential fields like auto-incrementing IDs.                                                                                                                          |\n| `TagBase`          | Internal utility tag – typically not used directly.                                                                                                                             |\n| `Type`             | Used to enforce a type name in JSON Schema generation.                                                                                                                          |\n| `UniqueItems`      | Ensures all elements in an array are unique.                                                                                                                                    |\n\n---\n\n### ✅ Examples\n\n```ts\ntype UserId = string & tags.Format<\'uuid\'>;\ntype LimitedString = string & tags.MinLength<5> & tags.MaxLength<20>;\ntype SmallNumber = number & tags.Minimum<1> & tags.Maximum<10>;\ntype ConstantStatus = string & tags.Constant<\'active\'>;\ntype Email = string & tags.Format<\'email\'>;\n```\n\n---\n\n### 🔒 Typia Tag Usage Notes\n\n* Tags are used at the **type level**, not runtime.\n* They are especially useful when:\n\n  * Generating OpenAPI / Swagger schemas\n  * Enforcing validation contracts across API boundaries\n  * Using `typia.assert`, `typia.validate`, or `typia.random`\n\n> ⚠️ **Never use these tags directly for logic branching in code.** They are strictly for static type and schema purposes.'
-    }, {
-        id: v4(),
-        created_at: (new Date).toISOString(),
-        type: "systemMessage",
-        text: "# Prisma Schemas\n```json\n{prisma_schemas}\n```\n# ℹ️ How to Use the Above Prisma Schemas\n- These Prisma schemas are extracted from your actual `schema.prisma` file.\n- You must always consult the schema when writing any `update`, `create`, or `select` logic.\n- Pay special attention to:\n  1. **Which fields are required, optional, or nullable**\n  2. **Which fields are scalar vs. relation fields** (e.g., `role_id` vs. `role`)\n  3. **Which fields can be updated directly** (scalar fields) vs. **indirectly** (via `connect`, `disconnect`, `set` in nested relation objects)\n- For relation fields like `user_role_id`, do not assign it directly — instead, use the relation name (e.g., `role: { connect: { id: ... } }`).\n- The type definitions generated by Prisma (e.g., `Prisma.UserUpdateInput`) are based directly on this schema — they **exclude computed/derived fields** and may treat relations differently.\n- When in doubt, cross-reference your assignment logic with this schema to avoid `TS2322`, `TS2339`, and other structural typing errors.\n- ❗Never assume a field exists in the update input just because it appears in the model. Some fields are only present in `createInput`, or must be updated through relations.\n\n# SDK\n\nThe following is the SDK for the API. Based on the information provided by this SDK, you must write code that maps the SDK-provided parameters directly into the `parameters` and `body` properties of the provider function response.\nIf there are no parameters, define `parameters` as `Record<string, never>`. Similarly, if there is no body, define `body` as `Record<string, never>`.\n**Every function must be implemented to accept both `parameters` and `body`, without exception.**\nIf any required type information is referenced in the SDK, refer to the definitions in the DTO section.\n\n```json\n{artifacts_sdk}\n```\n\n# DTO\nif you want to import this files, write this: 'import { something } from '../api/structures/something';'\n\n```json\n{artifacts_dto}\n```\n# Document\n```json\n{artifacts_document}\n```".replaceAll(`{prisma_schemas}`, JSON.stringify(state.prisma.schemas)).replaceAll(`{artifacts_sdk}`, JSON.stringify(artifacts.sdk)).replaceAll(`{artifacts_dto}`, JSON.stringify(artifacts.dto)).replaceAll(`{artifacts_document}`, JSON.stringify(artifacts.document))
+        text: "# Prisma Schemas\n```json\n{prisma_schemas}\n```\n# ℹ️ How to Use the Above Prisma Schemas\n- These Prisma schemas are extracted from your actual `schema.prisma` file.\n- You must always consult the schema when writing any `update`, `create`, or `select` logic.\n- Pay special attention to:\n  1. **Which fields are required, optional, or nullable**\n  2. **Which fields are scalar vs. relation fields** (e.g., `role_id` vs. `role`)\n  3. **Which fields can be updated directly** (scalar fields) vs. **indirectly** (via `connect`, `disconnect`, `set` in nested relation objects)\n- For relation fields like `user_role_id`, do not assign it directly — instead, use the relation name (e.g., `role: { connect: { id: ... } }`).\n- The type definitions generated by Prisma (e.g., `Prisma.UserUpdateInput`) are based directly on this schema — they **exclude computed/derived fields** and may treat relations differently.\n- When in doubt, cross-reference your assignment logic with this schema to avoid `TS2322`, `TS2339`, and other structural typing errors.\n- ❗Never assume a field exists in the update input just because it appears in the model. Some fields are only present in `createInput`, or must be updated through relations.\n\n# SDK\n\nThe following is the SDK for the API. Based on the information provided by this SDK, you must write code that maps the SDK-provided parameters directly into the `parameters` and `body` properties of the provider function response.\nIf there are no parameters, define `parameters` as `Record<string, never>`. Similarly, if there is no body, define `body` as `Record<string, never>`.\n**Every function must be implemented to accept both `parameters` and `body`, without exception.**\nIf any required type information is referenced in the SDK, refer to the definitions in the DTO section.\n\n```json\n{artifacts_sdk}\n```\n\n# DTO\nif you want to import this files, write this: 'import { something } from '../api/structures/something';'\n\n```json\n{artifacts_dto}\n```\n# Document\n```json\n{artifacts_document}\n```".replaceAll(`{prisma_schemas}`, JSON.stringify(state.prisma.schemas)).replaceAll(`{artifacts_sdk}`, JSON.stringify(artifacts.sdk)).replaceAll(`{artifacts_dto}`, JSON.stringify(artifacts.dto))
     }, ...previous !== null ? [ {
         id: v4(),
         created_at: (new Date).toISOString(),
         type: "assistantMessage",
-        text: "The code you previously wrote is as follows:\n```typescript\n{code}\n```\n\n```json\n{total_diagnostics}\n```\n\nThe list above shows all known errors.\nYou are currently editing the code, and based on your changes, the errors from this attempt are as follows:\n```json\n{current_diagnostics}\n```\n\n💡 Note:\n- If an error appears **only in the current errors** and not in the full list above, it is a **newly introduced error**.\n- If an error appears **only in the full list** and not in the current errors, it means it has been **fixed**.\n\n💡 **Tip Regarding Date Type Errors**\n\nIf you encounter errors related to the `Date` type, a common fix is to call the `.toISOString()` method on the `Date` object and treat it as a `string`.\nThis approach resolves most type-related issues.\nPlease note that in our defined types—especially in properties involving dates—and in all `Date` or `DateTime` fields from Prisma,\n**dates must be handled as `string` values**, not as native `Date` objects.\nAlways ensure date values conform to the expected format:\n\n```ts\nstring & tags.Format<'date-time'>\n```\n\n```ts\n// If there is some Date type property...\nDateProp.toISOString(); // GOOD!\nDateProp as string; // BAD!\n```".replaceAll(`{code}`, previous).replaceAll("{total_diagnostics}", JSON.stringify(total)).replaceAll("{current_diagnostics}", JSON.stringify(diagnostics))
+        text: "# List of compilation errors in this file\n\nYou are currently editing the code, and based on your changes, the errors from this attempt are as follows:\n\n```json\n{current_diagnostics}\n```\n\n💡 Note:\n- If an error appears **only in the current errors** and not in the full list above, it is a **newly introduced error**.\n- If an error appears **only in the full list** and not in the current errors, it means it has been **fixed**.\n\n💡 **Tip Regarding Date Type Errors**\n\nIf you encounter errors related to the `Date` type, a common fix is to call the `.toISOString()` method on the `Date` object and treat it as a `string`.\nThis approach resolves most type-related issues.\nPlease note that in our defined types—especially in properties involving dates—and in all `Date` or `DateTime` fields from Prisma,\n**dates must be handled as `string` values**, not as native `Date` objects.\nAlways ensure date values conform to the expected format:\n\n```ts\nstring & tags.Format<'date-time'>\n```\n\n```ts\n// If there is some Date type property...\nDateProp.toISOString(); // GOOD!\nDateProp as string; // BAD!\n```".replaceAll(`{code}`, previous).replaceAll("{current_diagnostics}", JSON.stringify(diagnostics))
     } ] : [], {
         id: v4(),
         created_at: (new Date).toISOString(),
         type: "systemMessage",
         text: [ previous ? "Modify the previous code to reflect the following operation." : "Write new code based on the following operation.", "```json", JSON.stringify(props), "```" ].join("\n")
+    }, {
+        id: v4(),
+        created_at: (new Date).toISOString(),
+        type: "assistantMessage",
+        text: [ `I understand your request.`, ``, `To summarize:`, `- I must **never use the native \`Date\` type** in any code or type definitions.`, `- Instead, all date and datetime values must be handled as \`string & tags.Format<'date-time'>\`.`, `- This rule is **strict** and applies everywhere, including domain types, API inputs/outputs, and Prisma models.`, `- Even if a library or tool returns a \`Date\`, I must convert it to the correct string format before use.`, ``, `Especially regarding the \`Date\` type: I understand that using it can lead to type inconsistency and runtime issues, so I will completely avoid it in all circumstances.`, ``, `I'll make sure to follow all these rules strictly. Let’s proceed with this in mind.` ].join("\n")
     } ];
 };
 
@@ -6870,16 +7443,18 @@ const orchestrateRealizeCoder = async (ctx, operation, props, previous, total, d
         vendor: ctx.vendor,
         config: {
             ...ctx.config,
+            backoffStrategy: randomBackoffStrategy,
             executor: {
                 describe: null
             }
         },
-        histories: transformRealizeCoderHistories(ctx.state(), props, artifacts, previous, total, diagnostics)
+        histories: transformRealizeCoderHistories(ctx.state(), props, artifacts, previous, diagnostics)
     });
     enforceToolCall(agent);
-    await agent.conversate("Write code.");
-    const tokenUsage = agent.getTokenUsage();
-    ctx.usage().record(tokenUsage, [ "realize" ]);
+    await randomBackoffRetry((() => agent.conversate([ `Write complete, production-ready TypeScript code that strictly follows these rules:`, "", `1. Do **not** use the native \`Date\` type anywhere.`, `2. All date or datetime values must be written as \`string & tags.Format<'date-time'>\`.`, `3. UUIDs must be generated using \`v4()\` and typed as \`string & tags.Format<'uuid'>\`.`, `4. Do not use \`as\` for type assertions — resolve types properly.`, `5. All functions must be fully typed with clear parameter and return types.`, `6. Do not skip validations or default values where necessary.`, `7. Follow functional, immutable, and consistent code structure.`, "", `Use \`@nestia/e2e\` test structure if relevant.` ].join("\n")))).finally((() => {
+        const tokenUsage = agent.getTokenUsage();
+        ctx.usage().record(tokenUsage, [ "realize" ]);
+    }));
     if (pointer.value === null) {
         return FAILED;
     }
@@ -6940,11 +7515,14 @@ const claude$4 = {
                     type: "object",
                     properties: {
                         filename: {
-                            description: 'The name of the file to be generated (e.g., "user.create.ts")',
                             type: "string"
                         },
                         plan: {
-                            description: "🧠 Provider Function Implementation Plan\n\nThis field outlines the strategic plan for implementing the provider\nfunction according to the Realize Coder Agent specification. Before\nwriting the actual code, think through the logic and structure.\n\nThe plan must consider:\n\n- 🧩 Required business entities (e.g., users, posts, logs) and their\n  relationships\n- 🛠 Operations needed to fulfill the business scenario (e.g., fetch,\n  create, update)\n- 🔄 Data dependencies between steps (e.g., use userId to fetch related\n  data)\n- ✅ Validation points (based on business rules, not field presence)\n- 🚧 Error and edge cases that must be handled explicitly (e.g., missing\n  records)\n- 🏗 Structure: always a single `async function`, using only `parameters`\n  and `body`\n\n⚠️ Important Constraints:\n\n- Do NOT perform input validation — assume `parameters` and `body` are\n  already valid\n- Use `typia.random<T>()` with an explanatory comment if logic can't be\n  implemented\n- Never use `any` or make assumptions without sufficient context\n- Use only allowed imports — DTOs and Prisma types\n- Use `MyGlobal.prisma` for DB access and respect Prisma typing rules\n\n⚠️ TypeScript-specific considerations:\n\n- Do **not** use native `Date` objects directly; convert all dates with\n  `.toISOString()`\n- Use `string & tags.Format<'date-time'>` for all date/time typed fields\n- Prefer `satisfies` for DTO conformance instead of unsafe `as` casts\n- Avoid weak typing such as `any`, `as any`, or `satisfies any`\n- Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where\n  applicable\n\n✅ Example Structure:\n\n```ts\nexport async function doSomething(\n  user: { id: string & tags.Format<\"uuid\">; type: string },\n  parameters: IParams,\n  body: IBody\n): Promise<IReturn> {\n  const { id } = parameters;\n  const { name } = body;\n  const user = await MyGlobal.prisma.users.findFirst({ where: { id } });\n  if (!user) throw new Error(\"User not found\");\n  ...\n  return result;\n}\n```\n\n🔥 Error Handling Plan:\n\nIf an error is expected or encountered during implementation:\n\n- Clearly document the error message(s) and TypeScript error codes.\n- Analyze the root cause (e.g., type mismatch, missing field, nullability\n  issue).\n- Define concrete steps to resolve the issue, such as:\n\n  - Adjusting type declarations or using Prisma-generated input types.\n  - Using `?? undefined` to normalize nullable fields.\n  - Applying correct relation handling (e.g., `connect` instead of direct\n      foreign key assignment).\n  - Ensuring `Date` fields use `.toISOString()` and branded types.\n- Include fallback or workaround plans if a direct fix is complex.\n- If no error is present, simply omit this section.\n\nThis plan ensures the function will:\n\n- Respect the global architecture and coding conventions\n- Be safe, predictable, and aligned with upstream logic",
+                            description: "🧠 Provider Function Implementation Plan\n\nThis field outlines the strategic plan for implementing the provider\nfunction according to the Realize Coder Agent specification. Before\nwriting the actual code, think through the logic and structure.\n\nThe plan must consider:\n\n- 🧩 Required business entities (e.g., users, posts, logs) and their\n  relationships\n- 🛠 Operations needed to fulfill the business scenario (e.g., fetch,\n  create, update)\n- 🔄 Data dependencies between steps (e.g., use userId to fetch related\n  data)\n- ✅ Validation points (based on business rules, not field presence)\n- 🚧 Error and edge cases that must be handled explicitly (e.g., missing\n  records)\n- 🏗 Structure: always a single `async function`, using only `parameters`\n  and `body`\n\n⚠️ Important Constraints:\n\n- Do NOT perform input validation — assume `parameters` and `body` are\n  already valid\n- Use `typia.random<T>()` with an explanatory comment if logic can't be\n  implemented\n- Never use `any` or make assumptions without sufficient context\n- Use only allowed imports — DTOs and Prisma types\n- Use `MyGlobal.prisma` for DB access and respect Prisma typing rules\n\n⚠️ TypeScript-specific considerations:\n\n- Do **not** use native `Date` objects directly; always convert all dates\n  to ISO strings with `.toISOString()` and brand as `string &\n  tags.Format<'date-time'>`. This rule applies throughout all phases.\n- Prefer `satisfies` for DTO conformance instead of unsafe `as` casts\n- Avoid weak typing such as `any`, `as any`, or `satisfies any`\n- Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where\n  applicable\n\n✅ Example Structure:\n\n```ts\nexport async function doSomething(\n  user: { id: string & tags.Format<\"uuid\">; type: string },\n  parameters: IParams,\n  body: IBody\n): Promise<IReturn> {\n  const { id } = parameters;\n  const { name } = body;\n  const user = await MyGlobal.prisma.users.findFirst({ where: { id } });\n  if (!user) throw new Error(\"User not found\");\n  ...\n  return result;\n}\n```\n\n🔥 Error Handling Plan:\n\nIf an error is expected or encountered during implementation:\n\n- Clearly document the error message(s) and TypeScript error codes.\n- Analyze the root cause (e.g., type mismatch, missing field, nullability\n  issue).\n- Define concrete steps to resolve the issue, such as:\n\n  - Adjusting type declarations or using Prisma-generated input types.\n  - Using `?? undefined` to normalize nullable fields.\n  - Applying correct relation handling (e.g., `connect` instead of direct\n      foreign key assignment).\n  - Ensuring all date fields use `.toISOString()` and proper branding.\n- Include fallback or workaround plans if a direct fix is complex.\n- If no error is present, simply omit this section.\n\nThis plan ensures the function will:\n\n- Respect the global architecture and coding conventions\n- Be safe, predictable, and aligned with upstream logic",
+                            type: "string"
+                        },
+                        draft_without_date_type: {
+                            description: "✏️ Phase 1: Draft code\n\nThis is the initial drafting phase where you outline the basic skeleton\nof the function.\n\n- The function signature must correctly include `user`, `parameters`, and\n  `body` arguments.\n- Design the main flow of business logic, such as DB fetches and early\n  returns based on conditions.\n- Mark any incomplete or missing parts clearly with placeholders (e.g.,\n  comments or temporary values).\n\n⚠️ Import rules:\n\n- Do NOT add any new import statements manually.\n- All necessary imports are provided globally or by the system\n  automatically.\n- Writing import statements directly is prohibited and may cause compile\n  errors. If import errors occur, check your environment configuration.\n\n✅ Requirements:\n\n- Avoid using the `any` type at all costs to ensure type safety.\n- Do NOT assign native `Date` objects directly; always convert dates using\n  `.toISOString()` before assignment and apply proper branding.\n- Maintain a single-function structure; avoid using classes.",
                             type: "string"
                         },
                         review: {
@@ -6952,21 +7530,21 @@ const claude$4 = {
                             type: "string"
                         },
                         withCompilerFeedback: {
-                            description: "🛠 Phase 3: With compiler feedback (optional)\n\nA correction pass that applies fixes for compile-time errors that arose\nduring the review stage (if any).\n\n✅ Must:\n\n- Resolve all TypeScript errors without using `as any`\n- Provide safe brand casting only if required (e.g., `as string &\n  tags.Format<'uuid'>`)",
+                            description: "🛠 Phase 3: With compiler feedback (optional)\n\nA correction pass that applies fixes for compile-time errors that arose\nduring the review stage (if any).\n\n✅ Must:\n\n- Only include this field if TypeScript errors are detected in the Review\n  phase.\n- Resolve all TypeScript errors without using `as any`.\n- Provide safe brand casting only if required (e.g., `as string &\n  tags.Format<'uuid'>`).",
                             type: "string"
                         },
                         implementationCode: {
-                            description: "✅ Phase 4: Final implementation\n\nThe complete and fully correct TypeScript function implementation.\n\n- Passes strict type checking without errors.\n- Uses only safe branding or literal type assertions.\n- Converts all Date values properly to ISO string format.\n- Follows DTO structures using `satisfies`.\n- Avoids any weak typing such as `any`, `as any`, or `satisfies any`.\n- Uses only allowed imports (e.g., from `src/api/structures` and\n  `MyGlobal.prisma`).\n\n⚠️ Prohibited Practices:\n\n- Do NOT add or modify import statements manually. Imports are handled\n  automatically by the system.\n- Do NOT use `any`, `as any`, or `satisfies any` to bypass type checking.\n- Do NOT assign native `Date` objects directly; always convert them to ISO\n  strings with `.toISOString()`.\n- Do NOT use unsafe type assertions except for safe branding or literal\n  narrowing.\n- Do NOT write code outside the single async function structure (e.g., no\n  classes or multiple functions).\n- Do NOT perform any input validation — assume all inputs are already\n  validated.\n- Do NOT use dynamic import expressions (`import()`); all imports must be\n  static.\n- Do NOT rely on DTO types for database update input; always use\n  Prisma-generated input types.",
+                            description: "✅ Phase 4: Final implementation\n\nThe complete and fully correct TypeScript function implementation.\n\n- Passes strict type checking without errors.\n- Uses only safe branding or literal type assertions.\n- Converts all date values properly to ISO string format.\n- Follows DTO structures using `satisfies`.\n- Avoids any weak typing such as `any`, `as any`, or `satisfies any`.\n- Uses only allowed imports (e.g., from `src/api/structures` and\n  `MyGlobal.prisma`).\n\n⚠️ Prohibited Practices:\n\n- Do NOT add or modify import statements manually. Imports are handled\n  automatically by the system.\n- Do NOT use `any`, `as any`, or `satisfies any` to bypass type checking.\n- Do NOT assign native `Date` objects directly; always convert them to ISO\n  strings with `.toISOString()`.\n- Do NOT use unsafe type assertions except for safe branding or literal\n  narrowing.\n- Do NOT write code outside the single async function structure (e.g., no\n  classes or multiple functions).\n- Do NOT perform any input validation — assume all inputs are already\n  validated.\n- Do NOT use dynamic import expressions (`import()`); all imports must be\n  static.\n- Do NOT rely on DTO types for database update input; always use\n  Prisma-generated input types.",
                             type: "string"
                         }
                     },
-                    required: [ "filename", "plan", "review", "implementationCode" ]
+                    required: [ "filename", "plan", "draft_without_date_type", "review", "implementationCode" ]
                 }
             }
         },
         validate: (() => {
             const _io0 = input => "object" === typeof input.output && null !== input.output && _io1(input.output);
-            const _io1 = input => "string" === typeof input.filename && "string" === typeof input.plan && "string" === typeof input.review && (undefined === input.withCompilerFeedback || "string" === typeof input.withCompilerFeedback) && "string" === typeof input.implementationCode;
+            const _io1 = input => "string" === typeof input.filename && "string" === typeof input.plan && "string" === typeof input.draft_without_date_type && "string" === typeof input.review && (undefined === input.withCompilerFeedback || "string" === typeof input.withCompilerFeedback) && "string" === typeof input.implementationCode;
             const _vo0 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.output && null !== input.output || _report(_exceptionable, {
                 path: _path + ".output",
                 expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
@@ -6984,6 +7562,10 @@ const claude$4 = {
                 path: _path + ".plan",
                 expected: "string",
                 value: input.plan
+            }), "string" === typeof input.draft_without_date_type || _report(_exceptionable, {
+                path: _path + ".draft_without_date_type",
+                expected: "string",
+                value: input.draft_without_date_type
             }), "string" === typeof input.review || _report(_exceptionable, {
                 path: _path + ".review",
                 expected: "string",
@@ -7058,11 +7640,14 @@ const collection$4 = {
                         type: "object",
                         properties: {
                             filename: {
-                                description: 'The name of the file to be generated (e.g., "user.create.ts")',
                                 type: "string"
                             },
                             plan: {
-                                description: "🧠 Provider Function Implementation Plan\n\nThis field outlines the strategic plan for implementing the provider\nfunction according to the Realize Coder Agent specification. Before\nwriting the actual code, think through the logic and structure.\n\nThe plan must consider:\n\n- 🧩 Required business entities (e.g., users, posts, logs) and their\n  relationships\n- 🛠 Operations needed to fulfill the business scenario (e.g., fetch,\n  create, update)\n- 🔄 Data dependencies between steps (e.g., use userId to fetch related\n  data)\n- ✅ Validation points (based on business rules, not field presence)\n- 🚧 Error and edge cases that must be handled explicitly (e.g., missing\n  records)\n- 🏗 Structure: always a single `async function`, using only `parameters`\n  and `body`\n\n⚠️ Important Constraints:\n\n- Do NOT perform input validation — assume `parameters` and `body` are\n  already valid\n- Use `typia.random<T>()` with an explanatory comment if logic can't be\n  implemented\n- Never use `any` or make assumptions without sufficient context\n- Use only allowed imports — DTOs and Prisma types\n- Use `MyGlobal.prisma` for DB access and respect Prisma typing rules\n\n⚠️ TypeScript-specific considerations:\n\n- Do **not** use native `Date` objects directly; convert all dates with\n  `.toISOString()`\n- Use `string & tags.Format<'date-time'>` for all date/time typed fields\n- Prefer `satisfies` for DTO conformance instead of unsafe `as` casts\n- Avoid weak typing such as `any`, `as any`, or `satisfies any`\n- Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where\n  applicable\n\n✅ Example Structure:\n\n```ts\nexport async function doSomething(\n  user: { id: string & tags.Format<\"uuid\">; type: string },\n  parameters: IParams,\n  body: IBody\n): Promise<IReturn> {\n  const { id } = parameters;\n  const { name } = body;\n  const user = await MyGlobal.prisma.users.findFirst({ where: { id } });\n  if (!user) throw new Error(\"User not found\");\n  ...\n  return result;\n}\n```\n\n🔥 Error Handling Plan:\n\nIf an error is expected or encountered during implementation:\n\n- Clearly document the error message(s) and TypeScript error codes.\n- Analyze the root cause (e.g., type mismatch, missing field, nullability\n  issue).\n- Define concrete steps to resolve the issue, such as:\n\n  - Adjusting type declarations or using Prisma-generated input types.\n  - Using `?? undefined` to normalize nullable fields.\n  - Applying correct relation handling (e.g., `connect` instead of direct\n      foreign key assignment).\n  - Ensuring `Date` fields use `.toISOString()` and branded types.\n- Include fallback or workaround plans if a direct fix is complex.\n- If no error is present, simply omit this section.\n\nThis plan ensures the function will:\n\n- Respect the global architecture and coding conventions\n- Be safe, predictable, and aligned with upstream logic",
+                                description: "🧠 Provider Function Implementation Plan\n\nThis field outlines the strategic plan for implementing the provider\nfunction according to the Realize Coder Agent specification. Before\nwriting the actual code, think through the logic and structure.\n\nThe plan must consider:\n\n- 🧩 Required business entities (e.g., users, posts, logs) and their\n  relationships\n- 🛠 Operations needed to fulfill the business scenario (e.g., fetch,\n  create, update)\n- 🔄 Data dependencies between steps (e.g., use userId to fetch related\n  data)\n- ✅ Validation points (based on business rules, not field presence)\n- 🚧 Error and edge cases that must be handled explicitly (e.g., missing\n  records)\n- 🏗 Structure: always a single `async function`, using only `parameters`\n  and `body`\n\n⚠️ Important Constraints:\n\n- Do NOT perform input validation — assume `parameters` and `body` are\n  already valid\n- Use `typia.random<T>()` with an explanatory comment if logic can't be\n  implemented\n- Never use `any` or make assumptions without sufficient context\n- Use only allowed imports — DTOs and Prisma types\n- Use `MyGlobal.prisma` for DB access and respect Prisma typing rules\n\n⚠️ TypeScript-specific considerations:\n\n- Do **not** use native `Date` objects directly; always convert all dates\n  to ISO strings with `.toISOString()` and brand as `string &\n  tags.Format<'date-time'>`. This rule applies throughout all phases.\n- Prefer `satisfies` for DTO conformance instead of unsafe `as` casts\n- Avoid weak typing such as `any`, `as any`, or `satisfies any`\n- Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where\n  applicable\n\n✅ Example Structure:\n\n```ts\nexport async function doSomething(\n  user: { id: string & tags.Format<\"uuid\">; type: string },\n  parameters: IParams,\n  body: IBody\n): Promise<IReturn> {\n  const { id } = parameters;\n  const { name } = body;\n  const user = await MyGlobal.prisma.users.findFirst({ where: { id } });\n  if (!user) throw new Error(\"User not found\");\n  ...\n  return result;\n}\n```\n\n🔥 Error Handling Plan:\n\nIf an error is expected or encountered during implementation:\n\n- Clearly document the error message(s) and TypeScript error codes.\n- Analyze the root cause (e.g., type mismatch, missing field, nullability\n  issue).\n- Define concrete steps to resolve the issue, such as:\n\n  - Adjusting type declarations or using Prisma-generated input types.\n  - Using `?? undefined` to normalize nullable fields.\n  - Applying correct relation handling (e.g., `connect` instead of direct\n      foreign key assignment).\n  - Ensuring all date fields use `.toISOString()` and proper branding.\n- Include fallback or workaround plans if a direct fix is complex.\n- If no error is present, simply omit this section.\n\nThis plan ensures the function will:\n\n- Respect the global architecture and coding conventions\n- Be safe, predictable, and aligned with upstream logic",
+                                type: "string"
+                            },
+                            draft_without_date_type: {
+                                description: "✏️ Phase 1: Draft code\n\nThis is the initial drafting phase where you outline the basic skeleton\nof the function.\n\n- The function signature must correctly include `user`, `parameters`, and\n  `body` arguments.\n- Design the main flow of business logic, such as DB fetches and early\n  returns based on conditions.\n- Mark any incomplete or missing parts clearly with placeholders (e.g.,\n  comments or temporary values).\n\n⚠️ Import rules:\n\n- Do NOT add any new import statements manually.\n- All necessary imports are provided globally or by the system\n  automatically.\n- Writing import statements directly is prohibited and may cause compile\n  errors. If import errors occur, check your environment configuration.\n\n✅ Requirements:\n\n- Avoid using the `any` type at all costs to ensure type safety.\n- Do NOT assign native `Date` objects directly; always convert dates using\n  `.toISOString()` before assignment and apply proper branding.\n- Maintain a single-function structure; avoid using classes.",
                                 type: "string"
                             },
                             review: {
@@ -7070,21 +7655,21 @@ const collection$4 = {
                                 type: "string"
                             },
                             withCompilerFeedback: {
-                                description: "🛠 Phase 3: With compiler feedback (optional)\n\nA correction pass that applies fixes for compile-time errors that arose\nduring the review stage (if any).\n\n✅ Must:\n\n- Resolve all TypeScript errors without using `as any`\n- Provide safe brand casting only if required (e.g., `as string &\n  tags.Format<'uuid'>`)",
+                                description: "🛠 Phase 3: With compiler feedback (optional)\n\nA correction pass that applies fixes for compile-time errors that arose\nduring the review stage (if any).\n\n✅ Must:\n\n- Only include this field if TypeScript errors are detected in the Review\n  phase.\n- Resolve all TypeScript errors without using `as any`.\n- Provide safe brand casting only if required (e.g., `as string &\n  tags.Format<'uuid'>`).",
                                 type: "string"
                             },
                             implementationCode: {
-                                description: "✅ Phase 4: Final implementation\n\nThe complete and fully correct TypeScript function implementation.\n\n- Passes strict type checking without errors.\n- Uses only safe branding or literal type assertions.\n- Converts all Date values properly to ISO string format.\n- Follows DTO structures using `satisfies`.\n- Avoids any weak typing such as `any`, `as any`, or `satisfies any`.\n- Uses only allowed imports (e.g., from `src/api/structures` and\n  `MyGlobal.prisma`).\n\n⚠️ Prohibited Practices:\n\n- Do NOT add or modify import statements manually. Imports are handled\n  automatically by the system.\n- Do NOT use `any`, `as any`, or `satisfies any` to bypass type checking.\n- Do NOT assign native `Date` objects directly; always convert them to ISO\n  strings with `.toISOString()`.\n- Do NOT use unsafe type assertions except for safe branding or literal\n  narrowing.\n- Do NOT write code outside the single async function structure (e.g., no\n  classes or multiple functions).\n- Do NOT perform any input validation — assume all inputs are already\n  validated.\n- Do NOT use dynamic import expressions (`import()`); all imports must be\n  static.\n- Do NOT rely on DTO types for database update input; always use\n  Prisma-generated input types.",
+                                description: "✅ Phase 4: Final implementation\n\nThe complete and fully correct TypeScript function implementation.\n\n- Passes strict type checking without errors.\n- Uses only safe branding or literal type assertions.\n- Converts all date values properly to ISO string format.\n- Follows DTO structures using `satisfies`.\n- Avoids any weak typing such as `any`, `as any`, or `satisfies any`.\n- Uses only allowed imports (e.g., from `src/api/structures` and\n  `MyGlobal.prisma`).\n\n⚠️ Prohibited Practices:\n\n- Do NOT add or modify import statements manually. Imports are handled\n  automatically by the system.\n- Do NOT use `any`, `as any`, or `satisfies any` to bypass type checking.\n- Do NOT assign native `Date` objects directly; always convert them to ISO\n  strings with `.toISOString()`.\n- Do NOT use unsafe type assertions except for safe branding or literal\n  narrowing.\n- Do NOT write code outside the single async function structure (e.g., no\n  classes or multiple functions).\n- Do NOT perform any input validation — assume all inputs are already\n  validated.\n- Do NOT use dynamic import expressions (`import()`); all imports must be\n  static.\n- Do NOT rely on DTO types for database update input; always use\n  Prisma-generated input types.",
                                 type: "string"
                             }
                         },
-                        required: [ "filename", "plan", "review", "implementationCode" ]
+                        required: [ "filename", "plan", "draft_without_date_type", "review", "implementationCode" ]
                     }
                 }
             },
             validate: (() => {
                 const _io0 = input => "object" === typeof input.output && null !== input.output && _io1(input.output);
-                const _io1 = input => "string" === typeof input.filename && "string" === typeof input.plan && "string" === typeof input.review && (undefined === input.withCompilerFeedback || "string" === typeof input.withCompilerFeedback) && "string" === typeof input.implementationCode;
+                const _io1 = input => "string" === typeof input.filename && "string" === typeof input.plan && "string" === typeof input.draft_without_date_type && "string" === typeof input.review && (undefined === input.withCompilerFeedback || "string" === typeof input.withCompilerFeedback) && "string" === typeof input.implementationCode;
                 const _vo0 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.output && null !== input.output || _report(_exceptionable, {
                     path: _path + ".output",
                     expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
@@ -7102,6 +7687,10 @@ const collection$4 = {
                     path: _path + ".plan",
                     expected: "string",
                     value: input.plan
+                }), "string" === typeof input.draft_without_date_type || _report(_exceptionable, {
+                    path: _path + ".draft_without_date_type",
+                    expected: "string",
+                    value: input.draft_without_date_type
                 }), "string" === typeof input.review || _report(_exceptionable, {
                     path: _path + ".review",
                     expected: "string",
@@ -7168,7 +7757,7 @@ const orchestrateRealizePlanner = async (ctx, operation) => {
     };
 };
 
-async function writeCodeUntilCompilePassed(ctx, ops, retry = 5) {
+async function writeCodeUntilCompilePassed(ctx, ops, retry = 3) {
     const files = Object.entries(await ctx.files({
         dbms: "postgres"
     })).filter((([key]) => key.startsWith("src"))).reduce(((acc, [filename, content]) => Object.assign(acc, {
@@ -7182,8 +7771,14 @@ async function writeCodeUntilCompilePassed(ctx, ops, retry = 5) {
         current: [],
         total: []
     };
+    ops = ops.filter(((_el, i) => i < 10));
     for (let i = 0; i < retry; i++) {
-        const generatedCodes = await Promise.all(ops.filter((op => shouldProcessOperation(op, diagnostics.current))).map((op => process$1(ctx, op, diagnostics, entireCodes))));
+        const targets = ops.filter((op => shouldProcessOperation(op, diagnostics.current)));
+        const metadata = {
+            total: targets.length,
+            count: 0
+        };
+        const generatedCodes = await Promise.all(targets.map((op => process$1(ctx, metadata, op, diagnostics, entireCodes))));
         for (const c of generatedCodes) {
             if (c.type === "success") {
                 entireCodes[c.result.filename] = {
@@ -7209,7 +7804,7 @@ async function writeCodeUntilCompilePassed(ctx, ops, retry = 5) {
         } else if (compiled.type === "failure") {
             diagnostics.current = compiled.diagnostics;
             diagnostics.total = [ ...diagnostics.total, ...compiled.diagnostics ];
-            console.log(JSON.stringify(diagnostics, null, 2), i);
+            console.log(JSON.stringify(diagnostics.current, null, 2), `현재 에러의 수: ${diagnostics.current.length}\n`, `현재 시도 수: ${i}`);
         }
     }
     return Object.entries(entireCodes).map((([filename, {content}]) => ({
@@ -7232,13 +7827,26 @@ async function loadTemplateFiles(templateFiles) {
     return result;
 }
 
-async function process$1(ctx, op, diagnostics, entireCodes) {
-    const result = await pipe(op, (op => orchestrateRealizePlanner(ctx, op)), (p => {
+async function process$1(ctx, metadata, op, diagnostics, entireCodes) {
+    const result = await pipe(op, (op => orchestrateRealizePlanner(ctx, op)), (async p => {
         const filename = `src/providers/${p.functionName}.ts`;
         const t = diagnostics.total.filter((el => el.file === filename));
         const d = diagnostics.current.filter((el => el.file === filename));
         const c = entireCodes[filename]?.content ?? null;
-        return orchestrateRealizeCoder(ctx, op, p, c, t, d);
+        return orchestrateRealizeCoder(ctx, op, p, c, t, d).then((res => {
+            if (res === FAILED) ; else {
+                ctx.dispatch({
+                    type: "realizeProgress",
+                    filename: res.filename,
+                    content: res.implementationCode,
+                    completed: ++metadata.count,
+                    created_at: (new Date).toISOString(),
+                    step: ctx.state().analyze?.step ?? 0,
+                    total: metadata.total
+                });
+            }
+            return res;
+        }));
     }));
     if (result === FAILED) {
         return {
@@ -7271,6 +7879,13 @@ const orchestrateRealize = ctx => async props => {
     if (!ops) {
         throw new Error("Can't do realize agent because operations are nothing.");
     }
+    ctx.dispatch({
+        type: "realizeStart",
+        created_at: (new Date).toISOString(),
+        reason: props.reason,
+        step: ctx.state().test?.step ?? 0
+    });
+    await orchestrateRealizeDecorator(ctx);
     await writeCodeUntilCompilePassed(ctx, ops, 3);
     const now = (new Date).toISOString();
     ctx.dispatch({
@@ -7502,7 +8117,7 @@ const compile = async (ctx, func) => {
 };
 
 const predicate = async (ctx, content, event, life) => {
-    ctx.dispatch(event);
+    if (event.result.type === "failure") ctx.dispatch(event);
     return event.result.type === "failure" ? correct(ctx, content, event, life - 1) : event;
 };
 
@@ -9802,193 +10417,6 @@ const createAutoBeState = histories => {
     };
 };
 
-async function getAutoBeGenerated(ctx, histories, tokenUsage, options) {
-    const state = ctx.state();
-    const ret = {};
-    if (state.analyze === null) return {};
-    Object.assign(ret, Object.fromEntries(Object.entries(state.analyze.files).map((([key, value]) => [ `docs/analysis/${key.split("/").at(-1)}`, value ]))));
-    const compiler = await ctx.compiler();
-    if (state.prisma?.step === state.analyze.step) {
-        const schemaFiles = (options?.dbms ?? "postgres") === "postgres" ? state.prisma.schemas : await compiler.prisma.write(state.prisma.result.data, options.dbms);
-        Object.assign(ret, Object.fromEntries(Object.entries(schemaFiles).map((([key, value]) => [ `prisma/schema/${key.split("/").at(-1)}`, value ]))), {
-            "autobe/prisma.json": (() => {
-                const _so0 = input => `{"files":${`[${input.files.map((elem => _so1(elem))).join(",")}]`}}`;
-                const _so1 = input => `{"filename":${__typia_transform__jsonStringifyString._jsonStringifyString(input.filename)},"namespace":${__typia_transform__jsonStringifyString._jsonStringifyString(input.namespace)},"models":${`[${input.models.map((elem => _so2(elem))).join(",")}]`}}`;
-                const _so2 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"material":${input.material},"primaryField":${_so3(input.primaryField)},"foreignFields":${`[${input.foreignFields.map((elem => _so4(elem))).join(",")}]`},"plainFields":${`[${input.plainFields.map((elem => _so6(elem))).join(",")}]`},"uniqueIndexes":${`[${input.uniqueIndexes.map((elem => _so7(elem))).join(",")}]`},"plainIndexes":${`[${input.plainIndexes.map((elem => _so8(elem))).join(",")}]`},"ginIndexes":${`[${input.ginIndexes.map((elem => _so9(elem))).join(",")}]`}}`;
-                const _so3 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"type":${'"' + input.type + '"'},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)}}`;
-                const _so4 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"type":${'"' + input.type + '"'},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"relation":${_so5(input.relation)},"unique":${input.unique},"nullable":${input.nullable}}`;
-                const _so5 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"targetModel":${__typia_transform__jsonStringifyString._jsonStringifyString(input.targetModel)}}`;
-                const _so6 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"type":${'"' + input.type + '"'},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"nullable":${input.nullable}}`;
-                const _so7 = input => `{"fieldNames":${`[${input.fieldNames.map((elem => __typia_transform__jsonStringifyString._jsonStringifyString(elem))).join(",")}]`},"unique":${input.unique}}`;
-                const _so8 = input => `{"fieldNames":${`[${input.fieldNames.map((elem => __typia_transform__jsonStringifyString._jsonStringifyString(elem))).join(",")}]`}}`;
-                const _so9 = input => `{"fieldName":${__typia_transform__jsonStringifyString._jsonStringifyString(input.fieldName)}}`;
-                return input => _so0(input);
-            })()(state.prisma.result.data)
-        });
-        if (state.prisma.compiled.type === "success") ret["docs/ERD.md"] = state.prisma.compiled.document; else if (state.prisma.compiled.type === "failure") ret["prisma/compile-error-reason.log"] = state.prisma.compiled.reason;
-    }
-    if (state.interface?.step === state.analyze.step) {
-        const files = await compiler.interface.write(state.interface.document);
-        Object.assign(ret, state.test?.step === state.interface.step ? Object.fromEntries(Object.entries(files).filter((([key]) => key.startsWith("test/features/") === false))) : files, {
-            "autobe/document.json": (() => {
-                const _so0 = input => `{"operations":${`[${input.operations.map((elem => _so1(elem))).join(",")}]`},"components":${_so8(input.components)}}`;
-                const _so1 = input => `{"specification":${__typia_transform__jsonStringifyString._jsonStringifyString(input.specification)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"summary":${__typia_transform__jsonStringifyString._jsonStringifyString(input.summary)},"parameters":${`[${input.parameters.map((elem => _so2(elem))).join(",")}]`},"requestBody":${null !== input.requestBody ? _so6(input.requestBody) : "null"},"responseBody":${null !== input.responseBody ? _so7(input.responseBody) : "null"},"authorizationRoles":${null !== input.authorizationRoles ? `[${input.authorizationRoles.map((elem => __typia_transform__jsonStringifyString._jsonStringifyString(elem))).join(",")}]` : "null"},"path":${__typia_transform__jsonStringifyString._jsonStringifyString(input.path)},"method":${'"' + input.method + '"'}}`;
-                const _so2 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"schema":${_su0(input.schema)}}`;
-                const _so3 = input => `{${undefined === input.minimum ? "" : `"minimum":${undefined !== input.minimum ? input.minimum : undefined},`}${undefined === input.maximum ? "" : `"maximum":${undefined !== input.maximum ? input.maximum : undefined},`}${undefined === input.exclusiveMinimum ? "" : `"exclusiveMinimum":${undefined !== input.exclusiveMinimum ? input.exclusiveMinimum : undefined},`}${undefined === input.exclusiveMaximum ? "" : `"exclusiveMaximum":${undefined !== input.exclusiveMaximum ? input.exclusiveMaximum : undefined},`}${undefined === input.multipleOf ? "" : `"multipleOf":${undefined !== input.multipleOf ? input.multipleOf : undefined},`}"type":${'"' + input.type + '"'}}`;
-                const _so4 = input => `{${undefined === input.minimum ? "" : `"minimum":${undefined !== input.minimum ? input.minimum : undefined},`}${undefined === input.maximum ? "" : `"maximum":${undefined !== input.maximum ? input.maximum : undefined},`}${undefined === input.exclusiveMinimum ? "" : `"exclusiveMinimum":${undefined !== input.exclusiveMinimum ? input.exclusiveMinimum : undefined},`}${undefined === input.exclusiveMaximum ? "" : `"exclusiveMaximum":${undefined !== input.exclusiveMaximum ? input.exclusiveMaximum : undefined},`}${undefined === input.multipleOf ? "" : `"multipleOf":${undefined !== input.multipleOf ? input.multipleOf : undefined},`}"type":${'"' + input.type + '"'}}`;
-                const _so5 = input => `{${undefined === input.format ? "" : `"format":${undefined !== input.format ? __typia_transform__jsonStringifyString._jsonStringifyString(input.format) : undefined},`}${undefined === input.pattern ? "" : `"pattern":${undefined !== input.pattern ? __typia_transform__jsonStringifyString._jsonStringifyString(input.pattern) : undefined},`}${undefined === input.contentMediaType ? "" : `"contentMediaType":${undefined !== input.contentMediaType ? __typia_transform__jsonStringifyString._jsonStringifyString(input.contentMediaType) : undefined},`}${undefined === input.minLength ? "" : `"minLength":${undefined !== input.minLength ? input.minLength : undefined},`}${undefined === input.maxLength ? "" : `"maxLength":${undefined !== input.maxLength ? input.maxLength : undefined},`}"type":${'"' + input.type + '"'}}`;
-                const _so6 = input => `{"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"typeName":${__typia_transform__jsonStringifyString._jsonStringifyString(input.typeName)}}`;
-                const _so7 = input => `{"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"typeName":${__typia_transform__jsonStringifyString._jsonStringifyString(input.typeName)}}`;
-                const _so8 = input => `{${undefined === input.authorization ? "" : `"authorization":${undefined !== input.authorization ? `[${input.authorization.map((elem => _so11(elem))).join(",")}]` : undefined},`}"schemas":${_so9(input.schemas)}}`;
-                const _so9 = input => `{${Object.entries(input).map((([key, value]) => {
-                    if (undefined === value) return "";
-                    return `${JSON.stringify(key)}:${_so10(value)}`;
-                })).filter((str => "" !== str)).join(",")}}`;
-                const _so10 = input => `{"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)}}`;
-                const _so11 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)}}`;
-                const _su0 = input => (() => {
-                    if ("number" === input.type) return _so4(input); else if ("integer" === input.type) return _so3(input); else if ("string" === input.type) return _so5(input); else __typia_transform__throwTypeGuardError._throwTypeGuardError({
-                        method: "typia.json.stringify",
-                        expected: "(AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.IString)",
-                        value: input
-                    });
-                })();
-                return input => _so0(input);
-            })()(state.interface.document)
-        });
-    }
-    if (state.test?.step === state.analyze.step) Object.assign(ret, Object.fromEntries(state.test.files.map((f => [ f.location, f.content ]))), await compiler.test.getTemplate());
-    if (state.realize?.step === state.analyze.step) Object.assign(ret, state.realize.files, await compiler.realize.getTemplate());
-    Object.assign(ret, {
-        "autobe/histories.json": (() => {
-            const _so0 = input => `{"reason":${__typia_transform__jsonStringifyString._jsonStringifyString(input.reason)},"step":${input.step},"prefix":${__typia_transform__jsonStringifyString._jsonStringifyString(input.prefix)},"files":${_so1(input.files)},"completed_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.completed_at)},"roles":${`[${input.roles.map((elem => _so2(elem))).join(",")}]`},"id":${__typia_transform__jsonStringifyString._jsonStringifyString(input.id)},"type":${'"' + input.type + '"'},"created_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.created_at)}}`;
-            const _so1 = input => `{${Object.entries(input).map((([key, value]) => {
-                if (undefined === value) return "";
-                return `${JSON.stringify(key)}:${__typia_transform__jsonStringifyString._jsonStringifyString(value)}`;
-            })).filter((str => "" !== str)).join(",")}}`;
-            const _so2 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)}}`;
-            const _so3 = input => `{"text":${__typia_transform__jsonStringifyString._jsonStringifyString(input.text)},"completed_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.completed_at)},"id":${__typia_transform__jsonStringifyString._jsonStringifyString(input.id)},"type":${'"' + input.type + '"'},"created_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.created_at)}}`;
-            const _so4 = input => `{"document":${_so5(input.document)},"reason":${__typia_transform__jsonStringifyString._jsonStringifyString(input.reason)},"step":${input.step},"completed_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.completed_at)},"id":${__typia_transform__jsonStringifyString._jsonStringifyString(input.id)},"type":${'"' + input.type + '"'},"created_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.created_at)}}`;
-            const _so5 = input => `{"operations":${`[${input.operations.map((elem => _so6(elem))).join(",")}]`},"components":${_so13(input.components)}}`;
-            const _so6 = input => `{"specification":${__typia_transform__jsonStringifyString._jsonStringifyString(input.specification)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"summary":${__typia_transform__jsonStringifyString._jsonStringifyString(input.summary)},"parameters":${`[${input.parameters.map((elem => _so7(elem))).join(",")}]`},"requestBody":${null !== input.requestBody ? _so11(input.requestBody) : "null"},"responseBody":${null !== input.responseBody ? _so12(input.responseBody) : "null"},"authorizationRoles":${null !== input.authorizationRoles ? `[${input.authorizationRoles.map((elem => __typia_transform__jsonStringifyString._jsonStringifyString(elem))).join(",")}]` : "null"},"path":${__typia_transform__jsonStringifyString._jsonStringifyString(input.path)},"method":${'"' + input.method + '"'}}`;
-            const _so7 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"schema":${_su2(input.schema)}}`;
-            const _so8 = input => `{${undefined === input.minimum ? "" : `"minimum":${undefined !== input.minimum ? input.minimum : undefined},`}${undefined === input.maximum ? "" : `"maximum":${undefined !== input.maximum ? input.maximum : undefined},`}${undefined === input.exclusiveMinimum ? "" : `"exclusiveMinimum":${undefined !== input.exclusiveMinimum ? input.exclusiveMinimum : undefined},`}${undefined === input.exclusiveMaximum ? "" : `"exclusiveMaximum":${undefined !== input.exclusiveMaximum ? input.exclusiveMaximum : undefined},`}${undefined === input.multipleOf ? "" : `"multipleOf":${undefined !== input.multipleOf ? input.multipleOf : undefined},`}"type":${'"' + input.type + '"'}}`;
-            const _so9 = input => `{${undefined === input.minimum ? "" : `"minimum":${undefined !== input.minimum ? input.minimum : undefined},`}${undefined === input.maximum ? "" : `"maximum":${undefined !== input.maximum ? input.maximum : undefined},`}${undefined === input.exclusiveMinimum ? "" : `"exclusiveMinimum":${undefined !== input.exclusiveMinimum ? input.exclusiveMinimum : undefined},`}${undefined === input.exclusiveMaximum ? "" : `"exclusiveMaximum":${undefined !== input.exclusiveMaximum ? input.exclusiveMaximum : undefined},`}${undefined === input.multipleOf ? "" : `"multipleOf":${undefined !== input.multipleOf ? input.multipleOf : undefined},`}"type":${'"' + input.type + '"'}}`;
-            const _so10 = input => `{${undefined === input.format ? "" : `"format":${undefined !== input.format ? __typia_transform__jsonStringifyString._jsonStringifyString(input.format) : undefined},`}${undefined === input.pattern ? "" : `"pattern":${undefined !== input.pattern ? __typia_transform__jsonStringifyString._jsonStringifyString(input.pattern) : undefined},`}${undefined === input.contentMediaType ? "" : `"contentMediaType":${undefined !== input.contentMediaType ? __typia_transform__jsonStringifyString._jsonStringifyString(input.contentMediaType) : undefined},`}${undefined === input.minLength ? "" : `"minLength":${undefined !== input.minLength ? input.minLength : undefined},`}${undefined === input.maxLength ? "" : `"maxLength":${undefined !== input.maxLength ? input.maxLength : undefined},`}"type":${'"' + input.type + '"'}}`;
-            const _so11 = input => `{"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"typeName":${__typia_transform__jsonStringifyString._jsonStringifyString(input.typeName)}}`;
-            const _so12 = input => `{"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"typeName":${__typia_transform__jsonStringifyString._jsonStringifyString(input.typeName)}}`;
-            const _so13 = input => `{${undefined === input.authorization ? "" : `"authorization":${undefined !== input.authorization ? `[${input.authorization.map((elem => _so16(elem))).join(",")}]` : undefined},`}"schemas":${_so14(input.schemas)}}`;
-            const _so14 = input => `{${Object.entries(input).map((([key, value]) => {
-                if (undefined === value) return "";
-                return `${JSON.stringify(key)}:${_so15(value)}`;
-            })).filter((str => "" !== str)).join(",")}}`;
-            const _so15 = input => `{"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)}}`;
-            const _so16 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)}}`;
-            const _so17 = input => `{"result":${_su3(input.result)},"schemas":${_so1(input.schemas)},"compiled":${_su4(input.compiled)},"reason":${__typia_transform__jsonStringifyString._jsonStringifyString(input.reason)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"step":${input.step},"completed_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.completed_at)},"id":${__typia_transform__jsonStringifyString._jsonStringifyString(input.id)},"type":${'"' + input.type + '"'},"created_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.created_at)}}`;
-            const _so18 = input => `{"success":${input.success},"data":${_so19(input.data)}}`;
-            const _so19 = input => `{"files":${`[${input.files.map((elem => _so20(elem))).join(",")}]`}}`;
-            const _so20 = input => `{"filename":${__typia_transform__jsonStringifyString._jsonStringifyString(input.filename)},"namespace":${__typia_transform__jsonStringifyString._jsonStringifyString(input.namespace)},"models":${`[${input.models.map((elem => _so21(elem))).join(",")}]`}}`;
-            const _so21 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"material":${input.material},"primaryField":${_so22(input.primaryField)},"foreignFields":${`[${input.foreignFields.map((elem => _so23(elem))).join(",")}]`},"plainFields":${`[${input.plainFields.map((elem => _so25(elem))).join(",")}]`},"uniqueIndexes":${`[${input.uniqueIndexes.map((elem => _so26(elem))).join(",")}]`},"plainIndexes":${`[${input.plainIndexes.map((elem => _so27(elem))).join(",")}]`},"ginIndexes":${`[${input.ginIndexes.map((elem => _so28(elem))).join(",")}]`}}`;
-            const _so22 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"type":${'"' + input.type + '"'},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)}}`;
-            const _so23 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"type":${'"' + input.type + '"'},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"relation":${_so24(input.relation)},"unique":${input.unique},"nullable":${input.nullable}}`;
-            const _so24 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"targetModel":${__typia_transform__jsonStringifyString._jsonStringifyString(input.targetModel)}}`;
-            const _so25 = input => `{"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"type":${'"' + input.type + '"'},"description":${__typia_transform__jsonStringifyString._jsonStringifyString(input.description)},"nullable":${input.nullable}}`;
-            const _so26 = input => `{"fieldNames":${`[${input.fieldNames.map((elem => __typia_transform__jsonStringifyString._jsonStringifyString(elem))).join(",")}]`},"unique":${input.unique}}`;
-            const _so27 = input => `{"fieldNames":${`[${input.fieldNames.map((elem => __typia_transform__jsonStringifyString._jsonStringifyString(elem))).join(",")}]`}}`;
-            const _so28 = input => `{"fieldName":${__typia_transform__jsonStringifyString._jsonStringifyString(input.fieldName)}}`;
-            const _so29 = input => `{"success":${input.success},"data":${_so19(input.data)},"errors":${`[${input.errors.map((elem => _so30(elem))).join(",")}]`}}`;
-            const _so30 = input => `{"path":${__typia_transform__jsonStringifyString._jsonStringifyString(input.path)},"table":${null !== input.table ? __typia_transform__jsonStringifyString._jsonStringifyString(input.table) : "null"},"field":${null !== input.field ? __typia_transform__jsonStringifyString._jsonStringifyString(input.field) : "null"},"message":${__typia_transform__jsonStringifyString._jsonStringifyString(input.message)}}`;
-            const _so31 = input => `{"type":${'"' + input.type + '"'},"document":${__typia_transform__jsonStringifyString._jsonStringifyString(input.document)},"diagrams":${_so1(input.diagrams)},"schemas":${_so1(input.schemas)},"nodeModules":${_so1(input.nodeModules)}}`;
-            const _so32 = input => `{"type":${'"' + input.type + '"'},"reason":${__typia_transform__jsonStringifyString._jsonStringifyString(input.reason)}}`;
-            const _so33 = input => `{${undefined === input.error || "function" === typeof input.error ? "" : `"error":${undefined !== input.error ? JSON.stringify(input.error) : undefined},`}"type":${'"' + input.type + '"'}}`;
-            const _so34 = input => `{"files":${_so1(input.files)},"compiled":${_su5(input.compiled)},"reason":${__typia_transform__jsonStringifyString._jsonStringifyString(input.reason)},"step":${input.step},"completed_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.completed_at)},"id":${__typia_transform__jsonStringifyString._jsonStringifyString(input.id)},"type":${'"' + input.type + '"'},"created_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.created_at)}}`;
-            const _so35 = input => `{"type":${'"' + input.type + '"'}}`;
-            const _so36 = input => `{"type":${'"' + input.type + '"'},"diagnostics":${`[${input.diagnostics.map((elem => _so37(elem))).join(",")}]`}}`;
-            const _so37 = input => `{${undefined === input.start ? "" : `"start":${undefined !== input.start ? input.start : undefined},`}${undefined === input.length ? "" : `"length":${undefined !== input.length ? input.length : undefined},`}"file":${null !== input.file ? __typia_transform__jsonStringifyString._jsonStringifyString(input.file) : "null"},"category":${'"' + input.category + '"'},"code":${(() => {
-                if ("string" === typeof input.code) return __typia_transform__jsonStringifyString._jsonStringifyString(input.code);
-                if ("number" === typeof input.code) return input.code;
-                __typia_transform__throwTypeGuardError._throwTypeGuardError({
-                    method: "typia.json.stringify",
-                    expected: "(number | string)",
-                    value: input.code
-                });
-            })()},"messageText":${__typia_transform__jsonStringifyString._jsonStringifyString(input.messageText)}}`;
-            const _so38 = input => `{${undefined === input.error || "function" === typeof input.error ? "" : `"error":${undefined !== input.error ? JSON.stringify(input.error) : undefined},`}"type":${'"' + input.type + '"'}}`;
-            const _so39 = input => `{"files":${`[${input.files.map((elem => _so40(elem))).join(",")}]`},"compiled":${_su5(input.compiled)},"reason":${__typia_transform__jsonStringifyString._jsonStringifyString(input.reason)},"step":${input.step},"completed_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.completed_at)},"id":${__typia_transform__jsonStringifyString._jsonStringifyString(input.id)},"type":${'"' + input.type + '"'},"created_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.created_at)}}`;
-            const _so40 = input => `{"location":${__typia_transform__jsonStringifyString._jsonStringifyString(input.location)},"content":${__typia_transform__jsonStringifyString._jsonStringifyString(input.content)},"scenario":${_so41(input.scenario)}}`;
-            const _so41 = input => `{"endpoint":${_so42(input.endpoint)},"draft":${__typia_transform__jsonStringifyString._jsonStringifyString(input.draft)},"functionName":${__typia_transform__jsonStringifyString._jsonStringifyString(input.functionName)},"dependencies":${`[${input.dependencies.map((elem => _so43(elem))).join(",")}]`}}`;
-            const _so42 = input => `{"path":${__typia_transform__jsonStringifyString._jsonStringifyString(input.path)},"method":${'"' + input.method + '"'}}`;
-            const _so43 = input => `{"purpose":${__typia_transform__jsonStringifyString._jsonStringifyString(input.purpose)},"endpoint":${_so42(input.endpoint)}}`;
-            const _so44 = input => `{"contents":${`[${input.contents.map((elem => _su1(elem))).join(",")}]`},"id":${__typia_transform__jsonStringifyString._jsonStringifyString(input.id)},"type":${'"' + input.type + '"'},"created_at":${__typia_transform__jsonStringifyString._jsonStringifyString(input.created_at)}}`;
-            const _so45 = input => `{"data":${__typia_transform__jsonStringifyString._jsonStringifyString(input.data)},"format":${'"' + input.format + '"'},"type":${'"' + input.type + '"'}}`;
-            const _so46 = input => `{"file":${_su6(input.file)},"type":${'"' + input.type + '"'}}`;
-            const _so47 = input => `{"type":${'"' + input.type + '"'},"id":${__typia_transform__jsonStringifyString._jsonStringifyString(input.id)}}`;
-            const _so48 = input => `{"type":${'"' + input.type + '"'},"name":${__typia_transform__jsonStringifyString._jsonStringifyString(input.name)},"data":${__typia_transform__jsonStringifyString._jsonStringifyString(input.data)}}`;
-            const _so49 = input => `{${undefined === input.detail ? "" : `"detail":${undefined !== input.detail ? '"' + input.detail + '"' : undefined},`}"url":${__typia_transform__jsonStringifyString._jsonStringifyString(input.url)},"type":${'"' + input.type + '"'}}`;
-            const _so50 = input => `{"text":${__typia_transform__jsonStringifyString._jsonStringifyString(input.text)},"type":${'"' + input.type + '"'}}`;
-            const _su0 = input => (() => {
-                if ("analyze" === input.type) return _so0(input); else if ("assistantMessage" === input.type) return _so3(input); else if ("interface" === input.type) return _so4(input); else if ("prisma" === input.type) return _so17(input); else if ("test" === input.type) return _so39(input); else if ("realize" === input.type) return _so34(input); else if ("userMessage" === input.type) return _so44(input); else __typia_transform__throwTypeGuardError._throwTypeGuardError({
-                    method: "typia.json.stringify",
-                    expected: "(AutoBeAnalyzeHistory | AutoBeAssistantMessageHistory | AutoBeInterfaceHistory | AutoBePrismaHistory | AutoBeTestHistory | AutoBeRealizeHistory | AutoBeUserMessageHistory)",
-                    value: input
-                });
-            })();
-            const _su1 = input => (() => {
-                if (undefined !== input.format) return _so45(input); else if ("file" === input.type) return _so46(input); else if ("image" === input.type) return _so49(input); else if ("text" === input.type) return _so50(input); else __typia_transform__throwTypeGuardError._throwTypeGuardError({
-                    method: "typia.json.stringify",
-                    expected: "(AutoBeUserMessageAudioContent | AutoBeUserMessageFileContent | AutoBeUserMessageImageContent | AutoBeUserMessageTextContent)",
-                    value: input
-                });
-            })();
-            const _su2 = input => (() => {
-                if ("number" === input.type) return _so9(input); else if ("integer" === input.type) return _so8(input); else if ("string" === input.type) return _so10(input); else __typia_transform__throwTypeGuardError._throwTypeGuardError({
-                    method: "typia.json.stringify",
-                    expected: "(AutoBeOpenApi.IJsonSchema.INumber | AutoBeOpenApi.IJsonSchema.IInteger | AutoBeOpenApi.IJsonSchema.IString)",
-                    value: input
-                });
-            })();
-            const _su3 = input => (() => {
-                if (true === input.success) return _so18(input); else if (false === input.success) return _so29(input); else __typia_transform__throwTypeGuardError._throwTypeGuardError({
-                    method: "typia.json.stringify",
-                    expected: "(IAutoBePrismaValidation.ISuccess | IAutoBePrismaValidation.IFailure)",
-                    value: input
-                });
-            })();
-            const _su4 = input => (() => {
-                if ("success" === input.type) return _so31(input); else if ("failure" === input.type) return _so32(input); else if ("exception" === input.type) return _so33(input); else __typia_transform__throwTypeGuardError._throwTypeGuardError({
-                    method: "typia.json.stringify",
-                    expected: "(IAutoBePrismaCompileResult.ISuccess | IAutoBePrismaCompileResult.IFailure | IAutoBePrismaCompileResult.IException)",
-                    value: input
-                });
-            })();
-            const _su5 = input => (() => {
-                if ("success" === input.type) return _so35(input); else if ("failure" === input.type) return _so36(input); else if ("exception" === input.type) return _so38(input); else __typia_transform__throwTypeGuardError._throwTypeGuardError({
-                    method: "typia.json.stringify",
-                    expected: "(IAutoBeTypeScriptCompileResult.ISuccess | IAutoBeTypeScriptCompileResult.IFailure | IAutoBeTypeScriptCompileResult.IException)",
-                    value: input
-                });
-            })();
-            const _su6 = input => (() => {
-                if ("reference" === input.type) return _so47(input); else if ("data" === input.type) return _so48(input); else __typia_transform__throwTypeGuardError._throwTypeGuardError({
-                    method: "typia.json.stringify",
-                    expected: "(AutoBeUserMessageFileContent.IReference | AutoBeUserMessageFileContent.IData)",
-                    value: input
-                });
-            })();
-            return input => `[${input.map((elem => _su0(elem))).join(",")}]`;
-        })()(histories),
-        "autobe/tokenUsage.json": (() => {
-            const _so9 = input => `{"facade":${_so10(input.facade)},"analyze":${_so10(input.analyze)},"prisma":${_so10(input.prisma)},"interface":${_so10(input.interface)},"test":${_so10(input.test)},"realize":${_so10(input.realize)}}`;
-            const _so10 = input => `{"aggregate":${_so11(input.aggregate)},"initialize":${_so11(input.initialize)},"select":${_so11(input.select)},"cancel":${_so11(input.cancel)},"call":${_so11(input.call)},"describe":${_so11(input.describe)}}`;
-            const _so11 = input => `{"total":${input.total},"input":${_so12(input.input)},"output":${_so13(input.output)}}`;
-            const _so12 = input => `{"total":${input.total},"cached":${input.cached}}`;
-            const _so13 = input => `{"total":${input.total},"reasoning":${input.reasoning},"accepted_prediction":${input.accepted_prediction},"rejected_prediction":${input.rejected_prediction}}`;
-            return input => _so9(input.toJSON());
-        })()(tokenUsage)
-    });
-    return ret;
-}
-
 function transformFacadeStateMessage(state) {
     const currentState = getCurrentState(state);
     return "# AutoBE Main Agent System Prompt\n\nYou are the AutoBE Main Agent, an orchestrator for backend server development automation. Your role is to manage the conversation with users about their backend requirements and coordinate the execution of five specialized functional agents through function calling.\n\n## Core Responsibilities\n\n1. **Requirements Gathering**: Engage in detailed conversations with users to understand their backend server needs, asking clarifying questions about business logic, data models, API endpoints, and technical requirements.\n\n2. **Agent Orchestration**: Execute the appropriate functional agents in the correct sequence based on the development stage and user needs.\n\n3. **Progress Communication**: Keep users informed about the current development stage, what has been completed, and what steps remain.\n\n## Functional Agents Overview\n\nYou have access to five functional agents that must be executed in a specific order:\n\n1. **Analyze Agent** - Converts conversations into structured requirements specifications\n2. **Prisma Agent** - Generates database schemas and ERD documentation\n3. **Interface Agent** - Creates API interfaces with OpenAPI schemas and TypeScript code\n4. **Test Agent** - Generates comprehensive E2E test suites\n5. **Realize Agent** - Implements actual business logic for service providers\n\n## Execution Rules\n\n### 1. Sequential Dependencies\n\n- **analyze()**: Can only be called when sufficient requirements have been gathered.\n- **prisma()**: Requires successful completion of analyze()\n- **interface()**: Requires successful completion of prisma()\n- **test()**: Requires successful completion of interface()\n- **realize()**: Requires successful completion of interface()\n\n### 2. Requirements Gathering and analyze() Calling Criteria\n\n- Since users are not developers, it is okay if they do not understand technical terms like “endpoints” or “data models.”  \n\n- Your job is to help users clearly express their intended **features** by asking many questions.  \n\n- Use examples and simple questions to guide them if they have trouble explaining.  \n\n- Break down features into smaller steps if needed to complete the planning gradually.  \n\n- For instance, ask questions like “What tasks do you want to automate?”, “What roles do users have?”, “What screens or actions are involved?”  \n\n- Even if the system requires many or complex APIs, it is not necessary to know all of them upfront. Focus on gathering core requirements step by step.  \n\n#### Conditions for Calling analyze()  \n- Call analyze() only when the user has clearly stated sufficient **features** and **requirements**, or  \n- The user explicitly delegates the planning to you by saying things like “I’ll leave the planning to you” or “Please proceed as you see fit.”  \n\n#### Pre-call Checks  \n- If requirements are insufficient for some features, do **not** call analyze() and keep asking questions until the specifications are complete.  \n- Continue asking actively and explain any technical terms in an easy-to-understand way.\n\n### 3. Requirements Gathering Phase\n\nBefore calling analyze(), ensure you have discussed:\n\n- System purpose and overall goals\n- Core features and functionalities\n- User roles and permissions\n- Main data entities and their relationships\n- Key business rules and constraints\n- API endpoints needed\n- Any specific technical requirements\n\nIf these aspects are unclear, continue the conversation to gather more details.\n\n### 4. Development Workflow\n\n1. Start by understanding the user's needs through conversation\n2. When requirements are sufficiently detailed, execute analyze()\n3. Review the analysis results with the user\n4. If approved, proceed with prisma() → interface() → test() → realize()\n5. At each stage, present results and get user confirmation before proceeding\n\n### 5. Handling Changes\n\n- If users request changes after agents have been executed, first understand the scope\n- For minor adjustments, you may re-run specific agents\n- For major changes, consider re-running analyze() to update the specification\n- Always explain the impact of changes on already generated code\n\n## Communication Guidelines\n\n1. **Be Transparent**: Clearly explain which agent is being executed and why\n2. **Show Progress**: Indicate completed steps and remaining work\n3. **Confirm Understanding**: Summarize requirements before executing agents\n4. **Request Approval**: Get user confirmation before moving to the next stage\n5. **Explain Results**: Briefly describe what each agent has generated\n\n## Current State\n\n{% STATE %}".replace("{% STATE %}", StringUtil.trim`
@@ -10027,22 +10455,15 @@ function getCurrentState(state) {
     };
 }
 
-function emplaceMap(dict, key, generator) {
-    const oldbie = dict.get(key);
-    if (oldbie !== undefined) {
-        return oldbie;
-    }
-    const value = generator();
-    dict.set(key, value);
-    return value;
-}
-
-class AutoBeAgent {
+class AutoBeAgent extends AutoBeAgentBase {
     constructor(props) {
+        super({
+            compiler: () => this.context_.compiler(),
+            state: () => this.state_
+        });
         this.props_ = props;
         this.histories_ = props.histories?.slice() ?? [];
         this.state_ = createAutoBeState(this.histories_);
-        this.listeners_ = new Map;
         this.usage_ = props.tokenUsage instanceof AutoBeTokenUsage ? props.tokenUsage : new AutoBeTokenUsage(props.tokenUsage);
         const vendor = {
             ...props.vendor,
@@ -10138,9 +10559,6 @@ class AutoBeAgent {
         await this.agentica_.conversate(content);
         return this.histories_.slice(index);
     }
-    async getFiles(options) {
-        return getAutoBeGenerated(await this.getContext(), this.histories_, this.usage_, options);
-    }
     getHistories() {
         return this.histories_;
     }
@@ -10150,26 +10568,6 @@ class AutoBeAgent {
     getContext() {
         return this.context_;
     }
-    on(type, listener) {
-        emplaceMap(this.listeners_, type, (() => new Set)).add(listener);
-        return this;
-    }
-    off(type, listener) {
-        const set = this.listeners_.get(type);
-        if (set === undefined) return this;
-        set.delete(listener);
-        if (set.size === 0) this.listeners_.delete(type);
-        return this;
-    }
-    async dispatch(event) {
-        const set = this.listeners_.get(event.type);
-        if (set === undefined) return;
-        await Promise.all(Array.from(set).map((async listener => {
-            try {
-                await listener(event);
-            } catch {}
-        })));
-    }
 }
 
 var index$1 = Object.freeze({
@@ -10186,5 +10584,97 @@ var index = Object.freeze({
     test: orchestrateTest
 });
 
-export { AutoBeAgent, AutoBeTokenUsage, index$1 as factory, index as orchestrate };
+class AutoBeMockAgent extends AutoBeAgentBase {
+    constructor(props) {
+        super({
+            compiler: () => this.compiler_.get(),
+            state: () => createAutoBeState(this.histories_)
+        });
+        this.props_ = props;
+        this.histories_ = [];
+        this.compiler_ = new Singleton((async () => props.compiler({
+            realize: {
+                test: {
+                    onOperation: async () => {},
+                    onReset: async () => {}
+                }
+            }
+        })));
+        this.token_usage_ = new AutoBeTokenUsage;
+    }
+    async conversate(content) {
+        const userMessage = {
+            id: v4(),
+            type: "userMessage",
+            contents: typeof content === "string" ? [ {
+                type: "text",
+                text: content
+            } ] : Array.isArray(content) ? content : [ content ],
+            created_at: (new Date).toISOString()
+        };
+        void this.dispatch(userMessage).catch((() => {}));
+        const state = createAutoBeState(this.histories_);
+        if (state.test !== null) {
+            await sleep_for(2e3);
+            const assistantMessage = {
+                id: v4(),
+                type: "assistantMessage",
+                text: [ "You've reached to the test agent.", "", "The realize agent would be developed until 2025-08-31.", "", "Thanks for using AutoBE!" ].join("\n"),
+                created_at: (new Date).toISOString(),
+                completed_at: (new Date).toISOString()
+            };
+            void this.dispatch(assistantMessage).catch((() => {}));
+            this.histories_.push(userMessage, assistantMessage);
+            return this.histories_;
+        }
+        const take = async type => {
+            for (const s of this.getEventSnapshots(type)) {
+                await sleep_for(sleepMap[s.event.type] ?? 500);
+                void this.dispatch(s.event).catch((() => {}));
+                this.token_usage_ = new AutoBeTokenUsage(s.tokenUsage);
+            }
+            this.histories_.push(userMessage);
+            this.histories_.push(this.props_.preset.histories.find((h => h.type === type)));
+        };
+        if (state.analyze === null) await take("analyze"); else if (state.prisma === null) await take("prisma"); else if (state.interface === null) await take("interface"); else if (state.test === null) await take("test");
+        return this.histories_;
+    }
+    getHistories() {
+        return this.histories_;
+    }
+    getTokenUsage() {
+        return this.token_usage_;
+    }
+    getEventSnapshots(state) {
+        return this.props_.preset[state];
+    }
+}
+
+const sleepMap = {
+    analyzeStart: 1e3,
+    analyzeWrite: 500,
+    analyzeReview: 300,
+    analyzeComplete: 1e3,
+    prismaStart: 1e3,
+    prismaComponents: 1e3,
+    prismaSchemas: 500,
+    prismaValidate: 2e3,
+    prismaCorrect: 500,
+    prismaInsufficient: 1e3,
+    prismaComplete: 1e3,
+    interfaceStart: 1e3,
+    interfaceEndpoints: 1e3,
+    interfaceOperations: 400,
+    interfaceComponents: 400,
+    interfaceComplement: 2e3,
+    interfaceComplete: 1e3,
+    testStart: 1e3,
+    testScenario: 1e3,
+    testWrite: 40,
+    testValidate: 100,
+    testCorrect: 100,
+    testComplete: 1e3
+};
+
+export { AutoBeAgent, AutoBeMockAgent, AutoBeTokenUsage, index$1 as factory, index as orchestrate };
 //# sourceMappingURL=index.mjs.map