@specverse/engines 4.1.14 → 4.1.16

package/libs/instance-factories/services/templates/prisma/ai-behaviors-generator.ts

@@ -19,6 +19,74 @@
 
 import type { TemplateContext } from '@specverse/types';
 import { matchStep, type StepContext } from './step-conventions.js';
+import { createHash } from 'crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Validate generated TypeScript using esbuild's transform.
+ * Returns null if valid, or an error message describing the problem.
+ *
+ * This catches syntax errors (unbalanced braces, unclosed strings, etc.)
+ * but not type errors — those need full tsc which requires the project
+ * context. That's a separate validation step run by the realize pipeline.
+ */
+async function validateTypeScript(code: string): Promise<string | null> {
+  try {
+    const esbuild = await import('esbuild');
+    await esbuild.transform(code, {
+      loader: 'ts',
+      format: 'esm',
+      target: 'es2022',
+    });
+    return null;
+  } catch (err: any) {
+    const msg = err?.errors?.[0]?.text || err?.message || 'unknown syntax error';
+    return msg;
+  }
+}
+
+/**
+ * AI output cache — avoids re-calling Claude for unchanged steps.
+ *
+ * Cache key: sha256(step + modelName + operationName + inputs + promptVersion)
+ * Cache location: $SPECVERSE_USER_CWD/.specverse/ai-cache/<hash>.ts
+ *
+ * Invalidation: automatic — any change to the step text or inputs
+ * produces a new hash. The prompt version is part of the hash so
+ * prompt upgrades also invalidate.
+ */
+const PROMPT_VERSION = '9.1.0';
+
+function cacheKey(step: string, modelName: string, operationName: string, functionName: string, inputs: string[]): string {
+  const payload = JSON.stringify({ step, modelName, operationName, functionName, inputs: [...inputs].sort(), v: PROMPT_VERSION });
+  return createHash('sha256').update(payload).digest('hex').slice(0, 16);
+}
+
+function cacheDir(): string {
+  const cwd = process.env.SPECVERSE_USER_CWD || process.cwd();
+  return join(cwd, '.specverse', 'ai-cache');
+}
+
+function cacheRead(key: string): string | null {
+  const path = join(cacheDir(), `${key}.ts`);
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function cacheWrite(key: string, body: string): void {
+  const dir = cacheDir();
+  try {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${key}.ts`), body, 'utf8');
+  } catch (err: any) {
+    console.warn(`      [ai-cache] write failed: ${err?.message || err}`);
+  }
+}
 
 /**
  * Generate AI behaviors file for a controller's unmatched steps.
@@ -43,6 +111,7 @@ export default async function generateAiBehaviors(context: TemplateContext): Pro
     operationName: string;
     parameterNames: string[];
     inputs: string[];
+    returns?: Record<string, string> | string;
   }> = [];
 
   for (const [actionName, action] of Object.entries(controller.actions) as [string, any][]) {
@@ -61,8 +130,13 @@ export default async function generateAiBehaviors(context: TemplateContext): Pro
     }
 
     for (let i = 0; i < steps.length; i++) {
-      const step = steps[i];
-      if (typeof step !== 'string') continue;
+      const stepInput = steps[i];
+      // Support both string steps and object steps { step, as, returns }
+      const stepText = typeof stepInput === 'string' ? stepInput : stepInput?.step;
+      const stepAs = typeof stepInput === 'object' ? stepInput?.as : undefined;
+      const stepReturns = typeof stepInput === 'object' ? stepInput?.returns : undefined;
+
+      if (typeof stepText !== 'string') continue;
 
       const ctx: StepContext = {
         modelName,
@@ -72,19 +146,21 @@ export default async function generateAiBehaviors(context: TemplateContext): Pro
         stepNum: i + 1,
         parameterNames,
         declaredVars,
+        resultName: stepAs,
       };
 
-      const result = matchStep(step, ctx);
+      const result = matchStep(stepText, ctx);
       if (!result.matched && result.functionName) {
-        // Avoid duplicate function definitions, but capture the widest set of inputs
+        // Avoid duplicate function definitions
         const existing = unmatchedFunctions.find(f => f.functionName === result.functionName);
         if (!existing) {
           unmatchedFunctions.push({
             functionName: result.functionName,
-            step,
+            step: stepText,
             operationName: actionName,
             parameterNames,
             inputs: result.inputs || [],
+            returns: stepReturns,
           });
         }
       }
@@ -93,7 +169,40 @@ export default async function generateAiBehaviors(context: TemplateContext): Pro
 
   if (unmatchedFunctions.length === 0) return '';
 
-  // Start a Claude session for this controller — all unmatched functions share
+  return generateAiBehaviorsFile({
+    ownerName: `${modelName}Controller`,
+    unmatchedFunctions: unmatchedFunctions.map(f => ({
+      ...f,
+      modelName,
+    })),
+    availableModels,
+    spec: context.spec,
+  });
+}
+
+/**
+ * Generate an AI behaviors file from a pre-collected list of unmatched
+ * functions. Used by both the controller generator (via generateAiBehaviors
+ * above) and the service generator (via collectUnmatched → this function).
+ */
+export async function generateAiBehaviorsFile(opts: {
+  ownerName: string;
+  unmatchedFunctions: Array<{
+    functionName: string;
+    step: string;
+    operationName: string;
+    parameterNames: string[];
+    inputs: string[];
+    returns?: Record<string, string> | string;
+    modelName: string;
+  }>;
+  availableModels: string[];
+  spec?: any;
+}): Promise<string> {
+  const { ownerName, unmatchedFunctions, availableModels, spec } = opts;
+  if (unmatchedFunctions.length === 0) return '';
+
+  // Start a Claude session for this owner — all unmatched functions share
   // the conversation context, so Claude builds understanding of the spec
   // across calls (mirrors app-demo's session-based AI service)
   let aiService: any = null;
@@ -103,17 +212,17 @@ export default async function generateAiBehaviors(context: TemplateContext): Pro
     if (!aiService.isAvailable) {
       aiService = null;
     } else {
-      aiService.startSession(`${modelName}Controller`);
+      aiService.startSession(ownerName);
     }
   } catch {
     aiService = null;
   }
 
-  const availableModels = (context.spec?.models ? Object.keys(context.spec.models) : []) as string[];
-
   // Generate function bodies sequentially — same Claude session for all
   const functions: string[] = [];
-  for (const { functionName, step, operationName, parameterNames, inputs } of unmatchedFunctions) {
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  for (const { functionName, step, operationName, parameterNames, inputs, returns, modelName } of unmatchedFunctions) {
     // Pure function signature: all inputs as a typed destructured object
     const signature = inputs.length > 0
       ? `input: { ${inputs.map(n => `${n}: any`).join('; ')} }`
@@ -124,10 +233,39 @@ export default async function generateAiBehaviors(context: TemplateContext): Pro
       ? `  const { ${inputs.join(', ')} } = input;`
       : '';
 
-    let body: string | null = null;
-    let source = 'STUB';
+    // Build return type from spec declaration (if provided)
+    // returns can be:
+    //   - a string: "number" → Promise<number>
+    //   - an object: { amount: "number", rate: "number" } → Promise<{ amount: number; rate: number }>
+    //   - undefined → Promise<any>
+    let returnType = 'any';
+    if (typeof returns === 'string') {
+      returnType = returns;
+    } else if (returns && typeof returns === 'object') {
+      const fields = Object.entries(returns).map(([k, v]) => `${k}: ${v}`).join('; ');
+      returnType = `{ ${fields} }`;
+    }
+
+    // Check cache first — skip Claude if we've generated this exact step before
+    const key = cacheKey(step, modelName, operationName, functionName, inputs);
+    let body: string | null = cacheRead(key);
+    let source: 'AI-CACHED' | 'AI-GENERATED' | 'AI-INVALID' | 'STUB' = body ? 'AI-CACHED' : 'STUB';
+    if (body) {
+      // Validate cache entry — a previously valid entry may have been
+      // corrupted on disk or the validator rules may have changed
+      const testCode = `export async function ${functionName}(input: any): Promise<any> {\n${body}\n}`;
+      const validationError = await validateTypeScript(testCode);
+      if (validationError) {
+        console.warn(`      [ai-validate] cached ${functionName} failed validation: ${validationError}`);
+        body = null;  // Force regeneration
+        source = 'STUB';
+      } else {
+        cacheHits++;
+      }
+    }
 
-    if (aiService) {
+    if (!body && aiService) {
+      cacheMisses++;
       try {
         body = await aiService.generateBehavior({
           step,
@@ -136,9 +274,24 @@ export default async function generateAiBehaviors(context: TemplateContext): Pro
           functionName,
           parameterNames: inputs,  // the actual inputs to the pure function
           availableModels,
-          spec: context.spec,
+          spec,
+          returnType,  // Pass declared return type to Claude
         });
-        if (body) source = 'AI-GENERATED';
+
+        if (body) {
+          // Validate the generated body as a standalone function
+          const testCode = `export async function ${functionName}(input: any): Promise<any> {\n${body}\n}`;
+          const validationError = await validateTypeScript(testCode);
+          if (validationError) {
+            console.warn(`      [ai-validate] ${functionName} has syntax error: ${validationError}`);
+            // Don't cache invalid output; treat as failed generation
+            body = `// AI-generated code failed validation: ${validationError}\n  // Step: ${step}\n  throw new Error('AI behavior has invalid syntax — see comment above');`;
+            source = 'AI-INVALID';
+          } else {
+            source = 'AI-GENERATED';
+            cacheWrite(key, body);
+          }
+        }
       } catch {
         // Fall through to stub
       }
