@specverse/engines 6.53.1 → 6.63.0

package/libs/instance-factories/services/templates/postgres-native/step-conventions.ts

@@ -20,6 +20,7 @@ import {
   type SharedConvention,
   type SharedStepContext,
 } from '../_shared/step-matching.js';
+import { safeEntityName } from '@specverse/types';
 
 export type PgStepConvention = SharedConvention<PgStepContext>;
 
@@ -146,7 +147,8 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
     generateCall: (m, ctx) => {
       const model = m[1]!;
       const field = m[2]!;
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       const table = toTable(model);
       const params = ctx.parameterNames || [];
       const declared = ctx.declaredVars || new Set();
@@ -174,7 +176,8 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
       const model = m[1]!;
       const f1 = m[2]!;
       const f2 = m[3]!;
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       const table = toTable(model);
       const declared = ctx.declaredVars || new Set();
       if (declared.has(modelVar)) {
@@ -201,10 +204,13 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
   // --- Create model record ---
   {
     name: 'create',
-    pattern: /^create\s+(?:new\s+)?(\w+)(?:\s+(?:with\s+)?(.+))?/i,
+    // Leading-adjective skip (NL_LEADING_ADJECTIVES) + isUnsafeEntityName
+    // safety net — see comment in prisma/step-conventions.ts "find" block.
+    pattern: /^create\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)(?:\s+(?:with\s+)?(.+))?/i,
     generateCall: (m, ctx) => {
       const model = m[1]!;
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       const table = toTable(model);
       const params = ctx.parameterNames || [];
       const declared = ctx.declaredVars || new Set();
@@ -218,12 +224,13 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
   // --- Update specific field on previously-loaded model ---
   {
     name: 'update-field',
-    pattern: /^update\s+(\w+)\s+(\w+)\s+to\s+(.+)/i,
+    pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+(\w+)\s+to\s+(.+)/i,
     generateCall: (m, ctx) => {
       const model = m[1]!;
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       const field = m[2]!;
       const rawValue = m[3]!;
-      const modelVar = toVar(model);
       if (!ctx.declaredVars?.has(modelVar)) return '';
       const table = toTable(model);
       const val = resolveValue(rawValue, ctx);
@@ -235,11 +242,12 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
   // --- Update field timestamp ---
   {
     name: 'update-field-timestamp',
-    pattern: /^update\s+(\w+)\s+(\w+)\s+timestamp$/i,
+    pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+(\w+)\s+timestamp$/i,
     generateCall: (m, ctx) => {
       const model = m[1]!;
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       const field = m[2]!;
-      const modelVar = toVar(model);
       if (!ctx.declaredVars?.has(modelVar)) return '';
       const table = toTable(model);
       return `    // Step ${ctx.stepNum}: Update ${model}.${field} timestamp
@@ -250,10 +258,11 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
   // --- Generic "Update X" (writes args back) ---
   {
     name: 'update',
-    pattern: /^update\s+(\w+)(?:\s+(.+))?$/i,
+    pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)(?:\s+(.+))?$/i,
     generateCall: (m, ctx) => {
       const model = m[1]!;
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       if (!ctx.declaredVars?.has(modelVar)) return '';
       const table = toTable(model);
       return `    // Step ${ctx.stepNum}: Update ${model}
@@ -264,10 +273,11 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
   // --- Delete model record ---
   {
     name: 'delete',
-    pattern: /^delete\s+(\w+)/i,
+    pattern: /^delete\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)/i,
     generateCall: (m, ctx) => {
       const model = m[1]!;
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       if (!ctx.declaredVars?.has(modelVar)) return '';
       const table = toTable(model);
       return `    // Step ${ctx.stepNum}: Delete ${model}
@@ -282,7 +292,8 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
     generateCall: (m, ctx) => {
       const model = m[1]!;
       const state = m[2]!;
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       if (!ctx.declaredVars?.has(modelVar)) return '';
       const table = toTable(model);
       return `    // Step ${ctx.stepNum}: Transition ${model} to ${state}
@@ -337,7 +348,8 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
     name: 'persist',
     pattern: /^(?:persist|save|store)\s+(\w+(?:\s+\w+)?)(?:\s+(?:for|to|record).*)?$/i,
     generateCall: (m, ctx) => {
-      const target = toVar(m[1]!.replace(/\s+(.)/g, (_, c) => c.toUpperCase()));
+      const target = safeEntityName(m[1]!.replace(/\s+(.)/g, (_, c) => c.toUpperCase()));
+      if (!target) return '';
       const table = toTable(target);
       const recordSrc = mostRecentStepResult(ctx) ?? 'args';
       // Ensure `record` is an object before insertOne — wrap primitives.
@@ -355,7 +367,8 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
     name: 'conditional-create',
     pattern: /^if\s+(\w+)\s+does\s+not\s+exist,?\s+create\s+new\s+(\w+)(?:\s+with\s+.+)?$/i,
     generateCall: (m, ctx) => {
-      const modelVar = toVar(m[1]!);
+      const modelVar = safeEntityName(m[1]!);
+      if (!modelVar) return '';
       const Model = pascal(m[2]!);
       const table = toTable(Model);
       if (!ctx.declaredVars?.has(modelVar)) return '';
@@ -374,7 +387,8 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
     name: 'conditional-update',
     pattern: /^if\s+(\w+)\s+exists,?\s+update\s+(\w+)(?:\s+(.+))?$/i,
     generateCall: (m, ctx) => {
-      const modelVar = toVar(m[1]!);
+      const modelVar = safeEntityName(m[1]!);
+      if (!modelVar) return '';
       const field = m[2]!;
       const table = toTable(m[1]!);
       if (!ctx.declaredVars?.has(modelVar)) return '';
@@ -428,7 +442,8 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
     pattern: /^otherwise\s+create\s+(?:new\s+)?(\w+)\s+record$/i,
     generateCall: (m, ctx) => {
       const Model = pascal(m[1]!);
-      const modelVar = toVar(Model);
+      const modelVar = safeEntityName(Model);
+      if (!modelVar) return '';
       const table = toTable(Model);
       const wasDeclared = ctx.declaredVars?.has(modelVar);
       const declared = Array.from(ctx.declaredVars || []);
@@ -480,9 +495,11 @@ export const PG_STEP_CONVENTIONS: PgStepConvention[] = [
     generateCall: (m, ctx) => {
       const service = m[1]!;
       const method = m[2]!;
+      const serviceVar = safeEntityName(service);
+      if (!serviceVar) return '';
       const args = (ctx.parameterNames || []).join(', ');
       return `    // Step ${ctx.stepNum}: Call ${service}.${method}
-    await (${toVar(service)} as any).${method}({ ${args} });`;
+    await (${serviceVar} as any).${method}({ ${args} });`;
     },
   },
 

package/libs/instance-factories/services/templates/prisma/__tests__/step-conventions-create.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Step-conventions — `create` pattern reserved-word regression.
+ *
+ * Surfaced 2026-05-14 by the 9-cell comparison matrix: sonnet's
+ * idle-meta realize γ-stubbed `PlayersController.post0` with the
+ * precise diagnostic "pre-baked step 7 uses reserved keyword 'new' as
+ * a variable identifier — cannot emit coherently". The pre-baked
+ * snippet was:
+ *
+ *   // Step 7: Create new
+ *   const new = await prisma.new.create({ data: data });
+ *
+ * Root cause: prisma's `create` convention pattern was
+ * `/^create\s+(\w+).../i` — for the step "Create new Player with level 1",
+ * m[1] captured the adjective "new" rather than the noun "Player".
+ * Then toVar("new") = "new" (a JS reserved word) became both the
+ * variable name AND the prisma model name in the generated snippet,
+ * neither of which is legal/correct.
+ *
+ * mongo and pg conventions already had `(?:new\s+)?` in their create
+ * patterns — this was a parity gap. Fix: add the same optional group
+ * to prisma's create pattern. After the fix, m[1] = "Player" → snippet
+ * uses `prisma.player.create`.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { STEP_CONVENTIONS } from '../step-conventions.js';
+import type { StepContext } from '../step-conventions.js';
+
+function findCreateConvention() {
+  const c = STEP_CONVENTIONS.find((x) => x.name === 'create');
+  expect(c).toBeDefined();
+  return c!;
+}
+
+function makeCtx(overrides: Partial<StepContext> = {}): StepContext {
+  return {
+    modelName: 'Player',
+    serviceName: 'PlayersController',
+    operationName: 'post0',
+    stepNum: 7,
+    parameterNames: [],
+    declaredVars: new Set<string>(),
+    ...overrides,
+  } as any;
+}
+
+describe('prisma step-convention `create` — adjective-skip + entity-name correctness', () => {
+  it('extracts the entity noun, not the adjective, from "Create new Player with …"', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new Player with level 1, experience 0'.match(convention.pattern)!;
+    expect(m[1]).toBe('Player');
+  });
+
+  it('emits a snippet referencing `prisma.player` (not `prisma.new`) for the adjective case', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new Player with level 1, experience 0'.match(convention.pattern)!;
+    const call = convention.generateCall(m, makeCtx())!;
+    expect(call).toContain('prisma.player.create');
+    expect(call).not.toContain('prisma.new');
+    expect(call).not.toContain('const new ');
+  });
+
+  it('still works for the no-adjective case "Create Player with …" (no regression)', () => {
+    const convention = findCreateConvention();
+    const m = 'Create Player with level 1'.match(convention.pattern)!;
+    expect(m[1]).toBe('Player');
+    const call = convention.generateCall(m, makeCtx())!;
+    expect(call).toContain('prisma.player.create');
+  });
+
+  it('uses parameter names for the data shape when provided', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new Player with level 1'.match(convention.pattern)!;
+    const call = convention.generateCall(m, makeCtx({ parameterNames: ['userId', 'gameId'] }))!;
+    expect(call).toContain('{ userId, gameId }');
+  });
+
+  it('emits a syntactically valid `const <var> = await prisma.<var>.create(...)` shape', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new Player with level 1'.match(convention.pattern)!;
+    const call = convention.generateCall(m, makeCtx())!;
+    // const <var> = await prisma.<var>.create(...);
+    // Variable name must NOT be a JS reserved word; both the variable
+    // and the prisma model reference should be the lowercased entity.
+    expect(call).toMatch(/const\s+player\s+=\s+await\s+prisma\.player\.create/);
+  });
+
+  // Wider adjective list (engines 6.60.4) — kept in sync with
+  // NL_LEADING_ADJECTIVES in _shared/step-matching.ts.
+  it.each([
+    ['existing', 'Create existing Player with level 1'],
+    ['current',  'Create current Player'],
+    ['the',      'Create the Player with level 1'],
+    ['a',        'Create a Player with level 1'],
+    ['an',       'Create an Order with total 100'],
+  ])('skips the leading adjective %s (no regression for any in the list)', (_adj, step) => {
+    const convention = findCreateConvention();
+    const m = step.match(convention.pattern)!;
+    // m[1] is the noun (Player/Order), never the adjective.
+    expect(['Player', 'Order']).toContain(m[1]);
+    const call = convention.generateCall(m, makeCtx())!;
+    expect(call).not.toMatch(/const\s+(existing|current|the|a|an)\s+=/);
+    expect(call).not.toMatch(/prisma\.(existing|current|the|a|an)\./);
+  });
+});
+
+describe('prisma step-convention `create` — reserved-word safety net', () => {
+  // The pattern's leading-adjective skip catches the common cases. The
+  // safety net catches anything that still leaks a JS reserved word as
+  // the entity name (an adjective not in the skip list, or a mis-parse).
+  // generateCall returns '' → the matcher falls through to the AI
+  // [WRITE] fallback instead of emitting `const class = await prisma.class...`.
+  it.each([
+    ['class',    'Create class Foo'],
+    ['function', 'Create function Bar'],
+    ['delete',   'Create delete Marker'],
+    ['return',   'Create return Receipt'],
+  ])('returns empty string when m[1] would be reserved word "%s"', (reserved, step) => {
+    const convention = findCreateConvention();
+    const m = step.match(convention.pattern);
+    // The pattern still matches structurally; the generateCall guard refuses.
+    if (m) {
+      expect(m[1]!.toLowerCase()).toBe(reserved);
+      const call = convention.generateCall(m, makeCtx());
+      expect(call).toBe('');
+    }
+  });
+
+  it('matches but refuses "Create new class" (post-adjective-skip the captured noun is reserved)', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new class'.match(convention.pattern)!;
+    expect(m[1]).toBe('class');
+    expect(convention.generateCall(m, makeCtx())).toBe('');
+  });
+});
+
+describe('prisma step-conventions — extracted-input reserved-word safety (transition + call-service)', () => {
+  // 2026-05-15 audit of all toVar(extracted) sites. Same shape as the
+  // create-convention safety net above: when the captured noun lowercases
+  // to a TS reserved word, generateCall returns '' so the matcher falls
+  // through to the AI [WRITE] fallback instead of emitting illegal TS.
+
+  function findConvention(name: string) {
+    const c = STEP_CONVENTIONS.find((x) => x.name === name);
+    expect(c).toBeDefined();
+    return c!;
+  }
+
+  it.each([
+    ['delete',  'transition delete to active'],
+    ['return',  'transition return to closed'],
+    ['class',   'transition class to graduated'],
+  ])('transition: refuses reserved-word model "%s"', (_reserved, step) => {
+    const convention = findConvention('transition');
+    const m = step.match(convention.pattern)!;
+    expect(convention.generateCall(m, makeCtx())).toBe('');
+  });
+
+  it('transition: still works for a real model name (no regression)', () => {
+    const convention = findConvention('transition');
+    const m = 'transition Player to active'.match(convention.pattern)!;
+    const ctx = makeCtx({ declaredVars: new Set(['player']) });
+    const call = convention.generateCall(m, ctx)!;
+    expect(call).toContain('prisma.player.update');
+    expect(call).toContain("'active'");
+  });
+
+  it.each([
+    ['delete',  'call delete.purge'],
+    ['return',  'call return.process'],
+  ])('call-service: refuses reserved-word service name "%s"', (_reserved, step) => {
+    const convention = findConvention('call-service');
+    const m = step.match(convention.pattern)!;
+    expect(convention.generateCall(m, makeCtx())).toBe('');
+  });
+
+  it('call-service: still works for a real service name (no regression)', () => {
+    const convention = findConvention('call-service');
+    const m = 'call notificationService.send'.match(convention.pattern)!;
+    const call = convention.generateCall(m, makeCtx())!;
+    expect(call).toContain('notificationService.send');
+  });
+});

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

@@ -18,6 +18,7 @@
  */
 
 import type { TemplateContext } from '@specverse/types';
+import { safeFunctionName } from '@specverse/types';
 import { matchStep, type StepContext } from './step-conventions.js';
 import { validateImportWhitelist } from '@specverse/engines/ai';
 import { createHash } from 'crypto';
@@ -352,6 +353,15 @@ export async function generateAiBehaviorsFile(opts: {
   let cacheHits = 0;
   let cacheMisses = 0;
   for (const { functionName, step, operationName, parameterNames, inputs, returns, modelName } of unmatchedFunctions) {
+    // Reserved-word safety for the function declaration. `functionName`
+    // came from `toMethod(step)` in step-matching; a step text like
+    // "Delete" camelCases to `delete` — a JS keyword that's illegal as
+    // a function-declaration identifier. Suffix-rename the decl and
+    // append a re-export so callers (`aiBehaviors.delete(...)`) still
+    // resolve via the re-export's binding. Same shape as the γ-stub
+    // renderers in per-owner-runner + per-action-recovery.
+    const { name: safeName, reserved: nameReserved } = safeFunctionName(functionName);
+
     // Pure function signature + destructure are built AFTER the body so we
     // can match what the LLM actually references — strict tsc's
     // noUnusedLocals / noUnusedParameters fire on every input the body
@@ -471,6 +481,22 @@ export async function generateAiBehaviorsFile(opts: {
       returnType = `{ ${fields} }`;
     }
 
+    // Build the validation harness EXACTLY as the function is finally
+    // emitted: real signature + the wrapper-added destructure + real
+    // return type. Pre-fix the harness was a bare
+    // `export async function X(input: any)` with NO destructure — but
+    // the LLM is explicitly told (see the retry-hint prose below) to
+    // emit ONLY the body that goes AFTER `const { ... } = input;`. So a
+    // valid body using bare input references (`return userId + 1`)
+    // would spuriously fail re-validation with "Cannot find name
+    // 'userId'", forcing regeneration / STUB. The harness must match
+    // emission or the gate rejects its own correct output.
+    const buildTestCode = (rawBody: string): string => {
+      const { signature, destructure } = buildSignatureAndDestructure(rawBody);
+      const destructureLine = destructure ? destructure + '\n' : '';
+      return `export async function ${safeName}(${signature}): Promise<${returnType}> {\n${destructureLine}${rawBody}\n}`;
+    };
+
     // 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);
@@ -480,7 +506,7 @@ export async function generateAiBehaviorsFile(opts: {
       // corrupted on disk OR the validation rules may have tightened
       // (e.g. tsc type checks added). A cache hit must still be re-validated
       // through both gates so old bodies don't leak past the new bar.
-      const testCode = `export async function ${functionName}(input: any): Promise<any> {\n${body}\n}`;
+      const testCode = buildTestCode(body);
       const syntaxError = await validateTypeScript(testCode);
       const typeError = syntaxError ? null : await validateTypeScriptTypes(testCode);
       const importError = (syntaxError || typeError) ? null : validateImports(testCode);
@@ -516,7 +542,7 @@ export async function generateAiBehaviorsFile(opts: {
           //      with the error message appended; only ONE retry to bound
           //      cost. If that still fails we keep the body but mark it
           //      AI-INVALID so the user sees it needs review.
-          const testCode = `export async function ${functionName}(input: any): Promise<any> {\n${body}\n}`;
+          const testCode = buildTestCode(body);
           const syntaxError = await validateTypeScript(testCode);
           if (syntaxError) {
             console.warn(`      [ai-validate] ${functionName} has syntax error: ${syntaxError}`);
@@ -547,7 +573,7 @@ export async function generateAiBehaviorsFile(opts: {
                   returnType,
                 });
                 if (retried) {
-                  const retryCode = `export async function ${functionName}(input: any): Promise<any> {\n${retried}\n}`;
+                  const retryCode = buildTestCode(retried);
                   const retrySyntaxError = await validateTypeScript(retryCode);
                   const retryTypeError = retrySyntaxError ? null : await validateTypeScriptTypes(retryCode);
                   const retryImportError = (retrySyntaxError || retryTypeError) ? null : validateImports(retryCode);
@@ -594,6 +620,9 @@ export async function generateAiBehaviorsFile(opts: {
       ? ` * Returns: ${returnType}\n`
       : '';
 
+    const reExportLine = nameReserved
+      ? `\nexport { ${safeName} as ${functionName} };`
+      : '';
     functions.push(`/**
  * ${functionName}
  *
@@ -612,7 +641,7 @@ ${inputsDoc}${returnsDoc} * Source: ${source}
    ? '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}(${(() => {
+${nameReserved ? 'async' : 'export async'} function ${safeName}(${(() => {
   const { signature: sig } = buildSignatureAndDestructure(body);
   return sig;
 })()}): Promise<${returnType}> {
@@ -620,7 +649,7 @@ ${(() => {
   const { destructure } = buildSignatureAndDestructure(body);
   return destructure ? destructure + '\n' : '';
 })()}${body}
-}`);
+}${reExportLine}`);
   }
 
   // End the session

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

@@ -65,7 +65,12 @@ export default function generatePrismaController(context: TemplateContext): stri
 
   const usesPrisma = /\bprisma\b/.test(classBody);
   const usesParseId = /\bparseId\(/.test(classBody);
-  const usesEventBus = hasEventPublishing(curedOps, controller);
+  // Symbol-presence check on the actual class body — matches the
+  // `usesPrisma` pattern. Pre-fix this was a stub `hasEventPublishing`
+  // that returned true unconditionally, producing an unused-import
+  // TS6133 on every backend-only ProductController (validate-only,
+  // no CRUD, no eventBus.publish in the body).
+  const usesEventBus = /\beventBus\./.test(classBody);
   const usesAiBehaviors = customActions.needsAiBehaviors;
 
   // Build top-of-file declarations conditionally.

package/libs/instance-factories/services/templates/prisma/step-conventions.ts

@@ -17,6 +17,7 @@ import {
   type SharedConvention,
   type SharedStepContext,
 } from '../_shared/step-matching.js';
+import { safeEntityName } from '@specverse/types';
 
 export type StepConvention = SharedConvention<StepContext>;
 
@@ -125,13 +126,27 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   },
 
   // --- Find / Lookup ---
+  //
+  // All entity-targeting patterns (find / create / update / delete) share
+  // two safeguards:
+  //   1. A pattern-level leading-adjective skip
+  //      `(?:(?:new|existing|current|the|a|an)\s+)?` so NL phrasings like
+  //      "Find existing Player by id" or "Create new Player with ..."
+  //      extract the noun, not the adjective. Kept in sync with
+  //      `NL_LEADING_ADJECTIVES` in `_shared/step-matching.ts`.
+  //   2. `safeEntityName(m[1])` — the reserved-word-safe primitive from
+  //      `@specverse/types`. Returns the lowerCamel identifier, or `null`
+  //      when the extraction would emit a TS reserved word
+  //      (e.g. `prisma.new.create`). On null, generateCall returns `''` so
+  //      the matcher falls through to the AI [WRITE] fallback.
   {
     name: 'find',
-    pattern: /^find\s+(\w+)\s+by\s+(\w+)/i,
+    pattern: /^find\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+by\s+(\w+)/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       const field = m[2];
-      const modelVar = toVar(model);
       const params = ctx.parameterNames || [];
       const declared = ctx.declaredVars || new Set();
 
@@ -154,10 +169,11 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   // --- Create ---
   {
     name: 'create',
-    pattern: /^create\s+(\w+)(?:\s+(?:with\s+)?(.+))?/i,
+    pattern: /^create\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)(?:\s+(?:with\s+)?(.+))?/i,
     generateCall: (m, ctx) => {
       const model = m[1];
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       // Build data from parameter names if available
       const paramNames = ctx.parameterNames || [];
       const dataFields = paramNames.length > 0
@@ -171,12 +187,13 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   // --- Update field ---
   {
     name: 'update-field',
-    pattern: /^update\s+(\w+)\s+(\w+)\s+to\s+(.+)/i,
+    pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+(\w+)\s+to\s+(.+)/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       const field = m[2];
       const rawValue = m[3];
-      const modelVar = toVar(model);
       const val = resolveValue(rawValue, ctx);
       return `    // Step ${ctx.stepNum}: Update ${model} ${field} to ${rawValue.trim()}
     await prisma.${modelVar}.update({
@@ -189,10 +206,11 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   // --- Generic update ---
   {
     name: 'update',
-    pattern: /^update\s+(\w+)(?:\s+(.+))?/i,
+    pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)(?:\s+(.+))?/i,
     generateCall: (m, ctx) => {
       const model = m[1];
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       return `    // Step ${ctx.stepNum}: Update ${model}
     await prisma.${modelVar}.update({
       where: { id: ${modelVar}.id },
@@ -204,10 +222,11 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   // --- Delete ---
   {
     name: 'delete',
-    pattern: /^delete\s+(\w+)/i,
+    pattern: /^delete\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)/i,
     generateCall: (m, ctx) => {
       const model = m[1];
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       return `    // Step ${ctx.stepNum}: Delete ${model}
     await prisma.${modelVar}.delete({ where: { id: ${modelVar}.id } });`;
     },
@@ -220,7 +239,8 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const model = m[1];
       const state = m[2];
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       return `    // Step ${ctx.stepNum}: Transition ${model} to ${state}
     if (${modelVar}.status === '${state}') throw new Error('${model} is already ${state}');
     await prisma.${modelVar}.update({
@@ -314,8 +334,10 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const service = m[1];
       const method = m[2];
+      const serviceVar = safeEntityName(service);
+      if (!serviceVar) return '';
       return `    // Step ${ctx.stepNum}: Call ${service}.${method}
-    await ${toVar(service)}.${method}({ ${(ctx.parameterNames || []).join(', ')} });`;
+    await ${serviceVar}.${method}({ ${(ctx.parameterNames || []).join(', ')} });`;
     },
   },
 

package/libs/instance-factories/services/templates/shared-patterns.ts

@@ -1,12 +1,22 @@
 /**
  * Shared Convention Pattern Definitions
  *
- * The canonical list of step convention patterns. Both the Prisma factory
- * (code generation) and the Memory factory (runtime interpretation) use
- * these same patterns. Add new patterns here — both targets pick them up.
+ * Canonical pattern list consumed by the Memory factory's runtime
+ * interpreter (`generateInterpreterModule` reads them to emit
+ * dispatch code). Prisma / Mongo / Postgres step-conventions split
+ * off into their own inline-regex files historically and no longer
+ * read from here — changes in this file primarily affect Memory.
  *
- * This is the "interface" of the convention system. Each factory provides
- * the "implementation" (generateCall or execute).
+ * Entity-targeting patterns (find / create / update-field / update /
+ * delete) carry a leading-adjective skip
+ * `(?:(?:new|existing|current|the|a|an)\s+)?` so an NL step like
+ * "Create new Player with …" extracts `Player`, not `new`. Mirrors
+ * `NL_LEADING_ADJECTIVES` in `_shared/step-matching.ts`. Without this,
+ * Memory's interpreter would call `ctx.store.create("new", data)` and
+ * fail at lookup; the structural cause is identical to the TS-side bug
+ * that `safeEntityName` (from `@specverse/types`) addresses in the
+ * other ORMs — only the *consequence* differs (runtime lookup failure
+ * here vs TS syntax error there).
  */
 
 export interface PatternDefinition {
@@ -19,13 +29,13 @@ export const CONVENTION_PATTERNS: PatternDefinition[] = [
   { name: 'validate',         pattern: /^validate\s+(.+)/i,                                    description: 'Validate input data' },
   { name: 'check-no-existing', pattern: /^check\s+(?:no\s+existing|.*has\s+no\s+existing)\s+(\w+)\s+for\s+(\w+)\s+in\s+(\w+)/i, description: 'Check no duplicate entity exists for a pair' },
   { name: 'check',            pattern: /^check\s+(.+)/i,                                       description: 'Check a condition' },
-  { name: 'find',             pattern: /^find\s+(\w+)\s+by\s+(\w+)/i,                          description: 'Find entity by field' },
+  { name: 'find',             pattern: /^find\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+by\s+(\w+)/i, description: 'Find entity by field' },
   { name: 'find-all-for',     pattern: /^find\s+(?:all\s+)?(\w+?)s?\s+(?:for|of|belonging\s+to)\s+(\w+)/i, description: 'Cross-model query via foreign key' },
   { name: 'count-per',        pattern: /^count\s+(\w+?)s?\s+(?:per|by|for\s+each)\s+(\w+)/i,   description: 'Group-by aggregation count' },
-  { name: 'create',           pattern: /^create\s+(\w+)(?:\s+record)?/i,                       description: 'Create a new entity' },
-  { name: 'update-field',     pattern: /^update\s+(\w+)\s+(\w+)\s+to\s+(.+)/i,                 description: 'Update specific field to value' },
-  { name: 'update',           pattern: /^update\s+(\w+)$/i,                                    description: 'Update entity with params' },
-  { name: 'delete',           pattern: /^delete\s+(\w+)/i,                                     description: 'Delete an entity' },
+  { name: 'create',           pattern: /^create\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)(?:\s+record)?/i, description: 'Create a new entity' },
+  { name: 'update-field',     pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+(\w+)\s+to\s+(.+)/i, description: 'Update specific field to value' },
+  { name: 'update',           pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)$/i, description: 'Update entity with params' },
+  { name: 'delete',           pattern: /^delete\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)/i, description: 'Delete an entity' },
   { name: 'transition',       pattern: /^transition\s+(\w+)\s+to\s+(\w+)/i,                    description: 'Lifecycle state transition' },
   { name: 'set',              pattern: /^set\s+(\w+)\s+to\s+(.+)/i,                            description: 'Set a field value' },
   { name: 'increment',        pattern: /^increment\s+(\w+)\s+by\s+(\w+)/i,                     description: 'Increment numeric field' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specverse/engines",
-  "version": "6.53.1",
+  "version": "6.63.0",
   "description": "SpecVerse toolchain — parser, inference, realize, generators, AI, registry, bundles",
   "type": "module",
   "main": "dist/index.js",