sweagent 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,7 +1,8 @@
+import { z } from 'zod';
+import pino from 'pino';
 import * as ai from 'ai';
 import { LanguageModelUsage, ModelMessage, Tool, FinishReason } from 'ai';
 export { FinishReason, LanguageModelUsage, ModelMessage, Tool, ToolExecutionOptions, jsonSchema, tool } from 'ai';
-import { z } from 'zod';
 
 /**
  * Custom error classes for the library
@@ -48,6 +49,30 @@ declare class SubagentError extends LibraryError {
     constructor(message: string, subagentName?: string | undefined, cause?: Error);
 }
 
+/**
+ * Shared utilities for extracting and parsing JSON from model responses.
+ *
+ * Models frequently wrap JSON in markdown code blocks or include extra text.
+ * These helpers handle extraction, parsing, and Zod validation with clear errors
+ * so the agent can retry on failure.
+ */
+
+/**
+ * Extract a JSON string from model output.
+ * Handles markdown code blocks (```json ... ``` or ``` ... ```) and bare JSON.
+ */
+declare function extractJson(text: string): string;
+/**
+ * Parse a model text response as JSON then validate with a Zod schema.
+ * Throws a descriptive error on failure (JSON syntax or validation) so the
+ * wrapping ToolError gives the agent enough context to retry.
+ */
+declare function parseModelJsonResponse<T>(text: string, schema: z.ZodType<T>): T;
+/**
+ * Parse a raw JSON string (e.g. tool input) with a descriptive error on failure.
+ */
+declare function safeJsonParse(jsonStr: string, label?: string): unknown;
+
 /**
  * Common types shared across modules
  * Re-exports AI SDK message types; keeps sweagent-specific ImageInput and Logger
@@ -72,31 +97,47 @@ interface Logger {
     info(message: string, data?: Record<string, unknown>): void;
     warn(message: string, data?: Record<string, unknown>): void;
     error(message: string, error?: Error | Record<string, unknown>): void;
+    /** Create a child logger with additional context bindings */
+    child(bindings: Record<string, unknown>): Logger;
 }
 
 /**
- * Simple logger with optional prefix and progress support
+ * Structured logger using Pino (JSON by default, optional pretty/file).
+ * Use loggerConfigFromEnv() for .env-driven config (SWE_LOG_* vars).
  */
 
-/**
- * Log levels
- */
 type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-/**
- * Logger configuration
- */
 interface LoggerConfig {
-    /** Prefix for all log messages */
-    prefix?: string;
-    /** Minimum log level to output */
+    /** Logger name (appears in logs) */
+    name?: string;
+    /** Minimum log level */
     level?: LogLevel;
-    /** Whether to output timestamps */
-    timestamps?: boolean;
+    /** Use pino-pretty for readable output */
+    pretty?: boolean;
+    /** File path for JSON logs */
+    file?: string;
+    /** Console stream: stderr avoids mixing with stdout prompts (e.g. inquirer). Default: stderr when pretty, else stdout. */
+    stream?: 'stdout' | 'stderr';
+    /** When false, returns a no-op logger (no output). Set via SWE_LOG_ENABLED=0. */
+    enabled?: boolean;
+    /** Optional stream for testing (bypasses transport) */
+    destination?: pino.DestinationStream;
 }
+declare function createLogger(config?: LoggerConfig): Logger;
 /**
- * Create a logger with the given configuration
+ * Build logger config from process.env (SWE_* vars). Caller loads .env if desired (e.g. dotenv or `node --env-file=.env`).
+ *
+ * Env vars (all optional):
+ * - SWE_LOG_ENABLED: 1|true|yes (default) = on; 0|false|no|disabled = off (no-op logger).
+ * - SWE_LOG_LEVEL: debug|info|warn|error (default: info).
+ * - SWE_LOG_STREAM: stdout|stderr; default stderr when SWE_LOG_PRETTY is true, else stdout.
+ * - SWE_LOG_PRETTY: 1|true|yes = human-readable (pino-pretty); 0|false (default) = JSON.
+ * - SWE_LOG_FILE: path to also write JSON logs to a file.
+ * - SWE_LOG_NAME: logger name in output.
+ *
+ * For interactive CLIs (e.g. inquirer), use pretty and stderr so logs do not mix with stdout prompts.
  */
-declare function createLogger(config?: LoggerConfig): Logger;
+declare function loggerConfigFromEnv(overrides?: Partial<LoggerConfig>): LoggerConfig;
 
 /**
  * Utility functions
@@ -159,6 +200,20 @@ interface InvokeOptions {
     /** Stop sequences */
     stop?: string[];
 }
+/**
+ * Options for structured object invocation (no tools)
+ */
+interface InvokeObjectOptions {
+    maxOutputTokens?: number;
+    temperature?: number;
+}
+/**
+ * Result of invokeObject (structured output)
+ */
+interface InvokeObjectResult<T> {
+    data: T;
+    usage?: LanguageModelUsage;
+}
 /**
  * Options for vision generation
  */
@@ -197,6 +252,11 @@ interface Model {
      * Generate a response with vision (images)
      */
     generateVision(prompt: string, images: ImageInput[], options?: VisionOptions): Promise<ModelResponse>;
+    /**
+     * Invoke the model and return a structured object matching the given schema (Zod).
+     * Uses AI SDK generateObject; when not implemented, callers may fall back to invoke + manual parse.
+     */
+    invokeObject?<T>(messages: ModelMessage[], schema: unknown, options?: InvokeObjectOptions): Promise<InvokeObjectResult<T>>;
 }
 
 /**
@@ -267,6 +327,15 @@ interface AgentToolResult {
     output: unknown;
     isError?: boolean;
 }
+/**
+ * Observer for agent events (step, tool execution, error).
+ * Multiple observers can be attached via AgentConfig.observers.
+ */
+interface AgentObserver {
+    onStep?(step: AgentStep): void;
+    onToolExecution?(toolName: string, result: unknown): void;
+    onError?(error: Error): void;
+}
 /**
  * Configuration for running an agent
  */
@@ -283,6 +352,10 @@ interface AgentConfig {
     maxIterations?: number;
     /** Callback for each step */
     onStep?: (step: AgentStep) => void;
+    /** Optional observers for step, tool execution, and error events */
+    observers?: AgentObserver[];
+    /** Optional logger for agent execution */
+    logger?: Logger;
 }
 /**
  * A single step in the agent's execution
@@ -440,14 +513,15 @@ type ToolSet = Record<string, Tool>;
 declare function createToolSet(tools: ToolSet): ToolSet;
 declare function getTools(toolSet: ToolSet): Tool[];
 declare function getTool(toolSet: ToolSet, name: string): Tool | undefined;
-declare function executeTool<TInput, TOutput>(toolImpl: Tool<TInput, TOutput>, input: TInput, options?: {
+interface ExecuteToolOptions {
     toolCallId?: string;
     abortSignal?: AbortSignal;
+    logger?: Logger;
+}
+declare function executeTool<TInput, TOutput>(toolImpl: Tool<TInput, TOutput>, input: TInput, options?: ExecuteToolOptions & {
+    toolName?: string;
 }): Promise<ToolExecutionResult<TOutput>>;
-declare function executeToolByName(tools: ToolSet, name: string, input: unknown, options?: {
-    toolCallId?: string;
-    abortSignal?: AbortSignal;
-}): Promise<ToolExecutionResult>;
+declare function executeToolByName(tools: ToolSet, name: string, input: unknown, options?: ExecuteToolOptions): Promise<ToolExecutionResult>;
 
 /**
  * Subagents: define, run, and expose as tools to a parent agent
@@ -482,6 +556,104 @@ declare function createSubagentTool(definition: SubagentDefinition, options?: Cr
  */
 declare function createSubagentToolSet(definitions: SubagentDefinition[], options?: CreateSubagentToolOptions): ToolSet;
 
+/**
+ * Template engine types for Handlebars-based project scaffolding
+ */
+/** Context data passed to Handlebars templates during compilation */
+interface TemplateContext {
+    /** Application name */
+    appName: string;
+    /** Application description */
+    description?: string;
+    /** API endpoint URL */
+    apiEndpoint?: string;
+    /** Module definitions for iterating in templates */
+    modules?: TemplateModule[];
+    /** Auth configuration */
+    auth?: TemplateAuth;
+    /** Branding configuration */
+    branding?: TemplateBranding;
+    /** Arbitrary additional data for templates */
+    [key: string]: unknown;
+}
+interface TemplateModule {
+    name: string;
+    /** PascalCase name for class/component names */
+    pascalName: string;
+    /** camelCase name for variable names */
+    camelName: string;
+    fields?: TemplateField[];
+    operations?: TemplateOperation[];
+    /** Arbitrary additional data for templates */
+    [key: string]: unknown;
+}
+interface TemplateField {
+    name: string;
+    type: string;
+    required: boolean;
+    graphqlType?: string;
+    /** Arbitrary additional data */
+    [key: string]: unknown;
+}
+interface TemplateOperation {
+    name: string;
+    type: string;
+    queryString?: string;
+    hookName?: string;
+    /** Arbitrary additional data */
+    [key: string]: unknown;
+}
+interface TemplateAuth {
+    strategy: string;
+    providers?: string[];
+    hasRoles: boolean;
+    roles?: string[];
+}
+interface TemplateBranding {
+    brandName: string;
+    primaryColor: string;
+    secondaryColor: string;
+    logo: string;
+}
+/** Configuration for scaffold_project tool */
+interface ScaffoldConfig {
+    /** Absolute path to the template directory (e.g. .ref/templates/vite) */
+    templateDir: string;
+    /** Absolute path to the output directory */
+    outputDir: string;
+    /** Context data to compile templates with */
+    context: TemplateContext;
+    /** File patterns to skip (glob-style) */
+    skipPatterns?: string[];
+}
+/** Result from scaffolding a project */
+interface ScaffoldResult {
+    /** Total files generated */
+    fileCount: number;
+    /** List of generated file paths (relative to outputDir) */
+    files: string[];
+    /** Any files that failed to compile */
+    errors: ScaffoldError[];
+}
+interface ScaffoldError {
+    file: string;
+    message: string;
+}
+
+/**
+ * Handlebars template compiler - reads .hbs files, compiles with context, writes output
+ */
+
+/** Compile a single Handlebars template string with context */
+declare function compileTemplate(template: string, context: TemplateContext): string;
+/**
+ * Scaffold a project: compile all .hbs templates in templateDir with context,
+ * write results to outputDir, return summary.
+ */
+declare function scaffoldProject(config: ScaffoldConfig): Promise<ScaffoldResult>;
+/** Register common Handlebars helpers */
+declare function registerHelpers(): void;
+
 /**
  * MCP client types - transport, config, and response shapes
  * for the Model Context Protocol client infrastructure.
@@ -573,6 +745,8 @@ interface HelloWorldAgentConfig {
     maxIterations?: number;
     /** Callback for each step */
     onStep?: (step: AgentStep) => void;
+    /** Optional logger for execution logs */
+    logger?: Logger;
 }
 declare function runHelloWorldAgent(config: HelloWorldAgentConfig): Promise<AgentResult>;
 
@@ -582,7 +756,7 @@ declare function runHelloWorldAgent(config: HelloWorldAgentConfig): Promise<Agen
 
 declare const fieldSchema: z.ZodObject<{
     fieldName: z.ZodString;
-    fieldType: z.ZodEnum<{
+    fieldType: z.ZodPipe<z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<"string" | "number" | "boolean" | "object" | "enum" | "Date" | "Types.ObjectId" | "email" | "password", string>>, z.ZodEnum<{
         string: "string";
         number: "number";
         boolean: "boolean";
@@ -592,19 +766,19 @@ declare const fieldSchema: z.ZodObject<{
         "Types.ObjectId": "Types.ObjectId";
         email: "email";
         password: "password";
-    }>;
-    isArray: z.ZodBoolean;
-    isRequired: z.ZodBoolean;
-    isUnique: z.ZodBoolean;
-    values: z.ZodArray<z.ZodString>;
+    }>>;
+    isArray: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    isRequired: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    isUnique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    values: z.ZodDefault<z.ZodArray<z.ZodString>>;
     defaultVal: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodNull]>>;
     relationTo: z.ZodOptional<z.ZodString>;
-    relationType: z.ZodOptional<z.ZodEnum<{
+    relationType: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"" | "one-to-one" | "many-to-one", string>>, z.ZodEnum<{
         "": "";
         "one-to-one": "one-to-one";
         "many-to-one": "many-to-one";
-    }>>;
-    isPrivate: z.ZodBoolean;
+    }>>>;
+    isPrivate: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
 }, z.core.$strip>;
 type TFieldSchema = z.infer<typeof fieldSchema>;
 
@@ -614,12 +788,12 @@ type TFieldSchema = z.infer<typeof fieldSchema>;
 
 declare const moduleSchema: z.ZodObject<{
     moduleName: z.ZodString;
-    isUserModule: z.ZodBoolean;
-    authMethod: z.ZodOptional<z.ZodEnum<{
+    isUserModule: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    authMethod: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"" | "EMAIL_AND_PASSWORD" | "PHONE_AND_OTP", string>>, z.ZodEnum<{
         "": "";
         EMAIL_AND_PASSWORD: "EMAIL_AND_PASSWORD";
         PHONE_AND_OTP: "PHONE_AND_OTP";
-    }>>;
+    }>>>;
     emailField: z.ZodOptional<z.ZodString>;
     passwordField: z.ZodOptional<z.ZodString>;
     phoneField: z.ZodOptional<z.ZodString>;
@@ -630,9 +804,9 @@ declare const moduleSchema: z.ZodObject<{
         UPDATE: "UPDATE";
         DELETE: "DELETE";
     }>>>>;
-    fields: z.ZodArray<z.ZodObject<{
+    fields: z.ZodPipe<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
         fieldName: z.ZodString;
-        fieldType: z.ZodEnum<{
+        fieldType: z.ZodPipe<z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<"string" | "number" | "boolean" | "object" | "enum" | "Date" | "Types.ObjectId" | "email" | "password", string>>, z.ZodEnum<{
             string: "string";
             number: "number";
             boolean: "boolean";
@@ -642,20 +816,42 @@ declare const moduleSchema: z.ZodObject<{
             "Types.ObjectId": "Types.ObjectId";
             email: "email";
             password: "password";
-        }>;
-        isArray: z.ZodBoolean;
-        isRequired: z.ZodBoolean;
-        isUnique: z.ZodBoolean;
-        values: z.ZodArray<z.ZodString>;
+        }>>;
+        isArray: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        isRequired: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        isUnique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        values: z.ZodDefault<z.ZodArray<z.ZodString>>;
         defaultVal: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodNull]>>;
         relationTo: z.ZodOptional<z.ZodString>;
-        relationType: z.ZodOptional<z.ZodEnum<{
+        relationType: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"" | "one-to-one" | "many-to-one", string>>, z.ZodEnum<{
             "": "";
             "one-to-one": "one-to-one";
             "many-to-one": "many-to-one";
-        }>>;
-        isPrivate: z.ZodBoolean;
-    }, z.core.$strip>>;
+        }>>>;
+        isPrivate: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    }, z.core.$strip>>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>, z.ZodTransform<{
+        fieldName: string;
+        fieldType: "string" | "number" | "boolean" | "object" | "enum" | "Date" | "Types.ObjectId" | "email" | "password";
+        isArray: boolean;
+        isRequired: boolean;
+        isUnique: boolean;
+        values: string[];
+        isPrivate: boolean;
+        defaultVal?: string | number | boolean | null | undefined;
+        relationTo?: string | undefined;
+        relationType?: "" | "one-to-one" | "many-to-one" | undefined;
+    }[], Record<string, unknown> | {
+        fieldName: string;
+        fieldType: "string" | "number" | "boolean" | "object" | "enum" | "Date" | "Types.ObjectId" | "email" | "password";
+        isArray: boolean;
+        isRequired: boolean;
+        isUnique: boolean;
+        values: string[];
+        isPrivate: boolean;
+        defaultVal?: string | number | boolean | null | undefined;
+        relationTo?: string | undefined;
+        relationType?: "" | "one-to-one" | "many-to-one" | undefined;
+    }[]>>;
 }, z.core.$strip>;
 type TModuleSchema$1 = z.infer<typeof moduleSchema>;
 