@@ -154,22 +307,29 @@ export default async function generateAiBehaviors(context: TemplateContext): Pro
     const inputsDoc = inputs.length > 0
       ? ` * Inputs: ${inputs.join(', ')}\n`
       : '';
+    const returnsDoc = returnType !== 'any'
+      ? ` * Returns: ${returnType}\n`
+      : '';
 
     functions.push(`/**
  * ${functionName}
  *
  * Spec step: "${step}"
- * Called by: ${modelName}Controller.${operationName}()
-${inputsDoc} * Source: ${source}
+ * Called by: ${ownerName}.${operationName}()
+${inputsDoc}${returnsDoc} * Source: ${source}
  * Generated: ${new Date().toISOString().split('T')[0]}
  *
  * PURE FUNCTION — no database access, no event publishing, no external services.
  * All data comes in via \`input\`; all effects happen in the calling controller.
  * ${source === 'AI-GENERATED'
    ? 'AI-generated implementation. Review and test before deploying.'
+   : source === 'AI-CACHED'
+   ? 'Restored from AI cache (.specverse/ai-cache/). Delete cache entry to regenerate.'
+   : source === 'AI-INVALID'
+   ? 'AI returned code with syntax errors — function throws at runtime. Fix or regenerate.'
    : 'STUB — Claude CLI unavailable. Install Claude Code or implement manually.'}
  */
-export async function ${functionName}(${signature}): Promise<any> {
+export async function ${functionName}(${signature}): Promise<${returnType}> {
 ${destructure ? destructure + '\n' : ''}${body}
 }`);
   }
