tryassay 0.13.0 → 0.14.0

package/dist/runtime/app-create-orchestrator.js

@@ -0,0 +1,722 @@
+// ============================================================
+// Assay Verified App Creator — Meta-Orchestrator
+// Two-phase flow: PlannerAgent designs architecture,
+// then MultiAgentLoop builds each feature with verification.
+// ============================================================
+import { EventEmitter } from 'node:events';
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { PlannerAgent } from './agents/planner-agent.js';
+import { CodeAgent } from './agents/code-agent.js';
+import { MessageBus } from './message-bus.js';
+import { CompositionVerifier } from './composition-verifier.js';
+import { MultiAgentLoop } from './multi-agent-loop.js';
+// ── Default safety policy ───────────────────────────────────
+const DEFAULT_SAFETY = {
+    formalOverridesConsensus: true,
+    noSelfVerification: true,
+    criticalClaimsRequireFormal: true,
+    escalationRules: {
+        maxFormalOverridesBeforeHalt: 3,
+        maxTrustDemotions: 2,
+        maxRejectCyclesPerTask: 3,
+    },
+    preferModelDiversity: false,
+};
+// ── App Create Orchestrator ─────────────────────────────────
+export class AppCreateOrchestrator extends EventEmitter {
+    description;
+    options;
+    auditTrail = [];
+    startTime = 0;
+    constructor(description, options) {
+        super();
+        this.description = description;
+        this.options = options;
+    }
+    /** Run the full app creation pipeline. */
+    async run() {
+        this.startTime = Date.now();
+        const projectPath = join(this.options.outputPath, this.slugify(this.description.name));
+        // Phase: initializing
+        this.emitPhase({ phase: 'initializing' });
+        await mkdir(projectPath, { recursive: true });
+        await mkdir(join(projectPath, '.assay'), { recursive: true });
+        this.audit('task_status_change', { phase: 'initializing', projectPath });
+        // Phase: planning
+        this.emitPhase({ phase: 'planning' });
+        const plan = await this.runPlanningPhase(projectPath);
+        if (!plan) {
+            this.emitPhase({ phase: 'failed', reason: 'Planning failed after retries' });
+            return this.makeResult('failed', projectPath, null, [], null);
+        }
+        // Phase: verifying_plan
+        this.emitPhase({ phase: 'verifying_plan' });
+        const planValid = this.verifyPlanStructure(plan);
+        if (!planValid) {
+            this.emitPhase({ phase: 'failed', reason: 'Plan verification failed — invalid structure' });
+            return this.makeResult('failed', projectPath, plan, [], null);
+        }
+        this.audit('verification_completed', {
+            phase: 'verifying_plan',
+            features: plan.features.length,
+            schema: plan.schema.length,
+            apiRoutes: plan.apiRoutes.length,
+        });
+        // Write plan to disk
+        await writeFile(join(projectPath, '.assay', 'architecture-plan.json'), JSON.stringify(plan, null, 2), 'utf-8');
+        // Phase: scaffolding
+        this.emitPhase({ phase: 'scaffolding' });
+        const scaffoldResult = await this.runScaffoldingPhase(projectPath, plan);
+        if (scaffoldResult.status !== 'completed') {
+            this.audit('task_status_change', { phase: 'scaffolding', status: 'failed' });
+            // Continue — scaffolding failure is not necessarily fatal
+        }
+        // Phase: building features
+        const featureResults = [];
+        const completedFeatures = [];
+        const failedFeatures = [];
+        if (this.options.sequential) {
+            // Sequential mode (legacy): build features one at a time in dependency order
+            for (let i = 0; i < plan.dependencyOrder.length; i++) {
+                const featureId = plan.dependencyOrder[i];
+                const feature = plan.features.find(f => f.id === featureId);
+                if (!feature) {
+                    featureResults.push({ featureId, featureName: featureId, status: 'skipped', filesCreated: [], verificationSummary: { totalClaims: 0, passed: 0, failed: 0 }, durationMs: 0, error: 'Feature not found in plan' });
+                    failedFeatures.push(featureId);
+                    continue;
+                }
+                const depsFailed = feature.dependsOn.some(dep => failedFeatures.includes(dep));
+                if (depsFailed) {
+                    featureResults.push({ featureId, featureName: feature.name, status: 'skipped', filesCreated: [], verificationSummary: { totalClaims: 0, passed: 0, failed: 0 }, durationMs: 0, error: 'Dependency failed' });
+                    failedFeatures.push(featureId);
+                    continue;
+                }
+                this.emitPhase({ phase: 'building_feature', featureId, featureIndex: i, totalFeatures: plan.dependencyOrder.length });
+                const featureStart = Date.now();
+                const result = await this.buildFeature(projectPath, plan, feature, completedFeatures);
+                const buildResult = { featureId, featureName: feature.name, status: result.status === 'completed' ? 'completed' : 'failed', filesCreated: result.filesCreated, verificationSummary: result.verificationSummary, durationMs: Date.now() - featureStart, error: result.error };
+                featureResults.push(buildResult);
+                if (buildResult.status === 'completed') {
+                    completedFeatures.push(featureId);
+                }
+                else {
+                    failedFeatures.push(featureId);
+                }
+                this.audit('task_status_change', { phase: 'building_feature', featureId, status: buildResult.status, claims: buildResult.verificationSummary });
+            }
+        }
+        else {
+            // Wave mode (default): build independent features in parallel
+            const waves = this.computeWaves(plan);
+            for (let waveIdx = 0; waveIdx < waves.length; waveIdx++) {
+                const wave = waves[waveIdx];
+                // Filter out features whose deps failed
+                const buildable = wave.filter(featureId => {
+                    const feature = plan.features.find(f => f.id === featureId);
+                    if (!feature) {
+                        featureResults.push({ featureId, featureName: featureId, status: 'skipped', filesCreated: [], verificationSummary: { totalClaims: 0, passed: 0, failed: 0 }, durationMs: 0, error: 'Feature not found in plan' });
+                        failedFeatures.push(featureId);
+                        return false;
+                    }
+                    const depsFailed = feature.dependsOn.some(dep => failedFeatures.includes(dep));
+                    if (depsFailed) {
+                        featureResults.push({ featureId, featureName: feature.name, status: 'skipped', filesCreated: [], verificationSummary: { totalClaims: 0, passed: 0, failed: 0 }, durationMs: 0, error: 'Dependency failed' });
+                        failedFeatures.push(featureId);
+                        return false;
+                    }
+                    return true;
+                });
+                if (buildable.length === 0)
+                    continue;
+                this.emitPhase({ phase: 'building_wave', waveIndex: waveIdx, totalWaves: waves.length, featureIds: buildable });
+                // Build all features in this wave concurrently
+                const wavePromises = buildable.map(async (featureId) => {
+                    const feature = plan.features.find(f => f.id === featureId);
+                    this.emitPhase({ phase: 'building_feature', featureId, featureIndex: plan.dependencyOrder.indexOf(featureId), totalFeatures: plan.dependencyOrder.length });
+                    const featureStart = Date.now();
+                    // Choose direct mode vs full multi-agent loop
+                    const result = this.shouldUseDirect(feature)
+                        ? await this.buildFeatureDirect(projectPath, plan, feature, completedFeatures)
+                        : await this.buildFeature(projectPath, plan, feature, completedFeatures);
+                    const buildResult = { featureId, featureName: feature.name, status: result.status === 'completed' ? 'completed' : 'failed', filesCreated: result.filesCreated, verificationSummary: result.verificationSummary, durationMs: Date.now() - featureStart, error: result.error };
+                    this.audit('task_status_change', { phase: 'building_feature', featureId, status: buildResult.status, claims: buildResult.verificationSummary, wave: waveIdx, mode: this.shouldUseDirect(feature) ? 'direct' : 'multi-agent' });
+                    return buildResult;
+                });
+                const waveResults = await Promise.allSettled(wavePromises);
+                for (const settled of waveResults) {
+                    if (settled.status === 'fulfilled') {
+                        featureResults.push(settled.value);
+                        if (settled.value.status === 'completed') {
+                            completedFeatures.push(settled.value.featureId);
+                        }
+                        else {
+                            failedFeatures.push(settled.value.featureId);
+                        }
+                    }
+                    else {
+                        // Promise rejected — shouldn't happen but handle gracefully
+                        const featureId = buildable[waveResults.indexOf(settled)];
+                        featureResults.push({ featureId, featureName: featureId, status: 'failed', filesCreated: [], verificationSummary: { totalClaims: 0, passed: 0, failed: 0 }, durationMs: 0, error: `Build threw: ${settled.reason}` });
+                        failedFeatures.push(featureId);
+                    }
+                }
+            }
+        }
+        // Phase: cross-verifying
+        this.emitPhase({ phase: 'cross_verifying' });
+        const crossVerification = await this.runCrossVerification(projectPath, plan);
+        this.audit('verification_completed', {
+            phase: 'cross_verifying',
+            passed: crossVerification.passedCount,
+            failed: crossVerification.failedCount,
+        });
+        // Phase: finalizing
+        this.emitPhase({ phase: 'finalizing' });
+        const allCompleted = featureResults.every(r => r.status === 'completed');
+        const anyCompleted = featureResults.some(r => r.status === 'completed');
+        const finalStatus = allCompleted ? 'completed' : anyCompleted ? 'partial' : 'failed';
+        this.emitPhase({ phase: 'completed' });
+        return this.makeResult(finalStatus, projectPath, plan, featureResults, crossVerification);
+    }
+    // ── Planning Phase ─────────────────────────────────────────
+    async runPlanningPhase(projectPath) {
+        const messageBus = new MessageBus();
+        const planner = new PlannerAgent(messageBus, { model: this.options.models?.planner });
+        const maxRetries = this.options.maxRetries ?? 3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            const result = await planner.executeTask({
+                taskId: `plan-${randomUUID().slice(0, 8)}`,
+                goal: `Design architecture for: ${this.description.description}`,
+                constraints: [
+                    `App name: ${this.description.name}`,
+                    `Framework: ${this.description.techStack.framework}`,
+                    `Database: ${this.description.techStack.database}`,
+                    `Language: ${this.description.techStack.language}`,
+                    `Features: ${this.description.features.join(', ')}`,
+                    ...(this.description.authModel
+                        ? [`Auth: ${this.description.authModel.methods.join(', ')} via ${this.description.authModel.provider}`]
+                        : []),
+                    ...(this.description.constraints ?? []),
+                ],
+                dependencies: [],
+                contextRefs: [],
+            });
+            if (result.status === 'completed' && result.artifacts.length > 0) {
+                try {
+                    const plan = JSON.parse(result.artifacts[0].content);
+                    if (plan.features && plan.features.length > 0) {
+                        return plan;
+                    }
+                }
+                catch {
+                    // Parse failed, retry
+                }
+            }
+            this.audit('task_status_change', {
+                phase: 'planning',
+                attempt,
+                status: 'retry',
+                reason: result.summary,
+            });
+        }
+        return null;
+    }
+    // ── Plan Verification ──────────────────────────────────────
+    verifyPlanStructure(plan) {
+        // Check dependency order is acyclic
+        if (!this.isAcyclic(plan.features, plan.dependencyOrder)) {
+            this.audit('verification_completed', { check: 'acyclic', verdict: 'FAIL' });
+            return false;
+        }
+        // Check all features in dependencyOrder exist
+        for (const id of plan.dependencyOrder) {
+            if (!plan.features.find(f => f.id === id)) {
+                this.audit('verification_completed', { check: 'feature_exists', featureId: id, verdict: 'FAIL' });
+                return false;
+            }
+        }
+        // Check all features are in dependencyOrder
+        for (const feature of plan.features) {
+            if (!plan.dependencyOrder.includes(feature.id)) {
+                this.audit('verification_completed', { check: 'feature_in_order', featureId: feature.id, verdict: 'FAIL' });
+                return false;
+            }
+        }
+        return true;
+    }
+    isAcyclic(features, order) {
+        const visited = new Set();
+        const inStack = new Set();
+        const depMap = new Map();
+        for (const f of features) {
+            depMap.set(f.id, f.dependsOn);
+        }
+        const visit = (id) => {
+            if (inStack.has(id))
+                return false; // cycle
+            if (visited.has(id))
+                return true;
+            inStack.add(id);
+            for (const dep of depMap.get(id) ?? []) {
+                if (!visit(dep))
+                    return false;
+            }
+            inStack.delete(id);
+            visited.add(id);
+            return true;
+        };
+        for (const id of order) {
+            if (!visit(id))
+                return false;
+        }
+        return true;
+    }
+    // ── Scaffolding Phase ──────────────────────────────────────
+    async runScaffoldingPhase(projectPath, plan) {
+        const schemaDesc = plan.schema
+            .map(e => `${e.name}: ${e.fields.map(f => `${f.name}:${f.type}`).join(', ')}`)
+            .join('\n');
+        const authDesc = plan.authPlan
+            ? `Auth: ${plan.authPlan.provider} with ${plan.authPlan.methods.join(', ')}`
+            : 'No auth';
+        const scaffoldGoal = `Scaffold base project: package.json, tsconfig.json, directory structure, database schema, and auth setup.
+
+Framework: ${this.description.techStack.framework}
+Database: ${this.description.techStack.database}
+Language: ${this.description.techStack.language}
+
+Schema:
+${schemaDesc}
+
+${authDesc}
+
+Create the project foundation files. Do NOT implement features — only the base project structure and schema.`;
+        // Direct mode: single CodeAgent call for scaffolding (bypasses full team)
+        const messageBus = new MessageBus();
+        const codeAgent = new CodeAgent(messageBus, { model: this.options.models?.code });
+        try {
+            const result = await codeAgent.executeTask({
+                taskId: `scaffold-${randomUUID().slice(0, 8)}`,
+                goal: scaffoldGoal,
+                constraints: [],
+                dependencies: [],
+                contextRefs: [],
+            });
+            if (result.status === 'failed') {
+                this.audit('task_status_change', { phase: 'scaffolding', status: 'failed', reason: result.summary });
+                return { status: 'failed' };
+            }
+            // Write artifacts to disk
+            for (const artifact of result.artifacts) {
+                if (!artifact.path)
+                    continue;
+                const absPath = join(projectPath, artifact.path);
+                try {
+                    await mkdir(dirname(absPath), { recursive: true });
+                    await writeFile(absPath, artifact.content, 'utf-8');
+                }
+                catch {
+                    // Best-effort write
+                }
+            }
+            this.audit('task_status_change', {
+                phase: 'scaffolding',
+                status: 'completed',
+                filesCreated: result.artifacts.filter(a => a.path).map(a => a.path),
+            });
+            return { status: 'completed' };
+        }
+        catch (err) {
+            this.audit('task_status_change', { phase: 'scaffolding', status: 'failed', error: err instanceof Error ? err.message : String(err) });
+            return { status: 'failed' };
+        }
+    }
+    // ── Feature Build Phase ────────────────────────────────────
+    async buildFeature(projectPath, plan, feature, completedFeatures) {
+        const goal = this.buildFeatureGoal(plan, feature, completedFeatures);
+        const tier = this.getVerificationTier(feature);
+        const agents = ['coordinator', 'code', 'review', 'test'];
+        const loop = new MultiAgentLoop(projectPath, {
+            goal,
+            agents,
+            safetyPolicy: DEFAULT_SAFETY,
+            maxConcurrentTasks: this.options.maxConcurrentTasks ?? 3,
+            stallTimeoutMs: this.options.stallTimeoutMs ?? 120_000,
+            maxTotalAttempts: 15,
+            models: this.options.models,
+            verificationTier: tier,
+            useFastVerification: tier === 'full' && !this.options.fullVerification,
+        });
+        const result = await loop.run();
+        this.auditTrail.push(...result.auditTrail);
+        // Write artifacts to disk and collect file paths
+        const filesCreated = [];
+        for (const handoff of result.artifacts) {
+            const path = handoff.artifact.path;
+            if (!path)
+                continue;
+            const absPath = join(projectPath, path);
+            try {
+                await mkdir(dirname(absPath), { recursive: true });
+                await writeFile(absPath, handoff.artifact.content, 'utf-8');
+                filesCreated.push(path);
+            }
+            catch {
+                // Best-effort write
+            }
+        }
+        // Aggregate verification stats
+        let totalClaims = 0;
+        let passed = 0;
+        let failed = 0;
+        for (const handoff of result.artifacts) {
+            totalClaims += handoff.verificationResult.total;
+            passed += handoff.verificationResult.passed;
+            failed += handoff.verificationResult.failed;
+        }
+        return {
+            status: result.status === 'completed' ? 'completed' : 'failed',
+            filesCreated,
+            verificationSummary: { totalClaims, passed, failed },
+            error: result.status !== 'completed' ? `Feature build ${result.status}` : undefined,
+        };
+    }
+    // ── Cross-Feature Verification ─────────────────────────────
+    async runCrossVerification(projectPath, plan) {
+        const checks = [];
+        // Check 1: API routes have corresponding files
+        for (const route of plan.apiRoutes) {
+            const expectedPath = this.routeToFilePath(route.path, this.description.techStack.framework);
+            const exists = await this.fileExists(join(projectPath, expectedPath));
+            checks.push({
+                type: 'api_route_exists',
+                description: `${route.method} ${route.path} has handler at ${expectedPath}`,
+                verdict: exists ? 'PASS' : 'FAIL',
+                evidence: exists ? `File exists: ${expectedPath}` : `Missing: ${expectedPath}`,
+            });
+        }
+        // Check 2: Pages have corresponding files
+        for (const page of plan.pages) {
+            const expectedPath = this.pageToFilePath(page.path, page.component, this.description.techStack.framework);
+            const exists = await this.fileExists(join(projectPath, expectedPath));
+            checks.push({
+                type: 'page_references_valid',
+                description: `Page ${page.path} has component at ${expectedPath}`,
+                verdict: exists ? 'PASS' : 'FAIL',
+                evidence: exists ? `File exists: ${expectedPath}` : `Missing: ${expectedPath}`,
+            });
+        }
+        // Check 3: Schema entities exist in schema/migration files
+        for (const entity of plan.schema) {
+            const found = await this.searchForSchemaEntity(projectPath, entity.name);
+            checks.push({
+                type: 'schema_entity_exists',
+                description: `Schema entity "${entity.name}" defined in project`,
+                verdict: found ? 'PASS' : 'FAIL',
+                evidence: found ? `Found in project files` : `Not found in schema/migration files`,
+            });
+        }
+        // Check 4: Dependency consistency — features that depend on others were built after them
+        for (const feature of plan.features) {
+            for (const dep of feature.dependsOn) {
+                const depIndex = plan.dependencyOrder.indexOf(dep);
+                const featureIndex = plan.dependencyOrder.indexOf(feature.id);
+                const ordered = depIndex < featureIndex;
+                checks.push({
+                    type: 'dependency_consistency',
+                    description: `${feature.id} depends on ${dep} — build order correct`,
+                    verdict: ordered ? 'PASS' : 'FAIL',
+                    evidence: ordered
+                        ? `${dep} (index ${depIndex}) built before ${feature.id} (index ${featureIndex})`
+                        : `${dep} (index ${depIndex}) NOT before ${feature.id} (index ${featureIndex})`,
+                });
+            }
+        }
+        const passedCount = checks.filter(c => c.verdict === 'PASS').length;
+        const failedCount = checks.filter(c => c.verdict === 'FAIL').length;
+        return {
+            checks,
+            passedCount,
+            failedCount,
+            verdict: failedCount === 0 ? 'PASS' : passedCount === 0 ? 'FAIL' : 'PARTIAL',
+        };
+    }
+    // ── Wave Computation ──────────────────────────────────────
+    /**
+     * Group features into waves based on dependency graph.
+     * Wave 0: features with no dependencies
+     * Wave N: features whose deps are all in waves < N
+     */
+    computeWaves(plan) {
+        const featureMap = new Map(plan.features.map(f => [f.id, f]));
+        const waves = [];
+        const placed = new Set();
+        // Iteratively find features whose deps are all placed
+        let remaining = [...plan.dependencyOrder];
+        while (remaining.length > 0) {
+            const wave = [];
+            for (const id of remaining) {
+                const feature = featureMap.get(id);
+                if (!feature)
+                    continue;
+                const allDepsPlaced = feature.dependsOn.every(dep => placed.has(dep));
+                if (allDepsPlaced) {
+                    wave.push(id);
+                }
+            }
+            if (wave.length === 0) {
+                // Remaining features have unresolvable deps — put them all in final wave
+                waves.push(remaining);
+                break;
+            }
+            waves.push(wave);
+            for (const id of wave)
+                placed.add(id);
+            remaining = remaining.filter(id => !placed.has(id));
+        }
+        return waves;
+    }
+    // ── Direct Generation Mode ───────────────────────────────
+    /**
+     * Build a feature using a single CodeAgent call — bypasses MultiAgentLoop.
+     * Used for trivial/small features where full team coordination is overkill.
+     */
+    async buildFeatureDirect(projectPath, plan, feature, completedFeatures) {
+        const goal = this.buildFeatureGoal(plan, feature, completedFeatures);
+        const messageBus = new MessageBus();
+        const codeAgent = new CodeAgent(messageBus, { model: this.options.models?.code });
+        try {
+            const result = await codeAgent.executeTask({
+                taskId: `direct-${feature.id}-${randomUUID().slice(0, 8)}`,
+                goal,
+                constraints: [
+                    `Framework: ${this.description.techStack.framework}`,
+                    `Database: ${this.description.techStack.database}`,
+                    `Language: ${this.description.techStack.language}`,
+                ],
+                dependencies: [],
+                contextRefs: [],
+            });
+            if (result.status === 'failed') {
+                return {
+                    status: 'failed',
+                    filesCreated: [],
+                    verificationSummary: { totalClaims: 0, passed: 0, failed: 0 },
+                    error: result.summary,
+                };
+            }
+            // Write artifacts to disk
+            const filesCreated = [];
+            for (const artifact of result.artifacts) {
+                if (!artifact.path)
+                    continue;
+                const absPath = join(projectPath, artifact.path);
+                try {
+                    await mkdir(dirname(absPath), { recursive: true });
+                    await writeFile(absPath, artifact.content, 'utf-8');
+                    filesCreated.push(artifact.path);
+                }
+                catch {
+                    // Best-effort write
+                }
+            }
+            // In direct mode (single agent), use lightweight (regex-only) verification
+            // since there's no cross-agent boundary to verify. This avoids LLM calls
+            // per-file while still catching TODOs, empty functions, hardcoded secrets.
+            const tier = this.getVerificationTier(feature);
+            let totalClaims = 0;
+            let passed = 0;
+            let failed = 0;
+            if (tier !== 'skip' && filesCreated.length > 0) {
+                const verifier = new CompositionVerifier(projectPath);
+                const sourceIdentity = codeAgent.getIdentity();
+                const targetIdentity = sourceIdentity; // Self-review in direct mode
+                for (const artifact of result.artifacts) {
+                    if (!artifact.path)
+                        continue;
+                    // Always use lightweight in direct mode — no cross-agent handoff to verify
+                    const handoff = await verifier.verifyHandoffLightweight(sourceIdentity, targetIdentity, artifact);
+                    totalClaims += handoff.verificationResult.total;
+                    passed += handoff.verificationResult.passed;
+                    failed += handoff.verificationResult.failed;
+                }
+            }
+            return {
+                status: 'completed',
+                filesCreated,
+                verificationSummary: { totalClaims, passed, failed },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'failed',
+                filesCreated: [],
+                verificationSummary: { totalClaims: 0, passed: 0, failed: 0 },
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /** Whether to use direct generation (single CodeAgent) vs full MultiAgentLoop.
+     *  For app creation (greenfield), direct mode is used for ALL features by default
+     *  since there's no existing codebase to review against and the architecture plan
+     *  already provides full context. Multi-agent mode adds overhead without proportional value. */
+    shouldUseDirect(_feature) {
+        if (this.options.noDirectMode)
+            return false;
+        return true; // Default to direct mode for all features in create pipeline
+    }
+    /** Determine verification tier based on feature characteristics. */
+    getVerificationTier(feature) {
+        if (this.options.fullVerification)
+            return 'full';
+        // Auth/security features always get full verification
+        const hasAuth = feature.name.toLowerCase().includes('auth')
+            || feature.schemaEntities.some(e => e.toLowerCase().includes('user') || e.toLowerCase().includes('session'));
+        if (hasAuth)
+            return 'full';
+        // Features with API routes get at least lightweight
+        if (feature.apiRoutes.length > 0)
+            return 'lightweight';
+        // UI-only trivial features can be skipped
+        if (feature.complexityEstimate === 'trivial')
+            return 'skip';
+        // Small UI-only features get lightweight
+        if (feature.complexityEstimate === 'small' && feature.apiRoutes.length === 0)
+            return 'lightweight';
+        return 'full';
+    }
+    // ── Feature Goal Builder ─────────────────────────────────
+    /** Build the goal string for a feature (shared between buildFeature and buildFeatureDirect). */
+    buildFeatureGoal(plan, feature, completedFeatures) {
+        const relevantSchema = plan.schema
+            .filter(e => feature.schemaEntities.includes(e.name))
+            .map(e => `${e.name}: ${e.fields.map(f => `${f.name}:${f.type}`).join(', ')}`)
+            .join('\n');
+        const relevantRoutes = plan.apiRoutes
+            .filter(r => r.featureId === feature.id)
+            .map(r => `${r.method} ${r.path} — ${r.description}`)
+            .join('\n');
+        const relevantPages = plan.pages
+            .filter(p => p.featureId === feature.id)
+            .map(p => `${p.path} — ${p.component}: ${p.description ?? ''}`)
+            .join('\n');
+        return `Implement feature: ${feature.name}
+
+Feature description: Build the "${feature.name}" feature for a ${this.description.techStack.framework} application.
+
+Schema entities:
+${relevantSchema || 'None'}
+
+API routes to implement:
+${relevantRoutes || 'None'}
+
+Pages to implement:
+${relevantPages || 'None'}
+
+Tech stack: ${this.description.techStack.framework}, ${this.description.techStack.database}, ${this.description.techStack.language}
+
+Previously completed features: ${completedFeatures.join(', ') || 'None'}
+
+Implement all API routes, pages, and business logic for this feature. Write complete, working code — no TODOs or stubs.`;
+    }
+    // ── Helpers ────────────────────────────────────────────────
+    emitPhase(phase) {
+        const progress = {
+            phase,
+            currentFeatureIndex: 'featureIndex' in phase ? phase.featureIndex : 0,
+            totalFeatures: 'totalFeatures' in phase ? phase.totalFeatures : 0,
+            completedFeatures: [],
+            failedFeatures: [],
+            elapsedMs: Date.now() - this.startTime,
+        };
+        this.emit('progress', progress);
+    }
+    makeResult(status, projectPath, plan, featureResults, crossVerification) {
+        return {
+            status,
+            projectPath,
+            plan,
+            featureResults,
+            crossVerification,
+            totalDurationMs: Date.now() - this.startTime,
+            auditTrail: this.auditTrail,
+        };
+    }
+    audit(eventType, details) {
+        const entry = {
+            id: randomUUID(),
+            eventType: eventType,
+            agentName: 'app-create-orchestrator',
+            timestamp: new Date().toISOString(),
+            details,
+            relatedIds: {},
+        };
+        this.auditTrail.push(entry);
+        this.emit('audit', entry);
+    }
+    slugify(name) {
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    routeToFilePath(routePath, framework) {
+        if (framework === 'next.js') {
+            // /api/users -> src/app/api/users/route.ts
+            return `src/app${routePath}/route.ts`;
+        }
+        // Express or similar: src/routes/<path>.ts
+        const parts = routePath.replace(/^\/api/, '').replace(/^\//, '');
+        return `src/routes/${parts || 'index'}.ts`;
+    }
+    pageToFilePath(pagePath, _component, framework) {
+        if (framework === 'next.js') {
+            // / -> src/app/page.tsx, /dashboard -> src/app/dashboard/page.tsx
+            const normalized = pagePath === '/' ? '' : pagePath;
+            return `src/app${normalized}/page.tsx`;
+        }
+        if (framework === 'sveltekit') {
+            const normalized = pagePath === '/' ? '' : pagePath;
+            return `src/routes${normalized}/+page.svelte`;
+        }
+        // Generic: src/pages/<path>.tsx
+        const normalized = pagePath === '/' ? '/index' : pagePath;
+        return `src/pages${normalized}.tsx`;
+    }
+    async fileExists(path) {
+        try {
+            await readFile(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async searchForSchemaEntity(projectPath, entityName) {
+        // Check common schema file locations
+        const candidates = [
+            'schema.prisma',
+            'prisma/schema.prisma',
+            'drizzle/schema.ts',
+            'src/db/schema.ts',
+            'supabase/migrations',
+            'src/schema.ts',
+            'db/schema.ts',
+        ];
+        for (const candidate of candidates) {
+            try {
+                const content = await readFile(join(projectPath, candidate), 'utf-8');
+                if (content.includes(entityName) || content.includes(entityName.toLowerCase())) {
+                    return true;
+                }
+            }
+            catch {
+                // File doesn't exist, continue
+            }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=app-create-orchestrator.js.map