@@ -664,16 +860,16 @@ type TModuleSchema$1 = z.infer<typeof moduleSchema>;
  */
 
 declare const projectSchema: z.ZodObject<{
-    projectName: z.ZodString;
-    projectDescription: z.ZodString;
-    modules: z.ZodArray<z.ZodObject<{
+    projectName: z.ZodDefault<z.ZodString>;
+    projectDescription: z.ZodDefault<z.ZodString>;
+    modules: z.ZodPipe<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
         moduleName: z.ZodString;
-        isUserModule: z.ZodBoolean;
-        authMethod: z.ZodOptional<z.ZodEnum<{
+        isUserModule: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        authMethod: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"" | "EMAIL_AND_PASSWORD" | "PHONE_AND_OTP", string>>, z.ZodEnum<{
             "": "";
             EMAIL_AND_PASSWORD: "EMAIL_AND_PASSWORD";
             PHONE_AND_OTP: "PHONE_AND_OTP";
-        }>>;
+        }>>>;
         emailField: z.ZodOptional<z.ZodString>;
         passwordField: z.ZodOptional<z.ZodString>;
         phoneField: z.ZodOptional<z.ZodString>;
@@ -684,9 +880,9 @@ declare const projectSchema: z.ZodObject<{
             UPDATE: "UPDATE";
             DELETE: "DELETE";
         }>>>>;
-        fields: z.ZodArray<z.ZodObject<{
+        fields: z.ZodPipe<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
             fieldName: z.ZodString;
-            fieldType: z.ZodEnum<{
+            fieldType: z.ZodPipe<z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<"string" | "number" | "boolean" | "object" | "enum" | "Date" | "Types.ObjectId" | "email" | "password", string>>, z.ZodEnum<{
                 string: "string";
                 number: "number";
                 boolean: "boolean";
@@ -696,21 +892,85 @@ declare const projectSchema: z.ZodObject<{
                 "Types.ObjectId": "Types.ObjectId";
                 email: "email";
                 password: "password";
-            }>;
-            isArray: z.ZodBoolean;
-            isRequired: z.ZodBoolean;
-            isUnique: z.ZodBoolean;
-            values: z.ZodArray<z.ZodString>;
+            }>>;
+            isArray: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            isRequired: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            isUnique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            values: z.ZodDefault<z.ZodArray<z.ZodString>>;
             defaultVal: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodNull]>>;
             relationTo: z.ZodOptional<z.ZodString>;
-            relationType: z.ZodOptional<z.ZodEnum<{
+            relationType: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"" | "one-to-one" | "many-to-one", string>>, z.ZodEnum<{
                 "": "";
                 "one-to-one": "one-to-one";
                 "many-to-one": "many-to-one";
-            }>>;
-            isPrivate: z.ZodBoolean;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
+            }>>>;
+            isPrivate: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        }, z.core.$strip>>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>, z.ZodTransform<{
+            fieldName: string;
+            fieldType: "string" | "number" | "boolean" | "object" | "enum" | "Date" | "Types.ObjectId" | "email" | "password";
+            isArray: boolean;
+            isRequired: boolean;
+            isUnique: boolean;
+            values: string[];
+            isPrivate: boolean;
+            defaultVal?: string | number | boolean | null | undefined;
+            relationTo?: string | undefined;
+            relationType?: "" | "one-to-one" | "many-to-one" | undefined;
+        }[], Record<string, unknown> | {
+            fieldName: string;
+            fieldType: "string" | "number" | "boolean" | "object" | "enum" | "Date" | "Types.ObjectId" | "email" | "password";
+            isArray: boolean;
+            isRequired: boolean;
+            isUnique: boolean;
+            values: string[];
+            isPrivate: boolean;
+            defaultVal?: string | number | boolean | null | undefined;
+            relationTo?: string | undefined;
+            relationType?: "" | "one-to-one" | "many-to-one" | undefined;
+        }[]>>;
+    }, z.core.$strip>>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>, z.ZodTransform<{
+        moduleName: string;
+        isUserModule: boolean;
+        fields: {
+            fieldName: string;
+            fieldType: "string" | "number" | "boolean" | "object" | "enum" | "Date" | "Types.ObjectId" | "email" | "password";
+            isArray: boolean;
+            isRequired: boolean;
+            isUnique: boolean;
+            values: string[];
+            isPrivate: boolean;
+            defaultVal?: string | number | boolean | null | undefined;
+            relationTo?: string | undefined;
+            relationType?: "" | "one-to-one" | "many-to-one" | undefined;
+        }[];
+        authMethod?: "" | "EMAIL_AND_PASSWORD" | "PHONE_AND_OTP" | undefined;
+        emailField?: string | undefined;
+        passwordField?: string | undefined;
+        phoneField?: string | undefined;
+        roleField?: string | undefined;
+        permissions?: Record<string, ("CREATE" | "READ" | "UPDATE" | "DELETE")[]> | undefined;
+    }[], Record<string, unknown> | {
+        moduleName: string;
+        isUserModule: boolean;
+        fields: {
+            fieldName: string;
+            fieldType: "string" | "number" | "boolean" | "object" | "enum" | "Date" | "Types.ObjectId" | "email" | "password";
+            isArray: boolean;
+            isRequired: boolean;
+            isUnique: boolean;
+            values: string[];
+            isPrivate: boolean;
+            defaultVal?: string | number | boolean | null | undefined;
+            relationTo?: string | undefined;
+            relationType?: "" | "one-to-one" | "many-to-one" | undefined;
+        }[];
+        authMethod?: "" | "EMAIL_AND_PASSWORD" | "PHONE_AND_OTP" | undefined;
+        emailField?: string | undefined;
+        passwordField?: string | undefined;
+        phoneField?: string | undefined;
+        roleField?: string | undefined;
+        permissions?: Record<string, ("CREATE" | "READ" | "UPDATE" | "DELETE")[]> | undefined;
+    }[]>>;
     author: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 type TBackendProjectSchema = z.infer<typeof projectSchema>;
@@ -719,7 +979,7 @@ type TBackendProjectSchema = z.infer<typeof projectSchema>;
  * db-designer module types - structured requirements and agent config
  */
 
-interface Actor {
+interface Actor$1 {
     id: string;
     name: string;
     description: string;
@@ -756,7 +1016,7 @@ interface StructuredRequirementsInput {
     projectName: string;
     projectGoal: string;
     projectDescription?: string;
-    actors: Actor[];
+    actors: Actor$1[];
     flows: ExtractedFlow[];
     stories: ExtractedStory[];
     technicalRequirements?: TechnicalRequirements;
@@ -770,6 +1030,8 @@ interface DbDesignerAgentConfig {
     maxIterations?: number;
     /** Callback for each step */
     onStep?: (step: AgentStep) => void;
+    /** Optional logger for execution logs */
+    logger?: Logger;
 }
 
 /**
@@ -788,11 +1050,11 @@ declare function createDbDesignPrompt(requirement: string): string;
 /**
  * Format actors/user types into prompt-friendly string
  */
-declare function formatUserTypes(actors: Actor[]): string;
+declare function formatUserTypes(actors: Actor$1[]): string;
 /**
  * Format user flows into prompt-friendly string
  */
-declare function formatUserFlows(flows: ExtractedFlow[], actors: Actor[]): string;
+declare function formatUserFlows(flows: ExtractedFlow[], actors: Actor$1[]): string;
 /**
  * Format user stories with dataInvolved into prompt-friendly string
  */
@@ -808,7 +1070,7 @@ declare function extractDataEntities(stories: ExtractedStory[]): string[];
 /**
  * Extract roles from actors for RBAC configuration
  */
-declare function extractRoles(actors: Actor[]): string[];
+declare function extractRoles(actors: Actor$1[]): string[];
 /**
  * Build complete prompt variables from structured requirements
  */
@@ -826,7 +1088,7 @@ declare function createRedesignPrompt(existingSchema: string, userFeedback: stri
 /**
  * validate_schema tool - validates JSON against projectSchema (no AI)
  */
-declare const validateSchemaTool: ai.Tool;
+declare const validateSchemaTool$1: ai.Tool;
 
 /**
  * Creates the design_database tool. Requires a model to invoke for schema generation.
@@ -851,12 +1113,12 @@ declare function createDbDesignerTools(model: Model): ToolSet;
 /**
  * entity-analyzer subagent - extracts entities, relationships, and roles from requirements (no tools)
  */
-declare const entityAnalyzerSubagent: SubagentDefinition;
+declare const entityAnalyzerSubagent$1: SubagentDefinition;
 
 /**
  * schema-refiner subagent - validates schema and suggests refinements (has validate_schema tool)
  */
-declare function createSchemaRefinerSubagent(): SubagentDefinition;
+declare function createSchemaRefinerSubagent$1(): SubagentDefinition;
 
 /**
  * runDbDesignerAgent - orchestrator for the full DB design workflow
@@ -921,10 +1183,10 @@ declare const FormFieldSchema: z.ZodObject<{
         date: "date";
         email: "email";
         password: "password";
+        select: "select";
         multiSelect: "multiSelect";
         textarea: "textarea";
         hidden: "hidden";
-        select: "select";
     }>;
     required: z.ZodOptional<z.ZodBoolean>;
     validation: z.ZodOptional<z.ZodObject<{
@@ -1003,10 +1265,10 @@ declare const DrawerSchema: z.ZodObject<{
             date: "date";
             email: "email";
             password: "password";
+            select: "select";
             multiSelect: "multiSelect";
             textarea: "textarea";
             hidden: "hidden";
-            select: "select";
         }>;
         required: z.ZodOptional<z.ZodBoolean>;
         validation: z.ZodOptional<z.ZodObject<{
@@ -1061,10 +1323,10 @@ declare const AuthPageSchema: z.ZodObject<{
             date: "date";
             email: "email";
             password: "password";
+            select: "select";
             multiSelect: "multiSelect";
             textarea: "textarea";
             hidden: "hidden";
-            select: "select";
         }>;
         required: z.ZodOptional<z.ZodBoolean>;
         validation: z.ZodOptional<z.ZodObject<{
@@ -1120,10 +1382,10 @@ declare const ListingPageSchema: z.ZodObject<{
                 date: "date";
                 email: "email";
                 password: "password";
+                select: "select";
                 multiSelect: "multiSelect";
                 textarea: "textarea";
                 hidden: "hidden";
-                select: "select";
             }>;
             required: z.ZodOptional<z.ZodBoolean>;
             validation: z.ZodOptional<z.ZodObject<{
@@ -1152,10 +1414,10 @@ declare const ListingPageSchema: z.ZodObject<{
                 date: "date";
                 email: "email";
                 password: "password";
+                select: "select";
                 multiSelect: "multiSelect";
                 textarea: "textarea";
                 hidden: "hidden";
-                select: "select";
             }>;
             required: z.ZodOptional<z.ZodBoolean>;
             validation: z.ZodOptional<z.ZodObject<{
@@ -1211,10 +1473,10 @@ declare const PageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             date: "date";
             email: "email";
             password: "password";
+            select: "select";
             multiSelect: "multiSelect";
             textarea: "textarea";
             hidden: "hidden";
-            select: "select";
         }>;
         required: z.ZodOptional<z.ZodBoolean>;
         validation: z.ZodOptional<z.ZodObject<{
@@ -1269,10 +1531,10 @@ declare const PageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 date: "date";
                 email: "email";
                 password: "password";
+                select: "select";
                 multiSelect: "multiSelect";
                 textarea: "textarea";
                 hidden: "hidden";
-                select: "select";
             }>;
             required: z.ZodOptional<z.ZodBoolean>;
             validation: z.ZodOptional<z.ZodObject<{
@@ -1301,10 +1563,10 @@ declare const PageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 date: "date";
                 email: "email";
                 password: "password";
+                select: "select";
                 multiSelect: "multiSelect";
                 textarea: "textarea";
                 hidden: "hidden";
-                select: "select";
             }>;
             required: z.ZodOptional<z.ZodBoolean>;
             validation: z.ZodOptional<z.ZodObject<{
@@ -1368,10 +1630,10 @@ declare const ModuleSchema: z.ZodObject<{
                 date: "date";
                 email: "email";
                 password: "password";
+                select: "select";
                 multiSelect: "multiSelect";
                 textarea: "textarea";
                 hidden: "hidden";
-                select: "select";
             }>;
             required: z.ZodOptional<z.ZodBoolean>;
             validation: z.ZodOptional<z.ZodObject<{
@@ -1426,10 +1688,10 @@ declare const ModuleSchema: z.ZodObject<{
                     date: "date";
                     email: "email";
                     password: "password";
+                    select: "select";
                     multiSelect: "multiSelect";
                     textarea: "textarea";
                     hidden: "hidden";
-                    select: "select";
                 }>;
                 required: z.ZodOptional<z.ZodBoolean>;
                 validation: z.ZodOptional<z.ZodObject<{
@@ -1458,10 +1720,10 @@ declare const ModuleSchema: z.ZodObject<{
                     date: "date";
                     email: "email";
                     password: "password";
+                    select: "select";
                     multiSelect: "multiSelect";
                     textarea: "textarea";
                     hidden: "hidden";
-                    select: "select";
                 }>;
                 required: z.ZodOptional<z.ZodBoolean>;
                 validation: z.ZodOptional<z.ZodObject<{
@@ -1533,10 +1795,10 @@ declare const ApplicationSchema: z.ZodObject<{
                     date: "date";
                     email: "email";
                     password: "password";
+                    select: "select";
                     multiSelect: "multiSelect";
                     textarea: "textarea";
                     hidden: "hidden";
-                    select: "select";
                 }>;
                 required: z.ZodOptional<z.ZodBoolean>;
                 validation: z.ZodOptional<z.ZodObject<{
@@ -1591,10 +1853,10 @@ declare const ApplicationSchema: z.ZodObject<{
                         date: "date";
                         email: "email";
                         password: "password";
+                        select: "select";
                         multiSelect: "multiSelect";
                         textarea: "textarea";
                         hidden: "hidden";
-                        select: "select";
                     }>;
                     required: z.ZodOptional<z.ZodBoolean>;
                     validation: z.ZodOptional<z.ZodObject<{
@@ -1623,10 +1885,10 @@ declare const ApplicationSchema: z.ZodObject<{
                         date: "date";
                         email: "email";
                         password: "password";
+                        select: "select";
                         multiSelect: "multiSelect";
                         textarea: "textarea";
                         hidden: "hidden";
-                        select: "select";
                     }>;
                     required: z.ZodOptional<z.ZodBoolean>;
                     validation: z.ZodOptional<z.ZodObject<{
@@ -1751,12 +2013,14 @@ interface ReactBuilderAgentConfig {
     maxIterations?: number;
     /** Callback for each step */
     onStep?: (step: AgentStep) => void;
+    /** Optional logger for execution logs */
+    logger?: Logger;
 }
 
 /**
  * System prompt for GraphQL-to-frontend configuration conversion
  */
-declare const REACT_BUILDER_SYSTEM_PROMPT = "You are an expert GraphQL-to-frontend configuration converter. Transform the provided GraphQL schema into a structured JSON configuration for rapid app development.\n\n**Your output must be valid JSON only.** No markdown code fences, no explanations. Return the raw JSON object matching the application schema (app with name, description, author, branding, apiEndpoint; modules array with name and pages; each page has type, name, route, isPrivate, api, and for listing pages: columns, actions, drawerCreate, drawerUpdate; for auth pages: fields when needed).\n\nStrict guidelines:\n- Use every available CRUD GraphQL query and mutation from the project schema.\n- Map GraphQL types to frontend modules and pages.\n- EmailAddress \u2192 \"type\": \"email\" with validation; DateTime \u2192 \"type\": \"date\"; enums \u2192 select with options.values.\n- Relationships \u2192 multiSelect with query-based options where appropriate.\n- Add isPrivate: true for authenticated operations.\n- Maintain camelCase. Ensure valid JSON syntax.";
+declare const REACT_BUILDER_SYSTEM_PROMPT = "You are an expert GraphQL-to-frontend configuration converter. Transform the provided GraphQL schema into a structured JSON configuration for a React + Vite frontend application.\n\n## Target Tech Stack\nThe generated configuration will be consumed by a Vite + React 19 + TypeScript template with:\n- **UI Components**: ShadCN UI (Radix-based) from src/components/ui/\n- **Styling**: Tailwind CSS v4 with OKLCH color space\n- **Routing**: React Router v7 with private route support\n- **Forms**: React Hook Form + Zod validation (zodResolver)\n- **GraphQL Client**: Apollo Client with typed hooks from CodeGen\n- **Path Aliases**: @/{appName}/* maps to ./src/*\n\n**Your output must be valid JSON only.** No markdown code fences, no explanations. Return the raw JSON object matching the application schema (app with name, description, author, branding, apiEndpoint; modules array with name and pages; each page has type, name, route, isPrivate, api, and for listing pages: columns, actions, drawerCreate, drawerUpdate; for auth pages: fields when needed).\n\nStrict guidelines:\n- Use every available CRUD GraphQL query and mutation from the project schema.\n- Map GraphQL types to frontend modules and pages.\n- EmailAddress \u2192 \"type\": \"email\" with validation; DateTime \u2192 \"type\": \"date\"; enums \u2192 select with options.values.\n- Relationships \u2192 multiSelect with query-based options where appropriate.\n- Add isPrivate: true for authenticated operations (route guarded by React Router).\n- Form fields should map to React Hook Form + Zod validation schemas.\n- Maintain camelCase. Ensure valid JSON syntax.";
 
 /**
  * Instruction template for GraphQL-to-frontend conversion
@@ -1813,4 +2077,3008 @@ declare function createConfigValidatorSubagent(): SubagentDefinition;
  */
 declare function runReactBuilderAgent(config: ReactBuilderAgentConfig): Promise<AgentResult>;
 
-export { type Actor, type AgentConfig, AgentError, type AgentResult, type AgentStep, type AgentTool, type AgentToolResult, ApiResponseTypeSchema, AppConfigSchema, type AppInfo, ApplicationSchema, AuthPageApiSchema, AuthPageSchema, BaseMcpClient, BrandingSchema, ColumnSchema, type CreateSubagentToolOptions, CreateUserInputSchema, DB_DESIGN_SYSTEM_PROMPT, type DbDesignerAgentConfig, DrawerSchema, EXAMPLE_GRAPHQL_SCHEMA, EXAMPLE_JSON_OUTPUT, type ExtractedFlow, type ExtractedStory, type FeatureBreakdownResult, FieldOptionsSchema, ForgotPasswordSchema, FormFieldSchema, type HelloWorldAgentConfig, type ImageInput, type InvokeOptions, LibraryError, ListingPageApiSchema, ListingPageSchema, type LogLevel, type Logger, type LoggerConfig, LoginInputSchema, type McpClientConfig, type McpClientInfo, type McpResolveOptions, type McpToolContent, type McpTransport, type Model, type ModelConfig, ModelError, type ModelProvider, type ModelResponse, type ModelTool, type ModelToolCall, ModuleSchema, PageSchema, REACT_BUILDER_INSTRUCTION, REACT_BUILDER_SYSTEM_PROMPT, type ReactBuilderAgentConfig, ResetPasswordSchema, type RunSubagentOptions, SpecializationSchema, type StructuredRequirementsInput, type SubagentConfig, type SubagentDefinition, SubagentError, type SubagentResult, type TApiResponseTypeSchema, type TAppConfigSchema, type TApplicationSchema, type TBackendProjectSchema, type TBrandingSchema, type TColumnSchema, type TCreateUserInputSchema, type TFieldSchema, type TForgotPasswordSchema, type TFormFieldSchema, type TLoginInputSchema, type TModuleSchema$1 as TModuleSchema, type TPageSchema, type TModuleSchema as TReactModuleSchema, type TResetPasswordSchema, type TSpecializationSchema, type TUpdateUserInputSchema, type TUserSchema, type TechnicalRequirements, type ToolConfig, type ToolContext, ToolError, type ToolExecutionResult, type ToolLogger, type ToolSet, UpdateUserInputSchema, UserSchema, ValidationError, ValidationSchema, type VisionOptions, buildExampleShotPrompt, buildFeedbackPrompt, buildInstructionPrompt, buildPromptVariables, createAnthropicModel, createConfigValidatorSubagent, createDbDesignPrompt, createDbDesignerTools, createDesignDatabaseProTool, createDesignDatabaseTool, createGenerateFeatureBreakdownTool, createGenerateFrontendTool, createGoogleModel, createLogger, createModel, createOpenAIModel, createProDbDesignPrompt, createReactBuilderTools, createRedesignDatabaseTool, createRedesignPrompt, createSchemaRefinerSubagent, createSubagentTool, createSubagentToolSet, createToolSet, defineSubagent, defineTool, entityAnalyzerSubagent, executeTool, executeToolByName, extractDataEntities, extractRoles, fieldSchema, formatTechnicalRequirements, formatUserFlows, formatUserStories, formatUserTypes, getTool, getTools, graphqlAnalyzerSubagent, helloWorldTool, moduleSchema, projectSchema, runAgent, runDbDesignerAgent, runHelloWorldAgent, runReactBuilderAgent, runSubagent, sumTokenUsage, validateFrontendConfigTool, validateSchemaTool };
+/**
+ * Zod schemas for RequirementContext, ProjectBrief, Question, ChatEntry
+ */
+
+declare const projectBriefSchema: z.ZodObject<{
+    name: z.ZodString;
+    goal: z.ZodString;
+    features: z.ZodArray<z.ZodString>;
+    domain: z.ZodString;
+    database: z.ZodEnum<{
+        mongodb: "mongodb";
+        postgresql: "postgresql";
+    }>;
+    backendRuntime: z.ZodLiteral<"nodejs">;
+    apiStyle: z.ZodEnum<{
+        rest: "rest";
+        graphql: "graphql";
+    }>;
+}, z.core.$strip>;
+declare const questionSchema: z.ZodObject<{
+    id: z.ZodString;
+    question: z.ZodString;
+    context: z.ZodString;
+    suggestions: z.ZodArray<z.ZodString>;
+    multiSelect: z.ZodBoolean;
+    required: z.ZodBoolean;
+}, z.core.$strip>;
+declare const chatEntrySchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+    }>;
+    content: z.ZodString;
+}, z.core.$strip>;
+declare const requirementContextSchema: z.ZodObject<{
+    stage: z.ZodEnum<{
+        discovery: "discovery";
+        requirements: "requirements";
+        design: "design";
+        complete: "complete";
+    }>;
+    projectBrief: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        goal: z.ZodString;
+        features: z.ZodArray<z.ZodString>;
+        domain: z.ZodString;
+        database: z.ZodEnum<{
+            mongodb: "mongodb";
+            postgresql: "postgresql";
+        }>;
+        backendRuntime: z.ZodLiteral<"nodejs">;
+        apiStyle: z.ZodEnum<{
+            rest: "rest";
+            graphql: "graphql";
+        }>;
+    }, z.core.$strip>>;
+    actors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        goals: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    flows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        actorId: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        trigger: z.ZodString;
+        outcome: z.ZodString;
+    }, z.core.$strip>>;
+    stories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        flowId: z.ZodString;
+        actor: z.ZodString;
+        action: z.ZodString;
+        benefit: z.ZodString;
+        preconditions: z.ZodArray<z.ZodString>;
+        postconditions: z.ZodArray<z.ZodString>;
+        dataInvolved: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    modules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        entity: z.ZodString;
+        apis: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            operation: z.ZodEnum<{
+                create: "create";
+                update: "update";
+                delete: "delete";
+                read: "read";
+                readAll: "readAll";
+            }>;
+            description: z.ZodString;
+            inputs: z.ZodArray<z.ZodString>;
+            outputs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    database: z.ZodNullable<z.ZodObject<{
+        type: z.ZodEnum<{
+            mongodb: "mongodb";
+            postgresql: "postgresql";
+        }>;
+        reasoning: z.ZodString;
+        entities: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            fields: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                required: z.ZodBoolean;
+                unique: z.ZodBoolean;
+                description: z.ZodString;
+                default: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            indexes: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                fields: z.ZodArray<z.ZodString>;
+                unique: z.ZodBoolean;
+            }, z.core.$strip>>;
+            relations: z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                references: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    apiDesign: z.ZodNullable<z.ZodObject<{
+        style: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+            rest: "rest";
+            graphql: "graphql";
+        }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+            rest: "rest";
+            graphql: "graphql";
+        }>>;
+        rest: z.ZodOptional<z.ZodObject<{
+            baseUrl: z.ZodDefault<z.ZodString>;
+            endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                moduleId: z.ZodString;
+                method: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+                    DELETE: "DELETE";
+                    GET: "GET";
+                    POST: "POST";
+                    PUT: "PUT";
+                    PATCH: "PATCH";
+                }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+                    DELETE: "DELETE";
+                    GET: "GET";
+                    POST: "POST";
+                    PUT: "PUT";
+                    PATCH: "PATCH";
+                }>>;
+                path: z.ZodString;
+                description: z.ZodString;
+                auth: z.ZodCoercedBoolean<unknown>;
+                roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                requestBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+                    [k: string]: string;
+                }, Record<string, unknown>>>;
+                responseBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+                    [k: string]: string;
+                }, Record<string, unknown>>>;
+                queryParams: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+                    [k: string]: string;
+                }, Record<string, unknown>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        graphql: z.ZodOptional<z.ZodObject<{
+            types: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                kind: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+                    input: "input";
+                    type: "type";
+                    enum: "enum";
+                }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+                    input: "input";
+                    type: "type";
+                    enum: "enum";
+                }>>;
+                fields: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    description: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            queries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                moduleId: z.ZodString;
+                description: z.ZodString;
+                auth: z.ZodCoercedBoolean<unknown>;
+                roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                args: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    required: z.ZodCoercedBoolean<unknown>;
+                }, z.core.$strip>>;
+                returnType: z.ZodString;
+            }, z.core.$strip>>>;
+            mutations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                moduleId: z.ZodString;
+                description: z.ZodString;
+                auth: z.ZodCoercedBoolean<unknown>;
+                roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                args: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    required: z.ZodCoercedBoolean<unknown>;
+                }, z.core.$strip>>;
+                returnType: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    history: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+        }>;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    pendingQuestions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        context: z.ZodString;
+        suggestions: z.ZodArray<z.ZodString>;
+        multiSelect: z.ZodBoolean;
+        required: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type Question$1 = z.infer<typeof questionSchema>;
+type ChatEntry$2 = z.infer<typeof chatEntrySchema>;
+
+/**
+ * Zod schemas for DatabaseDesign, DatabaseEntity, EntityField, EntityIndex, EntityRelation
+ */
+
+declare const entityFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    required: z.ZodBoolean;
+    unique: z.ZodBoolean;
+    description: z.ZodString;
+    default: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const entityIndexSchema: z.ZodObject<{
+    name: z.ZodString;
+    fields: z.ZodArray<z.ZodString>;
+    unique: z.ZodBoolean;
+}, z.core.$strip>;
+declare const entityRelationSchema: z.ZodObject<{
+    field: z.ZodString;
+    references: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+declare const databaseEntitySchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        unique: z.ZodBoolean;
+        description: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    indexes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodArray<z.ZodString>;
+        unique: z.ZodBoolean;
+    }, z.core.$strip>>;
+    relations: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        references: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const databaseDesignSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        mongodb: "mongodb";
+        postgresql: "postgresql";
+    }>;
+    reasoning: z.ZodString;
+    entities: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        fields: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            required: z.ZodBoolean;
+            unique: z.ZodBoolean;
+            description: z.ZodString;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        indexes: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodArray<z.ZodString>;
+            unique: z.ZodBoolean;
+        }, z.core.$strip>>;
+        relations: z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            references: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type EntityField$2 = z.infer<typeof entityFieldSchema>;
+type EntityIndex$2 = z.infer<typeof entityIndexSchema>;
+type EntityRelation$2 = z.infer<typeof entityRelationSchema>;
+type DatabaseEntity$1 = z.infer<typeof databaseEntitySchema>;
+type DatabaseDesign$1 = z.infer<typeof databaseDesignSchema>;
+
+/**
+ * Zod schemas for ApiDesign, RestEndpoint, GraphqlTypeDefinition, GraphqlOperation
+ * Uses coercion so LLM output (e.g. "GET" vs "get", "true" vs true) still validates.
+ */
+
+declare const restEndpointSchema$1: z.ZodObject<{
+    id: z.ZodString;
+    moduleId: z.ZodString;
+    method: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>>;
+    path: z.ZodString;
+    description: z.ZodString;
+    auth: z.ZodCoercedBoolean<unknown>;
+    roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requestBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, unknown>>>;
+    responseBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, unknown>>>;
+    queryParams: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, unknown>>>;
+}, z.core.$strip>;
+declare const restApiDesignSchema: z.ZodObject<{
+    baseUrl: z.ZodDefault<z.ZodString>;
+    endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        moduleId: z.ZodString;
+        method: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+        }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+        }>>;
+        path: z.ZodString;
+        description: z.ZodString;
+        auth: z.ZodCoercedBoolean<unknown>;
+        roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requestBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, unknown>>>;
+        responseBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, unknown>>>;
+        queryParams: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, unknown>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const graphqlTypeDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+        input: "input";
+        type: "type";
+        enum: "enum";
+    }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+        input: "input";
+        type: "type";
+        enum: "enum";
+    }>>;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const graphqlOperationSchema$1: z.ZodObject<{
+    name: z.ZodString;
+    moduleId: z.ZodString;
+    description: z.ZodString;
+    auth: z.ZodCoercedBoolean<unknown>;
+    roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    args: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodCoercedBoolean<unknown>;
+    }, z.core.$strip>>;
+    returnType: z.ZodString;
+}, z.core.$strip>;
+declare const graphqlApiDesignSchema: z.ZodObject<{
+    types: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+            input: "input";
+            type: "type";
+            enum: "enum";
+        }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+            input: "input";
+            type: "type";
+            enum: "enum";
+        }>>;
+        fields: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    queries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        moduleId: z.ZodString;
+        description: z.ZodString;
+        auth: z.ZodCoercedBoolean<unknown>;
+        roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        args: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            required: z.ZodCoercedBoolean<unknown>;
+        }, z.core.$strip>>;
+        returnType: z.ZodString;
+    }, z.core.$strip>>>;
+    mutations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        moduleId: z.ZodString;
+        description: z.ZodString;
+        auth: z.ZodCoercedBoolean<unknown>;
+        roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        args: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            required: z.ZodCoercedBoolean<unknown>;
+        }, z.core.$strip>>;
+        returnType: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const apiDesignSchema$1: z.ZodObject<{
+    style: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+        rest: "rest";
+        graphql: "graphql";
+    }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+        rest: "rest";
+        graphql: "graphql";
+    }>>;
+    rest: z.ZodOptional<z.ZodObject<{
+        baseUrl: z.ZodDefault<z.ZodString>;
+        endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            moduleId: z.ZodString;
+            method: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+                DELETE: "DELETE";
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+            }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+                DELETE: "DELETE";
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+            }>>;
+            path: z.ZodString;
+            description: z.ZodString;
+            auth: z.ZodCoercedBoolean<unknown>;
+            roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            requestBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+                [k: string]: string;
+            }, Record<string, unknown>>>;
+            responseBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+                [k: string]: string;
+            }, Record<string, unknown>>>;
+            queryParams: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+                [k: string]: string;
+            }, Record<string, unknown>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    graphql: z.ZodOptional<z.ZodObject<{
+        types: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+                input: "input";
+                type: "type";
+                enum: "enum";
+            }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+                input: "input";
+                type: "type";
+                enum: "enum";
+            }>>;
+            fields: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        queries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            moduleId: z.ZodString;
+            description: z.ZodString;
+            auth: z.ZodCoercedBoolean<unknown>;
+            roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            args: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                required: z.ZodCoercedBoolean<unknown>;
+            }, z.core.$strip>>;
+            returnType: z.ZodString;
+        }, z.core.$strip>>>;
+        mutations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            moduleId: z.ZodString;
+            description: z.ZodString;
+            auth: z.ZodCoercedBoolean<unknown>;
+            roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            args: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                required: z.ZodCoercedBoolean<unknown>;
+            }, z.core.$strip>>;
+            returnType: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type RestEndpoint$2 = z.infer<typeof restEndpointSchema$1>;
+type RestApiDesign$1 = z.infer<typeof restApiDesignSchema>;
+type GraphqlTypeDefinition$1 = z.infer<typeof graphqlTypeDefinitionSchema>;
+type GraphqlOperation$2 = z.infer<typeof graphqlOperationSchema$1>;
+type GraphqlApiDesign$1 = z.infer<typeof graphqlApiDesignSchema>;
+type ApiDesign$2 = z.infer<typeof apiDesignSchema$1>;
+
+/**
+ * Zod schemas for FinalRequirement, RequirementSummary
+ */
+
+declare const requirementSummarySchema: z.ZodObject<{
+    totalActors: z.ZodNumber;
+    totalFlows: z.ZodNumber;
+    totalStories: z.ZodNumber;
+    totalModules: z.ZodNumber;
+    totalEntities: z.ZodNumber;
+    totalEndpoints: z.ZodNumber;
+    overview: z.ZodString;
+}, z.core.$strip>;
+declare const finalRequirementSchema: z.ZodObject<{
+    project: z.ZodObject<{
+        name: z.ZodString;
+        goal: z.ZodString;
+        features: z.ZodArray<z.ZodString>;
+        domain: z.ZodString;
+        database: z.ZodEnum<{
+            mongodb: "mongodb";
+            postgresql: "postgresql";
+        }>;
+        backendRuntime: z.ZodLiteral<"nodejs">;
+        apiStyle: z.ZodEnum<{
+            rest: "rest";
+            graphql: "graphql";
+        }>;
+    }, z.core.$strip>;
+    actors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        goals: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    flows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        actorId: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        trigger: z.ZodString;
+        outcome: z.ZodString;
+    }, z.core.$strip>>;
+    stories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        flowId: z.ZodString;
+        actor: z.ZodString;
+        action: z.ZodString;
+        benefit: z.ZodString;
+        preconditions: z.ZodArray<z.ZodString>;
+        postconditions: z.ZodArray<z.ZodString>;
+        dataInvolved: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    modules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        entity: z.ZodString;
+        apis: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            operation: z.ZodEnum<{
+                create: "create";
+                update: "update";
+                delete: "delete";
+                read: "read";
+                readAll: "readAll";
+            }>;
+            description: z.ZodString;
+            inputs: z.ZodArray<z.ZodString>;
+            outputs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    database: z.ZodObject<{
+        type: z.ZodEnum<{
+            mongodb: "mongodb";
+            postgresql: "postgresql";
+        }>;
+        reasoning: z.ZodString;
+        entities: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            fields: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                required: z.ZodBoolean;
+                unique: z.ZodBoolean;
+                description: z.ZodString;
+                default: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            indexes: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                fields: z.ZodArray<z.ZodString>;
+                unique: z.ZodBoolean;
+            }, z.core.$strip>>;
+            relations: z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                references: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    apiDesign: z.ZodObject<{
+        style: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+            rest: "rest";
+            graphql: "graphql";
+        }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+            rest: "rest";
+            graphql: "graphql";
+        }>>;
+        rest: z.ZodOptional<z.ZodObject<{
+            baseUrl: z.ZodDefault<z.ZodString>;
+            endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                moduleId: z.ZodString;
+                method: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+                    DELETE: "DELETE";
+                    GET: "GET";
+                    POST: "POST";
+                    PUT: "PUT";
+                    PATCH: "PATCH";
+                }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+                    DELETE: "DELETE";
+                    GET: "GET";
+                    POST: "POST";
+                    PUT: "PUT";
+                    PATCH: "PATCH";
+                }>>;
+                path: z.ZodString;
+                description: z.ZodString;
+                auth: z.ZodCoercedBoolean<unknown>;
+                roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                requestBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+                    [k: string]: string;
+                }, Record<string, unknown>>>;
+                responseBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+                    [k: string]: string;
+                }, Record<string, unknown>>>;
+                queryParams: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+                    [k: string]: string;
+                }, Record<string, unknown>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        graphql: z.ZodOptional<z.ZodObject<{
+            types: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                kind: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+                    input: "input";
+                    type: "type";
+                    enum: "enum";
+                }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+                    input: "input";
+                    type: "type";
+                    enum: "enum";
+                }>>;
+                fields: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    description: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            queries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                moduleId: z.ZodString;
+                description: z.ZodString;
+                auth: z.ZodCoercedBoolean<unknown>;
+                roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                args: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    required: z.ZodCoercedBoolean<unknown>;
+                }, z.core.$strip>>;
+                returnType: z.ZodString;
+            }, z.core.$strip>>>;
+            mutations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                moduleId: z.ZodString;
+                description: z.ZodString;
+                auth: z.ZodCoercedBoolean<unknown>;
+                roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                args: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    required: z.ZodCoercedBoolean<unknown>;
+                }, z.core.$strip>>;
+                returnType: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    summary: z.ZodObject<{
+        totalActors: z.ZodNumber;
+        totalFlows: z.ZodNumber;
+        totalStories: z.ZodNumber;
+        totalModules: z.ZodNumber;
+        totalEntities: z.ZodNumber;
+        totalEndpoints: z.ZodNumber;
+        overview: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type RequirementSummary$1 = z.infer<typeof requirementSummarySchema>;
+
+/**
+ * Zod schema for extract_actors tool output
+ */
+
+declare const actorSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    goals: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const actorsResultSchema: z.ZodObject<{
+    actors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        goals: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    message: z.ZodString;
+}, z.core.$strip>;
+type ActorResult = z.infer<typeof actorsResultSchema>;
+
+/**
+ * Zod schema for generate_flows tool output
+ */
+
+declare const flowSchema: z.ZodObject<{
+    id: z.ZodString;
+    actorId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    trigger: z.ZodString;
+    outcome: z.ZodString;
+}, z.core.$strip>;
+declare const flowsResultSchema: z.ZodObject<{
+    flows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        actorId: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        trigger: z.ZodString;
+        outcome: z.ZodString;
+    }, z.core.$strip>>;
+    message: z.ZodString;
+}, z.core.$strip>;
+type FlowsResult = z.infer<typeof flowsResultSchema>;
+
+/**
+ * Zod schema for generate_stories tool output
+ */
+
+declare const storySchema: z.ZodObject<{
+    id: z.ZodString;
+    flowId: z.ZodString;
+    actor: z.ZodString;
+    action: z.ZodString;
+    benefit: z.ZodString;
+    preconditions: z.ZodArray<z.ZodString>;
+    postconditions: z.ZodArray<z.ZodString>;
+    dataInvolved: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const storiesResultSchema: z.ZodObject<{
+    stories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        flowId: z.ZodString;
+        actor: z.ZodString;
+        action: z.ZodString;
+        benefit: z.ZodString;
+        preconditions: z.ZodArray<z.ZodString>;
+        postconditions: z.ZodArray<z.ZodString>;
+        dataInvolved: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    message: z.ZodString;
+}, z.core.$strip>;
+type StoriesResult = z.infer<typeof storiesResultSchema>;
+
+/**
+ * Zod schema for extract_modules tool output
+ */
+
+declare const crudApiSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    operation: z.ZodEnum<{
+        create: "create";
+        update: "update";
+        delete: "delete";
+        read: "read";
+        readAll: "readAll";
+    }>;
+    description: z.ZodString;
+    inputs: z.ZodArray<z.ZodString>;
+    outputs: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const extractedModuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    entity: z.ZodString;
+    apis: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        operation: z.ZodEnum<{
+            create: "create";
+            update: "update";
+            delete: "delete";
+            read: "read";
+            readAll: "readAll";
+        }>;
+        description: z.ZodString;
+        inputs: z.ZodArray<z.ZodString>;
+        outputs: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const modulesResultSchema: z.ZodObject<{
+    modules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        entity: z.ZodString;
+        apis: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            operation: z.ZodEnum<{
+                create: "create";
+                update: "update";
+                delete: "delete";
+                read: "read";
+                readAll: "readAll";
+            }>;
+            description: z.ZodString;
+            inputs: z.ZodArray<z.ZodString>;
+            outputs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        totalModules: z.ZodNumber;
+        totalApis: z.ZodNumber;
+    }, z.core.$strip>;
+    message: z.ZodString;
+}, z.core.$strip>;
+type ModulesResult = z.infer<typeof modulesResultSchema>;
+
+/**
+ * requirement-gatherer module types
+ * Chat-based 4-stage flow: discovery -> requirements -> design -> complete
+ */
+
+/** Stage in the requirement gathering flow */
+type Stage$1 = 'discovery' | 'requirements' | 'design' | 'complete';
+/** Project brief from discovery (name, goal, api style, backend runtime) */
+interface ProjectBrief {
+    name: string;
+    goal: string;
+    features: string[];
+    domain: string;
+    database: 'mongodb' | 'postgresql';
+    backendRuntime: 'nodejs';
+    apiStyle: 'rest' | 'graphql';
+}
+/** Clarifying question for the user */
+interface Question {
+    id: string;
+    question: string;
+    context: string;
+    suggestions: string[];
+    multiSelect: boolean;
+    required: boolean;
+}
+/** Single chat message entry */
+interface ChatEntry$1 {
+    role: 'user' | 'assistant';
+    content: string;
+}
+/** Actor (user type) from requirements stage */
+interface Actor {
+    id: string;
+    name: string;
+    description: string;
+    goals: string[];
+}
+/** Flow (user journey) from requirements stage */
+interface Flow {
+    id: string;
+    actorId: string;
+    name: string;
+    description: string;
+    trigger: string;
+    outcome: string;
+}
+/** User story with data involved */
+interface Story {
+    id: string;
+    flowId: string;
+    actor: string;
+    action: string;
+    benefit: string;
+    preconditions: string[];
+    postconditions: string[];
+    dataInvolved: string[];
+}
+/** Module with CRUD APIs from requirements stage */
+interface CrudApi {
+    id: string;
+    name: string;
+    operation: 'create' | 'read' | 'readAll' | 'update' | 'delete';
+    description: string;
+    inputs: string[];
+    outputs: string[];
+}
+interface Module {
+    id: string;
+    name: string;
+    description: string;
+    entity: string;
+    apis: CrudApi[];
+}
+/** Database design: MongoDB or PostgreSQL with entities */
+interface EntityField$1 {
+    name: string;
+    type: string;
+    required: boolean;
+    unique: boolean;
+    description: string;
+    default?: string;
+}
+interface EntityIndex$1 {
+    name: string;
+    fields: string[];
+    unique: boolean;
+}
+interface EntityRelation$1 {
+    field: string;
+    references: string;
+    description: string;
+}
+interface DatabaseEntity {
+    name: string;
+    description: string;
+    fields: EntityField$1[];
+    indexes: EntityIndex$1[];
+    relations: EntityRelation$1[];
+}
+interface DatabaseDesign {
+    type: 'mongodb' | 'postgresql';
+    reasoning: string;
+    entities: DatabaseEntity[];
+}
+/** REST API design */
+interface RestEndpoint$1 {
+    id: string;
+    moduleId: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    description: string;
+    auth: boolean;
+    roles: string[];
+    requestBody?: Record<string, string>;
+    responseBody?: Record<string, string>;
+    queryParams?: Record<string, string>;
+}
+interface RestApiDesign {
+    baseUrl: string;
+    endpoints: RestEndpoint$1[];
+}
+/** GraphQL API design */
+interface GraphqlTypeDefinition {
+    name: string;
+    kind: 'type' | 'input' | 'enum';
+    fields: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+}
+interface GraphqlOperation$1 {
+    name: string;
+    moduleId: string;
+    description: string;
+    auth: boolean;
+    roles: string[];
+    args: {
+        name: string;
+        type: string;
+        required: boolean;
+    }[];
+    returnType: string;
+}
+interface GraphqlApiDesign {
+    types: GraphqlTypeDefinition[];
+    queries: GraphqlOperation$1[];
+    mutations: GraphqlOperation$1[];
+}
+/** Combined API design: REST and/or GraphQL */
+interface ApiDesign$1 {
+    style: 'rest' | 'graphql';
+    rest?: RestApiDesign;
+    graphql?: GraphqlApiDesign;
+}
+/** Summary for final requirement document */
+interface RequirementSummary {
+    totalActors: number;
+    totalFlows: number;
+    totalStories: number;
+    totalModules: number;
+    totalEntities: number;
+    totalEndpoints: number;
+    overview: string;
+}
+/** Final requirement document output */
+interface FinalRequirement {
+    project: ProjectBrief;
+    actors: Actor[];
+    flows: Flow[];
+    stories: Story[];
+    modules: Module[];
+    database: DatabaseDesign;
+    apiDesign: ApiDesign$1;
+    summary: RequirementSummary;
+}
+/** Accumulated context across chat turns */
+interface RequirementContext {
+    stage: Stage$1;
+    projectBrief: ProjectBrief | null;
+    actors: Actor[];
+    flows: Flow[];
+    stories: Story[];
+    modules: Module[];
+    database: DatabaseDesign | null;
+    apiDesign: ApiDesign$1 | null;
+    history: ChatEntry$1[];
+    pendingQuestions: Question[];
+}
+/** Result of a single chat turn */
+interface ChatTurnResult {
+    message: string;
+    context: RequirementContext;
+    questions: Question[];
+    finalRequirement: FinalRequirement | null;
+}
+/** Config for processRequirementChat */
+interface RequirementChatConfig {
+    model?: ModelConfig;
+    maxIterations?: number;
+    onStep?: (step: AgentStep) => void;
+    logger?: Logger;
+}
+/** Result of a stage processor */
+interface StageResult {
+    message: string;
+    questions?: Question[];
+    advance: boolean;
+    data: Partial<RequirementContext> & {
+        finalRequirement?: FinalRequirement;
+    };
+}
+/** Legacy alias for Module (backward compatibility) */
+type ExtractedModule = Module;
+/** Legacy: minimal project info (backward compatibility) */
+interface BasicProjectInfo {
+    name: string;
+    goal: string;
+    features: string;
+}
+/** Legacy: runRequirementGathererAgent config (one-shot wrapper) */
+interface RequirementGathererAgentConfig {
+    input: string;
+    model?: ModelConfig;
+    maxIterations?: number;
+    onStep?: (step: AgentStep) => void;
+    logger?: Logger;
+}
+
+/**
+ * System prompt for chat-based requirement gathering
+ */
+declare const REQUIREMENT_GATHERER_SYSTEM_PROMPT = "You are a senior fullstack developer helping scope and plan a project. Your role is to understand what the user wants to build and produce a clear, actionable requirement document.\n\nYou work in stages: discovery (understand the project and tech preferences), requirements (actors, flows, stories, modules), design (database + APIs), and complete (final document).\n\nThink about the project the way a developer would: core problem, user interactions, data model, auth, integrations, real-time needs. Do NOT ask generic template questions (e.g. scale, complexity level, \"how many users?\"). Ask only questions that directly unblock design decisions.\n\nGuidelines:\n- For tech choices (API style: REST vs GraphQL; database: MongoDB vs PostgreSQL), offer predefined options and ask what the user is comfortable with.\n- For everything else, ask open-ended, context-specific questions based on what the user described. Leave suggestions empty for those.\n- Never repeat a question already answered in the conversation history.\n- When the user says \"continue\", \"yes\", \"looks good\", or similar, treat it as confirmation and advance.\n- Return valid JSON only when the prompt asks for JSON (no markdown code fences unless specified).\n- Backend is Node.js only; database is MongoDB or PostgreSQL per user preference.";
+
+/**
+ * Discovery stage prompt - understand project and optionally ask questions
+ */
+declare const DISCOVERY_SYSTEM_FRAGMENT = "You are in the discovery stage. Parse the user's message (and prior context) into a structured project brief. Ask clarifying questions only when something genuinely blocks design decisions.\n\nDetermine from the user's words:\n- Project name and goal\n- Key features (array of strings)\n- Domain (e.g. e-commerce, healthcare, saas)\n- API style: \"rest\" | \"graphql\" \u2014 infer from context or ask with predefined options\n- Database: \"mongodb\" | \"postgresql\" \u2014 ask which they are comfortable with, with predefined options\n- Backend is always \"nodejs\"\n\nQuestion rules:\n- Tech stack (API style, database): Always provide \"suggestions\" with predefined options (e.g. [\"REST\", \"GraphQL\"], [\"MongoDB\", \"PostgreSQL\"]). Frame as \"which are you comfortable with?\"\n- All other questions: Use \"suggestions\": []. Ask open-ended, specific to what the user described (e.g. file uploads, real-time features, auth provider, core user action).\n- Never ask: scale, \"how many users?\", \"what's the complexity?\", or generic intake-form questions.\n- Before asking, check conversation history \u2014 never repeat something already answered.\n- If the user's message is clear enough (e.g. \"Instagram clone with photo sharing, messaging, stories\"), infer the obvious and ask only about genuine gaps. If you have enough for the brief, set needsClarification to false and empty questions.";
+declare const DISCOVERY_USER_PROMPT = "## Current user message:\n{userMessage}\n\n## Prior conversation (if any):\n{history}\n\nAnalyze the message and prior context. If you have enough to fill the project brief, return it and set needsClarification to false. Otherwise ask 1-3 short, problem-focused questions.\n\nReturn ONLY valid JSON (no markdown, no explanation) in this shape:\n{\n  \"needsClarification\": boolean,\n  \"questions\": [\n    {\n      \"id\": \"q1\",\n      \"question\": \"Question text\",\n      \"context\": \"Why this helps\",\n      \"suggestions\": [],\n      \"multiSelect\": false,\n      \"required\": true\n    }\n  ],\n  \"conversationalMessage\": \"Brief friendly message to the user\",\n  \"projectBrief\": {\n    \"name\": \"string\",\n    \"goal\": \"string\",\n    \"features\": [\"string\"],\n    \"domain\": \"string\",\n    \"database\": \"mongodb\" | \"postgresql\",\n    \"backendRuntime\": \"nodejs\",\n    \"apiStyle\": \"rest\" | \"graphql\"\n  }\n}\n\nFor tech choices (API style, database), populate \"suggestions\" with the predefined options. For all other questions, use \"suggestions\": [].\nIf needsClarification is true, projectBrief can have empty/default values. If false, projectBrief must be complete.";
+declare function buildDiscoveryPrompt(userMessage: string, history: string): string;
+
+/**
+ * Requirements stage prompts - actors, flows, stories, modules (chained)
+ */
+declare const EXTRACT_ACTORS_PROMPT = "## Project:\n- **Name**: {projectName}\n- **Goal**: {projectGoal}\n- **Features**: {projectFeatures}\n\nIdentify ALL distinct user types (actors) who will use this system. 2-5 actors. Include unauthenticated and admin roles if applicable.\n\nReturn ONLY valid JSON:\n{\n  \"actors\": [\n    { \"id\": \"actor-1\", \"name\": \"Name\", \"description\": \"Who they are\", \"goals\": [\"goal1\", \"goal2\"] }\n  ],\n  \"message\": \"Brief explanation\"\n}";
+declare const GENERATE_FLOWS_PROMPT = "## Project:\n- **Name**: {projectName}\n- **Goal**: {projectGoal}\n- **Features**: {projectFeatures}\n\n## Actors (JSON):\n{actors}\n\nFor EACH actor, identify 2-5 key user journeys (flows). Each flow: id, actorId, name, description, trigger, outcome.\n\nReturn ONLY valid JSON:\n{\n  \"flows\": [\n    { \"id\": \"flow-1\", \"actorId\": \"actor-1\", \"name\": \"Flow Name\", \"description\": \"...\", \"trigger\": \"...\", \"outcome\": \"...\" }\n  ],\n  \"message\": \"Brief explanation\"\n}";
+declare const GENERATE_STORIES_PROMPT = "## Project:\n- **Name**: {projectName}\n- **Goal**: {projectGoal}\n- **Features**: {projectFeatures}\n\n## Actors: {actors}\n\n## Flows (JSON):\n{flows}\n\nFor EACH flow, generate 2-5 user stories. Each story MUST include dataInvolved (entity.field names) for DB design. Include preconditions, postconditions.\n\nReturn ONLY valid JSON:\n{\n  \"stories\": [\n    { \"id\": \"story-1\", \"flowId\": \"flow-1\", \"actor\": \"ActorName\", \"action\": \"...\", \"benefit\": \"...\", \"preconditions\": [], \"postconditions\": [], \"dataInvolved\": [\"User.email\", \"Order.total\"] }\n  ],\n  \"message\": \"Brief explanation\"\n}";
+declare const EXTRACT_MODULES_PROMPT = "## Project:\n- **Name**: {projectName}\n- **Goal**: {projectGoal}\n- **Features**: {projectFeatures}\n\n## Actors: {actors}\n## Flows: {flows}\n## Stories (JSON):\n{stories}\n\nExtract modules (one per major entity). Each module has apis: create, read, readAll, update, delete plus any extra (e.g. searchUsers). CamelCase names. Clear inputs/outputs.\n\nReturn ONLY valid JSON:\n{\n  \"modules\": [\n    { \"id\": \"module-1\", \"name\": \"User\", \"description\": \"...\", \"entity\": \"User\", \"apis\": [ { \"id\": \"api-1-1\", \"name\": \"createUser\", \"operation\": \"create\", \"description\": \"...\", \"inputs\": [], \"outputs\": [] } ] }\n  ],\n  \"summary\": { \"totalModules\": 0, \"totalApis\": 0 },\n  \"message\": \"Brief explanation\"\n}";
+declare function buildExtractActorsPrompt(projectName: string, projectGoal: string, projectFeatures: string): string;
+declare function buildGenerateFlowsPrompt(projectName: string, projectGoal: string, projectFeatures: string, actorsJson: string): string;
+declare function buildGenerateStoriesPrompt(projectName: string, projectGoal: string, projectFeatures: string, actorsJson: string, flowsJson: string): string;
+declare function buildExtractModulesPrompt(projectName: string, projectGoal: string, projectFeatures: string, actorsJson: string, flowsJson: string, storiesJson: string): string;
+
+/**
+ * Design stage prompts - direct LLM invocation for database and API design
+ */
+declare const DESIGN_DATABASE_SYSTEM_PROMPT = "You output only valid JSON. No markdown, no explanation.";
+declare const DESIGN_APIS_SYSTEM_PROMPT = "You output only valid JSON. No markdown, no explanation.";
+declare function buildDesignDatabasePrompt(projectBrief: string, modules: string, stories: string): string;
+declare function buildDesignApisPrompt(projectBrief: string, modules: string, actors: string, stories: string, database: string): string;
+
+/**
+ * Synthesis stage prompt - compile FinalRequirement document
+ */
+declare const SYNTHESIS_SYSTEM_FRAGMENT = "You are in the complete stage. You have the full context: project brief, actors, flows, stories, modules, database design, and API design. Your job is to produce a single final requirement document (JSON) that matches the FinalRequirement schema, with a summary that includes totalActors, totalFlows, totalStories, totalModules, totalEntities, totalEndpoints, and a short overview paragraph.";
+declare const SYNTHESIS_USER_PROMPT = "## Project brief (JSON):\n{projectBrief}\n\n## Actors (JSON):\n{actors}\n\n## Flows (JSON):\n{flows}\n\n## Stories (JSON):\n{stories}\n\n## Modules (JSON):\n{modules}\n\n## Database design (JSON):\n{database}\n\n## API design (JSON):\n{apiDesign}\n\nCompile the above into one FinalRequirement JSON. Include a \"summary\" object with: totalActors, totalFlows, totalStories, totalModules, totalEntities (from database.entities.length), totalEndpoints (count of REST endpoints or GraphQL queries+mutations as appropriate), and \"overview\" (2-4 sentence paragraph summarizing the project and tech choices).\n\nReturn ONLY valid JSON in this shape (no markdown, no extra text):\n{\n  \"project\": { ... },\n  \"actors\": [ ... ],\n  \"flows\": [ ... ],\n  \"stories\": [ ... ],\n  \"modules\": [ ... ],\n  \"database\": { ... },\n  \"apiDesign\": { ... },\n  \"summary\": {\n    \"totalActors\": 0,\n    \"totalFlows\": 0,\n    \"totalStories\": 0,\n    \"totalModules\": 0,\n    \"totalEntities\": 0,\n    \"totalEndpoints\": 0,\n    \"overview\": \"string\"\n  }\n}";
+declare function buildSynthesisPrompt(projectBrief: string, actors: string, flows: string, stories: string, modules: string, database: string, apiDesign: string): string;
+
+/**
+ * runRequirementGathererAgent - one-shot wrapper around processRequirementChat
+ * Runs the full chat flow non-interactively, auto-advancing with "continue" when questions are asked.
+ */
+
+/**
+ * Run the requirement gatherer in one-shot mode: single input, auto-advance through stages,
+ * return final requirement document or last message as AgentResult.
+ */
+declare function runRequirementGathererAgent(config: RequirementGathererAgentConfig): Promise<AgentResult>;
+
+/**
+ * processRequirementChat - main entry point for chat-based requirement gathering
+ */
+
+declare function processRequirementChat(userMessage: string, context: RequirementContext | null, config: RequirementChatConfig): Promise<ChatTurnResult>;
+
+/**
+ * Builder for RequirementContext - fluent API, max 150 lines.
+ */
+
+declare class RequirementContextBuilder {
+    private data;
+    withStage(stage: Stage$1): this;
+    withProjectBrief(projectBrief: ProjectBrief | null): this;
+    withActors(actors: Actor[]): this;
+    withFlows(flows: Flow[]): this;
+    withStories(stories: Story[]): this;
+    withModules(modules: Module[]): this;
+    withDatabase(database: DatabaseDesign | null): this;
+    withApiDesign(apiDesign: ApiDesign$1 | null): this;
+    withHistory(history: ChatEntry$1[]): this;
+    withPendingQuestions(pendingQuestions: Question[]): this;
+    reset(): this;
+    build(): RequirementContext;
+}
+declare function createRequirementContextBuilder(): RequirementContextBuilder;
+
+/**
+ * Context management for requirement chat
+ */
+
+declare function createInitialContext(): RequirementContext;
+declare function mergeStageResult(context: RequirementContext, result: StageResult): RequirementContext;
+declare function addChatEntry(context: RequirementContext, role: 'user' | 'assistant', content: string): RequirementContext;
+declare function advanceStage(context: RequirementContext): RequirementContext;
+
+/**
+ * planning module types
+ * Chat-based 4-stage flow: discovery -> requirements -> design -> complete
+ * All LLM output is raw markdown strings; no JSON parsing or schema validation.
+ */
+
+/** Stage in the planning flow */
+type Stage = 'discovery' | 'requirements' | 'design' | 'complete';
+/** Accumulated markdown sections -- each is a raw string from an LLM call */
+interface PlanSections {
+    overview: string | null;
+    techStack: string | null;
+    featureDecisions: string | null;
+    dataModels: string | null;
+    pagesAndRoutes: string | null;
+    authFlow: string | null;
+    apiRoutes: string | null;
+    implementation: string | null;
+    executionPlan: string | null;
+    edgeCases: string | null;
+    testingChecklist: string | null;
+}
+/** Single chat message entry */
+interface ChatEntry {
+    role: 'user' | 'assistant';
+    content: string;
+}
+/** Accumulated context across chat turns */
+interface PlanningContext {
+    stage: Stage;
+    projectDescription: string | null;
+    sections: PlanSections;
+    history: ChatEntry[];
+    pendingQuestions: string[];
+}
+/** Result of a single chat turn */
+interface PlanChatTurnResult {
+    message: string;
+    context: PlanningContext;
+    pendingQuestions: string[];
+    planMarkdown: string | null;
+}
+/** Config for processPlanningChat */
+interface PlanningChatConfig {
+    model?: ModelConfig;
+    maxIterations?: number;
+    onStep?: (step: AgentStep) => void;
+    logger?: Logger;
+}
+/** Result of a stage processor */
+interface PlanStageResult {
+    message: string;
+    advance: boolean;
+    sections: Partial<PlanSections>;
+    projectDescription?: string | null;
+    pendingQuestions?: string[];
+    /** Set by synthesis stage when plan is complete */
+    planMarkdown?: string;
+}
+/** Input passed to stage process() */
+interface StageInput {
+    userMessage: string;
+    model: Model;
+    logger?: Logger;
+}
+/** Config for runPlanningAgent (one-shot wrapper) */
+interface PlanningAgentConfig {
+    input: string;
+    model?: ModelConfig;
+    maxIterations?: number;
+    onStep?: (step: AgentStep) => void;
+    logger?: Logger;
+}
+/** Config for editPlan (edit existing plan with feedback) */
+interface EditPlanConfig {
+    /** Current plan.md content */
+    existingPlan: string;
+    /** Edit instructions or additional context */
+    feedback: string;
+    model?: ModelConfig;
+    logger?: Logger;
+}
+
+/**
+ * runPlanningAgent - one-shot wrapper around processPlanningChat
+ * Auto-advances with "continue"; returns plan markdown. Does not write to file.
+ */
+
+/**
+ * Run the planning agent in one-shot mode: single input, auto-advance through stages,
+ * return plan markdown as AgentResult. Does not write to file.
+ */
+declare function runPlanningAgent(config: PlanningAgentConfig): Promise<AgentResult>;
+
+/**
+ * editPlan - single LLM call to revise an existing plan based on feedback.
+ * Takes existing plan markdown + edit instructions, returns updated markdown.
+ */
+
+/**
+ * Edit an existing plan based on feedback or additional context.
+ * Single focused LLM call -- no multi-stage pipeline needed.
+ * Returns the full revised plan as a markdown string.
+ */
+declare function editPlan(config: EditPlanConfig): Promise<string>;
+
+/**
+ * processPlanningChat - main entry point for chat-based planning
+ */
+
+declare function processPlanningChat(userMessage: string, context: PlanningContext | null, config: PlanningChatConfig): Promise<PlanChatTurnResult>;
+
+/**
+ * Builder for PlanningContext - fluent API
+ */
+
+declare class PlanningContextBuilder {
+    private data;
+    withStage(stage: Stage): this;
+    withProjectDescription(projectDescription: string | null): this;
+    withSections(sections: Partial<PlanSections>): this;
+    withHistory(history: ChatEntry[]): this;
+    withPendingQuestions(pendingQuestions: string[]): this;
+    reset(): this;
+    build(): PlanningContext;
+}
+declare function createPlanningContextBuilder(): PlanningContextBuilder;
+
+/**
+ * Assemble plan sections into markdown and write to file
+ */
+
+declare function assemblePlan(projectName: string, sections: PlanSections): string;
+declare function writePlanToFile(markdown: string, outputPath: string): Promise<void>;
+
+/**
+ * System prompt for planning module - markdown-only, pro-level output
+ */
+declare const PLANNING_SYSTEM_PROMPT = "You are a senior software architect creating a single, implementation-ready plan that a developer can follow without ambiguity.\n\nCRITICAL RULES:\n- Output ONLY raw markdown text. Use code blocks ONLY for: request/response JSON examples, file/directory trees, and env or config snippets. No JSON or structured data outside those code blocks.\n- Use consistent structure: ## for main sections, ### for subsections, #### for per-item headings (e.g. per route, per endpoint). Use **bold** for labels (e.g. **Purpose**, **Request Body**, **Response on Success**).\n- Be concrete and actionable: include validation rules, HTTP status codes, redirects, field-level data model descriptions, and step-by-step auth flows. Every section should give enough detail to implement from the plan alone.";
+
+/**
+ * Zod schemas for DataModelDesign
+ */
+
+declare const dataEntitySchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    fields: z.ZodPipe<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        unique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        description: z.ZodDefault<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>, z.ZodTransform<{
+        name: string;
+        type: string;
+        required: boolean;
+        unique: boolean;
+        description: string;
+        default?: string | undefined;
+    }[], Record<string, unknown> | {
+        name: string;
+        type: string;
+        required: boolean;
+        unique: boolean;
+        description: string;
+        default?: string | undefined;
+    }[]>>;
+    indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodDefault<z.ZodString>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        unique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    }, z.core.$strip>>>;
+    relations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        references: z.ZodString;
+        type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            "1:1": "1:1";
+            "1:N": "1:N";
+            "M:N": "M:N";
+        }>>;
+        description: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const dataModelDesignSchema: z.ZodObject<{
+    type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        mongodb: "mongodb";
+        postgresql: "postgresql";
+    }>>;
+    reasoning: z.ZodDefault<z.ZodString>;
+    entities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodDefault<z.ZodString>;
+        fields: z.ZodPipe<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            required: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            unique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            description: z.ZodDefault<z.ZodString>;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>, z.ZodTransform<{
+            name: string;
+            type: string;
+            required: boolean;
+            unique: boolean;
+            description: string;
+            default?: string | undefined;
+        }[], Record<string, unknown> | {
+            name: string;
+            type: string;
+            required: boolean;
+            unique: boolean;
+            description: string;
+            default?: string | undefined;
+        }[]>>;
+        indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodDefault<z.ZodString>;
+            fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            unique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        }, z.core.$strip>>>;
+        relations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            references: z.ZodString;
+            type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+                "1:1": "1:1";
+                "1:N": "1:N";
+                "M:N": "M:N";
+            }>>;
+            description: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type TDataModelDesign = z.infer<typeof dataModelDesignSchema>;
+
+/**
+ * data-modeler module types
+ */
+
+type DatabaseType = 'mongodb' | 'postgresql';
+interface EntityField {
+    name: string;
+    type: string;
+    required: boolean;
+    unique: boolean;
+    description: string;
+    default?: string;
+}
+interface EntityIndex {
+    name: string;
+    fields: string[];
+    unique: boolean;
+}
+interface EntityRelation {
+    field: string;
+    references: string;
+    type: '1:1' | '1:N' | 'M:N';
+    description: string;
+}
+interface DataEntity {
+    name: string;
+    description: string;
+    fields: EntityField[];
+    indexes: EntityIndex[];
+    relations: EntityRelation[];
+}
+interface DataModelDesign {
+    type: DatabaseType;
+    reasoning: string;
+    entities: DataEntity[];
+}
+interface DataModelerAgentConfig {
+    /** User input: natural language description of data modeling needs */
+    input: string;
+    /** Model config; defaults to gpt-4o-mini */
+    model?: ModelConfig;
+    /** Max iterations; default 15 */
+    maxIterations?: number;
+    /** Callback for each step */
+    onStep?: (step: AgentStep) => void;
+    /** Optional logger */
+    logger?: Logger;
+}
+
+/**
+ * System prompt for data-modeler orchestrator
+ */
+declare const DATA_MODELER_SYSTEM_PROMPT = "You are a senior database architect specializing in both MongoDB and PostgreSQL schema design.\n\nYou analyze requirements and produce enterprise-quality data models with:\n- Properly typed fields (MongoDB: ObjectId, string, number, date, array; PostgreSQL: uuid, varchar, text, integer, timestamp, jsonb)\n- Indexes optimized for query patterns\n- Relationships with correct cardinality (1:1, 1:N, M:N)\n- Validation constraints and default values\n- Security considerations (hashed passwords, encrypted fields)\n\nOutput only valid JSON unless instructed otherwise.";
+
+/**
+ * validate_schema tool - validates JSON against dataModelDesignSchema (no AI)
+ */
+declare const validateSchemaTool: ai.Tool;
+
+/**
+ * Creates the design_schema tool. Requires a model for generation.
+ */
+declare function createDesignSchemaTool(model: Model): ai.Tool;
+
+/**
+ * Creates the design_schema_pro tool for structured 5-phase data modeling.
+ */
+declare function createDesignSchemaProTool(model: Model): ai.Tool;
+
+/**
+ * Creates the refine_schema tool for iterating on an existing data model.
+ */
+declare function createRefineSchemaTools(model: Model): ai.Tool;
+
+/**
+ * Create all data-modeler tools. Pass the model for AI-backed tools.
+ */
+declare function createDataModelerTools(model: Model): ToolSet;
+
+/**
+ * entity-analyzer subagent - extracts entities, fields, and relationships from requirements
+ */
+declare const entityAnalyzerSubagent: SubagentDefinition;
+
+/**
+ * relationship-mapper subagent - maps cardinality, foreign keys, indexes
+ */
+declare const relationshipMapperSubagent: SubagentDefinition;
+
+/**
+ * schema-refiner subagent - reviews schema for completeness and performance
+ */
+declare function createSchemaRefinerSubagent(): SubagentDefinition;
+
+/**
+ * runDataModelerAgent - orchestrator for data model design
+ */
+
+/**
+ * Run the data-modeler orchestrator agent with all tools and subagents.
+ */
+declare function runDataModelerAgent(config: DataModelerAgentConfig): Promise<AgentResult>;
+
+/**
+ * Zod schemas for ApiDesign
+ */
+
+declare const restEndpointSchema: z.ZodObject<{
+    id: z.ZodString;
+    resource: z.ZodString;
+    method: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>>;
+    path: z.ZodString;
+    description: z.ZodString;
+    auth: z.ZodCoercedBoolean<unknown>;
+    roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requestBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, unknown>>>;
+    responseBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, unknown>>>;
+    queryParams: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, unknown>>>;
+    validation: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodUnknown>>, z.ZodTransform<string[], unknown[]>>;
+    errorResponses: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodUnknown>>, z.ZodTransform<string[], unknown[]>>;
+}, z.core.$strip>;
+declare const graphqlOperationSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        query: "query";
+        mutation: "mutation";
+        subscription: "subscription";
+    }>;
+    description: z.ZodString;
+    auth: z.ZodCoercedBoolean<unknown>;
+    roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    args: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodCoercedBoolean<unknown>;
+    }, z.core.$strip>>;
+    returnType: z.ZodString;
+}, z.core.$strip>;
+declare const apiDesignSchema: z.ZodObject<{
+    style: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"rest" | "graphql", unknown>>;
+    baseUrl: z.ZodDefault<z.ZodString>;
+    endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        resource: z.ZodString;
+        method: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+        }>, z.ZodString]>, z.ZodTransform<string, string>>, z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+        }>>;
+        path: z.ZodString;
+        description: z.ZodString;
+        auth: z.ZodCoercedBoolean<unknown>;
+        roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requestBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, unknown>>>;
+        responseBody: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, unknown>>>;
+        queryParams: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, unknown>>>;
+        validation: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodUnknown>>, z.ZodTransform<string[], unknown[]>>;
+        errorResponses: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodUnknown>>, z.ZodTransform<string[], unknown[]>>;
+    }, z.core.$strip>>>;
+    graphqlOperations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            query: "query";
+            mutation: "mutation";
+            subscription: "subscription";
+        }>;
+        description: z.ZodString;
+        auth: z.ZodCoercedBoolean<unknown>;
+        roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        args: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            required: z.ZodCoercedBoolean<unknown>;
+        }, z.core.$strip>>;
+        returnType: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type TApiDesign = z.infer<typeof apiDesignSchema>;
+
+/**
+ * api-designer module types
+ */
+
+type ApiStyle = 'rest' | 'graphql';
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface RestEndpoint {
+    id: string;
+    resource: string;
+    method: HttpMethod;
+    path: string;
+    description: string;
+    auth: boolean;
+    roles: string[];
+    requestBody: Record<string, string>;
+    responseBody: Record<string, string>;
+    queryParams: Record<string, string>;
+    validation: string[];
+    errorResponses: string[];
+}
+interface GraphqlOperation {
+    name: string;
+    type: 'query' | 'mutation' | 'subscription';
+    description: string;
+    auth: boolean;
+    roles: string[];
+    args: {
+        name: string;
+        type: string;
+        required: boolean;
+    }[];
+    returnType: string;
+}
+interface ApiDesign {
+    style: ApiStyle;
+    baseUrl: string;
+    endpoints: RestEndpoint[];
+    graphqlOperations: GraphqlOperation[];
+}
+interface ApiDesignerAgentConfig {
+    /** User input: natural language description or data model + requirements */
+    input: string;
+    /** Model config; defaults to gpt-4o-mini */
+    model?: ModelConfig;
+    /** Max iterations; default 15 */
+    maxIterations?: number;
+    /** Callback for each step */
+    onStep?: (step: AgentStep) => void;
+    /** Optional logger */
+    logger?: Logger;
+}
+
+/**
+ * System prompt for api-designer orchestrator
+ */
+declare const API_DESIGNER_SYSTEM_PROMPT = "You are a senior API architect specializing in REST and GraphQL API design.\n\nYou analyze data models and requirements to produce enterprise-quality API designs with:\n- RESTful endpoints grouped by resource with proper HTTP methods\n- Request/response contracts with field types and validation rules\n- Error responses with appropriate HTTP status codes (400, 401, 403, 404, 500)\n- Pagination, filtering, and sorting patterns\n- Authentication and authorization annotations per endpoint\n- GraphQL types, queries, mutations, and subscriptions when applicable\n\nOutput only valid JSON unless instructed otherwise.";
+
+/**
+ * validate_api tool - validates JSON against apiDesignSchema (no AI)
+ */
+declare const validateApiTool: ai.Tool;
+
+/**
+ * Creates the design_api tool for plain text requirements.
+ */
+declare function createDesignApiTool(model: Model): ai.Tool;
+
+/**
+ * Creates the design_api_pro tool for structured API design.
+ */
+declare function createDesignApiProTool(model: Model): ai.Tool;
+
+/**
+ * Create all api-designer tools. Pass the model for AI-backed tools.
+ */
+declare function createApiDesignerTools(model: Model): ToolSet;
+
+/**
+ * endpoint-analyzer subagent - derives API endpoints from data model and requirements
+ */
+declare const endpointAnalyzerSubagent: SubagentDefinition;
+
+/**
+ * contract-designer subagent - designs request/response contracts per endpoint
+ */
+declare const contractDesignerSubagent: SubagentDefinition;
+
+/**
+ * runApiDesignerAgent - orchestrator for API design
+ */
+
+/**
+ * Run the api-designer orchestrator agent with all tools and subagents.
+ */
+declare function runApiDesignerAgent(config: ApiDesignerAgentConfig): Promise<AgentResult>;
+
+/**
+ * Zod schemas for AuthDesign
+ */
+
+declare const authFlowStepSchema: z.ZodObject<{
+    order: z.ZodNumber;
+    side: z.ZodEnum<{
+        frontend: "frontend";
+        backend: "backend";
+    }>;
+    action: z.ZodString;
+    details: z.ZodString;
+}, z.core.$strip>;
+declare const authFlowSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        order: z.ZodNumber;
+        side: z.ZodEnum<{
+            frontend: "frontend";
+            backend: "backend";
+        }>;
+        action: z.ZodString;
+        details: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const authMiddlewareSchema: z.ZodObject<{
+    name: z.ZodString;
+    purpose: z.ZodString;
+    behavior: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const roleDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    permissions: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const securityPolicySchema: z.ZodObject<{
+    area: z.ZodString;
+    rules: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const authDesignSchema: z.ZodObject<{
+    strategy: z.ZodEnum<{
+        jwt: "jwt";
+        oauth: "oauth";
+        session: "session";
+    }>;
+    flows: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        steps: z.ZodArray<z.ZodObject<{
+            order: z.ZodNumber;
+            side: z.ZodEnum<{
+                frontend: "frontend";
+                backend: "backend";
+            }>;
+            action: z.ZodString;
+            details: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    middleware: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        purpose: z.ZodString;
+        behavior: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    roles: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        permissions: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    policies: z.ZodArray<z.ZodObject<{
+        area: z.ZodString;
+        rules: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type TAuthDesign = z.infer<typeof authDesignSchema>;
+
+/**
+ * auth-designer module types
+ */
+
+type AuthStrategy = 'jwt' | 'session' | 'oauth';
+interface AuthFlow {
+    name: string;
+    description: string;
+    steps: AuthFlowStep[];
+}
+interface AuthFlowStep {
+    order: number;
+    side: 'frontend' | 'backend';
+    action: string;
+    details: string;
+}
+interface AuthMiddleware {
+    name: string;
+    purpose: string;
+    behavior: string[];
+}
+interface RoleDefinition {
+    name: string;
+    description: string;
+    permissions: string[];
+}
+interface SecurityPolicy {
+    area: string;
+    rules: string[];
+}
+interface AuthDesign {
+    strategy: AuthStrategy;
+    flows: AuthFlow[];
+    middleware: AuthMiddleware[];
+    roles: RoleDefinition[];
+    policies: SecurityPolicy[];
+}
+interface AuthDesignerAgentConfig {
+    /** User input: project context and auth requirements */
+    input: string;
+    /** Model config; defaults to gpt-4o-mini */
+    model?: ModelConfig;
+    /** Max iterations; default 15 */
+    maxIterations?: number;
+    /** Callback for each step */
+    onStep?: (step: AgentStep) => void;
+    /** Optional logger */
+    logger?: Logger;
+}
+
+/**
+ * System prompt for auth-designer orchestrator
+ */
+declare const AUTH_DESIGNER_SYSTEM_PROMPT = "You are a senior security engineer specializing in authentication, authorization, and web security.\n\nYou design enterprise-quality auth systems with:\n- Step-by-step auth flows (signup, login, logout, password reset) with both frontend and backend steps\n- JWT or session strategy with proper cookie configuration (httpOnly, secure, sameSite, maxAge)\n- Role-based access control (RBAC) with permission matrices\n- Middleware chains for route protection and API authentication\n- Security policies: password hashing (bcrypt), rate limiting, CORS, input sanitization, brute force protection\n- OAuth integration patterns when needed\n\nOutput only valid JSON unless instructed otherwise.";
+
+/**
+ * Design prompts for auth-designer
+ */
+declare const DESIGN_AUTH_PROMPT = "## Requirements:\n{requirement}\n\nDesign the authentication and authorization system. Include:\n\n1. Strategy: jwt, session, or oauth (choose based on requirements).\n2. Flows: signup, login, logout, password reset (if applicable). Each flow with numbered steps, frontend/backend side, action, and details.\n3. Middleware: route protection middleware, API auth middleware. Each with name, purpose, and behavior list.\n4. Roles: role definitions with name, description, and permissions list.\n5. Policies: security policies grouped by area (passwords, tokens, CORS, rate limiting, etc.).\n\nReturn ONLY valid JSON:\n{\n  \"strategy\": \"jwt\" | \"session\" | \"oauth\",\n  \"flows\": [{ \"name\": \"signup\", \"description\": \"...\", \"steps\": [{ \"order\": 1, \"side\": \"frontend\", \"action\": \"...\", \"details\": \"...\" }] }],\n  \"middleware\": [{ \"name\": \"authenticateRequest\", \"purpose\": \"...\", \"behavior\": [\"...\"] }],\n  \"roles\": [{ \"name\": \"user\", \"description\": \"...\", \"permissions\": [\"...\"] }],\n  \"policies\": [{ \"area\": \"passwords\", \"rules\": [\"...\"] }]\n}";
+declare function buildDesignAuthPrompt(requirement: string): string;
+
+/**
+ * validate_auth tool - validates JSON against authDesignSchema (no AI)
+ */
+declare const validateAuthTool: ai.Tool;
+
+/**
+ * Creates the design_auth tool for auth flow generation.
+ */
+declare function createDesignAuthTool(model: Model): ai.Tool;
+
+/**
+ * Create all auth-designer tools. Pass the model for AI-backed tools.
+ */
+declare function createAuthDesignerTools(model: Model): ToolSet;
+
+/**
+ * security-analyzer subagent - analyzes security requirements and threat vectors
+ */
+declare const securityAnalyzerSubagent: SubagentDefinition;
+
+/**
+ * flow-designer subagent - designs step-by-step auth flows
+ */
+declare const flowDesignerSubagent: SubagentDefinition;
+
+/**
+ * runAuthDesignerAgent - orchestrator for auth design
+ */
+
+/**
+ * Run the auth-designer orchestrator agent with all tools and subagents.
+ */
+declare function runAuthDesignerAgent(config: AuthDesignerAgentConfig): Promise<AgentResult>;
+
+/**
+ * Zod schemas for FrontendDesign
+ */
+
+declare const formFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    required: z.ZodCoercedBoolean<unknown>;
+    validation: z.ZodString;
+}, z.core.$strip>;
+declare const pageDesignSchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodString;
+    access: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+    }>>;
+    purpose: z.ZodString;
+    formFields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodCoercedBoolean<unknown>;
+        validation: z.ZodString;
+    }, z.core.$strip>>>;
+    actions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    emptyState: z.ZodDefault<z.ZodString>;
+    errorState: z.ZodDefault<z.ZodString>;
+    redirectOnSuccess: z.ZodDefault<z.ZodString>;
+    keyUiElements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const componentDesignSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        form: "form";
+        layout: "layout";
+        shared: "shared";
+        display: "display";
+        navigation: "navigation";
+    }>>;
+    purpose: z.ZodString;
+    props: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    usedIn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const frontendDesignSchema: z.ZodObject<{
+    pages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        name: z.ZodString;
+        access: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+        }>>;
+        purpose: z.ZodString;
+        formFields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            required: z.ZodCoercedBoolean<unknown>;
+            validation: z.ZodString;
+        }, z.core.$strip>>>;
+        actions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        emptyState: z.ZodDefault<z.ZodString>;
+        errorState: z.ZodDefault<z.ZodString>;
+        redirectOnSuccess: z.ZodDefault<z.ZodString>;
+        keyUiElements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    components: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            form: "form";
+            layout: "layout";
+            shared: "shared";
+            display: "display";
+            navigation: "navigation";
+        }>>;
+        purpose: z.ZodString;
+        props: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        usedIn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    stateManagement: z.ZodDefault<z.ZodString>;
+    routingNotes: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type TFrontendDesign = z.infer<typeof frontendDesignSchema>;
+
+/**
+ * frontend-architect module types
+ */
+
+type PageAccess = 'public' | 'protected';
+interface FormField {
+    name: string;
+    type: string;
+    required: boolean;
+    validation: string;
+}
+interface PageDesign {
+    path: string;
+    name: string;
+    access: PageAccess;
+    purpose: string;
+    formFields: FormField[];
+    actions: string[];
+    emptyState: string;
+    errorState: string;
+    redirectOnSuccess: string;
+    keyUiElements: string[];
+}
+interface ComponentDesign {
+    name: string;
+    type: 'layout' | 'shared' | 'form' | 'display' | 'navigation';
+    purpose: string;
+    props: string[];
+    usedIn: string[];
+}
+interface FrontendDesign {
+    pages: PageDesign[];
+    components: ComponentDesign[];
+    stateManagement: string;
+    routingNotes: string;
+}
+interface FrontendArchitectAgentConfig {
+    /** User input: project context, API surface, and frontend requirements */
+    input: string;
+    /** Model config; defaults to gpt-4o-mini */
+    model?: ModelConfig;
+    /** Max iterations; default 15 */
+    maxIterations?: number;
+    /** Callback for each step */
+    onStep?: (step: AgentStep) => void;
+    /** Optional logger */
+    logger?: Logger;
+}
+
+/**
+ * System prompt for frontend-architect orchestrator
+ */
+declare const FRONTEND_ARCHITECT_SYSTEM_PROMPT = "You are a senior frontend architect specializing in page design, routing, and component architecture.\n\nYou design enterprise-quality frontend architectures targeting a Vite + React 19 + TypeScript stack with:\n- **UI Library**: ShadCN UI (Radix-based components in src/components/ui/)\n- **Styling**: Tailwind CSS v4 with OKLCH color space and dark mode support\n- **Routing**: React Router v7 with private route guards\n- **Forms**: React Hook Form + Zod validation\n- **GraphQL**: Apollo Client with CodeGen-typed hooks\n- **Path Aliases**: @/{appName}/* mapping to ./src/*\n\nArchitecture outputs:\n- Public and protected pages with detailed route definitions\n- Per-page specifications: purpose, form fields with validation, actions, empty/error states, redirects\n- Component taxonomy: layout (sidebar, navbar), shared (data tables, dialogs), form (inputs, selects), display (cards, badges), navigation (breadcrumbs, tabs)\n- State management strategy (per-page vs global, Apollo cache vs local state)\n\nOutput only valid JSON unless instructed otherwise.";
+
+/**
+ * Design prompts for frontend-architect
+ */
+declare const DESIGN_FRONTEND_PROMPT = "## Requirements:\n{requirement}\n\nDesign the frontend architecture. Include:\n\n1. Pages: public and protected pages. For each page: path, name, access level, purpose, form fields (with validation), actions, empty state, error state, redirect on success, key UI elements.\n2. Components: reusable components. For each: name, type (layout/shared/form/display/navigation), purpose, props, and which pages use it.\n3. State management: describe the state strategy (e.g. React Server Components for data, client state for forms).\n4. Routing notes: any special routing behavior (redirects, guards, nested routes).\n\nReturn ONLY valid JSON:\n{\n  \"pages\": [{ \"path\": \"/login\", \"name\": \"Login\", \"access\": \"public\", \"purpose\": \"...\", \"formFields\": [{ \"name\": \"email\", \"type\": \"email\", \"required\": true, \"validation\": \"valid email format\" }], \"actions\": [\"Submit login form\"], \"emptyState\": \"\", \"errorState\": \"Show error message\", \"redirectOnSuccess\": \"/dashboard\", \"keyUiElements\": [\"Email input\", \"Password input\", \"Submit button\"] }],\n  \"components\": [{ \"name\": \"Navbar\", \"type\": \"navigation\", \"purpose\": \"...\", \"props\": [\"user\"], \"usedIn\": [\"/dashboard\", \"/profile\"] }],\n  \"stateManagement\": \"...\",\n  \"routingNotes\": \"...\"\n}";
+declare function buildDesignFrontendPrompt(requirement: string): string;
+
+/**
+ * validate_frontend tool - validates JSON against frontendDesignSchema (no AI)
+ */
+declare const validateFrontendTool: ai.Tool;
+
+/**
+ * Creates the design_frontend tool for frontend architecture generation.
+ */
+declare function createDesignFrontendTool(model: Model): ai.Tool;
+
+/**
+ * Create all frontend-architect tools. Pass the model for AI-backed tools.
+ */
+declare function createFrontendArchitectTools(model: Model): ToolSet;
+
+/**
+ * page-planner subagent - designs page structure, routes, and layouts
+ */
+declare const pagePlannerSubagent: SubagentDefinition;
+
+/**
+ * component-analyzer subagent - identifies reusable components and shared layouts
+ */
+declare const componentAnalyzerSubagent: SubagentDefinition;
+
+/**
+ * runFrontendArchitectAgent - routing orchestrator for frontend architecture design.
+ * Delegates to react-builder or nextjs-builder based on framework selection.
+ */
+
+/**
+ * Run the frontend-architect routing orchestrator with all tools and subagents.
+ */
+declare function runFrontendArchitectAgent(config: FrontendArchitectAgentConfig): Promise<AgentResult>;
+
+/**
+ * Zod schemas for ExecutionPlan
+ */
+
+declare const phaseStepSchema: z.ZodObject<{
+    order: z.ZodNumber;
+    action: z.ZodString;
+    details: z.ZodString;
+}, z.core.$strip>;
+declare const implementationPhaseSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        order: z.ZodNumber;
+        action: z.ZodString;
+        details: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const edgeCaseSchema: z.ZodObject<{
+    area: z.ZodString;
+    scenario: z.ZodString;
+    handling: z.ZodString;
+    severity: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        info: "info";
+        critical: "critical";
+        warning: "warning";
+    }>>;
+}, z.core.$strip>;
+declare const testChecklistItemSchema: z.ZodObject<{
+    flow: z.ZodString;
+    item: z.ZodString;
+    expectedResult: z.ZodString;
+}, z.core.$strip>;
+declare const executionPlanSchema: z.ZodObject<{
+    phases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        steps: z.ZodArray<z.ZodObject<{
+            order: z.ZodNumber;
+            action: z.ZodString;
+            details: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    currentState: z.ZodDefault<z.ZodString>;
+    desiredEndState: z.ZodDefault<z.ZodString>;
+    edgeCases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        area: z.ZodString;
+        scenario: z.ZodString;
+        handling: z.ZodString;
+        severity: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            info: "info";
+            critical: "critical";
+            warning: "warning";
+        }>>;
+    }, z.core.$strip>>>;
+    securityNotes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    performanceNotes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    testingChecklist: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        flow: z.ZodString;
+        item: z.ZodString;
+        expectedResult: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type TExecutionPlan = z.infer<typeof executionPlanSchema>;
+
+/**
+ * execution-planner module types
+ */
+
+interface PhaseStep {
+    order: number;
+    action: string;
+    details: string;
+}
+interface ImplementationPhase {
+    name: string;
+    description: string;
+    steps: PhaseStep[];
+}
+interface EdgeCase {
+    area: string;
+    scenario: string;
+    handling: string;
+    severity: 'critical' | 'warning' | 'info';
+}
+interface TestChecklistItem {
+    flow: string;
+    item: string;
+    expectedResult: string;
+}
+interface ExecutionPlan {
+    phases: ImplementationPhase[];
+    currentState: string;
+    desiredEndState: string;
+    edgeCases: EdgeCase[];
+    securityNotes: string[];
+    performanceNotes: string[];
+    testingChecklist: TestChecklistItem[];
+}
+interface ExecutionPlannerAgentConfig {
+    /** User input: all plan sections to create execution plan from */
+    input: string;
+    /** Model config; defaults to gpt-4o-mini */
+    model?: ModelConfig;
+    /** Max iterations; default 15 */
+    maxIterations?: number;
+    /** Callback for each step */
+    onStep?: (step: AgentStep) => void;
+    /** Optional logger */
+    logger?: Logger;
+}
+
+/**
+ * System prompt for execution-planner orchestrator
+ */
+declare const EXECUTION_PLANNER_SYSTEM_PROMPT = "You are a senior tech lead specializing in implementation strategy and project execution planning.\n\nYou create enterprise-quality execution plans with:\n- Phased implementation order with concrete, numbered steps per phase\n- Current state analysis and desired end state definition\n- Edge cases per domain area with handling strategies and severity levels\n- Security considerations (passwords, tokens, CORS, input validation)\n- Performance considerations (indexing, caching, lazy loading, N+1 prevention)\n- Manual testing checklists grouped by feature flow\n\nOutput only valid JSON unless instructed otherwise.";
+
+/**
+ * Design prompts for execution-planner
+ */
+declare const CREATE_EXECUTION_PLAN_PROMPT = "## Full Plan Context:\n{context}\n\nCreate a comprehensive execution plan. Include:\n\n1. **phases**: Implementation phases (Foundation, Auth, Core Features, etc.). Each phase has numbered steps with concrete actions (e.g. \"1. Install dependencies\", \"2. Create User model\").\n2. **currentState**: What the project starts with (e.g. \"vanilla Next.js, no DB, no auth\").\n3. **desiredEndState**: What must work when done (user capabilities + technical verification).\n4. **edgeCases**: Edge cases per area with scenario, handling strategy, and severity (critical/warning/info).\n5. **securityNotes**: Security considerations (password hashing, JWT config, rate limiting, etc.).\n6. **performanceNotes**: Performance considerations (indexing, caching, lazy loading, etc.).\n7. **testingChecklist**: Manual testing items per flow with expected results.\n\nReturn ONLY valid JSON:\n{\n  \"phases\": [{ \"name\": \"Phase 1: Foundation\", \"description\": \"...\", \"steps\": [{ \"order\": 1, \"action\": \"Install dependencies\", \"details\": \"npm install mongoose bcryptjs jsonwebtoken\" }] }],\n  \"currentState\": \"...\",\n  \"desiredEndState\": \"...\",\n  \"edgeCases\": [{ \"area\": \"Authentication\", \"scenario\": \"Email already exists\", \"handling\": \"Return 400 with clear message\", \"severity\": \"critical\" }],\n  \"securityNotes\": [\"...\"],\n  \"performanceNotes\": [\"...\"],\n  \"testingChecklist\": [{ \"flow\": \"Auth Flow\", \"item\": \"Sign up with valid credentials\", \"expectedResult\": \"Account created, redirected to dashboard\" }]\n}";
+declare function buildCreateExecutionPlanPrompt(context: string): string;
+
+/**
+ * validate_execution_plan tool - validates JSON against executionPlanSchema (no AI)
+ */
+declare const validateExecutionPlanTool: ai.Tool;
+
+/**
+ * Creates the create_execution_plan tool for generating phased plans.
+ */
+declare function createExecutionPlanTool(model: Model): ai.Tool;
+
+/**
+ * Create all execution-planner tools. Pass the model for AI-backed tools.
+ */
+declare function createExecutionPlannerTools(model: Model): ToolSet;
+
+/**
+ * edge-case-analyzer subagent - identifies edge cases per domain area
+ */
+declare const edgeCaseAnalyzerSubagent: SubagentDefinition;
+
+/**
+ * testing-strategist subagent - designs manual testing checklists
+ */
+declare const testingStrategistSubagent: SubagentDefinition;
+
+/**
+ * runExecutionPlannerAgent - orchestrator for execution plan design
+ */
+
+/**
+ * Run the execution-planner orchestrator agent with all tools and subagents.
+ */
+declare function runExecutionPlannerAgent(config: ExecutionPlannerAgentConfig): Promise<AgentResult>;
+
+/**
+ * Zod schemas for BackendDesign
+ */
+
+declare const middlewareSchema: z.ZodObject<{
+    name: z.ZodString;
+    purpose: z.ZodString;
+    appliesTo: z.ZodPipe<z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<"global" | "route" | "resource", string>>, z.ZodEnum<{
+        route: "route";
+        resource: "resource";
+        global: "global";
+    }>>;
+    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const serviceSchema: z.ZodObject<{
+    name: z.ZodString;
+    entity: z.ZodString;
+    operations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const routeGroupSchema: z.ZodObject<{
+    resource: z.ZodString;
+    basePath: z.ZodString;
+    endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        method: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+        }>>;
+        path: z.ZodString;
+        handler: z.ZodString;
+        auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const backendDesignSchema: z.ZodObject<{
+    framework: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        both: "both";
+        express: "express";
+        apollo: "apollo";
+    }>>;
+    language: z.ZodDefault<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        typescript: "typescript";
+        javascript: "javascript";
+    }>>>;
+    database: z.ZodDefault<z.ZodString>;
+    services: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        entity: z.ZodString;
+        operations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    middleware: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        purpose: z.ZodString;
+        appliesTo: z.ZodPipe<z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<"global" | "route" | "resource", string>>, z.ZodEnum<{
+            route: "route";
+            resource: "resource";
+            global: "global";
+        }>>;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    routes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        resource: z.ZodString;
+        basePath: z.ZodString;
+        endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            method: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+                DELETE: "DELETE";
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+            }>>;
+            path: z.ZodString;
+            handler: z.ZodString;
+            auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    folderStructure: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    envVars: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    notes: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type TBackendDesign = z.infer<typeof backendDesignSchema>;
+
+/**
+ * backend-architect module types
+ */
+
+interface BackendArchitectAgentConfig {
+    /** Project requirements, data model, and API design context */
+    input: string;
+    /** Model config; optional */
+    model?: ModelConfig;
+    /** Max iterations; default 15 */
+    maxIterations?: number;
+    /** Callback for each step */
+    onStep?: (step: AgentStep) => void;
+    /** Optional logger for execution logs */
+    logger?: Logger;
+}
+
+/**
+ * System prompt for backend-architect orchestrator
+ */
+declare const BACKEND_ARCHITECT_SYSTEM_PROMPT = "You are a senior backend architect specializing in Node.js server design.\n\nYou analyze data models, API designs, and auth requirements to produce enterprise-quality backend architectures with:\n- Framework selection (Express REST, Apollo GraphQL, or both)\n- Service layer design with clear operation contracts per entity\n- Middleware stack (auth, validation, error handling, CORS, rate limiting)\n- Route/resolver organization grouped by resource\n- Folder structure following domain-driven conventions\n- Environment variable inventory\n- Database connection and ORM/ODM strategy\n\nWhen \"both\" is selected (Express + Apollo), use the Apollo Gateway pattern:\n- Apollo Gateway as the single public entry point for GraphQL queries\n- Subgraphs as internal services composed via IntrospectAndCompose\n- RemoteGraphQLDataSource for header forwarding (auth tokens, service tokens)\n- Express for webhooks, file uploads, and health checks only\n- Gateway has no business logic, all logic lives in subgraphs\n\nOutput only valid JSON unless instructed otherwise.";
+
+/**
+ * Design prompt for backend architecture generation
+ */
+declare const DESIGN_BACKEND_PROMPT = "## Requirements:\n{requirement}\n\nDesign the backend architecture. Include:\n\n1. Framework: choose \"express\" (REST API), \"apollo\" (GraphQL subgraph), or \"both\" (Apollo subgraph + Express gateway).\n2. Services: one per entity with CRUD operations and dependencies.\n3. Middleware: auth (JWT/session), validation (Zod/Joi), error handling, CORS, rate limiting.\n4. Routes (if Express): RESTful routes grouped by resource with method, path, handler, auth, and roles.\n5. Folder structure: list of directories and key files.\n6. Env vars: list all required environment variables.\n\nReturn ONLY valid JSON:\n{\n  \"framework\": \"express\" | \"apollo\" | \"both\",\n  \"language\": \"typescript\",\n  \"database\": \"mongodb\",\n  \"services\": [{ \"name\": \"UserService\", \"entity\": \"User\", \"operations\": [\"create\", \"findById\", \"findAll\", \"update\", \"delete\"], \"dependencies\": [] }],\n  \"middleware\": [{ \"name\": \"authMiddleware\", \"purpose\": \"JWT token verification\", \"appliesTo\": \"global\", \"config\": {} }],\n  \"routes\": [{ \"resource\": \"users\", \"basePath\": \"/api/users\", \"endpoints\": [{ \"method\": \"GET\", \"path\": \"/\", \"handler\": \"getAll\", \"auth\": true, \"roles\": [\"admin\"] }] }],\n  \"folderStructure\": [\"src/\", \"src/routes/\", \"src/services/\", \"src/middleware/\", \"src/models/\", \"src/config/\"],\n  \"envVars\": [\"PORT\", \"DATABASE_URL\", \"JWT_SECRET\"],\n  \"notes\": \"\"\n}";
+declare function buildDesignBackendPrompt(requirement: string): string;
+
+/**
+ * validate_backend tool - validates JSON against backendDesignSchema (no AI)
+ */
+declare const validateBackendTool: ai.Tool;
+
+/**
+ * Creates the design_backend tool for backend architecture generation.
+ */
+declare function createDesignBackendTool(model: Model): ai.Tool;
+
+/**
+ * Create all backend-architect tools. Pass the model for AI-backed tools.
+ */
+declare function createBackendArchitectTools(model: Model): ToolSet;
+
+/**
+ * service-planner subagent - plans service layer, middleware stack, folder structure
+ */
+declare const servicePlannerSubagent: SubagentDefinition;
+
+/**
+ * framework-selector subagent - analyzes requirements and selects Express vs Apollo vs both
+ */
+declare const frameworkSelectorSubagent: SubagentDefinition;
+
+/**
+ * runBackendArchitectAgent - routing orchestrator for backend design
+ * Delegates to express-builder or apollo-builder based on framework selection.
+ */
+
+/**
+ * Run the backend-architect orchestrator agent.
+ */
+declare function runBackendArchitectAgent(config: BackendArchitectAgentConfig): Promise<AgentResult>;
+
+/**
+ * Zod schemas for Apollo subgraph configuration
+ */
+
+declare const graphqlFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    nullable: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    isList: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    description: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const graphqlTypeSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        input: "input";
+        type: "type";
+        enum: "enum";
+        union: "union";
+        interface: "interface";
+    }>>;
+    fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        nullable: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        isList: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        description: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    values: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    description: z.ZodDefault<z.ZodString>;
+    isEntity: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    keyFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const resolverOperationSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        query: "query";
+        mutation: "mutation";
+        subscription: "subscription";
+    }>>;
+    args: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        nullable: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        isList: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        description: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    returnType: z.ZodString;
+    auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    description: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const subgraphModuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    entity: z.ZodString;
+    types: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            input: "input";
+            type: "type";
+            enum: "enum";
+            union: "union";
+            interface: "interface";
+        }>>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            nullable: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            isList: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            description: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        values: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        description: z.ZodDefault<z.ZodString>;
+        isEntity: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        keyFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    operations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            query: "query";
+            mutation: "mutation";
+            subscription: "subscription";
+        }>>;
+        args: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            nullable: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            isList: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            description: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        returnType: z.ZodString;
+        auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        description: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    datasource: z.ZodDefault<z.ZodString>;
+    loader: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const subgraphConfigSchema: z.ZodObject<{
+    appName: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    database: z.ZodDefault<z.ZodString>;
+    modules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        entity: z.ZodString;
+        types: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+                input: "input";
+                type: "type";
+                enum: "enum";
+                union: "union";
+                interface: "interface";
+            }>>;
+            fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                nullable: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+                isList: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+                description: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>>;
+            values: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            description: z.ZodDefault<z.ZodString>;
+            isEntity: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            keyFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        operations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+                query: "query";
+                mutation: "mutation";
+                subscription: "subscription";
+            }>>;
+            args: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                nullable: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+                isList: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+                description: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>>;
+            returnType: z.ZodString;
+            auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            description: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        datasource: z.ZodDefault<z.ZodString>;
+        loader: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    sharedTypes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            input: "input";
+            type: "type";
+            enum: "enum";
+            union: "union";
+            interface: "interface";
+        }>>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            nullable: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            isList: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            description: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        values: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        description: z.ZodDefault<z.ZodString>;
+        isEntity: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        keyFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    authDirective: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    cacheDirective: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    envVars: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type TSubgraphConfig = z.infer<typeof subgraphConfigSchema>;
+
+/**
+ * apollo-builder module types
+ */
+
+interface ApolloBuilderAgentConfig {
+    /** Data model, API design, and project requirements */
+    input: string;
+    /** Model config; optional */
+    model?: ModelConfig;
+    /** Max iterations; default 15 */
+    maxIterations?: number;
+    /** Callback for each step */
+    onStep?: (step: AgentStep) => void;
+    /** Optional logger for execution logs */
+    logger?: Logger;
+}
+
+/**
+ * System prompt for apollo-builder orchestrator
+ */
+declare const APOLLO_BUILDER_SYSTEM_PROMPT = "You are an expert Apollo GraphQL subgraph architect using Apollo Federation v2.\n\nYou generate production-ready Apollo subgraph configurations from data models and API designs:\n- 4-file module pattern per entity: {module}.graphql, {module}.resolver.ts, {module}.datasource.ts, {module}.loader.ts\n- GraphQL type definitions with proper nullability, lists, and descriptions\n- Input types for mutations with validation annotations\n- Enum types from domain values\n- Federation directives: @key for entity references, @external for fields owned by other subgraphs, @requires for field dependencies, @provides for fields resolvable by this subgraph\n- __resolveReference for cross-subgraph entity resolution via buildSubgraphSchema\n- DataLoader per module for batching and caching database lookups (solves N+1)\n- Query and mutation resolvers with auth/role requirements\n- Datasource classes per entity (MongoDB datasource pattern)\n- Auth directive (@auth) configuration\n- Redis cache directives: @cacheSet on queries, @cachePurge on mutations\n- GraphQL CodeGen for TypeScript types (generates base-types.ts)\n- Module-based organization (one module per entity/domain)\n\nOutput only valid JSON unless instructed otherwise.";
+
+/**
+ * Design prompt for subgraph config generation
+ */
+declare const DESIGN_SUBGRAPH_PROMPT = "## Requirements:\n{requirement}\n\nGenerate an Apollo GraphQL subgraph configuration (Federation v2). Include:\n\n1. Modules: one per entity with 4 files each ({module}.graphql, {module}.resolver.ts, {module}.datasource.ts, {module}.loader.ts).\n2. Types: GraphQL object types with isEntity/keyFields for federation, input types, enums with fields/values.\n3. Operations: queries (getById, getAll, search) and mutations (create, update, delete) per module.\n4. Auth: mark which operations require authentication and which roles.\n5. DataLoader: one loader per module for batching lookups (loader name).\n6. Shared types: types used across modules (e.g. Pagination, SortOrder).\n7. Cache: set cacheDirective to true if Redis caching (@cacheSet/@cachePurge) is needed.\n8. Env vars: PORT, DATABASE_URL, JWT_SECRET, REDIS_URL, etc.\n\nReturn ONLY valid JSON:\n{\n  \"appName\": \"my-subgraph\",\n  \"port\": 4000,\n  \"database\": \"mongodb\",\n  \"modules\": [{\n    \"name\": \"user\",\n    \"entity\": \"User\",\n    \"types\": [{ \"name\": \"User\", \"kind\": \"type\", \"fields\": [{ \"name\": \"id\", \"type\": \"ID\", \"nullable\": false }], \"isEntity\": true, \"keyFields\": [\"id\"] }],\n    \"operations\": [{ \"name\": \"getUser\", \"type\": \"query\", \"args\": [{ \"name\": \"id\", \"type\": \"ID\", \"nullable\": false }], \"returnType\": \"User\", \"auth\": true, \"roles\": [] }],\n    \"datasource\": \"UserDataSource\",\n    \"loader\": \"UserLoader\"\n  }],\n  \"sharedTypes\": [],\n  \"authDirective\": true,\n  \"cacheDirective\": false,\n  \"envVars\": [\"PORT\", \"DATABASE_URL\", \"JWT_SECRET\", \"REDIS_URL\"]\n}";
+declare function buildDesignSubgraphPrompt(requirement: string): string;
+
+/**
+ * validate_subgraph tool - validates JSON against subgraphConfigSchema (no AI)
+ */
+declare const validateSubgraphTool: ai.Tool;
+
+/**
+ * Creates the generate_subgraph tool for Apollo subgraph config generation.
+ */
+declare function createGenerateSubgraphTool(model: Model): ai.Tool;
+
+/**
+ * scaffold_subgraph tool - compiles .ref/templates/subgraph/ with config
+ */
+declare const scaffoldSubgraphTool: ai.Tool;
+
+/**
+ * Create all apollo-builder tools. Pass the model for AI-backed tools.
+ */
+declare function createApolloBuilderTools(model: Model): ToolSet;
+
+/**
+ * schema-generator subagent - generates GraphQL type definitions from data model
+ */
+declare const schemaGeneratorSubagent: SubagentDefinition;
+
+/**
+ * resolver-planner subagent - plans resolver implementations per module
+ */
+declare const resolverPlannerSubagent: SubagentDefinition;
+
+/**
+ * runApolloBuilderAgent - orchestrator for Apollo GraphQL subgraph generation
+ */
+
+/**
+ * Run the apollo-builder orchestrator agent.
+ */
+declare function runApolloBuilderAgent(config: ApolloBuilderAgentConfig): Promise<AgentResult>;
+
+/**
+ * Zod schemas for Express app configuration
+ */
+
+declare const routerMethodSchema: z.ZodObject<{
+    name: z.ZodString;
+    httpMethod: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>>;
+    path: z.ZodString;
+    auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    validation: z.ZodDefault<z.ZodString>;
+    description: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const routerSchema: z.ZodObject<{
+    name: z.ZodString;
+    resource: z.ZodString;
+    basePath: z.ZodString;
+    methods: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        httpMethod: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+        }>>;
+        path: z.ZodString;
+        auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        validation: z.ZodDefault<z.ZodString>;
+        description: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const modelFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    required: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    unique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    ref: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const modelSchema: z.ZodObject<{
+    name: z.ZodString;
+    collection: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        unique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        ref: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    timestamps: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    indexes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const middlewareConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"validation" | "custom" | "auth" | "errorHandler" | "cors" | "rateLimit" | "logging", string>>, z.ZodEnum<{
+        validation: "validation";
+        custom: "custom";
+        auth: "auth";
+        errorHandler: "errorHandler";
+        cors: "cors";
+        rateLimit: "rateLimit";
+        logging: "logging";
+    }>>;
+    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const expressConfigSchema: z.ZodObject<{
+    appName: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    database: z.ZodDefault<z.ZodString>;
+    routers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        resource: z.ZodString;
+        basePath: z.ZodString;
+        methods: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            httpMethod: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+                DELETE: "DELETE";
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+            }>>;
+            path: z.ZodString;
+            auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            validation: z.ZodDefault<z.ZodString>;
+            description: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    models: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        collection: z.ZodString;
+        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            required: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            unique: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+            ref: z.ZodOptional<z.ZodString>;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        timestamps: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        indexes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    middleware: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"validation" | "custom" | "auth" | "errorHandler" | "cors" | "rateLimit" | "logging", string>>, z.ZodEnum<{
+            validation: "validation";
+            custom: "custom";
+            auth: "auth";
+            errorHandler: "errorHandler";
+            cors: "cors";
+            rateLimit: "rateLimit";
+            logging: "logging";
+        }>>;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    envVars: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type TExpressConfig = z.infer<typeof expressConfigSchema>;
+
+/**
+ * express-builder module types
+ */
+
+interface ExpressBuilderAgentConfig {
+    /** Data model, API design, and project requirements */
+    input: string;
+    /** Model config; optional */
+    model?: ModelConfig;
+    /** Max iterations; default 15 */
+    maxIterations?: number;
+    /** Callback for each step */
+    onStep?: (step: AgentStep) => void;
+    /** Optional logger for execution logs */
+    logger?: Logger;
+}
+
+/**
+ * System prompt for express-builder orchestrator
+ */
+declare const EXPRESS_BUILDER_SYSTEM_PROMPT = "You are an expert Express.js backend architect.\n\nYou generate production-ready Express application configurations from data models and API designs:\n- Co-located router pattern: each feature lives in src/routers/{name}/ with {name}.controller.ts, {name}.router.ts, and {name}.spec.ts\n- Mongoose/Prisma models with field types, validation, and relationships\n- Middleware stack (auth JWT, validation Zod, error handler, CORS, rate limiting)\n- Route organization with proper HTTP methods and paths\n- Health check endpoint at /health (included by default)\n- Jest tests per router using supertest\n- Environment variable inventory\n\nOutput only valid JSON unless instructed otherwise.";
+
+/**
+ * Design prompt for Express config generation
+ */
+declare const DESIGN_EXPRESS_PROMPT = "## Requirements:\n{requirement}\n\nGenerate an Express.js application configuration. Include:\n\n1. Routers: one per resource, co-located with controller and test spec. Each router has RESTful methods (GET, POST, PUT, DELETE).\n2. Health check: a default /health router is always included.\n3. Models: Mongoose models with fields, types, required, unique, refs, defaults, indexes.\n4. Middleware: auth (JWT), validation (Zod), error handler, CORS, rate limiting, logging.\n5. Env vars: PORT, DATABASE_URL, JWT_SECRET, NODE_ENV, etc.\n6. Folder structure: src/routers/{name}/ with {name}.controller.ts, {name}.router.ts, {name}.spec.ts per feature.\n\nReturn ONLY valid JSON:\n{\n  \"appName\": \"my-api\",\n  \"port\": 3000,\n  \"database\": \"mongodb\",\n  \"routers\": [{\n    \"name\": \"users\",\n    \"resource\": \"users\",\n    \"basePath\": \"/api/users\",\n    \"methods\": [{\n      \"name\": \"getAll\",\n      \"httpMethod\": \"GET\",\n      \"path\": \"/\",\n      \"auth\": true,\n      \"roles\": [\"admin\"],\n      \"validation\": \"\",\n      \"description\": \"Get all users with pagination\"\n    }]\n  }],\n  \"models\": [{\n    \"name\": \"User\",\n    \"collection\": \"users\",\n    \"fields\": [{ \"name\": \"email\", \"type\": \"String\", \"required\": true, \"unique\": true }],\n    \"timestamps\": true,\n    \"indexes\": [\"email\"]\n  }],\n  \"middleware\": [{ \"name\": \"authMiddleware\", \"type\": \"auth\", \"config\": {} }],\n  \"envVars\": [\"PORT\", \"DATABASE_URL\", \"JWT_SECRET\", \"NODE_ENV\"]\n}";
+declare function buildDesignExpressPrompt(requirement: string): string;
+
+/**
+ * validate_express tool - validates JSON against expressConfigSchema (no AI)
+ */
+declare const validateExpressTool: ai.Tool;
+
+/**
+ * Creates the generate_express tool for Express config generation.
+ */
+declare function createGenerateExpressTool(model: Model): ai.Tool;
+
+/**
+ * scaffold_express tool - compiles .ref/templates/express/ with config
+ */
+declare const scaffoldExpressTool: ai.Tool;
+
+/**
+ * Create all express-builder tools. Pass the model for AI-backed tools.
+ */
+declare function createExpressBuilderTools(model: Model): ToolSet;
+
+/**
+ * route-generator subagent - generates route files from API design
+ */
+declare const routeGeneratorSubagent: SubagentDefinition;
+
+/**
+ * middleware-configurator subagent - designs middleware stack
+ */
+declare const middlewareConfiguratorSubagent: SubagentDefinition;
+
+/**
+ * runExpressBuilderAgent - orchestrator for Express.js project generation
+ */
+
+/**
+ * Run the express-builder orchestrator agent.
+ */
+declare function runExpressBuilderAgent(config: ExpressBuilderAgentConfig): Promise<AgentResult>;
+
+/**
+ * Zod schemas for Next.js application configuration
+ */
+
+declare const nextjsPageSchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodString;
+    access: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        public: "public";
+        protected: "protected";
+    }>>;
+    routeGroup: z.ZodDefault<z.ZodString>;
+    purpose: z.ZodString;
+    hasForm: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    formFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dataFetching: z.ZodDefault<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        client: "client";
+        server: "server";
+        hybrid: "hybrid";
+    }>>>;
+    actions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const nextjsLayoutSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    routeGroup: z.ZodDefault<z.ZodString>;
+    components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    purpose: z.ZodString;
+}, z.core.$strip>;
+declare const nextjsApiRouteSchema: z.ZodObject<{
+    path: z.ZodString;
+    methods: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>>>>;
+    auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+    description: z.ZodString;
+}, z.core.$strip>;
+declare const serverActionSchema: z.ZodObject<{
+    name: z.ZodString;
+    module: z.ZodString;
+    description: z.ZodString;
+    revalidates: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const nextjsConfigSchema: z.ZodObject<{
+    appName: z.ZodDefault<z.ZodString>;
+    pages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        name: z.ZodString;
+        access: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            public: "public";
+            protected: "protected";
+        }>>;
+        routeGroup: z.ZodDefault<z.ZodString>;
+        purpose: z.ZodString;
+        hasForm: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        formFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        dataFetching: z.ZodDefault<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            client: "client";
+            server: "server";
+            hybrid: "hybrid";
+        }>>>;
+        actions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    layouts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        routeGroup: z.ZodDefault<z.ZodString>;
+        components: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        purpose: z.ZodString;
+    }, z.core.$strip>>>;
+    apiRoutes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        methods: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+        }>>>>;
+        auth: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+        description: z.ZodString;
+    }, z.core.$strip>>>;
+    serverActions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        module: z.ZodString;
+        description: z.ZodString;
+        revalidates: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    middleware: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    envVars: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    packages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type TNextjsConfig = z.infer<typeof nextjsConfigSchema>;
+
+/**
+ * nextjs-builder module types
+ */
+
+interface NextjsBuilderAgentConfig {
+    /** Frontend design, API design, and project requirements */
+    input: string;
+    /** Model config; optional */
+    model?: ModelConfig;
+    /** Max iterations; default 15 */
+    maxIterations?: number;
+    /** Callback for each step */
+    onStep?: (step: AgentStep) => void;
+    /** Optional logger for execution logs */
+    logger?: Logger;
+}
+
+/**
+ * System prompt for nextjs-builder orchestrator
+ */
+declare const NEXTJS_BUILDER_SYSTEM_PROMPT = "You are an expert Next.js application architect using the App Router.\n\nYou generate production-ready Next.js configurations from frontend designs and API designs:\n- App Router file structure with route groups, layouts, pages, loading, and error boundaries\n- Server Components by default, Client Components only when interactivity is needed\n- Server Actions for mutations (form submissions, data writes)\n- API Route Handlers for external integrations, webhooks, and file uploads\n- Next.js middleware for auth guards and redirects\n- Data fetching strategy (server vs client vs hybrid per page)\n- Package recommendations (next-auth, prisma, tailwindcss, shadcn/ui)\n\nOutput only valid JSON unless instructed otherwise.";
+
+/**
+ * Design prompt for Next.js config generation
+ */
+declare const DESIGN_NEXTJS_PROMPT = "## Requirements:\n{requirement}\n\nGenerate a Next.js App Router application configuration. Include:\n\n1. Pages: app router pages with path, name, access level, route group, purpose, data fetching strategy.\n2. Layouts: shared layouts with route groups (e.g. (auth), (dashboard)), components they include.\n3. API Routes: route handlers with path, HTTP methods, auth requirement, description.\n4. Server Actions: named actions with module, description, and paths they revalidate.\n5. Middleware: list of middleware behaviors (e.g. \"redirect unauthenticated to /login\").\n6. Env vars: NEXTAUTH_SECRET, DATABASE_URL, etc.\n7. Packages: recommended npm packages.\n\nReturn ONLY valid JSON:\n{\n  \"appName\": \"my-app\",\n  \"pages\": [{\n    \"path\": \"/dashboard\",\n    \"name\": \"Dashboard\",\n    \"access\": \"protected\",\n    \"routeGroup\": \"(dashboard)\",\n    \"purpose\": \"Main dashboard with stats\",\n    \"hasForm\": false,\n    \"formFields\": [],\n    \"dataFetching\": \"server\",\n    \"actions\": []\n  }],\n  \"layouts\": [{\n    \"name\": \"DashboardLayout\",\n    \"path\": \"app/(dashboard)/layout.tsx\",\n    \"routeGroup\": \"(dashboard)\",\n    \"components\": [\"Sidebar\", \"Header\"],\n    \"purpose\": \"Shared layout for authenticated pages\"\n  }],\n  \"apiRoutes\": [{\n    \"path\": \"/api/users\",\n    \"methods\": [\"GET\", \"POST\"],\n    \"auth\": true,\n    \"description\": \"User CRUD endpoints\"\n  }],\n  \"serverActions\": [{\n    \"name\": \"createUser\",\n    \"module\": \"users\",\n    \"description\": \"Create a new user\",\n    \"revalidates\": [\"/dashboard/users\"]\n  }],\n  \"middleware\": [\"Redirect unauthenticated users to /login\"],\n  \"envVars\": [\"DATABASE_URL\", \"NEXTAUTH_SECRET\"],\n  \"packages\": [\"next-auth\", \"prisma\", \"@prisma/client\", \"tailwindcss\"]\n}";
+declare function buildDesignNextjsPrompt(requirement: string): string;
+
+/**
+ * validate_nextjs tool - validates JSON against nextjsConfigSchema (no AI)
+ */
+declare const validateNextjsTool: ai.Tool;
+
+/**
+ * Creates the generate_nextjs tool for Next.js config generation.
+ */
+declare function createGenerateNextjsTool(model: Model): ai.Tool;
+
+/**
+ * Create all nextjs-builder tools. Pass the model for AI-backed tools.
+ */
+declare function createNextjsBuilderTools(model: Model): ToolSet;
+
+/**
+ * route-planner subagent - plans Next.js App Router file structure
+ */
+declare const routePlannerSubagent: SubagentDefinition;
+
+/**
+ * api-route-generator subagent - generates Next.js API routes and server actions
+ */
+declare const apiRouteGeneratorSubagent: SubagentDefinition;
+
+/**
+ * runNextjsBuilderAgent - orchestrator for Next.js project generation
+ */
+
+/**
+ * Run the nextjs-builder orchestrator agent.
+ */
+declare function runNextjsBuilderAgent(config: NextjsBuilderAgentConfig): Promise<AgentResult>;
+
+export { API_DESIGNER_SYSTEM_PROMPT, APOLLO_BUILDER_SYSTEM_PROMPT, AUTH_DESIGNER_SYSTEM_PROMPT, type Actor$1 as Actor, type ActorResult, type ApiDesign as AdApiDesign, type GraphqlOperation as AdGraphqlOperation, type RestEndpoint as AdRestEndpoint, type AgentConfig, AgentError, type AgentObserver, type AgentResult, type AgentStep, type AgentTool, type AgentToolResult, type ApiDesign$2 as ApiDesign, type ApiDesignerAgentConfig, ApiResponseTypeSchema, type ApiStyle, type ApolloBuilderAgentConfig, AppConfigSchema, type AppInfo, ApplicationSchema, type AuthDesign, type AuthDesignerAgentConfig, type AuthFlow, type AuthFlowStep, type AuthMiddleware, AuthPageApiSchema, AuthPageSchema, type AuthStrategy, BACKEND_ARCHITECT_SYSTEM_PROMPT, type BackendArchitectAgentConfig, BaseMcpClient, type BasicProjectInfo, BrandingSchema, CREATE_EXECUTION_PLAN_PROMPT, type ChatEntry$2 as ChatEntry, type ChatTurnResult, ColumnSchema, type ComponentDesign, type CreateSubagentToolOptions, CreateUserInputSchema, type CrudApi, DATA_MODELER_SYSTEM_PROMPT, DB_DESIGN_SYSTEM_PROMPT, DESIGN_APIS_SYSTEM_PROMPT, DESIGN_AUTH_PROMPT, DESIGN_BACKEND_PROMPT, DESIGN_DATABASE_SYSTEM_PROMPT, DESIGN_EXPRESS_PROMPT, DESIGN_FRONTEND_PROMPT, DESIGN_NEXTJS_PROMPT, DESIGN_SUBGRAPH_PROMPT, DISCOVERY_SYSTEM_FRAGMENT, DISCOVERY_USER_PROMPT, type DataEntity, type DataModelDesign, type DataModelerAgentConfig, type DatabaseDesign$1 as DatabaseDesign, type DatabaseEntity$1 as DatabaseEntity, type DatabaseType, type DbDesignerAgentConfig, type EntityField as DmEntityField, type EntityIndex as DmEntityIndex, type EntityRelation as DmEntityRelation, DrawerSchema, EXAMPLE_GRAPHQL_SCHEMA, EXAMPLE_JSON_OUTPUT, EXECUTION_PLANNER_SYSTEM_PROMPT, EXPRESS_BUILDER_SYSTEM_PROMPT, EXTRACT_ACTORS_PROMPT, EXTRACT_MODULES_PROMPT, type EdgeCase, type EditPlanConfig, type EntityField$2 as EntityField, type EntityIndex$2 as EntityIndex, type EntityRelation$2 as EntityRelation, type ExecutionPlan, type ExecutionPlannerAgentConfig, type ExpressBuilderAgentConfig, type ExtractedFlow, type ExtractedModule, type ExtractedStory, FRONTEND_ARCHITECT_SYSTEM_PROMPT, type FeatureBreakdownResult, FieldOptionsSchema, type FinalRequirement, type FlowsResult, ForgotPasswordSchema, type FormField, FormFieldSchema, type FrontendArchitectAgentConfig, type FrontendDesign, GENERATE_FLOWS_PROMPT, GENERATE_STORIES_PROMPT, type GraphqlApiDesign$1 as GraphqlApiDesign, type GraphqlOperation$2 as GraphqlOperation, type GraphqlTypeDefinition$1 as GraphqlTypeDefinition, type HelloWorldAgentConfig, type HttpMethod, type ImageInput, type ImplementationPhase, type InvokeObjectOptions, type InvokeObjectResult, type InvokeOptions, LibraryError, ListingPageApiSchema, ListingPageSchema, type LogLevel, type Logger, type LoggerConfig, LoginInputSchema, type McpClientConfig, type McpClientInfo, type McpResolveOptions, type McpToolContent, type McpTransport, type Model, type ModelConfig, ModelError, type ModelProvider, type ModelResponse, type ModelTool, type ModelToolCall, type Module, ModuleSchema, type ModulesResult, NEXTJS_BUILDER_SYSTEM_PROMPT, type NextjsBuilderAgentConfig, PLANNING_SYSTEM_PROMPT, type PageAccess, type PageDesign, PageSchema, type PhaseStep, type PlanChatTurnResult, type PlanSections, type PlanStageResult, type PlanningAgentConfig, type PlanningChatConfig, type ChatEntry as PlanningChatEntry, type PlanningContext, PlanningContextBuilder, type Stage as PlanningStage, type ProjectBrief, type Question$1 as Question, REACT_BUILDER_INSTRUCTION, REACT_BUILDER_SYSTEM_PROMPT, REQUIREMENT_GATHERER_SYSTEM_PROMPT, type ReactBuilderAgentConfig, type RequirementChatConfig, type RequirementContext, RequirementContextBuilder, type RequirementGathererAgentConfig, type RequirementSummary$1 as RequirementSummary, ResetPasswordSchema, type RestApiDesign$1 as RestApiDesign, type RestEndpoint$2 as RestEndpoint, type RoleDefinition, type RunSubagentOptions, SYNTHESIS_SYSTEM_FRAGMENT, SYNTHESIS_USER_PROMPT, type ScaffoldConfig, type ScaffoldError, type ScaffoldResult, type SecurityPolicy, SpecializationSchema, type Stage$1 as Stage, type StageInput, type StoriesResult, type StructuredRequirementsInput, type SubagentConfig, type SubagentDefinition, SubagentError, type SubagentResult, type TApiDesign, type TApiResponseTypeSchema, type TAppConfigSchema, type TApplicationSchema, type TAuthDesign, type TBackendDesign, type TBackendProjectSchema, type TBrandingSchema, type TColumnSchema, type TCreateUserInputSchema, type TDataModelDesign, type TExecutionPlan, type TExpressConfig, type TFieldSchema, type TForgotPasswordSchema, type TFormFieldSchema, type TFrontendDesign, type TLoginInputSchema, type TModuleSchema$1 as TModuleSchema, type TNextjsConfig, type TPageSchema, type TModuleSchema as TReactModuleSchema, type TResetPasswordSchema, type TSpecializationSchema, type TSubgraphConfig, type TUpdateUserInputSchema, type TUserSchema, type TechnicalRequirements, type TemplateAuth, type TemplateBranding, type TemplateContext, type TemplateField, type TemplateModule, type TemplateOperation, type TestChecklistItem, type ToolConfig, type ToolContext, ToolError, type ToolExecutionResult, type ToolLogger, type ToolSet, UpdateUserInputSchema, UserSchema, ValidationError, ValidationSchema, type VisionOptions, actorSchema, actorsResultSchema, apiDesignSchema as adApiDesignSchema, graphqlOperationSchema as adGraphqlOperationSchema, restEndpointSchema as adRestEndpointSchema, addChatEntry, advanceStage, apiDesignSchema$1 as apiDesignSchema, apiRouteGeneratorSubagent, assemblePlan, authDesignSchema, authFlowSchema, authFlowStepSchema, authMiddlewareSchema, backendDesignSchema, buildCreateExecutionPlanPrompt, buildDesignApisPrompt, buildDesignAuthPrompt, buildDesignBackendPrompt, buildDesignDatabasePrompt, buildDesignExpressPrompt, buildDesignFrontendPrompt, buildDesignNextjsPrompt, buildDesignSubgraphPrompt, buildDiscoveryPrompt, buildExampleShotPrompt, buildExtractActorsPrompt, buildExtractModulesPrompt, buildFeedbackPrompt, buildGenerateFlowsPrompt, buildGenerateStoriesPrompt, buildInstructionPrompt, buildPromptVariables, buildSynthesisPrompt, chatEntrySchema, compileTemplate, componentAnalyzerSubagent, componentDesignSchema, contractDesignerSubagent, createAnthropicModel, createApiDesignerTools, createApolloBuilderTools, createAuthDesignerTools, createBackendArchitectTools, createConfigValidatorSubagent, createDataModelerTools, createDbDesignPrompt, createDbDesignerTools, createDesignApiProTool, createDesignApiTool, createDesignAuthTool, createDesignBackendTool, createDesignDatabaseProTool, createDesignDatabaseTool, createDesignFrontendTool, createDesignSchemaProTool, createDesignSchemaTool, createExecutionPlanTool, createExecutionPlannerTools, createExpressBuilderTools, createFrontendArchitectTools, createGenerateExpressTool, createGenerateFeatureBreakdownTool, createGenerateFrontendTool, createGenerateNextjsTool, createGenerateSubgraphTool, createGoogleModel, createInitialContext, createLogger, createModel, createNextjsBuilderTools, createOpenAIModel, createPlanningContextBuilder, createProDbDesignPrompt, createReactBuilderTools, createRedesignDatabaseTool, createRedesignPrompt, createRefineSchemaTools, createRequirementContextBuilder, createSchemaRefinerSubagent$1 as createSchemaRefinerSubagent, createSubagentTool, createSubagentToolSet, createToolSet, crudApiSchema, databaseDesignSchema, databaseEntitySchema, defineSubagent, defineTool, createSchemaRefinerSubagent as dmCreateSchemaRefinerSubagent, dataEntitySchema as dmDataEntitySchema, dataModelDesignSchema as dmDataModelDesignSchema, entityAnalyzerSubagent as dmEntityAnalyzerSubagent, validateSchemaTool as dmValidateSchemaTool, edgeCaseAnalyzerSubagent, edgeCaseSchema, editPlan, endpointAnalyzerSubagent, entityAnalyzerSubagent$1 as entityAnalyzerSubagent, entityFieldSchema, entityIndexSchema, entityRelationSchema, executeTool, executeToolByName, executionPlanSchema, expressConfigSchema, extractDataEntities, extractJson, extractRoles, extractedModuleSchema, fieldSchema, finalRequirementSchema, flowDesignerSubagent, flowSchema, flowsResultSchema, formFieldSchema, formatTechnicalRequirements, formatUserFlows, formatUserStories, formatUserTypes, frameworkSelectorSubagent, frontendDesignSchema, getTool, getTools, graphqlAnalyzerSubagent, graphqlApiDesignSchema, graphqlFieldSchema, graphqlOperationSchema$1 as graphqlOperationSchema, graphqlTypeDefinitionSchema, graphqlTypeSchema, helloWorldTool, implementationPhaseSchema, loggerConfigFromEnv, mergeStageResult, middlewareConfigSchema, middlewareConfiguratorSubagent, middlewareSchema, modelFieldSchema, modelSchema, moduleSchema, modulesResultSchema, nextjsApiRouteSchema, nextjsConfigSchema, nextjsLayoutSchema, nextjsPageSchema, pageDesignSchema, pagePlannerSubagent, parseModelJsonResponse, phaseStepSchema, processPlanningChat, processRequirementChat, projectBriefSchema, projectSchema, questionSchema, registerHelpers, relationshipMapperSubagent, requirementContextSchema, requirementSummarySchema, resolverOperationSchema, resolverPlannerSubagent, restApiDesignSchema, restEndpointSchema$1 as restEndpointSchema, roleDefinitionSchema, routeGeneratorSubagent, routeGroupSchema, routePlannerSubagent, routerMethodSchema, routerSchema, runAgent, runApiDesignerAgent, runApolloBuilderAgent, runAuthDesignerAgent, runBackendArchitectAgent, runDataModelerAgent, runDbDesignerAgent, runExecutionPlannerAgent, runExpressBuilderAgent, runFrontendArchitectAgent, runHelloWorldAgent, runNextjsBuilderAgent, runPlanningAgent, runReactBuilderAgent, runRequirementGathererAgent, runSubagent, safeJsonParse, scaffoldExpressTool, scaffoldProject, scaffoldSubgraphTool, schemaGeneratorSubagent, securityAnalyzerSubagent, securityPolicySchema, serverActionSchema, servicePlannerSubagent, serviceSchema, storiesResultSchema, storySchema, subgraphConfigSchema, subgraphModuleSchema, sumTokenUsage, testChecklistItemSchema, testingStrategistSubagent, validateApiTool, validateAuthTool, validateBackendTool, validateExecutionPlanTool, validateExpressTool, validateFrontendConfigTool, validateFrontendTool, validateNextjsTool, validateSchemaTool$1 as validateSchemaTool, validateSubgraphTool, writePlanToFile };