@@ -177,13 +337,18 @@ ${destructure ? destructure + '\n' : ''}${body}
   // End the session
   if (aiService?.endSession) aiService.endSession();
 
+  // Report cache stats to stdout — picked up by realize pipeline
+  if (cacheHits > 0 || cacheMisses > 0) {
+    console.log(`      AI cache: ${cacheHits} hit(s), ${cacheMisses} miss(es) for ${ownerName}`);
+  }
+
   return `/**
- * ${modelName}Controller — AI-Generated Behaviors
+ * ${ownerName} — AI-Generated Behaviors
  *
  * ⚠️  THIS FILE CONTAINS STUBS FOR STEPS THAT NEED IMPLEMENTATION
  *
  * These functions could not be generated from convention patterns.
- * They are called by ${modelName}Controller when executing custom actions.
+ * They are called by ${ownerName} when executing operations.
  *
  * Options for each function:
  * - Implement manually (recommended for business-critical logic)

package/libs/instance-factories/services/templates/prisma/behavior-generator.ts

@@ -28,11 +28,24 @@ export interface BehaviorContext {
   parameterNames?: string[];
 }
 
+/**
+ * A step can be a plain string or an object with extra metadata.
+ * String form: "Find Order by id"
+ * Object form: { step: "Apply discount", as: "discount", returns: { amount: "number" } }
+ */
+export type Step = string | {
+  step: string;
+  /** Name the result variable (default: stepNResult) */
+  as?: string;
+  /** Declare return type for AI functions so types flow through */
+  returns?: Record<string, string> | string;
+};
+
 export interface BehaviorMetadata {
   preconditions?: string[];
   postconditions?: string[];
   sideEffects?: string[];
-  steps?: string[];
+  steps?: Step[];
   transactional?: boolean;
 }
 
@@ -52,6 +65,10 @@ export interface BehaviorResult {
     operationName: string;
     /** Names of variables passed as the typed input object */
     inputs: string[];
+    /** Declared return type from spec ({field: type} or a single type string) */
+    returns?: Record<string, string> | string;
+    /** Named result variable (default: stepNResult) */
+    resultName?: string;
   }>;
 }
 
@@ -216,19 +233,24 @@ function matchPreconditionPattern(
  * Generate step logic using convention-based pattern matching.
  */
 function generateStepLogic(
-  steps: string[],
+  steps: Step[],
   context: BehaviorContext,
   preconditionDeclared?: Set<string>
-): { code: string; helpers: string[]; unmatchedSteps: Array<{ step: string; functionName: string; operationName: string; inputs: string[] }> } {
+): { code: string; helpers: string[]; unmatchedSteps: BehaviorResult['unmatchedSteps'] } {
   const helpers: string[] = [];
-  const unmatchedSteps: Array<{ step: string; functionName: string; operationName: string; inputs: string[] }> = [];
+  const unmatchedSteps: BehaviorResult['unmatchedSteps'] = [];
 
   // Shared declared variables across steps — carried through from preconditions
   const declaredVars = preconditionDeclared || new Set<string>();
 
   if (steps && steps.length > 0) {
-    const stepCode = steps.map((step, i) => {
-      if (typeof step !== 'string') {
+    const stepCode = steps.map((stepInput, i) => {
+      // Normalize to { text, as, returns }
+      const stepText = typeof stepInput === 'string' ? stepInput : stepInput.step;
+      const resultName = typeof stepInput === 'object' ? stepInput.as : undefined;
+      const returns = typeof stepInput === 'object' ? stepInput.returns : undefined;
+
+      if (typeof stepText !== 'string') {
         return `    // Step ${i + 1}: Complex operation — see expanded definition`;
       }
 
