@auto-engineer/server-implementer 1.139.0 → 1.140.1

package/package.json

@@ -18,8 +18,8 @@
     "debug": "^4.3.4",
     "fast-glob": "^3.3.3",
     "vite": "^5.4.1",
-    "@auto-engineer/model-factory": "1.139.0",
-    "@auto-engineer/message-bus": "1.139.0"
+    "@auto-engineer/model-factory": "1.140.1",
+    "@auto-engineer/message-bus": "1.140.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -29,9 +29,9 @@
     "glob": "^11.0.3",
     "tsx": "^4.20.3",
     "typescript": "^5.8.3",
-    "@auto-engineer/cli": "1.139.0"
+    "@auto-engineer/cli": "1.140.1"
   },
-  "version": "1.139.0",
+  "version": "1.140.1",
   "scripts": {
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts",
     "test": "vitest run --reporter=dot",

package/src/agent/detectShadowsInSlice.specs.ts

@@ -2,9 +2,9 @@ import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { detectShadowsInSlice } from './runSlice';
+import { detectShadowsInMoment } from './runSlice';
 
-describe('detectShadowsInSlice', () => {
+describe('detectShadowsInMoment', () => {
   let tempDir: string;
 
   beforeEach(async () => {
@@ -18,7 +18,7 @@ describe('detectShadowsInSlice', () => {
   it('returns empty results for clean files', async () => {
     await writeFile(path.join(tempDir, 'projection.ts'), `import type { MyState } from './state';\nconst x = 1;\n`);
 
-    const result = await detectShadowsInSlice(tempDir);
+    const result = await detectShadowsInMoment(tempDir);
 
     expect(result).toEqual({ errors: '', failedFiles: [] });
   });
@@ -29,7 +29,7 @@ describe('detectShadowsInSlice', () => {
       `import type { MyState } from './state';\ntype MyState = { name: string };\n`,
     );
 
-    const result = await detectShadowsInSlice(tempDir);
+    const result = await detectShadowsInMoment(tempDir);
 
     expect(result).toEqual({
       errors:
@@ -44,7 +44,7 @@ describe('detectShadowsInSlice', () => {
       `import type { MyState } from './state';\ntype MyState = { name: string };\n`,
     );
 
-    const result = await detectShadowsInSlice(tempDir);
+    const result = await detectShadowsInMoment(tempDir);
 
     expect(result).toEqual({ errors: '', failedFiles: [] });
   });
@@ -53,7 +53,7 @@ describe('detectShadowsInSlice', () => {
     await writeFile(path.join(tempDir, 'a.ts'), `import type { Alpha } from './types';\ntype Alpha = { x: number };\n`);
     await writeFile(path.join(tempDir, 'b.ts'), `import type { Beta } from './types';\ninterface Beta { y: string }\n`);
 
-    const result = await detectShadowsInSlice(tempDir);
+    const result = await detectShadowsInMoment(tempDir);
 
     expect(result.failedFiles).toEqual([path.join(tempDir, 'a.ts'), path.join(tempDir, 'b.ts')]);
     expect(result.errors).toContain('CONTRACT VIOLATION in a.ts');

package/src/agent/runAllSlices.ts

@@ -1,12 +1,12 @@
 import path from 'node:path';
 import fg from 'fast-glob';
-import { runSlice } from './runSlice';
+import { runMoment } from './runSlice';
 
-export async function runAllSlices(flowDir: string): Promise<void> {
-  const flowName = path.basename(flowDir);
-  const sliceDirs = await fg(`${flowDir}/**/*/`, { onlyDirectories: true });
-  for (const sliceDir of sliceDirs) {
-    await runSlice(sliceDir, flowName);
+export async function runAllMoments(sceneDir: string): Promise<void> {
+  const sceneName = path.basename(sceneDir);
+  const momentDirs = await fg(`${sceneDir}/**/*/`, { onlyDirectories: true });
+  for (const momentDir of momentDirs) {
+    await runMoment(momentDir, sceneName);
   }
-  console.log('✅ All slices processed');
+  console.log('✅ All moments processed');
 }

package/src/agent/runFlows.ts

@@ -1,45 +1,45 @@
 import path from 'node:path';
 import createDebug from 'debug';
 import fg from 'fast-glob';
-import { runAllSlices } from './runAllSlices';
+import { runAllMoments } from './runAllSlices';
 
-const debug = createDebug('auto:server-implementer:flows');
-const debugFlow = createDebug('auto:server-implementer:flows:flow');
+const debug = createDebug('auto:server-implementer:scenes');
+const debugScene = createDebug('auto:server-implementer:scenes:scene');
 
-export async function runFlows(baseDir: string): Promise<void> {
-  debug('Running flows from base directory: %s', baseDir);
+export async function runScenes(baseDir: string): Promise<void> {
+  debug('Running scenes from base directory: %s', baseDir);
 
-  const flowDirs = await fg('*', {
+  const sceneDirs = await fg('*', {
     cwd: baseDir,
     onlyDirectories: true,
     absolute: true,
   });
 
-  debug('Found %d flow directories', flowDirs.length);
-  if (flowDirs.length > 0) {
+  debug('Found %d scene directories', sceneDirs.length);
+  if (sceneDirs.length > 0) {
     debug(
-      'Flow directories: %o',
-      flowDirs.map((d) => path.basename(d)),
+      'Scene directories: %o',
+      sceneDirs.map((d) => path.basename(d)),
     );
   }
 
-  console.log(`🚀 Found ${flowDirs.length} flows`);
-  for (const flowDir of flowDirs) {
-    const flowName = path.basename(flowDir);
-    debugFlow('Processing flow: %s', flowName);
-    debugFlow('  Path: %s', flowDir);
+  console.log(`🚀 Found ${sceneDirs.length} scenes`);
+  for (const sceneDir of sceneDirs) {
+    const sceneName = path.basename(sceneDir);
+    debugScene('Processing scene: %s', sceneName);
+    debugScene('  Path: %s', sceneDir);
 
-    console.log(`📂 Processing flow: ${flowName}`);
+    console.log(`📂 Processing scene: ${sceneName}`);
 
     try {
-      await runAllSlices(flowDir);
-      debugFlow('Flow %s completed successfully', flowName);
+      await runAllMoments(sceneDir);
+      debugScene('Scene %s completed successfully', sceneName);
     } catch (error) {
-      debugFlow('ERROR: Flow %s failed: %O', flowName, error);
+      debugScene('ERROR: Scene %s failed: %O', sceneName, error);
       throw error;
     }
   }
 
-  debug('All %d flows processed successfully', flowDirs.length);
-  console.log('✅ All flows processed');
+  debug('All %d scenes processed successfully', sceneDirs.length);
+  console.log('✅ All scenes processed');
 }

package/src/agent/runSlice.ts

@@ -34,34 +34,34 @@ export type VitestTestResult = {
   assertionResults: VitestAssertionResult[];
 };
 
-export async function runSlice(sliceDir: string, flow: string): Promise<void> {
-  const sliceName = path.basename(sliceDir);
-  console.log(`✏️ Implementing slice: ${sliceName} for flow: ${flow}`);
-  const contextFiles = await loadContextFiles(sliceDir);
+export async function runMoment(momentDir: string, scene: string): Promise<void> {
+  const momentName = path.basename(momentDir);
+  console.log(`✏️ Implementing slice: ${momentName} for scene: ${scene}`);
+  const contextFiles = await loadContextFiles(momentDir);
   const filesToImplement = findFilesToImplement(contextFiles, needsImplementation);
   for (const [targetFile] of filesToImplement) {
-    await implementFileFromAI(sliceDir, targetFile, contextFiles);
+    await implementFileFromAI(momentDir, targetFile, contextFiles);
   }
-  const result = await runTestsAndTypecheck(sliceDir);
-  reportTestAndTypecheckResults(sliceDir, flow, result);
+  const result = await runTestsAndTypecheck(momentDir);
+  reportTestAndTypecheckResults(momentDir, scene, result);
   if (result.success) {
     console.log(`✅ All tests and checks passed on first attempt.`);
     return;
   }
-  await retryFailedFiles(sliceDir, flow, result);
+  await retryFailedFiles(momentDir, scene, result);
   if (result.failedTestFiles.length > 0) {
-    await retryFailedTests(sliceDir, flow, result);
+    await retryFailedTests(momentDir, scene, result);
   }
 }
 
 async function retryFailedFiles(
-  sliceDir: string,
-  flow: string,
+  momentDir: string,
+  scene: string,
   initialResult: TestAndTypecheckResult,
   depth = 0,
 ): Promise<TestAndTypecheckResult> {
   const MAX_RECURSION_DEPTH = 2;
-  let contextFiles = await loadContextFiles(sliceDir);
+  let contextFiles = await loadContextFiles(momentDir);
   let result = initialResult;
   for (let attempt = 1; attempt <= 5; attempt++) {
     if (result.failedTypecheckFiles.length === 0) {
@@ -69,18 +69,18 @@ async function retryFailedFiles(
       break;
     }
     console.log(`🔁 Typecheck retry attempt ${attempt} for ${result.failedTypecheckFiles.length} files...`);
-    contextFiles = await loadContextFiles(sliceDir);
+    contextFiles = await loadContextFiles(momentDir);
     for (const filePath of result.failedTypecheckFiles) {
       const fileName = path.basename(filePath);
       const retryPrompt = buildRetryPrompt(fileName, contextFiles, result.testErrors, result.typecheckErrors);
-      console.log(`🔧 Retrying typecheck error in ${fileName} in flow ${flow}...`);
+      console.log(`🔧 Retrying typecheck error in ${fileName} in scene ${scene}...`);
       const { text: aiOutput } = await generateText({ model: createModelFromEnv(), prompt: retryPrompt });
       const cleanedCode = extractCodeBlock(aiOutput);
-      await writeFile(path.join(sliceDir, fileName), cleanedCode, 'utf-8');
+      await writeFile(path.join(momentDir, fileName), cleanedCode, 'utf-8');
       console.log(`♻️ Updated ${fileName} to fix typecheck errors`);
     }
-    result = await runTestsAndTypecheck(sliceDir);
-    reportTestAndTypecheckResults(sliceDir, flow, result);
+    result = await runTestsAndTypecheck(momentDir);
+    reportTestAndTypecheckResults(momentDir, scene, result);
   }
   if (result.failedTypecheckFiles.length > 0) {
     if (depth >= MAX_RECURSION_DEPTH) {
@@ -93,10 +93,10 @@ async function retryFailedFiles(
       testErrors: '', // Clear test errors since we're only fixing typecheck
       failedTestFiles: [], // Clear failed test files
     };
-    result = await retryFailedFiles(sliceDir, path.basename(sliceDir), typecheckOnlyResult, depth + 1);
+    result = await retryFailedFiles(momentDir, scene, typecheckOnlyResult, depth + 1);
     // After fixing typecheck, re-run everything to get fresh results
-    const freshResult = await runTestsAndTypecheck(sliceDir);
-    reportTestAndTypecheckResults(sliceDir, flow, freshResult);
+    const freshResult = await runTestsAndTypecheck(momentDir);
+    reportTestAndTypecheckResults(momentDir, scene, freshResult);
     result = freshResult;
     if (result.failedTestFiles.length === 0) {
       console.log(`✅ All test issues resolved after fixing type errors.`);
@@ -154,8 +154,8 @@ Return only the corrected full contents of ${targetFile}, no commentary, no mark
 `.trim();
 }
 
-async function implementFileFromAI(sliceDir: string, targetFile: string, contextFiles: Record<string, string>) {
-  const filePath = path.join(sliceDir, targetFile);
+async function implementFileFromAI(momentDir: string, targetFile: string, contextFiles: Record<string, string>) {
+  const filePath = path.join(momentDir, targetFile);
   const prompt = buildInitialPrompt(targetFile, contextFiles);
   console.log(`🔮 Analysing and Implementing ${targetFile}`);
   const { text: aiOutput } = await generateText({ model: createModelFromEnv(), prompt });
@@ -165,12 +165,12 @@ async function implementFileFromAI(sliceDir: string, targetFile: string, context
   console.log(`♻ Implemented ${targetFile}`);
 }
 
-export async function runTestsAndTypecheck(sliceDir: string): Promise<TestAndTypecheckResult> {
-  const rootDir = await findProjectRoot(sliceDir);
-  const testResult = await runTests(sliceDir, rootDir);
-  const typecheckResult = await runTypecheck(sliceDir, rootDir);
-  const shadowResult = await detectShadowsInSlice(sliceDir);
-  const assertionResult = await detectAssertionsInSlice(sliceDir);
+export async function runTestsAndTypecheck(momentDir: string): Promise<TestAndTypecheckResult> {
+  const rootDir = await findProjectRoot(momentDir);
+  const testResult = await runTests(momentDir, rootDir);
+  const typecheckResult = await runTypecheck(momentDir, rootDir);
+  const shadowResult = await detectShadowsInMoment(momentDir);
+  const assertionResult = await detectAssertionsInMoment(momentDir);
   const failedTypecheckFiles = [
     ...typecheckResult.failedTypecheckFiles,
     ...shadowResult.failedFiles,
@@ -193,38 +193,38 @@ export async function runTestsAndTypecheck(sliceDir: string): Promise<TestAndTyp
   };
 }
 
-export async function detectShadowsInSlice(sliceDir: string): Promise<{ errors: string; failedFiles: string[] }> {
-  const files = await fg(['*.ts'], { cwd: sliceDir, ignore: ['*.spec.ts', '*.specs.ts', '*.test.ts'] });
+export async function detectShadowsInMoment(momentDir: string): Promise<{ errors: string; failedFiles: string[] }> {
+  const files = await fg(['*.ts'], { cwd: momentDir, ignore: ['*.spec.ts', '*.specs.ts', '*.test.ts'] });
   const errors: string[] = [];
   const failedFiles: string[] = [];
   for (const file of files) {
-    const content = await readFile(path.join(sliceDir, file), 'utf-8');
+    const content = await readFile(path.join(momentDir, file), 'utf-8');
     const warning = buildShadowWarning(content, file);
     if (warning.length > 0) {
       errors.push(warning);
-      failedFiles.push(path.join(sliceDir, file));
+      failedFiles.push(path.join(momentDir, file));
     }
   }
   return { errors: errors.join('\n'), failedFiles };
 }
 
-export async function detectAssertionsInSlice(sliceDir: string): Promise<{ errors: string; failedFiles: string[] }> {
-  const files = await fg(['*.ts'], { cwd: sliceDir, ignore: ['*.spec.ts', '*.specs.ts', '*.test.ts'] });
+export async function detectAssertionsInMoment(momentDir: string): Promise<{ errors: string; failedFiles: string[] }> {
+  const files = await fg(['*.ts'], { cwd: momentDir, ignore: ['*.spec.ts', '*.specs.ts', '*.test.ts'] });
   const errors: string[] = [];
   const failedFiles: string[] = [];
   for (const file of files) {
-    const content = await readFile(path.join(sliceDir, file), 'utf-8');
+    const content = await readFile(path.join(momentDir, file), 'utf-8');
     const warning = buildTypeAssertionWarning(content, file);
     if (warning.length > 0) {
       errors.push(warning);
-      failedFiles.push(path.join(sliceDir, file));
+      failedFiles.push(path.join(momentDir, file));
     }
   }
   return { errors: errors.join('\n'), failedFiles };
 }
 
-async function retryFailedTests(sliceDir: string, flow: string, result: TestAndTypecheckResult) {
-  let contextFiles = await loadContextFiles(sliceDir);
+async function retryFailedTests(momentDir: string, scene: string, result: TestAndTypecheckResult) {
+  let contextFiles = await loadContextFiles(momentDir);
   for (let attempt = 1; attempt <= 5; attempt++) {
     if (result.failedTestFiles.length === 0) {
       console.log(`✅ Test failures resolved after attempt ${attempt - 1}`);
@@ -266,34 +266,34 @@ No commentary or markdown outside the code block.
     }
 
     const [, fileName, code] = match;
-    const absPath = path.join(sliceDir, fileName.trim());
+    const absPath = path.join(momentDir, fileName.trim());
     console.log('🔧 Applying AI fix to:', absPath);
     await writeFile(absPath, code.trim(), 'utf-8');
     console.log(`♻️ Updated ${fileName.trim()} to fix tests`);
-    contextFiles = await loadContextFiles(sliceDir);
-    result = await runTestsAndTypecheck(sliceDir);
-    reportTestAndTypecheckResults(sliceDir, flow, result);
+    contextFiles = await loadContextFiles(momentDir);
+    result = await runTestsAndTypecheck(momentDir);
+    reportTestAndTypecheckResults(momentDir, scene, result);
     // If test fix introduced a new type error, handle it before continuing
     if (result.failedTypecheckFiles.length > 0) {
       console.log(`⚠️ Fixing tests caused typecheck errors. Retrying typecheck fixes...`);
-      result = await retryFailedFiles(sliceDir, flow, result);
+      result = await retryFailedFiles(momentDir, scene, result);
       if (result.failedTestFiles.length === 0) {
         console.log(`✅ All test issues resolved after fixing type errors.`);
         break;
       }
     }
-    contextFiles = await loadContextFiles(sliceDir);
+    contextFiles = await loadContextFiles(momentDir);
   }
 
   if (result.failedTestFiles.length > 0) {
     console.error(`❌ Some test failures remain after retry attempts.`);
     for (const file of result.failedTestFiles) {
-      console.log(`   - ${path.relative(sliceDir, file)}`);
+      console.log(`   - ${path.relative(momentDir, file)}`);
     }
   }
 }
 
-async function runTypecheck(sliceDir: string, rootDir: string) {
+async function runTypecheck(momentDir: string, rootDir: string) {
   try {
     const result = await execa('npx', ['tsc', '--noEmit'], {
       cwd: rootDir,
@@ -302,14 +302,14 @@ async function runTypecheck(sliceDir: string, rootDir: string) {
     });
     const output = (result.stdout ?? '') + (result.stderr ?? '');
     if (result.exitCode !== 0 || output.includes('error')) {
-      return await processTypecheckOutput(output, sliceDir, rootDir);
+      return await processTypecheckOutput(output, momentDir, rootDir);
     }
     return { success: true, typecheckErrors: '', failedTypecheckFiles: [] };
   } catch (err: unknown) {
     const execaErr = err as { stdout?: string; stderr?: string };
     const output = (execaErr.stdout ?? '') + (execaErr.stderr ?? '');
     console.error('TypeScript execution error:', output);
-    const files = await fg(['*.ts'], { cwd: sliceDir, absolute: true });
+    const files = await fg(['*.ts'], { cwd: momentDir, absolute: true });
     return { success: false, typecheckErrors: output, failedTypecheckFiles: files };
   }
 }
@@ -322,7 +322,7 @@ function getTypecheckPatterns(): RegExp[] {
   ];
 }
 
-function extractFailedFiles(output: string, patterns: RegExp[], rootDir: string, sliceDir?: string): string[] {
+function extractFailedFiles(output: string, patterns: RegExp[], rootDir: string, momentDir?: string): string[] {
   const failedFiles = new Set<string>();
 
   for (const pattern of patterns) {
@@ -330,9 +330,9 @@ function extractFailedFiles(output: string, patterns: RegExp[], rootDir: string,
       const filePath = match[1] ? path.resolve(rootDir, match[1]) : '';
 
       const notNodeModules = !filePath.includes('node_modules');
-      const inSlice = sliceDir === undefined || filePath.startsWith(sliceDir);
+      const inMoment = momentDir === undefined || filePath.startsWith(momentDir);
 
-      if (notNodeModules && inSlice) {
+      if (notNodeModules && inMoment) {
         failedFiles.add(filePath);
       }
     }
@@ -341,15 +341,15 @@ function extractFailedFiles(output: string, patterns: RegExp[], rootDir: string,
   return Array.from(failedFiles);
 }
 
-async function processTypecheckOutput(output: string, sliceDir: string, rootDir: string) {
-  const relativePath = path.relative(rootDir, sliceDir);
+async function processTypecheckOutput(output: string, momentDir: string, rootDir: string) {
+  const relativePath = path.relative(rootDir, momentDir);
   const filtered = output
     .split('\n')
     .filter((line) => {
       const hasError = line.includes('error TS') || line.includes('): error');
       const notNodeModules = !line.includes('node_modules');
-      const hasSlicePath = line.includes(relativePath) || line.includes(sliceDir);
-      return hasError && notNodeModules && hasSlicePath;
+      const hasMomentPath = line.includes(relativePath) || line.includes(momentDir);
+      return hasError && notNodeModules && hasMomentPath;
     })
     .join('\n');
 
@@ -357,7 +357,7 @@ async function processTypecheckOutput(output: string, sliceDir: string, rootDir:
     return { success: true, typecheckErrors: '', failedTypecheckFiles: [] };
   }
 
-  const failedFiles = await processTypecheckFailure(filtered, rootDir, sliceDir);
+  const failedFiles = await processTypecheckFailure(filtered, rootDir, momentDir);
   return {
     success: false,
     typecheckErrors: filtered,
@@ -365,12 +365,12 @@ async function processTypecheckOutput(output: string, sliceDir: string, rootDir:
   };
 }
 
-async function processTypecheckFailure(output: string, rootDir: string, sliceDir: string): Promise<string[]> {
+async function processTypecheckFailure(output: string, rootDir: string, momentDir: string): Promise<string[]> {
   const patterns = getTypecheckPatterns();
-  let failed = extractFailedFiles(output, patterns, rootDir, sliceDir);
+  let failed = extractFailedFiles(output, patterns, rootDir, momentDir);
 
   if (failed.length === 0 && output.includes('error')) {
-    failed = await fg(['*.ts'], { cwd: sliceDir, absolute: true });
+    failed = await fg(['*.ts'], { cwd: momentDir, absolute: true });
   }
 
   return failed;
@@ -389,22 +389,22 @@ async function findProjectRoot(startDir: string): Promise<string> {
   throw new Error('❌ Could not find project root');
 }
 
-function reportTestAndTypecheckResults(sliceDir: string, flow: string, result: TestAndTypecheckResult) {
-  const sliceName = path.basename(sliceDir);
+function reportTestAndTypecheckResults(momentDir: string, scene: string, result: TestAndTypecheckResult) {
+  const momentName = path.basename(momentDir);
   if (result.success) {
-    console.log(`✅ All Tests and checks passed for: ${sliceName} in flow ${flow}`);
+    console.log(`✅ All Tests and checks passed for: ${momentName} in scene ${scene}`);
     return;
   }
-  console.error(`❌ ${sliceName} in floe ${flow} failed tests or type-checks.`);
+  console.error(`❌ ${momentName} in scene ${scene} failed tests or type-checks.`);
   if (result.failedTestFiles.length) {
-    const files = result.failedTestFiles.map((f) => path.relative(sliceDir, f));
+    const files = result.failedTestFiles.map((f) => path.relative(momentDir, f));
     console.log(`🧪 Failed test files: ${files.join(', ')}`);
     if (result.testErrors) {
       console.log(`📝 Test errors:\n${result.testErrors}`);
     }
   }
   if (result.failedTypecheckFiles.length) {
-    const files = result.failedTypecheckFiles.map((f) => path.relative(sliceDir, f));
+    const files = result.failedTypecheckFiles.map((f) => path.relative(momentDir, f));
     console.log(`📐 Failed typecheck files: ${files.join(', ')}`);
     if (result.typecheckErrors) {
       console.log(`📝 Typecheck errors:\n${result.typecheckErrors}`);

package/src/agent/runTests.ts

@@ -15,17 +15,17 @@ export type TestResult = {
   failedTestFiles: string[];
 };
 
-export async function runTests(sliceDir: string, rootDir: string): Promise<TestResult> {
-  console.log(`🔍 Running tests in ${path.basename(sliceDir)}...`);
-  const testFiles = await fg(['*.spec.ts', '*.specs.ts'], { cwd: sliceDir });
+export async function runTests(momentDir: string, rootDir: string): Promise<TestResult> {
+  console.log(`🔍 Running tests in ${path.basename(momentDir)}...`);
+  const testFiles = await fg(['*.spec.ts', '*.specs.ts'], { cwd: momentDir });
   if (testFiles.length === 0) {
-    console.warn(`⚠️ No test files found in ${sliceDir}`);
+    console.warn(`⚠️ No test files found in ${momentDir}`);
     return { success: true, testErrors: '', failedTestFiles: [] };
   } else {
-    console.log(`🔍 Found test files in ${path.basename(sliceDir)}:`, testFiles);
+    console.log(`🔍 Found test files in ${path.basename(momentDir)}:`, testFiles);
   }
-  const relativePaths = testFiles.map((f) => path.join(sliceDir, f).replace(`${rootDir}/`, ''));
-  const reportPath = path.join(sliceDir, 'vitest-results.json');
+  const relativePaths = testFiles.map((f) => path.join(momentDir, f).replace(`${rootDir}/`, ''));
+  const reportPath = path.join(momentDir, 'vitest-results.json');
   try {
     const { stdout, stderr } = await execa(
       'npx',
@@ -52,9 +52,9 @@ export async function runTests(sliceDir: string, rootDir: string): Promise<TestR
             const fileName = r.name ?? r.file;
             if (!fileName) {
               console.warn('⚠️ Skipping test result with missing name or file:', r);
-              return path.join(sliceDir, 'unknown');
+              return path.join(momentDir, 'unknown');
             }
-            return path.join(sliceDir, path.basename(fileName));
+            return path.join(momentDir, path.basename(fileName));
           });
 
         const failedTestSummaries = testResults
@@ -87,7 +87,7 @@ export async function runTests(sliceDir: string, rootDir: string): Promise<TestR
         return {
           success: false,
           testErrors: stdout || stderr || 'Failed to parse test results',
-          failedTestFiles: testFiles.map((f) => path.join(sliceDir, f)),
+          failedTestFiles: testFiles.map((f) => path.join(momentDir, f)),
         };
       }
     } else {
@@ -95,7 +95,7 @@ export async function runTests(sliceDir: string, rootDir: string): Promise<TestR
       return {
         success: false,
         testErrors: stdout || stderr || 'Test execution failed - no report generated',
-        failedTestFiles: testFiles.map((f) => path.join(sliceDir, f)),
+        failedTestFiles: testFiles.map((f) => path.join(momentDir, f)),
       };
     }
   } catch (err: unknown) {
@@ -105,7 +105,7 @@ export async function runTests(sliceDir: string, rootDir: string): Promise<TestR
     return {
       success: false,
       testErrors: output || 'Test execution failed with no output',
-      failedTestFiles: testFiles.map((f) => path.join(sliceDir, f)),
+      failedTestFiles: testFiles.map((f) => path.join(momentDir, f)),
     };
   } finally {
     // Clean up the report file

package/src/commands/implement-server.ts

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { type Command, defineCommandHandler, type Event } from '@auto-engineer/message-bus';
 import createDebug from 'debug';
-import { runFlows } from '../agent/runFlows';
+import { runScenes } from '../agent/runFlows';
 
 const debug = createDebug('auto:server-implementer:command');
 const debugHandler = createDebug('auto:server-implementer:command:handler');
@@ -20,7 +20,7 @@ export type ServerImplementedEvent = Event<
   'ServerImplemented',
   {
     serverDirectory: string;
-    flowsImplemented: number;
+    scenesImplemented: number;
   }
 >;
 
@@ -64,8 +64,8 @@ export const commandHandler = defineCommandHandler<
     if (result.type === 'ServerImplemented') {
       debug('Command handler completed: success');
       debug('✅ Server implementation completed successfully');
-      if (result.data.flowsImplemented > 0) {
-        debug('   %d flows implemented', result.data.flowsImplemented);
+      if (result.data.scenesImplemented > 0) {
+        debug('   %d scenes implemented', result.data.scenesImplemented);
       }
     } else {
       debug('Command handler completed: failure - %s', result.data.error);
@@ -87,19 +87,19 @@ async function handleImplementServerCommandInternal(
 
   try {
     const serverRoot = path.resolve(serverDirectory);
-    const flowsDir = path.join(serverRoot, 'src', 'domain', 'flows');
+    const scenesDir = path.join(serverRoot, 'src', 'domain', 'narratives');
 
     debugHandler('Resolved paths:');
     debugHandler('  Server root: %s', serverRoot);
-    debugHandler('  Flows directory: %s', flowsDir);
+    debugHandler('  Scenes directory: %s', scenesDir);
 
-    if (!existsSync(flowsDir)) {
-      debugHandler('ERROR: Flows directory not found at %s', flowsDir);
+    if (!existsSync(scenesDir)) {
+      debugHandler('ERROR: Scenes directory not found at %s', scenesDir);
       return {
         type: 'ServerImplementationFailed',
         data: {
           serverDirectory,
-          error: `Flows directory not found at: ${flowsDir}`,
+          error: `Scenes directory not found at: ${scenesDir}`,
         },
         timestamp: new Date(),
         requestId: command.requestId,
@@ -107,25 +107,25 @@ async function handleImplementServerCommandInternal(
       };
     }
 
-    debugProcess('Starting flow runner for directory: %s', flowsDir);
+    debugProcess('Starting scene runner for directory: %s', scenesDir);
 
-    // Run the flows directly without spawning
-    await runFlows(flowsDir);
+    // Run the scenes directly without spawning
+    await runScenes(scenesDir);
 
-    debugProcess('Flow runner completed successfully');
+    debugProcess('Scene runner completed successfully');
 
-    // For now, we don't have a way to count flows, so we'll use 0
-    // This could be enhanced by having runFlows return statistics
-    const flowsImplemented = 0;
+    // For now, we don't have a way to count scenes, so we'll use 0
+    // This could be enhanced by having runScenes return statistics
+    const scenesImplemented = 0;
 
     debugResult('Process succeeded');
-    debugResult('Flows implemented: %d', flowsImplemented);
+    debugResult('Scenes implemented: %d', scenesImplemented);
 
     const successEvent: ServerImplementedEvent = {
       type: 'ServerImplemented',
       data: {
         serverDirectory,
-        flowsImplemented,
+        scenesImplemented,
       },
       timestamp: new Date(),
       requestId: command.requestId,