aimeat 1.2.0

package/dist/src/services/generator-autopilot.js

@@ -0,0 +1,1076 @@
+/**
+ * @file generator-autopilot.ts
+ * @description Server-side autopilot for the generator pipeline. Runs the full
+ *   spec→code→validate→register→probe→test loop as a background process.
+ *   The browser just starts it and polls for status — closing the tab doesn't kill it.
+ *
+ *   Uses internal HTTP calls to the same server for registration, testing, and probing
+ *   to reuse all existing validation logic without duplication.
+ *
+ * @version-history
+ *   v1.0.0 — 2026-04-01 — Initial backend autopilot
+ */
+import { complete as openrouterComplete } from './openrouter.js';
+import { getEncryptionKey } from './encryption.js';
+import { decrypt } from './encryption.js';
+import { emitChange } from './event-bus.js';
+import { logger } from '../utils/logger.js';
+import { GeneratorDebugWriter } from './generator-debug.js';
+import { issueJWT } from '../auth/jwt.js';
+const log = { info: (m) => logger.info(m), warn: (m) => logger.warn(m), error: (m) => logger.error(m) };
+// ── Clean TypeScript imports from src/services/generator-prompts/ ──
+// No browser imports, no pathToFileURL hacks, no dynamic import()
+import { buildPrompt, stripCodeblock, createBundle } from './generator-prompts/index.js';
+import { validateComponent } from './generator-prompts/validate.js';
+import { validateExtensionSpec, validateDataApiSpec, validateComponentSpec, validateAppDomainSpec, validateSpecAgainstProbe } from './generator-prompts/spec-validate.js';
+// In-memory map of running autopilots (one per project)
+const runningAutopilots = new Map();
+export function getAutopilotStatus(projectId) {
+    return runningAutopilots.get(projectId)?.status ?? null;
+}
+export function cancelAutopilot(projectId) {
+    const entry = runningAutopilots.get(projectId);
+    if (entry && entry.status.status === 'running') {
+        entry.cancelFlag = true;
+        return true;
+    }
+    return false;
+}
+export function isAutopilotRunning(projectId) {
+    return runningAutopilots.get(projectId)?.status.status === 'running';
+}
+// ── Internal HTTP helper (calls own server) ──
+async function internalFetch(config, path, jwt, opts = {}) {
+    const url = `http://localhost:${config.port}${path}`;
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${jwt}`,
+    };
+    const fetchOpts = { method: opts.method || 'GET', headers };
+    if (opts.body)
+        fetchOpts.body = JSON.stringify(opts.body);
+    const resp = await fetch(url, fetchOpts);
+    const text = await resp.text();
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        log.error(`internalFetch ${opts.method || 'GET'} ${path} — non-JSON response (${resp.status}): ${text.slice(0, 500)}`);
+        return { ok: false, status: resp.status, data: null, error: { message: `Non-JSON response: ${text.slice(0, 200)}` } };
+    }
+    if (!resp.ok) {
+        log.warn(`internalFetch ${opts.method || 'GET'} ${path} — ${resp.status}: ${JSON.stringify(json.error || json).slice(0, 300)}`);
+    }
+    return { ok: resp.ok, status: resp.status, data: json.data, error: json.error };
+}
+// ── Main autopilot loop ──
+export async function runAutopilot(projectId, ownerGhii, ownerName, _jwt, config, storage) {
+    // Logger is the module-level winston wrapper defined above
+    if (isAutopilotRunning(projectId)) {
+        throw new Error('Autopilot already running for this project');
+    }
+    // Mint our own internal JWT — don't depend on the browser's token.
+    // The frontend JWT could expire or get revoked during long-running pipelines.
+    // 4-hour TTL, owner role, wildcard scopes — this is a trusted server-side process.
+    const jwt = await issueJWT({
+        sub: ownerName,
+        owner: ownerName,
+        node: config.nodeId,
+        roles: ['owner'],
+        scopes: ['*'],
+    }, 4 * 60 * 60); // 4 hours
+    log.info(`Autopilot minted internal JWT for ${ownerName} (4h TTL)`);
+    // Read project data
+    const projectRec = await storage.getMemory(ownerGhii, `generator.${projectId}.project`);
+    if (!projectRec)
+        throw new Error('Project not found');
+    const project = projectRec.value;
+    const blueprint = project.blueprint;
+    if (!blueprint)
+        throw new Error('No blueprint — generate blueprint first');
+    const interviewRec = await storage.getMemory(ownerGhii, `generator.${projectId}.interview-spec`);
+    const interviewSpec = interviewRec?.value ?? null;
+    const phases = blueprint.phases || [];
+    const phaseOrder = phases.flatMap(p => p.componentIds || []);
+    // Read OpenRouter settings
+    const prefsRecord = await storage.getMemory(ownerGhii, 'openrouter.settings');
+    const prefs = prefsRecord?.value ?? {};
+    const provider = prefs.provider || 'openrouter';
+    const baseUrl = prefs.baseUrl || (provider === 'lmstudio' ? 'http://localhost:1234/v1' : 'https://openrouter.ai/api/v1');
+    const model = prefs.model || prefs.executionModel || 'anthropic/claude-sonnet-4';
+    const temperature = prefs.temperature ?? undefined;
+    // Decrypt API key
+    let apiKey;
+    const apiKeyRecord = await storage.getMemory(ownerGhii, 'openrouter.apikey');
+    const encrypted = apiKeyRecord?.value?.encrypted ?? null;
+    if (encrypted) {
+        const encKey = getEncryptionKey(config);
+        if (encKey)
+            apiKey = decrypt(encrypted, encKey);
+    }
+    if (!apiKey && provider === 'openrouter')
+        throw new Error('No OpenRouter API key configured');
+    // Initialize status
+    const now = new Date().toISOString();
+    const entry = {
+        status: {
+            status: 'running',
+            currentComponent: null,
+            progress: { total: phaseOrder.length, completed: 0, failed: 0, skipped: 0 },
+            componentResults: [],
+            startedAt: now,
+            updatedAt: now,
+        },
+        cancelFlag: false,
+    };
+    runningAutopilots.set(projectId, entry);
+    const updateStatus = (patch) => {
+        Object.assign(entry.status, patch, { updatedAt: new Date().toISOString() });
+        // Persist to memory for UI polling
+        storage.setMemory({
+            key: `generator.${projectId}.autopilot-status`,
+            ownerGaii: ownerGhii,
+            value: entry.status,
+            visibility: 'owner',
+            version: 1,
+            tags: ['generator', 'autopilot'],
+            ttlHours: null,
+            createdAt: entry.status.startedAt,
+            updatedAt: entry.status.updatedAt,
+        }).catch(() => { });
+        emitChange('memory');
+    };
+    /** Call OpenRouter with the current settings */
+    async function callLLM(prompt) {
+        const result = await openrouterComplete(apiKey, model, prompt, undefined, baseUrl, { temperature });
+        return result.content;
+    }
+    /** Read all components for this project */
+    async function loadComponents() {
+        const records = await storage.listMemory(ownerGhii, { prefix: `generator.${projectId}.component.`, visibility: 'owner' });
+        return records.map(r => {
+            const val = (typeof r.value === 'string' ? JSON.parse(r.value) : r.value);
+            if (!val.id && r.key)
+                val.id = r.key.replace(`generator.${projectId}.component.`, '');
+            if (!val.label)
+                val.label = val.id;
+            return { ...val, _version: r.version };
+        });
+    }
+    /** Save component data */
+    async function saveComp(comp) {
+        const key = `generator.${projectId}.component.${comp.id}`;
+        const version = comp._version || 0;
+        const { _version, ...data } = comp;
+        try {
+            if (version === 0) {
+                await storage.setMemory({
+                    key, ownerGaii: ownerGhii, value: data, visibility: 'owner',
+                    version: 1, tags: ['generator', 'component'], ttlHours: null,
+                    createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
+                });
+            }
+            else {
+                const rec = await storage.getMemory(ownerGhii, key);
+                if (rec) {
+                    await storage.setMemory({ ...rec, value: data, version: (rec.version ?? 1) + 1, updatedAt: new Date().toISOString() });
+                }
+            }
+        }
+        catch (e) {
+            log.warn(`saveComp failed for ${comp.id} — retrying: ${e.message}`);
+            const rec = await storage.getMemory(ownerGhii, key);
+            if (rec) {
+                await storage.setMemory({ ...rec, value: data, version: (rec.version ?? 1) + 1, updatedAt: new Date().toISOString() });
+            }
+        }
+        emitChange('memory');
+    }
+    // ── Debug artifact writer ──
+    const debug = new GeneratorDebugWriter(projectId);
+    // Autopilot log lines — written to both terminal AND project debug dir
+    const autopilotLog = [];
+    const alog = {
+        info: (m) => { log.info(m); autopilotLog.push(`[INFO] ${new Date().toISOString()} ${m}`); },
+        warn: (m) => { log.warn(m); autopilotLog.push(`[WARN] ${new Date().toISOString()} ${m}`); },
+        error: (m) => { log.error(m); autopilotLog.push(`[ERROR] ${new Date().toISOString()} ${m}`); },
+        flush: () => debug.writeArtifact('_autopilot', 'terminal-log', autopilotLog.join('\n')).catch(() => { }),
+    };
+    // Write project metadata at start
+    debug.writeProjectMeta({ projectId, name: project.name, description: project.description }, interviewSpec, blueprint).catch(() => { });
+    // ── Main loop ──
+    try {
+        for (const cid of phaseOrder) {
+            if (entry.cancelFlag)
+                break;
+            const comps = await loadComponents();
+            // Enrich with subtype from blueprint and auto-fix stored records
+            const bpComps = blueprint.components || [];
+            for (const fc of comps) {
+                if (!fc.subtype) {
+                    const bpc = bpComps.find(b => b.label === fc.label || b.id === fc.id);
+                    if (bpc?.subtype) {
+                        fc.subtype = bpc.subtype;
+                        alog.warn(`[${fc.id}] ⚠️ SUBTYPE MISSING — auto-fixing to "${bpc.subtype}"`);
+                        // Permanently fix the stored record
+                        const key = `generator.${projectId}.component.${fc.id}`;
+                        const rec = await storage.getMemory(ownerGhii, key);
+                        if (rec) {
+                            const val = rec.value;
+                            val.subtype = bpc.subtype;
+                            await storage.setMemory({ ...rec, value: val, version: (rec.version ?? 1) + 1, updatedAt: new Date().toISOString() }).catch(() => { });
+                        }
+                    }
+                }
+            }
+            let comp = comps.find(c => c.id === cid);
+            if (!comp || comp.registeredAs) {
+                // Already registered — mark as completed and skip
+                if (comp?.registeredAs) {
+                    entry.status.progress.completed++;
+                    entry.status.componentResults.push({ id: cid, label: comp?.label || cid, status: 'already_registered' });
+                }
+                continue;
+            }
+            const compLabel = comp.label || cid;
+            const compType = comp.type || 'unknown';
+            // Phase gate: only process types enabled for this run.
+            // Enable one phase at a time. Verify each before enabling the next.
+            const ENABLED_TYPES = ['csm', 'memory', 'translation', 'extension', 'cortex']; // Phase gate: stop after cortex — app gated
+            // Cortex subtype gate: only cortex-data for now
+            const ENABLED_CORTEX_SUBTYPES = ['data', 'component', 'app-domain'];
+            if (!ENABLED_TYPES.includes(compType)) {
+                alog.info(`[${cid}] Phase gate: ${compType} not enabled yet — stopping pipeline`);
+                entry.status.componentResults.push({ id: cid, label: compLabel, status: 'phase_gated' });
+                break;
+            }
+            // Cortex subtype gate
+            if (compType === 'cortex') {
+                const bpC = (blueprint.components || []).find((c) => c.label === compLabel);
+                const sub = bpC?.subtype || '';
+                if (!ENABLED_CORTEX_SUBTYPES.includes(sub)) {
+                    alog.info(`[${cid}] Cortex subtype gate: ${sub} not enabled yet — stopping pipeline (enabled: ${ENABLED_CORTEX_SUBTYPES.join(', ')})`);
+                    entry.status.componentResults.push({ id: cid, label: compLabel, status: 'phase_gated' });
+                    break;
+                }
+            }
+            updateStatus({ currentComponent: compLabel });
+            alog.info(`[${cid}] Processing: ${compLabel} (${compType})`);
+            try {
+                // ── SPEC GENERATION ──
+                const specTypes = ['extension', 'cortex', 'app'];
+                let spec = null;
+                if (specTypes.includes(compType)) {
+                    const bpComp = (blueprint.components || []).find((c) => c.label === compLabel);
+                    if (bpComp) {
+                        let specPrompt = null;
+                        if (compType === 'extension') {
+                            specPrompt = await buildPrompt(storage, 'gen-extension-spec', { blueprint, blueprintComponent: bpComp, interviewSpec });
+                        }
+                        else if (bpComp.subtype === 'data') {
+                            const extComp = comps.find(c => c.type === 'extension' && c.spec);
+                            if (extComp?.spec)
+                                specPrompt = await buildPrompt(storage, 'gen-data-api-spec', { blueprint, extensionSpec: extComp.spec });
+                        }
+                        else if (bpComp.subtype === 'component' || bpComp.id?.startsWith('component-')) {
+                            const dataCortex = comps.find(c => c.type === 'cortex' && c.spec && (c.subtype === 'data'));
+                            if (dataCortex?.spec) {
+                                const translationKeys = comps.filter(c => c.type === 'translation' && c.contextBundle)
+                                    .flatMap(c => c.contextBundle?.keys || []);
+                                specPrompt = await buildPrompt(storage, 'gen-component-spec', { blueprint, dataApiSpec: dataCortex.spec, componentLabel: compLabel, translationKeys });
+                            }
+                        }
+                        else if (bpComp.subtype === 'app-domain') {
+                            const dataCortex = comps.find(c => c.type === 'cortex' && c.spec && (c.subtype === 'data'));
+                            const componentSpecs = comps.filter(c => c.spec && (c.subtype === 'component')).map(c => c.spec);
+                            const translationKeys = comps.filter(c => c.type === 'translation' && c.contextBundle)
+                                .flatMap(c => c.contextBundle?.keys || []);
+                            if (dataCortex?.spec) {
+                                specPrompt = await buildPrompt(storage, 'gen-app-domain-spec', {
+                                    blueprint, componentSpecs: componentSpecs,
+                                    dataApiSpec: dataCortex.spec,
+                                    useCases: interviewSpec?.useCases, translationKeys,
+                                    views: interviewSpec?.views,
+                                });
+                            }
+                        }
+                        else if (compType === 'app') {
+                            const appDomainComp = comps.find(c => c.type === 'cortex' && c.spec && (c.subtype === 'app-domain'));
+                            if (appDomainComp) {
+                                const allCortexes = comps.filter(c => c.type === 'cortex' && c.registeredAs);
+                                specPrompt = await buildPrompt(storage, 'gen-app-spec', {
+                                    blueprint, componentLabel: compLabel,
+                                    projectDescription: project.description,
+                                    completedComponents: allCortexes,
+                                });
+                            }
+                        }
+                        if (specPrompt) {
+                            alog.info(`[${cid}] Generating spec for ${compLabel}`);
+                            debug.writeArtifact(cid, 'spec-prompt', specPrompt).catch(() => { });
+                            const specRaw = await callLLM(specPrompt);
+                            debug.writeArtifact(cid, 'spec-raw-response', specRaw).catch(() => { });
+                            let specText = specRaw.trim();
+                            const fenceMatch = specText.match(/```(?:json)?\s*\n([\s\S]*?)```/);
+                            if (fenceMatch)
+                                specText = fenceMatch[1].trim();
+                            try {
+                                spec = JSON.parse(specText);
+                                debug.writeArtifact(cid, 'spec', JSON.stringify(spec, null, 2)).catch(() => { });
+                                alog.info(`[${cid}] Spec generated: ${spec.name}`);
+                                // Validate spec structure — per component type
+                                if (compType === 'extension') {
+                                    const sv = validateExtensionSpec(spec);
+                                    if (!sv.valid) {
+                                        alog.warn(`[${cid}] Spec validation issues: ${sv.errors.join('; ')}`);
+                                    }
+                                    // Validate spec has ALL blueprint actions
+                                    const specActionIds = new Set((spec.actions || []).map(a => a.id));
+                                    const bpActions = Object.keys(blueprint.dataModel ? blueprint.dataModel.actions || {} : {})
+                                        .filter(k => k.startsWith('ext:'))
+                                        .map(k => k.replace('ext:', '').replace(/^[^/]+\//, ''));
+                                    const missingActions = bpActions.filter(a => !specActionIds.has(a));
+                                    if (missingActions.length > 0) {
+                                        alog.warn(`[${cid}] Spec missing blueprint actions: ${missingActions.join(', ')} — spec will be used but code validator will flag these`);
+                                    }
+                                }
+                                else if (compType === 'cortex') {
+                                    const sub = bpComp?.subtype || '';
+                                    const sv = sub === 'data' ? validateDataApiSpec(spec)
+                                        : sub === 'component' ? validateComponentSpec(spec)
+                                            : sub === 'app-domain' ? validateAppDomainSpec(spec)
+                                                : { valid: true, errors: [] };
+                                    if (!sv.valid) {
+                                        alog.warn(`[${cid}] Spec validation issues: ${sv.errors.join('; ')}`);
+                                        // If name is non-ASCII, reject the spec entirely — it will break registration and tests
+                                        if (sv.errors.some(e => e.includes('ASCII'))) {
+                                            alog.error(`[${cid}] Spec has non-ASCII name — rejecting. Will retry without spec.`);
+                                            spec = null;
+                                        }
+                                    }
+                                }
+                            }
+                            catch {
+                                alog.warn(`[${cid}] Spec JSON parse failed — continuing without spec`);
+                                spec = null;
+                            }
+                            if (spec) {
+                                comp = { ...comp, spec };
+                                await saveComp(comp);
+                                // Save spec independently
+                                await storage.setMemory({
+                                    key: `generator.${projectId}.spec.${cid}`,
+                                    ownerGaii: ownerGhii, value: spec, visibility: 'owner',
+                                    version: 1, tags: ['generator', 'spec'], ttlHours: null,
+                                    createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
+                                }).catch(() => { });
+                            }
+                        }
+                    }
+                }
+                if (entry.cancelFlag)
+                    break;
+                // ── CODE GENERATION ──
+                alog.info(`[${cid}] Building code prompt for ${compLabel}`);
+                const freshComps = await loadComponents();
+                // Enrich stored components with subtype from blueprint (subtype is not stored in component records)
+                const bpComponents = blueprint.components || [];
+                for (const fc of freshComps) {
+                    if (!fc.subtype) {
+                        const bpc = bpComponents.find(b => b.label === fc.label || b.id === fc.id);
+                        if (bpc?.subtype) {
+                            fc.subtype = bpc.subtype;
+                            alog.warn(`[${fc.id}] ⚠️ SUBTYPE MISSING from stored component — enriched from blueprint as "${bpc.subtype}". Run will auto-fix this component record.`);
+                        }
+                    }
+                }
+                const completedComponents = freshComps.filter(c => c.status === 'done' && c.registeredAs);
+                // Map component type to the appropriate DB prompt ID
+                const promptIdMap = {
+                    csm: 'gen-csm', memory: 'gen-memory', translation: 'gen-translation',
+                    extension: 'gen-extension-code', app: 'gen-app',
+                };
+                let promptId = promptIdMap[compType];
+                // Cortex subtypes
+                if (compType === 'cortex') {
+                    const bpC = blueprint.components?.find((c) => c.label === compLabel);
+                    const sub = bpC?.subtype || '';
+                    if (sub === 'data')
+                        promptId = 'gen-cortex-data';
+                    else if (sub === 'component' || bpC?.id?.startsWith('component-'))
+                        promptId = 'gen-cortex-component';
+                    else if (sub === 'app-domain')
+                        promptId = 'gen-cortex-app-domain';
+                    else
+                        promptId = 'gen-cortex-component'; // default
+                }
+                if (!promptId)
+                    promptId = 'gen-extension-code'; // fallback
+                const prompt = await buildPrompt(storage, promptId, {
+                    blueprint: blueprint,
+                    interviewSpec: interviewSpec,
+                    componentLabel: compLabel,
+                    componentType: compType,
+                    completedComponents: completedComponents,
+                    selfSpec: comp.spec,
+                    projectDescription: project.description,
+                    blueprintComponent: (blueprint.components || []).find((c) => c.label === compLabel),
+                    extensionSpec: completedComponents.find(c => c.type === 'extension' && c.spec)?.spec,
+                    dataApiSpec: completedComponents.find(c => c.subtype === 'data' && c.spec)?.spec,
+                    translationKeys: completedComponents.filter(c => c.type === 'translation' && c.contextBundle?.keys)
+                        .flatMap(c => c.contextBundle?.keys || []),
+                });
+                alog.info(`[${cid}] Calling OpenRouter for ${compLabel} (prompt: ${prompt.length} chars)`);
+                debug.writeComponentPrompt(cid, prompt).catch(() => { });
+                let content = await callLLM(prompt);
+                debug.writeArtifact(cid, 'ai-raw-response', content).catch(() => { });
+                // Cortex validator needs the fenced blocks (```yaml + ```javascript) to extract manifest+libs.
+                // stripCodeblock would remove them, making the validator unable to parse the format.
+                if (compType !== 'cortex') {
+                    content = stripCodeblock(content);
+                }
+                debug.writeComponentGenerated(cid, content).catch(() => { });
+                // ── VALIDATE ──
+                let vr = validateComponent(compType, content, blueprint);
+                // Auto-retry on validation failure
+                if (!vr.valid) {
+                    const maxRetries = 3;
+                    for (let attempt = 1; attempt <= maxRetries && !vr.valid && !entry.cancelFlag; attempt++) {
+                        alog.info(`[${cid}] Retry ${attempt}/${maxRetries} for ${compLabel}`);
+                        const fixPrompt = await buildPrompt(storage, 'gen-fix', { blueprint: blueprint, interviewSpec: interviewSpec, originalPrompt: prompt, code: content, errors: vr.errors, componentType: compType });
+                        debug.writeArtifact(cid, `validation-fix-${attempt}-prompt`, fixPrompt).catch(() => { });
+                        content = await callLLM(fixPrompt);
+                        debug.writeArtifact(cid, `validation-fix-${attempt}-response`, content).catch(() => { });
+                        if (compType !== 'cortex')
+                            content = stripCodeblock(content);
+                        vr = validateComponent(compType, content, blueprint);
+                    }
+                }
+                if (!vr.valid) {
+                    alog.error(`[${cid}] Validation failed for ${compLabel} — STOPPING pipeline: ${vr.errors[0]}`);
+                    comp = { ...comp, result: content, status: 'errors', validationErrors: vr.errors };
+                    await saveComp(comp);
+                    entry.status.progress.failed++;
+                    entry.status.componentResults.push({ id: cid, label: compLabel, status: 'validation_failed', error: vr.errors[0] });
+                    break; // STOP — downstream components depend on this one
+                }
+                // ── REGISTER ──
+                alog.info(`[${cid}] Registering ${compLabel}`);
+                comp = { ...comp, result: content, status: 'done', validationErrors: [] };
+                await saveComp(comp);
+                // Use internal HTTP to register — reuses all existing validation/registration logic
+                try {
+                    // Submit content first
+                    const submitResp = await internalFetch(config, `/v1/generator/${projectId}/components/${cid}/submit`, jwt, {
+                        method: 'POST',
+                        body: { content, type: compType },
+                    });
+                    if (!submitResp.ok) {
+                        alog.warn(`[${cid}] Submit failed (${submitResp.status}): ${JSON.stringify(submitResp.error)}`);
+                        throw new Error(`Submit failed: ${JSON.stringify(submitResp.error)}`);
+                    }
+                    // For types that have catalogue registration (CSM, MSM, Extension, App)
+                    if (['csm', 'msm', 'extension', 'app'].includes(compType)) {
+                        alog.info(`[${cid}] Calling register endpoint for ${compType}...`);
+                        const regResp = await internalFetch(config, `/v1/generator/${projectId}/components/${cid}/register`, jwt, { method: 'POST' });
+                        if (!regResp.ok) {
+                            alog.error(`[${cid}] ❌ Register FAILED (${regResp.status}): ${JSON.stringify(regResp.error)}`);
+                            throw new Error(`Registration failed: ${JSON.stringify(regResp.error)}`);
+                        }
+                        alog.info(`[${cid}] ✅ Register succeeded for ${compType}`);
+                    }
+                    // For cortex: use the cortex API directly
+                    if (compType === 'cortex') {
+                        const extracted = vr.extracted;
+                        if (extracted?.manifest) {
+                            const libs = {};
+                            for (const lib of (extracted.libs || [])) {
+                                if (lib.filename && lib.code)
+                                    libs[lib.filename] = lib.code;
+                            }
+                            const cortexResp = await internalFetch(config, '/v1/cortex', jwt, {
+                                method: 'POST',
+                                body: { manifest: extracted.manifest, ...(Object.keys(libs).length > 0 ? { libs } : {}) },
+                            });
+                            if (!cortexResp.ok) {
+                                // Try deactivate + delete + retry
+                                const nameMatch = extracted.manifest.match(/name:\s*"?([^\s"]+)"?/);
+                                if (nameMatch) {
+                                    await internalFetch(config, `/v1/cortex/${encodeURIComponent(nameMatch[1])}/deactivate`, jwt, { method: 'POST' }).catch(() => { });
+                                    await internalFetch(config, `/v1/cortex/${encodeURIComponent(nameMatch[1])}`, jwt, { method: 'DELETE' }).catch(() => { });
+                                    await internalFetch(config, '/v1/cortex', jwt, {
+                                        method: 'POST',
+                                        body: { manifest: extracted.manifest, ...(Object.keys(libs).length > 0 ? { libs } : {}) },
+                                    });
+                                }
+                            }
+                            // Activate
+                            const name = extracted.manifest.match(/name:\s*"?([^\s"]+)"?/)?.[1];
+                            if (name) {
+                                await internalFetch(config, `/v1/cortex/${encodeURIComponent(name)}/deactivate`, jwt, { method: 'POST' }).catch(() => { });
+                                await internalFetch(config, `/v1/cortex/${encodeURIComponent(name)}/activate`, jwt, { method: 'POST' });
+                            }
+                        }
+                    }
+                    // For memory/translation: store in memory directly
+                    if (compType === 'memory' || compType === 'translation') {
+                        // service_slug comes from blueprint — the single source of truth
+                        const serviceSlug = blueprint.service_slug;
+                        if (!serviceSlug) {
+                            throw new Error(`Blueprint missing "service_slug" — cannot namespace memory keys. Regenerate blueprint with service_slug field.`);
+                        }
+                        alog.info(`[${cid}] serviceSlug="${serviceSlug}" (from blueprint.service_slug)`);
+                        if (compType === 'memory') {
+                            const stripped = typeof content === 'string' ? stripCodeblock(content) : content;
+                            const entries = typeof stripped === 'string' ? JSON.parse(stripped) : stripped;
+                            const rawKeys = Object.keys(entries);
+                            for (const [rawKey, value] of Object.entries(entries)) {
+                                const key = rawKey.startsWith(serviceSlug + '.') ? rawKey : `${serviceSlug}.${rawKey}`;
+                                alog.info(`[${cid}] Memory key: "${rawKey}" → stored as "${key}" (owner: ${ownerGhii})`);
+                                await storage.setMemory({
+                                    key, ownerGaii: ownerGhii, value, visibility: 'public',
+                                    version: 1, tags: ['generator', 'memory'], ttlHours: null,
+                                    createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
+                                });
+                            }
+                            alog.info(`[${cid}] Memory: ${rawKeys.length} keys stored with prefix "${serviceSlug}"`);
+                            debug.writeComponentArtifact(cid, 'memory-keys', rawKeys.map(k => `${k} → ${serviceSlug}.${k}`).join('\n')).catch(() => { });
+                        }
+                        if (compType === 'translation') {
+                            const stripped = typeof content === 'string' ? stripCodeblock(content) : content;
+                            const translations = typeof stripped === 'string' ? JSON.parse(stripped) : stripped;
+                            for (const [locale, strings] of Object.entries(translations)) {
+                                if (locale && typeof strings === 'object') {
+                                    const key = `${serviceSlug}.i18n.${locale}`;
+                                    const keyCount = Object.keys(strings).length;
+                                    alog.info(`[${cid}] Translation: locale="${locale}" → stored as "${key}" (${keyCount} keys, owner: ${ownerGhii})`);
+                                    await storage.setMemory({
+                                        key, ownerGaii: ownerGhii, value: strings, visibility: 'public',
+                                        version: 1, tags: ['generator', 'translation'], ttlHours: null,
+                                        createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
+                                    });
+                                }
+                            }
+                            debug.writeComponentArtifact(cid, 'translation-keys', Object.keys(translations).map(l => `${l} → ${serviceSlug}.i18n.${l}`).join('\n')).catch(() => { });
+                        }
+                    }
+                    // Determine registered name — memory/translation include serviceSlug prefix to match stored keys
+                    let regName = comp.registeredAs || extractRegisteredName(compType, content, vr);
+                    if ((compType === 'memory' || compType === 'translation') && regName) {
+                        const slug = blueprint.service_slug;
+                        if (!slug)
+                            throw new Error(`Blueprint missing "service_slug" — cannot determine registered name for ${compLabel}`);
+                        if (!regName.startsWith(slug + '.'))
+                            regName = `${slug}.${regName}`;
+                    }
+                    comp = { ...comp, registeredAs: regName, contextBundle: createBundle({ ...comp, registeredAs: regName }, []) };
+                    await saveComp(comp);
+                    alog.info(`[${cid}] Registered: ${compLabel} as ${regName}`);
+                }
+                catch (regErr) {
+                    alog.error(`[${cid}] Registration failed for ${compLabel} — STOPPING pipeline: ${regErr.message}`);
+                    entry.status.progress.failed++;
+                    entry.status.componentResults.push({ id: cid, label: compLabel, status: 'registration_failed', error: regErr.message });
+                    break; // STOP — downstream components depend on this one
+                }
+                // ── ACTIVATE EXTENSION ──
+                if (compType === 'extension' && comp.registeredAs) {
+                    try {
+                        await internalFetch(config, `/v1/generator/${projectId}/apply-settings/${encodeURIComponent(comp.registeredAs)}`, jwt, { method: 'POST' });
+                        await internalFetch(config, `/v1/extensions/${encodeURIComponent(comp.registeredAs)}/activate`, jwt, { method: 'POST' });
+                        alog.info(`[${cid}] Activated extension: ${comp.registeredAs}`);
+                    }
+                    catch (e) {
+                        alog.warn(`[${cid}] Extension activation failed: ${e.message}`);
+                    }
+                    // ── PROBE ──
+                    try {
+                        const probeResp = await internalFetch(config, `/v1/generator/${projectId}/probe-extension`, jwt, {
+                            method: 'POST',
+                            body: { extensionName: comp.registeredAs, scenarios: buildProbeScenarios(blueprint, comp, content) },
+                        });
+                        const probeResults = probeResp.data?.results || [];
+                        const contextBundle = createBundle({ ...comp, registeredAs: comp.registeredAs }, probeResults);
+                        comp = { ...comp, probeResults, contextBundle };
+                        await saveComp(comp);
+                        alog.info(`[${cid}] Probed extension: ${probeResults.length} actions`);
+                        // Check if ALL probes failed — means extension code is fundamentally broken
+                        const probeFailCount = probeResults.filter((p) => p.status !== 200).length;
+                        if (probeResults.length > 0 && probeFailCount === probeResults.length) {
+                            alog.error(`[${cid}] ALL ${probeResults.length} probe actions failed — extension code is broken, STOPPING`);
+                            entry.status.progress.failed++;
+                            entry.status.componentResults.push({ id: cid, label: compLabel, status: 'probe_all_failed', error: `All ${probeResults.length} actions returned errors` });
+                            break; // STOP — downstream components need working extension
+                        }
+                        // Spec-vs-probe validation
+                        if (comp.spec && probeResults.length > 0) {
+                            const sv = validateSpecAgainstProbe(comp.spec, probeResults);
+                            if (!sv.valid) {
+                                alog.warn(`[${cid}] Spec-vs-probe mismatch: ${sv.mismatches.map(m => m.message).join('; ')}`);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        alog.warn(`[${cid}] Extension probe failed: ${e.message}`);
+                    }
+                }
+                // ── CORTEX ACTIVATE ──
+                if (compType === 'cortex' && comp.registeredAs) {
+                    // Already activated during registration above
+                }
+                // ── TEST ──
+                let testPassed = true; // assume passed unless test runs and fails
+                if (['extension', 'cortex', 'app'].includes(compType) && comp.registeredAs) {
+                    try {
+                        let testPromptText;
+                        if (compType === 'cortex') {
+                            // Route to subtype-specific test prompt
+                            const freshCompsForTest = await loadComponents();
+                            // Enrich with subtype from blueprint
+                            const bpCompsForTest = blueprint.components || [];
+                            for (const fc of freshCompsForTest) {
+                                if (!fc.subtype) {
+                                    const bpc = bpCompsForTest.find(b => b.label === fc.label || b.id === fc.id);
+                                    if (bpc?.subtype) {
+                                        fc.subtype = bpc.subtype;
+                                        alog.warn(`[${fc.id}] ⚠️ SUBTYPE MISSING from stored component — enriched from blueprint as "${bpc.subtype}". Run will auto-fix this component record.`);
+                                    }
+                                }
+                            }
+                            const bpC = bpCompsForTest.find((c) => c.label === compLabel);
+                            const cortexSubtype = bpC?.subtype || comp.subtype || 'data';
+                            const testPromptId = cortexSubtype === 'component' ? 'gen-test-cortex-component'
+                                : cortexSubtype === 'app-domain' ? 'gen-test-cortex-app-domain'
+                                    : 'gen-test-cortex-spec'; // data cortex
+                            testPromptText = await buildPrompt(storage, testPromptId, {
+                                blueprint: blueprint, interviewSpec: interviewSpec,
+                                selfSpec: comp.spec,
+                                componentLabel: compLabel,
+                                componentType: compType,
+                                completedComponents: freshCompsForTest.filter(c => c.registeredAs),
+                            });
+                        }
+                        else if (compType === 'app') {
+                            // App test — uses gen-app test prompt (browser-based, loads all cortexes)
+                            const freshCompsForApp = await loadComponents();
+                            testPromptText = await buildPrompt(storage, 'gen-test-app', {
+                                blueprint: blueprint, interviewSpec: interviewSpec,
+                                selfSpec: comp.spec,
+                                componentLabel: compLabel,
+                                componentType: compType,
+                                completedComponents: freshCompsForApp.filter(c => c.registeredAs),
+                            });
+                        }
+                        else if (comp.spec && compType === 'extension') {
+                            testPromptText = await buildPrompt(storage, 'gen-test-extension-spec', {
+                                blueprint: blueprint, interviewSpec: interviewSpec,
+                                selfSpec: comp.spec, extensionName: comp.registeredAs,
+                                completedComponents: [comp], // pass current comp with probeResults for golden samples
+                            });
+                        }
+                        else {
+                            // Fallback — extension without spec
+                            testPromptText = await buildPrompt(storage, 'gen-test-extension-spec', {
+                                blueprint: blueprint, interviewSpec: interviewSpec,
+                                selfSpec: comp.spec,
+                                extensionName: comp.registeredAs,
+                                completedComponents: [comp],
+                            });
+                        }
+                        alog.info(`[${cid}] Generating test for ${compLabel}`);
+                        debug.writeArtifact(cid, 'test-prompt', testPromptText).catch(() => { });
+                        let testCode = await callLLM(testPromptText);
+                        debug.writeArtifact(cid, 'test-raw-response', testCode).catch(() => { });
+                        testCode = stripCodeblock(testCode);
+                        const testEnvironment = (compType === 'cortex' || compType === 'app') ? 'browser' : 'server';
+                        const testResp = await internalFetch(config, `/v1/generator/${projectId}/test/${cid}`, jwt, {
+                            method: 'POST',
+                            body: { testCode, environment: testEnvironment },
+                        });
+                        let testResult = testResp.data?.result;
+                        if (testResult) {
+                            // Store test result WITHOUT full trace (trace can be 100KB+, exceeds memory value limit)
+                            // Trace is already saved in debug artifacts and terminal log
+                            const testResultForStorage = { ...testResult };
+                            delete testResultForStorage.trace;
+                            comp = { ...comp, testCode, testResult: testResultForStorage };
+                            await saveComp(comp);
+                            const testErrors = testResult.errors || [];
+                            const testTrace = testResult.trace || [];
+                            if (testResult.status === 'passed') {
+                                alog.info(`[${cid}] ✅ Test PASSED`);
+                            }
+                            else {
+                                alog.error(`[${cid}] ❌ Test FAILED — ${testErrors.length} errors:`);
+                                for (const e of testErrors)
+                                    alog.error(`[${cid}]   - ${e}`);
+                            }
+                            // Log trace with shapes
+                            for (const t of testTrace) {
+                                const resultStr = t.result || 'null';
+                                const shapeMatch = resultStr.match(/\[shape extracted from (\d+) chars\]/);
+                                if (shapeMatch) {
+                                    const shapeJson = resultStr.slice(0, resultStr.indexOf('\n[shape extracted')).trim().replace(/\s+/g, ' ').slice(0, 500);
+                                    alog.info(`[${cid}]   [${t.status}] ${t.fn}(${(t.args || '').slice(0, 60)}) → SHAPE: ${shapeJson} [from ${shapeMatch[1]} chars]`);
+                                }
+                                else {
+                                    alog.info(`[${cid}]   [${t.status}] ${t.fn}(${(t.args || '').slice(0, 60)}) → ${resultStr.slice(0, 300)}`);
+                                }
+                            }
+                        }
+                        // ── TEST→REFLECT→FIX→RE-REGISTER→RE-TEST cycle ──
+                        // Matches browser flow: generator-detail.js handleFixFromTest
+                        const maxTestFixRounds = 2;
+                        let testFixRound = 0;
+                        const previousAttempts = [];
+                        while (testResult && testResult.status === 'failed' && testFixRound < maxTestFixRounds && !entry.cancelFlag) {
+                            testFixRound++;
+                            alog.info(`[${cid}] Test failed — starting reflect+fix round ${testFixRound}/${maxTestFixRounds}`);
+                            // Step 1: REFLECT — diagnose the failure (no code, just analysis)
+                            let reflectionDiagnosis = '';
+                            try {
+                                const reflectionPrompt = await buildPrompt(storage, 'gen-reflection', {
+                                    blueprint: blueprint,
+                                    interviewSpec: interviewSpec,
+                                    code: content,
+                                    selfSpec: comp.spec,
+                                    errors: testResult.errors || [],
+                                    testContext: testResult,
+                                });
+                                debug.writeArtifact(cid, `test-fix-${testFixRound}-reflection-prompt`, reflectionPrompt).catch(() => { });
+                                reflectionDiagnosis = await callLLM(reflectionPrompt);
+                                debug.writeArtifact(cid, `test-fix-${testFixRound}-reflection-response`, reflectionDiagnosis).catch(() => { });
+                                alog.info(`[${cid}] Reflection: ${reflectionDiagnosis.slice(0, 200)}`);
+                            }
+                            catch (e) {
+                                alog.warn(`[${cid}] Reflection failed: ${e.message}`);
+                            }
+                            previousAttempts.push({
+                                round: testFixRound,
+                                diagnosis: reflectionDiagnosis.slice(0, 500),
+                                errors: testResult.errors || [],
+                            });
+                            // Step 2: FIX — regenerate extension code with test context + diagnosis
+                            const fixPrompt = await buildPrompt(storage, 'gen-fix', {
+                                blueprint: blueprint,
+                                interviewSpec: interviewSpec,
+                                originalPrompt: prompt,
+                                code: content,
+                                errors: testResult.errors || [],
+                                componentType: compType,
+                                testContext: testResult,
+                                previousAttempts,
+                                reflectionDiagnosis,
+                            });
+                            debug.writeArtifact(cid, `test-fix-${testFixRound}-fix-prompt`, fixPrompt).catch(() => { });
+                            let fixedContent = await callLLM(fixPrompt);
+                            debug.writeArtifact(cid, `test-fix-${testFixRound}-fix-response`, fixedContent).catch(() => { });
+                            if (compType !== 'cortex')
+                                fixedContent = stripCodeblock(fixedContent);
+                            // Step 3: VALIDATE the fix
+                            let fixVr = validateComponent(compType, fixedContent, blueprint);
+                            if (!fixVr.valid) {
+                                alog.warn(`[${cid}] Fix round ${testFixRound} validation failed: ${fixVr.errors[0]}`);
+                                // One more try
+                                const fixPrompt2 = await buildPrompt(storage, 'gen-fix', {
+                                    blueprint: blueprint,
+                                    interviewSpec: interviewSpec,
+                                    originalPrompt: prompt,
+                                    code: fixedContent,
+                                    errors: fixVr.errors,
+                                    componentType: compType,
+                                });
+                                debug.writeArtifact(cid, `test-fix-${testFixRound}-refix-prompt`, fixPrompt2).catch(() => { });
+                                fixedContent = await callLLM(fixPrompt2);
+                                debug.writeArtifact(cid, `test-fix-${testFixRound}-refix-response`, fixedContent).catch(() => { });
+                                if (compType !== 'cortex')
+                                    fixedContent = stripCodeblock(fixedContent);
+                                fixVr = validateComponent(compType, fixedContent, blueprint);
+                            }
+                            if (!fixVr.valid) {
+                                alog.warn(`[${cid}] Fix round ${testFixRound} still invalid — skipping re-register`);
+                                continue;
+                            }
+                            // Step 4: RE-REGISTER
+                            content = fixedContent;
+                            comp = { ...comp, result: content, status: 'done', validationErrors: [] };
+                            await saveComp(comp);
+                            try {
+                                await internalFetch(config, `/v1/generator/${projectId}/components/${cid}/submit`, jwt, {
+                                    method: 'POST', body: { content, type: compType },
+                                });
+                                if (['csm', 'msm', 'extension', 'app'].includes(compType)) {
+                                    await internalFetch(config, `/v1/generator/${projectId}/components/${cid}/register`, jwt, { method: 'POST' });
+                                }
+                                if (compType === 'extension' && comp.registeredAs) {
+                                    await internalFetch(config, `/v1/extensions/${encodeURIComponent(comp.registeredAs)}/activate`, jwt, { method: 'POST' });
+                                }
+                                // Cortex re-registration: validate to extract manifest+libs, then re-register via cortex API
+                                if (compType === 'cortex') {
+                                    const reVr = validateComponent('cortex', content, blueprint);
+                                    const extracted = reVr.extracted;
+                                    if (extracted?.manifest) {
+                                        const libs = {};
+                                        for (const lib of (extracted.libs || [])) {
+                                            if (lib.filename && lib.code)
+                                                libs[lib.filename] = lib.code;
+                                        }
+                                        const newName = extracted.manifest.match(/name:\s*"?([^\s"]+)"?/)?.[1];
+                                        // Deactivate+delete OLD cortex name if it changed
+                                        const oldName = comp.registeredAs;
+                                        if (oldName && oldName !== newName) {
+                                            await internalFetch(config, `/v1/cortex/${encodeURIComponent(oldName)}/deactivate`, jwt, { method: 'POST' }).catch(() => { });
+                                            await internalFetch(config, `/v1/cortex/${encodeURIComponent(oldName)}`, jwt, { method: 'DELETE' }).catch(() => { });
+                                        }
+                                        // Deactivate+delete new name too (may exist from previous attempt)
+                                        if (newName) {
+                                            await internalFetch(config, `/v1/cortex/${encodeURIComponent(newName)}/deactivate`, jwt, { method: 'POST' }).catch(() => { });
+                                            await internalFetch(config, `/v1/cortex/${encodeURIComponent(newName)}`, jwt, { method: 'DELETE' }).catch(() => { });
+                                        }
+                                        await internalFetch(config, '/v1/cortex', jwt, {
+                                            method: 'POST', body: { manifest: extracted.manifest, ...(Object.keys(libs).length > 0 ? { libs } : {}) },
+                                        });
+                                        if (newName) {
+                                            await internalFetch(config, `/v1/cortex/${encodeURIComponent(newName)}/activate`, jwt, { method: 'POST' });
+                                            // Update registeredAs if name changed
+                                            if (newName !== oldName) {
+                                                comp = { ...comp, registeredAs: newName };
+                                                await saveComp(comp);
+                                                alog.info(`[${cid}] Cortex name changed: ${oldName} → ${newName}`);
+                                            }
+                                        }
+                                    }
+                                }
+                                alog.info(`[${cid}] Re-registered after fix round ${testFixRound}`);
+                                // Update debug artifacts with the actual registered code
+                                debug.writeComponentGenerated(cid, content).catch(() => { });
+                            }
+                            catch (e) {
+                                alog.warn(`[${cid}] Re-registration failed: ${e.message}`);
+                                break;
+                            }
+                            // Step 5: RE-TEST with the same test code
+                            try {
+                                const reTestResp = await internalFetch(config, `/v1/generator/${projectId}/test/${cid}`, jwt, {
+                                    method: 'POST', body: { testCode, environment: testEnvironment },
+                                });
+                                testResult = reTestResp.data?.result;
+                                if (testResult) {
+                                    const reTestForStorage = { ...testResult };
+                                    delete reTestForStorage.trace;
+                                    comp = { ...comp, testResult: reTestForStorage };
+                                    await saveComp(comp);
+                                    const reTestErrors = testResult.errors || [];
+                                    if (testResult.status === 'passed') {
+                                        alog.info(`[${cid}] ✅ Re-test round ${testFixRound}: PASSED`);
+                                    }
+                                    else {
+                                        alog.error(`[${cid}] ❌ Re-test round ${testFixRound}: FAILED — ${reTestErrors.length} errors:`);
+                                        for (const e of reTestErrors)
+                                            alog.error(`[${cid}]   - ${e}`);
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                alog.warn(`[${cid}] Re-test failed: ${e.message}`);
+                                break;
+                            }
+                        }
+                        // Final round: fresh generation if still failing
+                        if (testResult && testResult.status === 'failed' && !entry.cancelFlag) {
+                            alog.info(`[${cid}] All fix rounds exhausted — trying fresh generation`);
+                            try {
+                                const freshPrompt = await buildPrompt(storage, 'gen-fresh-generation', {
+                                    blueprint: blueprint,
+                                    interviewSpec: interviewSpec,
+                                    originalPrompt: prompt,
+                                    previousAttempts,
+                                    testContext: testResult,
+                                });
+                                debug.writeArtifact(cid, 'fresh-generation-prompt', freshPrompt).catch(() => { });
+                                let freshContent = await callLLM(freshPrompt);
+                                debug.writeArtifact(cid, 'fresh-generation-response', freshContent).catch(() => { });
+                                if (compType !== 'cortex')
+                                    freshContent = stripCodeblock(freshContent);
+                                const freshVr = validateComponent(compType, freshContent, blueprint);
+                                if (freshVr.valid) {
+                                    content = freshContent;
+                                    comp = { ...comp, result: content, status: 'done' };
+                                    await saveComp(comp);
+                                    // Re-register fresh
+                                    await internalFetch(config, `/v1/generator/${projectId}/components/${cid}/submit`, jwt, {
+                                        method: 'POST', body: { content, type: compType },
+                                    });
+                                    if (['csm', 'msm', 'extension', 'app'].includes(compType)) {
+                                        await internalFetch(config, `/v1/generator/${projectId}/components/${cid}/register`, jwt, { method: 'POST' });
+                                    }
+                                    if (compType === 'extension' && comp.registeredAs) {
+                                        await internalFetch(config, `/v1/extensions/${encodeURIComponent(comp.registeredAs)}/activate`, jwt, { method: 'POST' });
+                                    }
+                                    // Cortex fresh re-registration
+                                    if (compType === 'cortex') {
+                                        const freshExtracted = freshVr.extracted;
+                                        if (freshExtracted?.manifest) {
+                                            const libs = {};
+                                            for (const lib of (freshExtracted.libs || [])) {
+                                                if (lib.filename && lib.code)
+                                                    libs[lib.filename] = lib.code;
+                                            }
+                                            const newName = freshExtracted.manifest.match(/name:\s*"?([^\s"]+)"?/)?.[1];
+                                            const oldName = comp.registeredAs;
+                                            if (oldName && oldName !== newName) {
+                                                await internalFetch(config, `/v1/cortex/${encodeURIComponent(oldName)}/deactivate`, jwt, { method: 'POST' }).catch(() => { });
+                                                await internalFetch(config, `/v1/cortex/${encodeURIComponent(oldName)}`, jwt, { method: 'DELETE' }).catch(() => { });
+                                            }
+                                            if (newName) {
+                                                await internalFetch(config, `/v1/cortex/${encodeURIComponent(newName)}/deactivate`, jwt, { method: 'POST' }).catch(() => { });
+                                                await internalFetch(config, `/v1/cortex/${encodeURIComponent(newName)}`, jwt, { method: 'DELETE' }).catch(() => { });
+                                            }
+                                            await internalFetch(config, '/v1/cortex', jwt, {
+                                                method: 'POST', body: { manifest: freshExtracted.manifest, ...(Object.keys(libs).length > 0 ? { libs } : {}) },
+                                            });
+                                            if (newName) {
+                                                await internalFetch(config, `/v1/cortex/${encodeURIComponent(newName)}/activate`, jwt, { method: 'POST' });
+                                                if (newName !== oldName) {
+                                                    comp = { ...comp, registeredAs: newName };
+                                                    await saveComp(comp);
+                                                    alog.info(`[${cid}] Cortex name changed: ${oldName} → ${newName}`);
+                                                }
+                                            }
+                                        }
+                                    }
+                                    alog.info(`[${cid}] Fresh generation registered — re-testing`);
+                                    const reTestResp = await internalFetch(config, `/v1/generator/${projectId}/test/${cid}`, jwt, {
+                                        method: 'POST', body: { testCode, environment: testEnvironment },
+                                    });
+                                    testResult = reTestResp.data?.result;
+                                    if (testResult) {
+                                        const freshTestForStorage = { ...testResult };
+                                        delete freshTestForStorage.trace;
+                                        comp = { ...comp, testResult: freshTestForStorage };
+                                        await saveComp(comp);
+                                        alog.info(`[${cid}] Fresh generation test: ${testResult.status}`);
+                                    }
+                                }
+                                else {
+                                    alog.warn(`[${cid}] Fresh generation validation failed: ${freshVr.errors[0]}`);
+                                }
+                            }
+                            catch (e) {
+                                alog.warn(`[${cid}] Fresh generation failed: ${e.message}`);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        alog.error(`[${cid}] Test execution failed: ${e.message}`);
+                    }
+                    // Check final test status
+                    const finalTestResult = comp.testResult;
+                    if (finalTestResult && finalTestResult.status === 'failed') {
+                        testPassed = false;
+                    }
+                }
+                if (!testPassed) {
+                    const testErrors = comp.testResult?.errors || [];
+                    alog.error(`[${cid}] Test failed after all fix rounds — STOPPING pipeline: ${testErrors[0] || 'test failed'}`);
+                    entry.status.progress.failed++;
+                    entry.status.componentResults.push({ id: cid, label: compLabel, status: 'test_failed', error: testErrors[0] || 'Test failed after all fix rounds' });
+                    break;
+                }
+                entry.status.progress.completed++;
+                entry.status.componentResults.push({ id: cid, label: compLabel, status: 'completed' });
+                emitChange('memory');
+            }
+            catch (componentErr) {
+                alog.error(`[${cid}] Uncaught error processing ${compLabel} — STOPPING pipeline: ${componentErr.message}`);
+                entry.status.progress.failed++;
+                entry.status.componentResults.push({ id: cid, label: compLabel, status: 'error', error: componentErr.message });
+                break; // STOP — don't continue with broken state
+            }
+        }
+        updateStatus({
+            status: entry.cancelFlag ? 'cancelled' : (entry.status.progress.failed > 0 ? 'failed' : 'completed'),
+            currentComponent: null,
+        });
+        // Final summary with per-component status
+        alog.info(`\n${'═'.repeat(60)}`);
+        alog.info(`AUTOPILOT ${entry.status.progress.failed > 0 ? 'FAILED' : 'COMPLETED'}: ${entry.status.progress.completed} completed, ${entry.status.progress.failed} failed, ${entry.status.progress.skipped} skipped`);
+        for (const cr of entry.status.componentResults) {
+            const icon = cr.status === 'completed' || cr.status === 'already_registered' ? '✅' : cr.status === 'phase_gated' ? '⏸️' : '❌';
+            alog.info(`  ${icon} ${cr.label} — ${cr.status}${cr.error ? ': ' + cr.error : ''}`);
+        }
+        alog.info(`${'═'.repeat(60)}\n`);
+    }
+    catch (fatalErr) {
+        alog.error(`Autopilot fatal error: ${fatalErr.message}`);
+        updateStatus({ status: 'failed', currentComponent: null });
+    }
+    finally {
+        // Save complete autopilot terminal log to project debug directory
+        alog.flush();
+        // Keep status for 1 hour, then clean up
+        setTimeout(() => runningAutopilots.delete(projectId), 60 * 60 * 1000);
+    }
+}
+// ── Helpers ──
+function extractRegisteredName(type, content, vr) {
+    if (type === 'extension' || type === 'cortex') {
+        const nameMatch = (typeof content === 'string' ? content : '').match(/name:\s*"?([^\s"]+)"?/);
+        return nameMatch?.[1] || null;
+    }
+    if (type === 'csm' || type === 'msm') {
+        const nameMatch = (typeof content === 'string' ? content : '').match(/name:\s*"?([^\s"]+)"?/);
+        return nameMatch?.[1] || null;
+    }
+    if (type === 'memory') {
+        // Memory content is JSON object — return the first key name as the registered name
+        try {
+            const stripped = stripCodeblock(typeof content === 'string' ? content : '');
+            const parsed = JSON.parse(stripped);
+            const keys = Object.keys(parsed);
+            return keys.length > 0 ? `memory:${keys[0]}` : 'memory';
+        }
+        catch {
+            return 'memory';
+        }
+    }
+    if (type === 'translation') {
+        // Translation content is { locale: { key: value } } — return i18n.{locale} matching the stored memory key
+        try {
+            const stripped = stripCodeblock(typeof content === 'string' ? content : '');
+            const parsed = JSON.parse(stripped);
+            const locales = Object.keys(parsed);
+            return locales.length > 0 ? `i18n.${locales[0]}` : 'translation';
+        }
+        catch {
+            return 'translation';
+        }
+    }
+    if (type === 'app') {
+        // App content is HTML with manifest comment: <!-- AIMEAT App Manifest\nname: kebab-case-name -->
+        const nameMatch = (typeof content === 'string' ? content : '').match(/name:\s*([^\n\r]+)/);
+        return nameMatch?.[1]?.trim() || 'app';
+    }
+    return null;
+}
+function buildProbeScenarios(blueprint, comp, content) {
+    // Prefer SPEC actions — they have correct IDs and example inputs matching the actual API.
+    // Blueprint scenarios have abstract inputs (e.g. {query, type}) that don't match the extension.
+    const spec = comp.spec;
+    if (spec) {
+        const specActions = (spec.actions || []);
+        if (specActions.length > 0) {
+            return specActions
+                .filter(a => a.id && a.example)
+                .map(a => ({
+                action: a.id,
+                input: a.example?.input || {},
+            }));
+        }
+    }
+    // Fallback: extract action names from YAML content
+    const actionMatches = [...content.matchAll(/- id:\s*"?([^\s"]+)/g)];
+    return actionMatches.map(m => ({ action: m[1], input: {} }));
+}
+//# sourceMappingURL=generator-autopilot.js.map