@@ -240,18 +262,21 @@ function generateStepLogic(
         stepNum: i + 1,
         parameterNames: context.parameterNames,
         declaredVars,
+        resultName,  // Pass through the named result
       };
 
-      const result = matchStep(step, ctx);
+      const result = matchStep(stepText, ctx);
       if (result.helperMethod) {
         helpers.push(result.helperMethod);
       }
       if (!result.matched && result.functionName) {
         unmatchedSteps.push({
-          step,
+          step: stepText,
           functionName: result.functionName,
           operationName: context.operationName,
           inputs: result.inputs || [],
+          returns,
+          resultName: resultName || `step${i + 1}Result`,
         });
       }
       return result.call;
@@ -331,7 +356,7 @@ export function generateEventPublishing(
     : '';
 
   const publishes = sideEffects.map(event =>
-    `    await eventBus.publish('${event}', { ${paramFields}timestamp: new Date().toISOString() });`
+    `    await eventBus.publish('${event}', { ${paramFields}timestamp: new Date().toISOString() } as any);`
   );
 
   return `    // === EVENTS ===\n${publishes.join('\n')}`;

package/libs/instance-factories/services/templates/prisma/controller-generator.ts

@@ -26,9 +26,15 @@ export default function generatePrismaController(context: TemplateContext): stri
   const controllerName = controller.name;
   const modelName = model.name;
   const rawModelVar = modelName.charAt(0).toLowerCase() + modelName.slice(1);
-  // Avoid JavaScript reserved words as variable names
+  // Avoid JavaScript reserved words as local variable names
   const RESERVED_WORDS = new Set(['import', 'export', 'default', 'class', 'function', 'return', 'delete', 'new', 'this', 'switch', 'case', 'break', 'continue', 'for', 'while', 'do', 'if', 'else', 'try', 'catch', 'finally', 'throw', 'typeof', 'instanceof', 'in', 'of', 'let', 'const', 'var', 'void', 'with', 'yield', 'async', 'await', 'enum', 'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'super', 'extends']);
   const modelVar = RESERVED_WORDS.has(rawModelVar) ? `${rawModelVar}Item` : rawModelVar;
+  // Prisma delegate name always matches the Prisma model's camelCase form —
+  // even when the model name is a JS reserved word (prisma.import, prisma.export).
+  // Access these via bracket notation so tsc doesn't choke on the keyword.
+  const prismaDelegate = RESERVED_WORDS.has(rawModelVar)
+    ? `prisma['${rawModelVar}']`
+    : `prisma.${rawModelVar}`;
   const curedOps = controller.cured || {};
 
   // Determine ID type for proper parsing
@@ -62,11 +68,11 @@ function parseId(id: string): ${needsIntParse ? 'number' : 'string'} {
  */
 export class ${controllerName} {
   ${generateValidateMethod(model, modelName)}
-  ${curedOps.create ? generateCreateMethod(model, modelName, modelVar, controller, allModels) : ''}
-  ${curedOps.retrieve ? generateRetrieveMethod(model, modelName, modelVar) : ''}
-  ${curedOps.update ? generateUpdateMethod(model, modelName, modelVar, controller, allModels) : ''}
-  ${curedOps.evolve ? generateEvolveMethod(model, modelName, modelVar, controller) : ''}
-  ${curedOps.delete ? generateDeleteMethod(model, modelName, modelVar, controller) : ''}
+  ${curedOps.create ? generateCreateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) : ''}
+  ${curedOps.retrieve ? generateRetrieveMethod(model, modelName, modelVar, prismaDelegate) : ''}
+  ${curedOps.update ? generateUpdateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) : ''}
+  ${curedOps.evolve ? generateEvolveMethod(model, modelName, modelVar, prismaDelegate, controller) : ''}
+  ${curedOps.delete ? generateDeleteMethod(model, modelName, modelVar, prismaDelegate, controller) : ''}
   ${customActions.code}
 }
 
@@ -163,10 +169,7 @@ function generateValidationLogic(model: any, dataParam: string = '_data', contex
 /**
  * Generate create method
  */
-function generateCreateMethod(model: any, modelName: string, modelVar: string, controller: any, allModels?: any[]): string {
-  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
-  const createEvent = hasEvents ? controller.publishes.find((e: string) => e.includes('Created')) : null;
-
+function generateCreateMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string, controller: any, allModels?: any[]): string {
   return `
   /**
    * Create a new ${modelName}
@@ -183,17 +186,12 @@ function generateCreateMethod(model: any, modelName: string, modelVar: string, c
     ${generateFKTransform(model, 'prismaData', allModels)}
 
     // Create record
-    const ${modelVar} = await prisma.${modelVar}.create({
+    const ${modelVar} = await ${prismaDelegate}.create({
       data: prismaData${generateIncludeRelationships(model)}
     });
 
-    ${createEvent ? `
-    // Publish event
-    eventBus.publish(EventName.${createEvent}, {
-      ${modelVar},
-      timestamp: new Date().toISOString()
-    });
-    ` : ''}
+    // Publish CURED event
+    await eventBus.publish('${modelName}Created', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
 
     return ${modelVar};
   }
@@ -203,13 +201,13 @@ function generateCreateMethod(model: any, modelName: string, modelVar: string, c
 /**
  * Generate retrieve method
  */
-function generateRetrieveMethod(model: any, modelName: string, modelVar: string): string {
+function generateRetrieveMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string): string {
   return `
   /**
    * Retrieve ${modelName} by ID
    */
   public async retrieve(id: string): Promise<any> {
-    const ${modelVar} = await prisma.${modelVar}.findUnique({
+    const ${modelVar} = await ${prismaDelegate}.findUnique({
       where: { id: parseId(id) }${generateIncludeRelationships(model)}
     });
 
@@ -224,7 +222,7 @@ function generateRetrieveMethod(model: any, modelName: string, modelVar: string)
    * Retrieve all ${modelName}s
    */
   public async retrieveAll(options: { skip?: number; take?: number } = {}): Promise<any[]> {
-    return await prisma.${modelVar}.findMany({
+    return await ${prismaDelegate}.findMany({
       skip: options.skip,
       take: options.take${generateIncludeRelationships(model)}
     });
@@ -235,10 +233,7 @@ function generateRetrieveMethod(model: any, modelName: string, modelVar: string)
 /**
  * Generate update method
  */
-function generateUpdateMethod(model: any, modelName: string, modelVar: string, controller: any, allModels?: any[]): string {
-  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
-  const updateEvent = hasEvents ? controller.publishes.find((e: string) => e.includes('Updated')) : null;
-
+function generateUpdateMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string, controller: any, allModels?: any[]): string {
   return `
   /**
    * Update ${modelName}
@@ -263,18 +258,13 @@ function generateUpdateMethod(model: any, modelName: string, modelVar: string, c
     ${generateFKTransform(model, 'updateData', allModels)}
 
     // Update record
-    const ${modelVar} = await prisma.${modelVar}.update({
+    const ${modelVar} = await ${prismaDelegate}.update({
       where: { id: parseId(id) },
       data: updateData${generateIncludeRelationships(model)}
     });
 
-    ${updateEvent ? `
-    // Publish event
-    eventBus.publish(EventName.${updateEvent}, {
-      ${modelVar},
-      timestamp: new Date().toISOString()
-    });
-    ` : ''}
+    // Publish CURED event
+    await eventBus.publish('${modelName}Updated', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
 
     return ${modelVar};
   }
@@ -284,7 +274,7 @@ function generateUpdateMethod(model: any, modelName: string, modelVar: string, c
 /**
  * Generate evolve method (lifecycle-aware updates)
  */
-function generateEvolveMethod(model: any, modelName: string, modelVar: string, controller: any): string {
+function generateEvolveMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string, controller: any): string {
   // Extract lifecycle — handle both array and object format
   const lifecycles = Array.isArray(model.lifecycles) ? model.lifecycles :
     (model.lifecycles ? Object.entries(model.lifecycles).map(([name, lc]: [string, any]) => ({ name, ...lc })) : []);
@@ -308,7 +298,7 @@ function generateEvolveMethod(model: any, modelName: string, modelVar: string, c
     }
 
     // Get current record to check lifecycle state
-    const current = await prisma.${modelVar}.findUnique({ where: { id: parseId(id) } });
+    const current = await ${prismaDelegate}.findUnique({ where: { id: parseId(id) } });
     if (!current) {
       throw new Error('${modelName} not found');
     }
@@ -327,11 +317,14 @@ function generateEvolveMethod(model: any, modelName: string, modelVar: string, c
     ` : ''}
 
     // Update record
-    const ${modelVar} = await prisma.${modelVar}.update({
+    const ${modelVar} = await ${prismaDelegate}.update({
       where: { id: parseId(id) },
       data${generateIncludeRelationships(model)}
     });
 
+    // Publish CURED event
+    await eventBus.publish('${modelName}Evolved', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
+
     return ${modelVar};
   }
 `;
@@ -340,33 +333,23 @@ function generateEvolveMethod(model: any, modelName: string, modelVar: string, c
 /**
  * Generate delete method
  */
-function generateDeleteMethod(model: any, modelName: string, modelVar: string, controller: any): string {
-  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
-  const deleteEvent = hasEvents ? controller.publishes.find((e: string) => e.includes('Deleted')) : null;
-
+function generateDeleteMethod(model: any, modelName: string, modelVar: string, prismaDelegate: string, controller: any): string {
   return `
   /**
    * Delete ${modelName}
    */
   public async delete(id: string): Promise<void> {
-    ${deleteEvent ? `
     // Get record before deletion for event
-    const ${modelVar} = await prisma.${modelVar}.findUnique({ where: { id: parseId(id) } });
-    ` : ''}
+    const ${modelVar} = await ${prismaDelegate}.findUnique({ where: { id: parseId(id) } });
 
-    await prisma.${modelVar}.delete({
+    await ${prismaDelegate}.delete({
       where: { id: parseId(id) }
     });
 
-    ${deleteEvent ? `
-    // Publish event
+    // Publish CURED event
     if (${modelVar}) {
-      eventBus.publish(EventName.${deleteEvent}, {
-        ${modelVar},
-        timestamp: new Date().toISOString()
-      });
+      await eventBus.publish('${modelName}Deleted', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
     }
-    ` : ''}
   }
 `;
 }
@@ -548,12 +531,7 @@ ${includes}
  * Check if controller publishes events
  */
 function hasEventPublishing(curedOps: any, controller: any): boolean {
-  if (controller.publishes && Array.isArray(controller.publishes) && controller.publishes.length > 0) return true;
-  // Check if any custom action publishes events
-  if (controller.actions) {
-    for (const action of Object.values(controller.actions) as any[]) {
-      if (action.publishes?.length > 0 || action.events?.length > 0 || action.sideEffects?.length > 0) return true;
-    }
-  }
-  return false;
+  // Controllers always publish CURED events (Created, Updated, Deleted, Evolved)
+  // so the event bus is always needed
+  return true;
 }