@auto-engineer/pipeline 1.28.0 → 1.29.0

package/src/builder/define.ts

@@ -1,5 +1,6 @@
 import type { Event } from '@auto-engineer/message-bus';
 import type {
+  AcceptsDescriptor,
   CustomHandlerDescriptor,
   EmitHandlerDescriptor,
   EventPredicate,
@@ -23,10 +24,15 @@ export interface Pipeline {
   toGraph(): GraphIR;
 }
 
+export interface DeclareBuilder {
+  accepts(targets: string[]): PipelineBuilder;
+}
+
 export interface PipelineBuilder {
   version(v: string): PipelineBuilder;
   description(d: string): PipelineBuilder;
   key<E>(name: string, extractor: (event: E) => string): PipelineBuilder;
+  declare(commandType: string): DeclareBuilder;
   on(eventType: string): TriggerBuilder;
   settled(commandTypes: readonly string[]): SettledBuilder;
   build(): Pipeline;
@@ -42,11 +48,12 @@ export interface SettledBuilder {
     handler: (
       events: Record<string, Event[]>,
       send: (commandType: D[number], data: unknown) => void,
-    ) => void | { persist: boolean },
+    ) => undefined | { persist: boolean },
   ): SettledChain;
 }
 
 export interface SettledChain {
+  declare(commandType: string): DeclareBuilder;
   on(eventType: string): TriggerBuilder;
   settled(commandTypes: readonly string[]): SettledBuilder;
   build(): Pipeline;
@@ -124,12 +131,14 @@ export interface GatherChain {
 
 export interface EmitChain {
   emit(commandType: string, data: unknown): EmitChain;
+  declare(commandType: string): DeclareBuilder;
   on(eventType: string): TriggerBuilder;
   settled(commandTypes: readonly string[]): SettledBuilder;
   build(): Pipeline;
 }
 
 export interface HandleChain {
+  declare(commandType: string): DeclareBuilder;
   on(eventType: string): TriggerBuilder;
   build(): Pipeline;
 }
@@ -167,6 +176,10 @@ class PipelineBuilderImpl implements PipelineBuilder {
     return this;
   }
 
+  declare(commandType: string): DeclareBuilder {
+    return new DeclareBuilderImpl(this, commandType);
+  }
+
   on(eventType: string): TriggerBuilder {
     return new TriggerBuilderImpl(this, eventType);
   }
@@ -195,6 +208,18 @@ class PipelineBuilderImpl implements PipelineBuilder {
   }
 }
 
+class DeclareBuilderImpl implements DeclareBuilder {
+  constructor(
+    private readonly parent: PipelineBuilderImpl,
+    private readonly commandType: string,
+  ) {}
+
+  accepts(targets: string[]): PipelineBuilder {
+    this.parent.addHandler({ type: 'accepts', commandType: this.commandType, accepts: targets });
+    return this.parent;
+  }
+}
+
 type GraphBuilderContext = {
   nodeMap: Map<string, GraphNode>;
   edges: GraphEdge[];
@@ -254,6 +279,14 @@ function processCustomHandler(ctx: GraphBuilderContext, handler: CustomHandlerDe
   }
 }
 
+function processAcceptsHandler(ctx: GraphBuilderContext, handler: AcceptsDescriptor): void {
+  addNode(ctx, `cmd:${handler.commandType}`, 'command', handler.commandType);
+  for (const target of handler.accepts) {
+    addNode(ctx, `cmd:${target}`, 'command', target);
+    ctx.edges.push({ from: `cmd:${handler.commandType}`, to: `cmd:${target}` });
+  }
+}
+
 function processSettledHandler(ctx: GraphBuilderContext, handler: SettledHandlerDescriptor): void {
   const settledNodeId = `settled:${handler.commandTypes.join(',')}`;
   addNode(ctx, settledNodeId, 'settled', 'Settled');
@@ -294,6 +327,9 @@ function extractGraph(descriptor: PipelineDescriptor): GraphIR {
       case 'settled':
         processSettledHandler(ctx, handler);
         break;
+      case 'accepts':
+        processAcceptsHandler(ctx, handler);
+        break;
     }
   }
 
@@ -356,6 +392,11 @@ class EmitChainImpl implements EmitChain {
     return new EmitChainImpl(this.parent, this.eventType, [...this.commands, { commandType, data }], this.predicate);
   }
 
+  declare(commandType: string): DeclareBuilder {
+    this.finalizeHandler();
+    return new DeclareBuilderImpl(this.parent, commandType);
+  }
+
   on(eventType: string): TriggerBuilder {
     this.finalizeHandler();
     return new TriggerBuilderImpl(this.parent, eventType);
@@ -393,6 +434,11 @@ class HandleChainImpl implements HandleChain {
     private readonly declaredEmits?: string[],
   ) {}
 
+  declare(commandType: string): DeclareBuilder {
+    this.finalizeHandler();
+    return new DeclareBuilderImpl(this.parent, commandType);
+  }
+
   on(eventType: string): TriggerBuilder {
     this.finalizeHandler();
     return new TriggerBuilderImpl(this.parent, eventType);
@@ -682,6 +728,11 @@ class SettledChainImpl implements SettledChain {
     private readonly dispatches?: readonly string[],
   ) {}
 
+  declare(commandType: string): DeclareBuilder {
+    this.finalizeHandler();
+    return new DeclareBuilderImpl(this.parent, commandType);
+  }
+
   on(eventType: string): TriggerBuilder {
     this.finalizeHandler();
     return new TriggerBuilderImpl(this.parent, eventType);

package/src/core/descriptors.ts

@@ -78,7 +78,7 @@ type SettledSendFunction = (commandType: string, data: unknown) => void;
 export type SettledHandler = (
   events: Record<string, Event[]>,
   send: SettledSendFunction,
-) => void | { persist: boolean };
+) => undefined | { persist: boolean };
 
 export interface SettledHandlerDescriptor {
   type: 'settled';
@@ -87,13 +87,19 @@ export interface SettledHandlerDescriptor {
   dispatches?: readonly string[];
 }
 
+export interface AcceptsDescriptor {
+  type: 'accepts';
+  commandType: string;
+  accepts: string[];
+}
+
 export type EventHandlerDescriptor =
   | EmitHandlerDescriptor
   | RunAwaitHandlerDescriptor
   | ForEachPhasedDescriptor
   | CustomHandlerDescriptor;
 
-export type HandlerDescriptor = EventHandlerDescriptor | SettledHandlerDescriptor;
+export type HandlerDescriptor = EventHandlerDescriptor | SettledHandlerDescriptor | AcceptsDescriptor;
 
 export interface PipelineDescriptor {
   name: string;

package/src/index.ts

@@ -1,6 +1,7 @@
 export type { EventHandler, EventSubscription, MessageBus } from '@auto-engineer/message-bus';
 export type {
   CompletionConfig,
+  DeclareBuilder,
   EmitChain,
   ForEachBuilder,
   GatherBuilder,
@@ -17,6 +18,7 @@ export type {
 } from './builder/define';
 export { define } from './builder/define';
 export type {
+  AcceptsDescriptor,
   CustomHandlerDescriptor,
   EmitHandlerDescriptor,
   EventPredicate,

package/src/plugins/plugin-loader.specs.ts

@@ -277,12 +277,5 @@ describe('PluginLoader', () => {
       expect(handlerNames).toContain('GenerateServer');
       expect(handlers.length).toBeGreaterThan(3);
     });
-
-    it('should load ExportSchema from narrative package node entry', async () => {
-      const loader = new PluginLoader();
-      const handlers = await loader.loadPlugin('@auto-engineer/narrative');
-      const handlerNames = handlers.map((h) => h.name);
-      expect(handlerNames).toContain('ExportSchema');
-    });
   });
 });

package/src/runtime/pipeline-runtime.ts

@@ -109,7 +109,7 @@ export class PipelineRuntime {
   private buildHandlerIndex(): Map<string, EventHandlerDescriptor[]> {
     const index = new Map<string, EventHandlerDescriptor[]>();
     for (const handler of this.descriptor.handlers) {
-      if (handler.type === 'settled') {
+      if (handler.type === 'settled' || handler.type === 'accepts') {
         continue;
       }
       const existing = index.get(handler.eventType) ?? [];

package/src/runtime/settled-tracker.ts

@@ -4,7 +4,7 @@ import type { PipelineReadModel } from '../store/pipeline-read-model';
 
 type SendFunction = (commandType: string, data: unknown) => void;
 
-type SettledHandler = (events: Record<string, Event[]>, send: SendFunction) => void | { persist: boolean };
+type SettledHandler = (events: Record<string, Event[]>, send: SendFunction) => undefined | { persist: boolean };
 
 interface SettledHandlerRegistration {
   commandTypes: readonly string[];
@@ -223,7 +223,7 @@ export class SettledTracker {
     return events;
   }
 
-  private shouldPersist(result: void | { persist: boolean }): boolean {
+  private shouldPersist(result: undefined | { persist: boolean }): boolean {
     return (
       result !== null &&
       result !== undefined &&

package/src/server/full-orchestration.e2e.specs.ts

@@ -51,8 +51,8 @@ describe('Full Orchestration E2E', () => {
       expect(graph.edges.length).toBeGreaterThan(0);
 
       const nodeIds = graph.nodes.map((n) => n.id);
-      expect(nodeIds).toContain('evt:SchemaExported');
-      expect(nodeIds).toContain('cmd:GenerateServer');
+      expect(nodeIds).toContain('evt:ServerGenerated');
+      expect(nodeIds).toContain('cmd:GenerateIA');
       expect(nodeIds).toContain('evt:SliceImplemented');
       expect(nodeIds).toContain('evt:AllComponentsImplemented');
     });
@@ -260,11 +260,6 @@ describe('Full Orchestration E2E', () => {
   describe('complete kanban workflow', () => {
     it('should execute full kanban workflow with mock handlers', async () => {
       const handlers = createMockHandlers([
-        {
-          name: 'ExportSchema',
-          events: ['SchemaExported'],
-          fn: () => ({ type: 'SchemaExported', data: { outputPath: './schema.json' } }),
-        },
         {
           name: 'GenerateServer',
           events: ['ServerGenerated', 'SliceGenerated'],
@@ -340,7 +335,7 @@ describe('Full Orchestration E2E', () => {
       await fetchJson(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'ExportSchema', data: {} }),
+        body: JSON.stringify({ type: 'GenerateServer', data: {} }),
       });
 
       await delay(800);
@@ -349,7 +344,6 @@ describe('Full Orchestration E2E', () => {
       const eventTypes = messages.filter((m) => m.messageType === 'event').map((m) => m.message.type);
 
       const expectedSubsequence = [
-        'SchemaExported',
         'SliceGenerated',
         'SliceImplemented',
         'TestsCheckPassed',
@@ -363,7 +357,6 @@ describe('Full Orchestration E2E', () => {
       expect(eventTypes).toContain('AllComponentsImplemented');
 
       const missingEvents = findMissingEvents(eventTypes, [
-        'SchemaExported',
         'SliceGenerated',
         'SliceImplemented',
         'ServerGenerated',
@@ -381,11 +374,6 @@ describe('Full Orchestration E2E', () => {
       let typeCheckCallCount = 0;
 
       const handlers = createMockHandlers([
-        {
-          name: 'ExportSchema',
-          events: ['SchemaExported'],
-          fn: () => ({ type: 'SchemaExported', data: { outputPath: './schema.json' } }),
-        },
         {
           name: 'GenerateServer',
           events: ['ServerGenerated', 'SliceGenerated'],
@@ -461,7 +449,7 @@ describe('Full Orchestration E2E', () => {
       await fetchJson(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'ExportSchema', data: {} }),
+        body: JSON.stringify({ type: 'GenerateServer', data: {} }),
       });
 
       await delay(1000);

package/src/server/pipeline-server.e2e.specs.ts

@@ -55,17 +55,14 @@ describe('PipelineServer E2E', () => {
   describe('baseline endpoints (CLI E2E parity)', () => {
     it('should return registry with expected shape', async () => {
       const handler: CommandHandlerWithMetadata = {
-        name: 'ExportSchema',
-        alias: 'export:schema',
-        description: 'Export flow schemas to context directory',
-        events: ['SchemaExported'],
-        handle: async () => ({ type: 'SchemaExported', data: {} }),
+        name: 'TestCommand',
+        alias: 'test:run',
+        description: 'Run test command',
+        events: ['TestDone'],
+        handle: async () => ({ type: 'TestDone', data: {} }),
       };
 
-      const pipeline = define('kanban')
-        .on('SchemaExported')
-        .emit('GenerateServer', { modelPath: './.context/schema.json' })
-        .build();
+      const pipeline = define('kanban').on('TestDone').emit('GenerateServer', {}).build();
 
       const server = new PipelineServer({ port: 0 });
       server.registerCommandHandlers([handler]);
@@ -74,26 +71,26 @@ describe('PipelineServer E2E', () => {
 
       const registry = await fetchJson<RegistryResponse>(`http://localhost:${server.port}/registry`);
 
-      expect(registry.eventHandlers).toContain('SchemaExported');
-      expect(registry.commandHandlers).toContain('ExportSchema');
+      expect(registry.eventHandlers).toContain('TestDone');
+      expect(registry.commandHandlers).toContain('TestCommand');
       expect(registry.folds).toEqual([]);
       expect(registry.commandsWithMetadata).toHaveLength(1);
-      expect(registry.commandsWithMetadata[0].alias).toBe('export:schema');
-      expect(registry.commandsWithMetadata[0].description).toBe('Export flow schemas to context directory');
+      expect(registry.commandsWithMetadata[0].alias).toBe('test:run');
+      expect(registry.commandsWithMetadata[0].description).toBe('Run test command');
 
       await server.stop();
     });
 
     it('should return pipeline with expected shape', async () => {
       const handler: CommandHandlerWithMetadata = {
-        name: 'ExportSchema',
-        alias: 'export:schema',
-        description: 'Export schemas',
-        events: ['SchemaExported'],
-        handle: async () => ({ type: 'SchemaExported', data: {} }),
+        name: 'TestCommand',
+        alias: 'test:run',
+        description: 'Run test command',
+        events: ['TestDone'],
+        handle: async () => ({ type: 'TestDone', data: {} }),
       };
 
-      const pipeline = define('kanban').on('SchemaExported').emit('GenerateServer', {}).build();
+      const pipeline = define('kanban').on('TestDone').emit('GenerateServer', {}).build();
 
       const server = new PipelineServer({ port: 0 });
       server.registerCommandHandlers([handler]);
@@ -102,9 +99,9 @@ describe('PipelineServer E2E', () => {
 
       const pipelineRes = await fetchJson<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
 
-      expect(pipelineRes.nodes.some((n) => n.id === 'evt:SchemaExported')).toBe(true);
+      expect(pipelineRes.nodes.some((n) => n.id === 'evt:TestDone')).toBe(true);
       expect(pipelineRes.nodes.some((n) => n.id === 'cmd:GenerateServer')).toBe(true);
-      expect(pipelineRes.pipelineNodes.some((n) => n.id === 'ExportSchema')).toBe(true);
+      expect(pipelineRes.pipelineNodes.some((n) => n.id === 'TestCommand')).toBe(true);
 
       await server.stop();
     });
@@ -131,8 +128,8 @@ describe('PipelineServer E2E', () => {
 
     it('should accept command and return ack', async () => {
       const handler: CommandHandlerWithMetadata = {
-        name: 'ExportSchema',
-        handle: async () => ({ type: 'SchemaExported', data: {} }),
+        name: 'TestCommand',
+        handle: async () => ({ type: 'TestDone', data: {} }),
       };
 
       const server = new PipelineServer({ port: 0 });
@@ -142,7 +139,7 @@ describe('PipelineServer E2E', () => {
       const ack = await fetchJson<CommandAck>(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'ExportSchema', data: {} }),
+        body: JSON.stringify({ type: 'TestCommand', data: {} }),
       });
 
       expect(ack.status).toBe('ack');
@@ -155,9 +152,9 @@ describe('PipelineServer E2E', () => {
   describe('command execution and event routing', () => {
     it('should execute command and route resulting event through pipeline', async () => {
       const exportHandler: CommandHandlerWithMetadata = {
-        name: 'ExportSchema',
-        events: ['SchemaExported'],
-        handle: async () => ({ type: 'SchemaExported', data: { path: './schema.json' } }),
+        name: 'TestCommand',
+        events: ['TestDone'],
+        handle: async () => ({ type: 'TestDone', data: { path: './schema.json' } }),
       };
 
       const generateHandler: CommandHandlerWithMetadata = {
@@ -166,10 +163,7 @@ describe('PipelineServer E2E', () => {
         handle: async () => ({ type: 'ServerGenerated', data: { slices: 3 } }),
       };
 
-      const pipeline = define('kanban')
-        .on('SchemaExported')
-        .emit('GenerateServer', (e: { data: { path: string } }) => ({ modelPath: e.data.path }))
-        .build();
+      const pipeline = define('kanban').on('TestDone').emit('GenerateServer', {}).build();
 
       const server = new PipelineServer({ port: 0 });
       server.registerCommandHandlers([exportHandler, generateHandler]);
@@ -179,7 +173,7 @@ describe('PipelineServer E2E', () => {
       await fetchJson(`http://localhost:${server.port}/command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ type: 'ExportSchema', data: {} }),
+        body: JSON.stringify({ type: 'TestCommand', data: {} }),
       });
 
       await new Promise((r) => setTimeout(r, 200));
@@ -187,7 +181,7 @@ describe('PipelineServer E2E', () => {
       const messages = await fetchJson<StoredMessage[]>(`http://localhost:${server.port}/messages`);
       const eventTypes = messages.filter((m) => m.messageType === 'event').map((m) => m.message.type);
 
-      expect(eventTypes).toContain('SchemaExported');
+      expect(eventTypes).toContain('TestDone');
       expect(eventTypes).toContain('ServerGenerated');
 
       await server.stop();

package/src/server/pipeline-server.specs.ts

@@ -1117,11 +1117,9 @@ describe('PipelineServer', () => {
         handle: async () => ({ type: 'SliceImplemented', data: {} }),
       };
       const pipeline = define('test')
-        .on('SchemaExported')
-        .emit('GenerateServer', {})
         .on('ServerGenerated')
         .emit('GenerateIA', {})
-        .on('SliceGenerated')
+        .on('IAGenerated')
         .emit('ImplementSlice', {})
         .build();
       const server = new PipelineServer({ port: 0 });
@@ -1130,9 +1128,8 @@ describe('PipelineServer', () => {
       await server.start();
       const res = await fetch(`http://localhost:${server.port}/pipeline/mermaid`);
       const mermaid = await res.text();
-      expect(mermaid).toContain('evt_SchemaExported --> GenerateServer');
-      expect(mermaid).toContain('GenerateServer --> evt_ServerGenerated');
-      expect(mermaid).toContain('GenerateServer --> evt_SliceGenerated');
+      expect(mermaid).toContain('evt_ServerGenerated --> GenerateIA');
+      expect(mermaid).toContain('evt_IAGenerated --> ImplementSlice');
       await server.stop();
     });
 
@@ -1202,6 +1199,44 @@ describe('PipelineServer', () => {
       await server.stop();
     });
 
+    it('should show source commands whose events are listened to by the pipeline', async () => {
+      const sourceHandler = {
+        name: 'SourceCmd',
+        events: ['SourceEvent'],
+        handle: async () => ({ type: 'SourceEvent', data: {} }),
+      };
+      const nextHandler = {
+        name: 'NextCmd',
+        events: ['NextDone'],
+        handle: async () => ({ type: 'NextDone', data: {} }),
+      };
+      const pipeline = define('test').on('SourceEvent').emit('NextCmd', {}).build();
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([sourceHandler, nextHandler]);
+      server.registerPipeline(pipeline);
+      await server.start();
+      const res = await fetch(`http://localhost:${server.port}/pipeline/mermaid`);
+      const mermaid = await res.text();
+      expect(mermaid).toEqual(
+        [
+          'flowchart LR',
+          '  evt_SourceEvent([SourceEvent])',
+          '  NextCmd[NextCmd]',
+          '  SourceCmd[SourceCmd]',
+          '  evt_SourceEvent --> NextCmd',
+          '  SourceCmd --> evt_SourceEvent',
+          '',
+          '  classDef event fill:#fff3e0,stroke:#e65100',
+          '  classDef eventFailed fill:#fff3e0,stroke:#e65100,color:#d32f2f',
+          '  classDef command fill:#e3f2fd,stroke:#1565c0',
+          '  classDef settled fill:#f3e5f5,stroke:#7b1fa2',
+          '  class evt_SourceEvent event',
+          '  class NextCmd,SourceCmd command',
+        ].join('\n'),
+      );
+      await server.stop();
+    });
+
     it('should show edges from commands to settled node', async () => {
       const checkAHandler = {
         name: 'CheckA',

package/src/server/pipeline-server.ts

@@ -205,7 +205,7 @@ export class PipelineServer {
       const eventHandlers: string[] = [];
       for (const pipeline of this.pipelines.values()) {
         for (const handler of pipeline.descriptor.handlers) {
-          if (handler.type === 'settled') {
+          if (handler.type === 'settled' || handler.type === 'accepts') {
             continue;
           }
           if (!eventHandlers.includes(handler.eventType)) {
@@ -715,13 +715,17 @@ export class PipelineServer {
     const newEdges = [...graph.edges];
 
     for (const [commandName, events] of Object.entries(commandToEvents)) {
-      if (!commandNodes.has(commandName)) {
+      const relevantEvents = events.filter((e) => pipelineEvents.has(e));
+      if (relevantEvents.length === 0) {
         continue;
       }
-      for (const eventName of events) {
-        if (!pipelineEvents.has(eventName)) {
-          continue;
-        }
+
+      if (!commandNodes.has(commandName)) {
+        newNodes.push({ id: `cmd:${commandName}`, type: 'command', label: commandName });
+        commandNodes.add(commandName);
+      }
+
+      for (const eventName of relevantEvents) {
         const eventId = `evt:${eventName}`;
         if (!existingEventIds.has(eventId)) {
           newNodes.push({ id: eventId, type: 'event', label: eventName });

package/src/testing/fixtures/kanban-full.pipeline.specs.ts

@@ -52,13 +52,6 @@ describe('kanban-full.pipeline', () => {
       expect(pipeline.descriptor.name).toBe('kanban-full');
     });
 
-    it('should have emit handlers for schema export', () => {
-      const pipeline = createKanbanFullPipeline();
-      const emitHandlers = pipeline.descriptor.handlers.filter((h): h is EmitHandlerDescriptor => h.type === 'emit');
-      const eventTypes = emitHandlers.map((h) => h.eventType);
-      expect(eventTypes).toContain('SchemaExported');
-    });
-
     it('should have settled handler for slice checks', () => {
       const pipeline = createKanbanFullPipeline();
       const settledHandlers = pipeline.descriptor.handlers.filter((h) => h.type === 'settled');
@@ -92,23 +85,6 @@ describe('kanban-full.pipeline', () => {
       return undefined;
     }
 
-    it('should emit GenerateServer with modelPath and destination', () => {
-      const pipeline = createKanbanFullPipeline();
-      const cmd = findEmitCommand(pipeline, 'SchemaExported', 'GenerateServer');
-      expect(cmd).toBeDefined();
-      const data =
-        typeof cmd?.data === 'function'
-          ? cmd.data({
-              type: 'SchemaExported',
-              data: { outputPath: './.context/schema.json', directory: '.' },
-            })
-          : cmd?.data;
-      expect(data).toEqual({
-        modelPath: './.context/schema.json',
-        destination: '.',
-      });
-    });
-
     it('should emit ImplementSlice with slicePath, context, and aiOptions', () => {
       const pipeline = createKanbanFullPipeline();
       const cmd = findEmitCommand(pipeline, 'SliceGenerated', 'ImplementSlice');

package/src/testing/fixtures/kanban-full.pipeline.ts

@@ -6,11 +6,6 @@ interface Component {
   filePath: string;
 }
 
-interface SchemaExportedData {
-  directory: string;
-  outputPath: string;
-}
-
 interface SliceGeneratedData {
   slicePath: string;
 }
@@ -89,15 +84,6 @@ function resolvePath(relativePath: string): string {
 
 export function createKanbanFullPipeline() {
   return define('kanban-full')
-    .on('SchemaExported')
-    .emit('GenerateServer', (e: { data: SchemaExportedData }) => {
-      projectRoot = e.data.directory;
-      return {
-        modelPath: e.data.outputPath,
-        destination: e.data.directory,
-      };
-    })
-
     .on('SliceGenerated')
     .emit('ImplementSlice', (e: { data: SliceGeneratedData }) => ({
       slicePath: resolvePath(e.data.slicePath),

package/src/testing/fixtures/kanban-todo.config.ts

@@ -6,7 +6,6 @@ export default pipelineConfig({
     '@auto-engineer/server-checks',
     '@auto-engineer/server-generator-apollo-emmett',
     '@auto-engineer/narrative',
-    '@auto-engineer/information-architect',
     '@auto-engineer/generate-react-client',
     '@auto-engineer/react-component-implementer',
     '@auto-engineer/server-implementer',

package/src/testing/fixtures/kanban.pipeline.specs.ts

@@ -26,7 +26,6 @@ describe('kanban.pipeline', () => {
     it('should have handlers for slice workflow', () => {
       const pipeline = createKanbanPipeline();
       const eventTypes = pipeline.descriptor.handlers.filter((h) => h.type === 'emit').map((h) => h.eventType);
-      expect(eventTypes).toContain('SchemaExported');
       expect(eventTypes).toContain('SliceGenerated');
     });
   });

package/src/testing/fixtures/kanban.pipeline.ts

@@ -7,10 +7,6 @@ interface Component {
   filePath: string;
 }
 
-interface SchemaExportedData {
-  outputPath: string;
-}
-
 interface SliceGeneratedData {
   slicePath: string;
 }
@@ -68,9 +64,6 @@ function incrementRetryCount(slicePath: string): number {
 
 export function createKanbanPipeline() {
   return define('kanban')
-    .on('SchemaExported')
-    .emit('GenerateServer', (e: { data: SchemaExportedData }) => ({ modelPath: e.data.outputPath }))
-
     .on('SliceGenerated')
     .emit('ImplementSlice', (e: { data: SliceGeneratedData }) => ({ slicePath: e.data.slicePath }))
 

package/src/testing/kanban-todo.e2e.specs.ts

@@ -169,7 +169,7 @@ describe('Kanban-Todo Pipeline E2E Comparison', () => {
   describe('Workflow Sequence Validation', () => {
     it('should have correct causal dependencies in pipeline definition', () => {
       const expectedDependencies: [string, string][] = [
-        ['SchemaExported', 'GenerateServer'],
+        ['ServerGenerated', 'GenerateIA'],
         ['SliceGenerated', 'ImplementSlice'],
         ['SliceImplemented', 'CheckTests'],
         ['SliceImplemented', 'CheckTypes'],