@zigrivers/scaffold 3.8.0 → 3.9.0

package/dist/e2e/project-type-overlays.test.js

@@ -2,8 +2,8 @@
  * E2E integration tests for project-type overlay flow:
  *   init → config.yml → overlay resolution → knowledge injection
  *
- * Tests the full pipeline for web-app, backend, cli, library, and mobile-app
- * project types:
+ * Tests the full pipeline for web-app, backend, cli, library, mobile-app,
+ * data-pipeline, ml, and browser-extension project types:
  * 1. Init creates config with project-type-specific config block
  * 2. Config validates through ConfigSchema
  * 3. Overlay loads and resolves against real pipeline meta-prompts
@@ -745,48 +745,449 @@ describe('mobile-app overlay integration', () => {
     });
 });
 // ---------------------------------------------------------------------------
+// Tests — Data-pipeline
+// ---------------------------------------------------------------------------
+describe('data-pipeline overlay integration', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = makeTempDir();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    // Test 1: Config with data-pipeline + dataPipelineConfig validates through ConfigSchema
+    it('data-pipeline config with dataPipelineConfig validates through ConfigSchema', () => {
+        const result = ConfigSchema.safeParse({
+            version: 2,
+            methodology: 'deep',
+            platforms: ['claude-code'],
+            project: {
+                projectType: 'data-pipeline',
+                dataPipelineConfig: { processingModel: 'streaming' },
+            },
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            const project = result.data.project;
+            expect(project['projectType']).toBe('data-pipeline');
+            const dpc = project['dataPipelineConfig'];
+            expect(dpc['processingModel']).toBe('streaming');
+            expect(dpc['orchestration']).toBe('none'); // default
+            expect(dpc['dataQualityStrategy']).toBe('validation'); // default
+            expect(dpc['schemaManagement']).toBe('none'); // default
+            expect(dpc['hasDataCatalog']).toBe(false); // default
+        }
+    });
+    // Test 2: Init with projectType data-pipeline creates config with dataPipelineConfig
+    it('init with projectType data-pipeline creates config.yml with dataPipelineConfig defaults', async () => {
+        const output = createMockOutput();
+        const result = await runWizard({
+            projectRoot: tmpDir,
+            projectType: 'data-pipeline',
+            pipelineProcessing: 'batch',
+            methodology: 'deep',
+            force: false,
+            auto: true,
+            output,
+        });
+        expect(result.success).toBe(true);
+        const { config } = loadConfig(tmpDir, []);
+        expect(config).not.toBeNull();
+        expect(config.project?.projectType).toBe('data-pipeline');
+        expect(config.project?.dataPipelineConfig).toBeDefined();
+        expect(config.project?.dataPipelineConfig?.processingModel).toBe('batch');
+    });
+    // Test 3: config.yml round-trips through YAML correctly
+    it('config.yml round-trips projectType and dataPipelineConfig through YAML', async () => {
+        const output = createMockOutput();
+        await runWizard({
+            projectRoot: tmpDir,
+            projectType: 'data-pipeline',
+            pipelineProcessing: 'streaming',
+            methodology: 'deep',
+            force: false,
+            auto: true,
+            output,
+        });
+        const configPath = path.join(tmpDir, '.scaffold', 'config.yml');
+        const raw = yaml.load(fs.readFileSync(configPath, 'utf8'));
+        const project = raw['project'];
+        expect(project['projectType']).toBe('data-pipeline');
+        expect(project['dataPipelineConfig']).toBeDefined();
+        const dpc = project['dataPipelineConfig'];
+        expect(dpc['processingModel']).toBe('streaming');
+    });
+    // Test 4: Overlay loads successfully from content/methodology
+    it('data-pipeline overlay loads without errors', () => {
+        const methodologyDir = getPackageMethodologyDir();
+        const overlayPath = path.join(methodologyDir, 'data-pipeline-overlay.yml');
+        const { overlay, errors } = loadOverlay(overlayPath);
+        expect(errors).toHaveLength(0);
+        expect(overlay).not.toBeNull();
+        expect(overlay.projectType).toBe('data-pipeline');
+        expect(Object.keys(overlay.knowledgeOverrides).length).toBeGreaterThan(0);
+    });
+    // Test 5: Overlay injects data-pipeline knowledge into architecture step
+    it('overlay injects data-pipeline knowledge into system-architecture step', async () => {
+        const { overlayState } = await resolveProjectOverlay('data-pipeline');
+        expect(overlayState.knowledge['system-architecture']).toBeDefined();
+        expect(overlayState.knowledge['system-architecture']).toContain('data-pipeline-architecture');
+        expect(overlayState.knowledge['system-architecture']).toContain('data-pipeline-batch-patterns');
+        expect(overlayState.knowledge['system-architecture']).toContain('data-pipeline-streaming-patterns');
+    });
+    // Test 6: Overlay injects knowledge into tech-stack step
+    it('overlay injects data-pipeline knowledge into tech-stack step', async () => {
+        const { overlayState } = await resolveProjectOverlay('data-pipeline');
+        expect(overlayState.knowledge['tech-stack']).toBeDefined();
+        expect(overlayState.knowledge['tech-stack']).toContain('data-pipeline-architecture');
+    });
+    // Test 7: Overlay injects knowledge into testing steps
+    it('overlay injects data-pipeline knowledge into TDD, e2e, and create-evals steps', async () => {
+        const { overlayState } = await resolveProjectOverlay('data-pipeline');
+        expect(overlayState.knowledge['tdd']).toBeDefined();
+        expect(overlayState.knowledge['tdd']).toContain('data-pipeline-testing');
+        expect(overlayState.knowledge['tdd']).toContain('data-pipeline-quality');
+        expect(overlayState.knowledge['add-e2e-testing']).toBeDefined();
+        expect(overlayState.knowledge['add-e2e-testing']).toContain('data-pipeline-testing');
+        expect(overlayState.knowledge['create-evals']).toBeDefined();
+        expect(overlayState.knowledge['create-evals']).toContain('data-pipeline-testing');
+        expect(overlayState.knowledge['create-evals']).toContain('data-pipeline-quality');
+    });
+    // Test 8: Overlay injects knowledge into foundational steps
+    it('overlay injects data-pipeline knowledge into foundational steps', async () => {
+        const { overlayState } = await resolveProjectOverlay('data-pipeline');
+        expect(overlayState.knowledge['create-prd']).toContain('data-pipeline-requirements');
+        expect(overlayState.knowledge['coding-standards']).toContain('data-pipeline-conventions');
+        expect(overlayState.knowledge['project-structure']).toContain('data-pipeline-project-structure');
+    });
+    // Test 9: Overlay injects knowledge into domain-modeling, security, and operations steps
+    it('overlay injects data-pipeline knowledge into domain-modeling, security, and operations', async () => {
+        const { overlayState } = await resolveProjectOverlay('data-pipeline');
+        expect(overlayState.knowledge['domain-modeling']).toBeDefined();
+        expect(overlayState.knowledge['domain-modeling']).toContain('data-pipeline-schema-management');
+        expect(overlayState.knowledge['security']).toBeDefined();
+        expect(overlayState.knowledge['security']).toContain('data-pipeline-security');
+        expect(overlayState.knowledge['operations']).toBeDefined();
+        expect(overlayState.knowledge['operations']).toContain('data-pipeline-orchestration');
+    });
+    // Test 10: MVP methodology with data-pipeline overlay works
+    it('MVP methodology with data-pipeline overlay injects knowledge', async () => {
+        const { overlayState } = await resolveProjectOverlay('data-pipeline', 'mvp');
+        expect(overlayState.knowledge['system-architecture']).toContain('data-pipeline-architecture');
+        expect(overlayState.knowledge['tdd']).toContain('data-pipeline-testing');
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — ML
+// ---------------------------------------------------------------------------
+describe('ml overlay integration', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = makeTempDir();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    // Test 1: Config with ml + mlConfig validates through ConfigSchema
+    it('ml config with mlConfig validates through ConfigSchema', () => {
+        const result = ConfigSchema.safeParse({
+            version: 2,
+            methodology: 'deep',
+            platforms: ['claude-code'],
+            project: {
+                projectType: 'ml',
+                mlConfig: { projectPhase: 'training' },
+            },
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            const project = result.data.project;
+            expect(project['projectType']).toBe('ml');
+            const mc = project['mlConfig'];
+            expect(mc['projectPhase']).toBe('training');
+            expect(mc['modelType']).toBe('deep-learning'); // default
+            expect(mc['servingPattern']).toBe('none'); // default
+            expect(mc['hasExperimentTracking']).toBe(true); // default
+        }
+    });
+    // Test 2: Init with projectType ml creates config with mlConfig
+    it('init with projectType ml creates config.yml with mlConfig defaults', async () => {
+        const output = createMockOutput();
+        const result = await runWizard({
+            projectRoot: tmpDir,
+            projectType: 'ml',
+            mlPhase: 'training',
+            methodology: 'deep',
+            force: false,
+            auto: true,
+            output,
+        });
+        expect(result.success).toBe(true);
+        const { config } = loadConfig(tmpDir, []);
+        expect(config).not.toBeNull();
+        expect(config.project?.projectType).toBe('ml');
+        expect(config.project?.mlConfig).toBeDefined();
+        expect(config.project?.mlConfig?.projectPhase).toBe('training');
+    });
+    // Test 3: config.yml round-trips through YAML correctly
+    it('config.yml round-trips projectType and mlConfig through YAML', async () => {
+        const output = createMockOutput();
+        await runWizard({
+            projectRoot: tmpDir,
+            projectType: 'ml',
+            mlPhase: 'inference',
+            mlServing: 'realtime',
+            methodology: 'deep',
+            force: false,
+            auto: true,
+            output,
+        });
+        const configPath = path.join(tmpDir, '.scaffold', 'config.yml');
+        const raw = yaml.load(fs.readFileSync(configPath, 'utf8'));
+        const project = raw['project'];
+        expect(project['projectType']).toBe('ml');
+        expect(project['mlConfig']).toBeDefined();
+        const mc = project['mlConfig'];
+        expect(mc['projectPhase']).toBe('inference');
+        expect(mc['servingPattern']).toBe('realtime');
+    });
+    // Test 4: Overlay loads successfully from content/methodology
+    it('ml overlay loads without errors', () => {
+        const methodologyDir = getPackageMethodologyDir();
+        const overlayPath = path.join(methodologyDir, 'ml-overlay.yml');
+        const { overlay, errors } = loadOverlay(overlayPath);
+        expect(errors).toHaveLength(0);
+        expect(overlay).not.toBeNull();
+        expect(overlay.projectType).toBe('ml');
+        expect(Object.keys(overlay.knowledgeOverrides).length).toBeGreaterThan(0);
+    });
+    // Test 5: Overlay injects ml knowledge into architecture step
+    it('overlay injects ml knowledge into system-architecture step', async () => {
+        const { overlayState } = await resolveProjectOverlay('ml');
+        expect(overlayState.knowledge['system-architecture']).toBeDefined();
+        expect(overlayState.knowledge['system-architecture']).toContain('ml-architecture');
+        expect(overlayState.knowledge['system-architecture']).toContain('ml-training-patterns');
+        expect(overlayState.knowledge['system-architecture']).toContain('ml-serving-patterns');
+    });
+    // Test 6: Overlay injects knowledge into tech-stack step
+    it('overlay injects ml knowledge into tech-stack step', async () => {
+        const { overlayState } = await resolveProjectOverlay('ml');
+        expect(overlayState.knowledge['tech-stack']).toBeDefined();
+        expect(overlayState.knowledge['tech-stack']).toContain('ml-architecture');
+    });
+    // Test 7: Overlay injects knowledge into testing steps
+    it('overlay injects ml knowledge into TDD, e2e, and create-evals steps', async () => {
+        const { overlayState } = await resolveProjectOverlay('ml');
+        expect(overlayState.knowledge['tdd']).toBeDefined();
+        expect(overlayState.knowledge['tdd']).toContain('ml-testing');
+        expect(overlayState.knowledge['add-e2e-testing']).toBeDefined();
+        expect(overlayState.knowledge['add-e2e-testing']).toContain('ml-testing');
+        // model-evaluation routes to create-evals
+        expect(overlayState.knowledge['create-evals']).toBeDefined();
+        expect(overlayState.knowledge['create-evals']).toContain('ml-testing');
+        expect(overlayState.knowledge['create-evals']).toContain('ml-model-evaluation');
+    });
+    // Test 8: Overlay injects knowledge into foundational steps
+    it('overlay injects ml knowledge into foundational steps', async () => {
+        const { overlayState } = await resolveProjectOverlay('ml');
+        expect(overlayState.knowledge['create-prd']).toContain('ml-requirements');
+        expect(overlayState.knowledge['coding-standards']).toContain('ml-conventions');
+        expect(overlayState.knowledge['project-structure']).toContain('ml-project-structure');
+    });
+    // Test 9: Overlay injects knowledge into security and operations (experiment tracking + observability)
+    it('overlay injects ml knowledge into security and operations steps', async () => {
+        const { overlayState } = await resolveProjectOverlay('ml');
+        expect(overlayState.knowledge['security']).toBeDefined();
+        expect(overlayState.knowledge['security']).toContain('ml-security');
+        expect(overlayState.knowledge['operations']).toBeDefined();
+        expect(overlayState.knowledge['operations']).toContain('ml-experiment-tracking');
+        expect(overlayState.knowledge['operations']).toContain('ml-observability');
+    });
+    // Test 10: MVP methodology with ml overlay works
+    it('MVP methodology with ml overlay injects knowledge', async () => {
+        const { overlayState } = await resolveProjectOverlay('ml', 'mvp');
+        expect(overlayState.knowledge['system-architecture']).toContain('ml-architecture');
+        expect(overlayState.knowledge['create-evals']).toContain('ml-model-evaluation');
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — Browser-extension
+// ---------------------------------------------------------------------------
+describe('browser-extension overlay integration', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = makeTempDir();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        vi.restoreAllMocks();
+    });
+    // Test 1: Config with browser-extension + browserExtensionConfig validates through ConfigSchema
+    it('browser-extension config with browserExtensionConfig validates through ConfigSchema', () => {
+        const result = ConfigSchema.safeParse({
+            version: 2,
+            methodology: 'deep',
+            platforms: ['claude-code'],
+            project: {
+                projectType: 'browser-extension',
+                browserExtensionConfig: { manifestVersion: '3' },
+            },
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            const project = result.data.project;
+            expect(project['projectType']).toBe('browser-extension');
+            const bec = project['browserExtensionConfig'];
+            expect(bec['manifestVersion']).toBe('3');
+            expect(bec['uiSurfaces']).toEqual(['popup']); // default
+            expect(bec['hasContentScript']).toBe(false); // default
+            expect(bec['hasBackgroundWorker']).toBe(true); // default
+        }
+    });
+    // Test 2: Init with projectType browser-extension creates config (no required flag in auto mode)
+    it('init with projectType browser-extension creates config.yml with browserExtensionConfig defaults', async () => {
+        const output = createMockOutput();
+        const result = await runWizard({
+            projectRoot: tmpDir,
+            projectType: 'browser-extension',
+            methodology: 'deep',
+            force: false,
+            auto: true,
+            output,
+        });
+        expect(result.success).toBe(true);
+        const { config } = loadConfig(tmpDir, []);
+        expect(config).not.toBeNull();
+        expect(config.project?.projectType).toBe('browser-extension');
+        expect(config.project?.browserExtensionConfig).toBeDefined();
+        expect(config.project?.browserExtensionConfig?.manifestVersion).toBe('3');
+        expect(config.project?.browserExtensionConfig?.hasBackgroundWorker).toBe(true);
+    });
+    // Test 3: config.yml round-trips through YAML correctly
+    it('config.yml round-trips projectType and browserExtensionConfig through YAML', async () => {
+        const output = createMockOutput();
+        await runWizard({
+            projectRoot: tmpDir,
+            projectType: 'browser-extension',
+            extManifest: '3',
+            extUiSurfaces: ['popup', 'sidepanel'],
+            extContentScript: true,
+            methodology: 'deep',
+            force: false,
+            auto: true,
+            output,
+        });
+        const configPath = path.join(tmpDir, '.scaffold', 'config.yml');
+        const raw = yaml.load(fs.readFileSync(configPath, 'utf8'));
+        const project = raw['project'];
+        expect(project['projectType']).toBe('browser-extension');
+        expect(project['browserExtensionConfig']).toBeDefined();
+        const bec = project['browserExtensionConfig'];
+        expect(bec['manifestVersion']).toBe('3');
+        expect(bec['uiSurfaces']).toEqual(['popup', 'sidepanel']);
+        expect(bec['hasContentScript']).toBe(true);
+    });
+    // Test 4: Overlay loads successfully from content/methodology
+    it('browser-extension overlay loads without errors', () => {
+        const methodologyDir = getPackageMethodologyDir();
+        const overlayPath = path.join(methodologyDir, 'browser-extension-overlay.yml');
+        const { overlay, errors } = loadOverlay(overlayPath);
+        expect(errors).toHaveLength(0);
+        expect(overlay).not.toBeNull();
+        expect(overlay.projectType).toBe('browser-extension');
+        expect(Object.keys(overlay.knowledgeOverrides).length).toBeGreaterThan(0);
+    });
+    // Test 5: Overlay injects browser-extension knowledge into architecture step
+    it('overlay injects browser-extension knowledge into system-architecture step', async () => {
+        const { overlayState } = await resolveProjectOverlay('browser-extension');
+        expect(overlayState.knowledge['system-architecture']).toBeDefined();
+        expect(overlayState.knowledge['system-architecture']).toContain('browser-extension-architecture');
+        expect(overlayState.knowledge['system-architecture']).toContain('browser-extension-service-workers');
+    });
+    // Test 6: Overlay injects knowledge into tech-stack step
+    it('overlay injects browser-extension knowledge into tech-stack step', async () => {
+        const { overlayState } = await resolveProjectOverlay('browser-extension');
+        expect(overlayState.knowledge['tech-stack']).toBeDefined();
+        expect(overlayState.knowledge['tech-stack']).toContain('browser-extension-architecture');
+        expect(overlayState.knowledge['tech-stack']).toContain('browser-extension-manifest');
+    });
+    // Test 7: Overlay injects knowledge into testing steps
+    it('overlay injects browser-extension knowledge into TDD and e2e steps (cross-browser)', async () => {
+        const { overlayState } = await resolveProjectOverlay('browser-extension');
+        expect(overlayState.knowledge['tdd']).toBeDefined();
+        expect(overlayState.knowledge['tdd']).toContain('browser-extension-testing');
+        expect(overlayState.knowledge['tdd']).toContain('browser-extension-cross-browser');
+        expect(overlayState.knowledge['add-e2e-testing']).toBeDefined();
+        expect(overlayState.knowledge['add-e2e-testing']).toContain('browser-extension-testing');
+        expect(overlayState.knowledge['add-e2e-testing']).toContain('browser-extension-cross-browser');
+    });
+    // Test 8: Overlay injects knowledge into foundational steps (manifest in coding-standards)
+    it('overlay injects browser-extension knowledge into foundational steps', async () => {
+        const { overlayState } = await resolveProjectOverlay('browser-extension');
+        expect(overlayState.knowledge['create-prd']).toContain('browser-extension-requirements');
+        expect(overlayState.knowledge['coding-standards']).toContain('browser-extension-conventions');
+        expect(overlayState.knowledge['coding-standards']).toContain('browser-extension-manifest');
+        expect(overlayState.knowledge['project-structure']).toContain('browser-extension-project-structure');
+    });
+    // Test 9: Overlay injects knowledge into security, ux-spec, and operations steps
+    it('overlay injects browser-extension knowledge into security, ux-spec, and operations', async () => {
+        const { overlayState } = await resolveProjectOverlay('browser-extension');
+        expect(overlayState.knowledge['security']).toBeDefined();
+        expect(overlayState.knowledge['security']).toContain('browser-extension-security');
+        expect(overlayState.knowledge['security']).toContain('browser-extension-content-scripts');
+        expect(overlayState.knowledge['ux-spec']).toBeDefined();
+        expect(overlayState.knowledge['ux-spec']).toContain('browser-extension-architecture');
+        expect(overlayState.knowledge['operations']).toBeDefined();
+        expect(overlayState.knowledge['operations']).toContain('browser-extension-store-submission');
+    });
+    // Test 10: MVP methodology with browser-extension overlay works
+    it('MVP methodology with browser-extension overlay injects knowledge', async () => {
+        const { overlayState } = await resolveProjectOverlay('browser-extension', 'mvp');
+        expect(overlayState.knowledge['system-architecture']).toContain('browser-extension-architecture');
+        expect(overlayState.knowledge['tdd']).toContain('browser-extension-cross-browser');
+    });
+});
+// ---------------------------------------------------------------------------
 // Cross-type validation tests
 // ---------------------------------------------------------------------------
 describe('project-type overlay cross-validation', () => {
     it('each overlay type injects distinct knowledge entries (no accidental overlap)', async () => {
-        const [webResult, backendResult, cliResult, libraryResult, mobileResult] = await Promise.all([
+        const [webResult, backendResult, cliResult, libraryResult, mobileResult, pipelineResult, mlResult, extResult,] = await Promise.all([
             resolveProjectOverlay('web-app'),
             resolveProjectOverlay('backend'),
             resolveProjectOverlay('cli'),
             resolveProjectOverlay('library'),
             resolveProjectOverlay('mobile-app'),
+            resolveProjectOverlay('data-pipeline'),
+            resolveProjectOverlay('ml'),
+            resolveProjectOverlay('browser-extension'),
         ]);
         // system-architecture should have type-specific entries for each
-        const webArch = webResult.overlayState.knowledge['system-architecture'] ?? [];
-        const backendArch = backendResult.overlayState.knowledge['system-architecture'] ?? [];
-        const cliArch = cliResult.overlayState.knowledge['system-architecture'] ?? [];
-        const libraryArch = libraryResult.overlayState.knowledge['system-architecture'] ?? [];
-        const mobileArch = mobileResult.overlayState.knowledge['system-architecture'] ?? [];
-        expect(webArch).toContain('web-app-architecture');
-        expect(webArch).not.toContain('backend-architecture');
-        expect(webArch).not.toContain('cli-architecture');
-        expect(webArch).not.toContain('library-architecture');
-        expect(webArch).not.toContain('mobile-app-architecture');
-        expect(backendArch).toContain('backend-architecture');
-        expect(backendArch).not.toContain('web-app-architecture');
-        expect(backendArch).not.toContain('cli-architecture');
-        expect(backendArch).not.toContain('library-architecture');
-        expect(backendArch).not.toContain('mobile-app-architecture');
-        expect(cliArch).toContain('cli-architecture');
-        expect(cliArch).not.toContain('web-app-architecture');
-        expect(cliArch).not.toContain('backend-architecture');
-        expect(cliArch).not.toContain('library-architecture');
-        expect(cliArch).not.toContain('mobile-app-architecture');
-        expect(libraryArch).toContain('library-architecture');
-        expect(libraryArch).not.toContain('web-app-architecture');
-        expect(libraryArch).not.toContain('backend-architecture');
-        expect(libraryArch).not.toContain('cli-architecture');
-        expect(libraryArch).not.toContain('mobile-app-architecture');
-        expect(mobileArch).toContain('mobile-app-architecture');
-        expect(mobileArch).not.toContain('web-app-architecture');
-        expect(mobileArch).not.toContain('backend-architecture');
-        expect(mobileArch).not.toContain('cli-architecture');
-        expect(mobileArch).not.toContain('library-architecture');
+        const allArch = {
+            'web-app': webResult.overlayState.knowledge['system-architecture'] ?? [],
+            'backend': backendResult.overlayState.knowledge['system-architecture'] ?? [],
+            'cli': cliResult.overlayState.knowledge['system-architecture'] ?? [],
+            'library': libraryResult.overlayState.knowledge['system-architecture'] ?? [],
+            'mobile-app': mobileResult.overlayState.knowledge['system-architecture'] ?? [],
+            'data-pipeline': pipelineResult.overlayState.knowledge['system-architecture'] ?? [],
+            'ml': mlResult.overlayState.knowledge['system-architecture'] ?? [],
+            'browser-extension': extResult.overlayState.knowledge['system-architecture'] ?? [],
+        };
+        // Each project type's architecture step contains its own -architecture entry
+        // and none of the other 7 type-specific architecture entries.
+        const allTypes = Object.keys(allArch);
+        for (const type of allTypes) {
+            const ownEntry = `${type}-architecture`;
+            expect(allArch[type], `${type} should contain ${ownEntry}`).toContain(ownEntry);
+            for (const otherType of allTypes) {
+                if (otherType === type)
+                    continue;
+                const otherEntry = `${otherType}-architecture`;
+                expect(allArch[type], `${type} system-architecture must not leak ${otherEntry}`).not.toContain(otherEntry);
+            }
+        }
     });
     it('config schema rejects cross-typed config blocks', () => {
         // gameConfig on web-app
@@ -829,6 +1230,71 @@ describe('project-type overlay cross-validation', () => {
             version: 2, methodology: 'deep', platforms: ['claude-code'],
             project: { projectType: 'library', mobileAppConfig: { platform: 'android' } },
         }).success).toBe(false);
+        // dataPipelineConfig on backend
+        expect(ConfigSchema.safeParse({
+            version: 2, methodology: 'deep', platforms: ['claude-code'],
+            project: { projectType: 'backend', dataPipelineConfig: { processingModel: 'streaming' } },
+        }).success).toBe(false);
+        // mlConfig on data-pipeline
+        expect(ConfigSchema.safeParse({
+            version: 2, methodology: 'deep', platforms: ['claude-code'],
+            project: { projectType: 'data-pipeline', mlConfig: { projectPhase: 'training' } },
+        }).success).toBe(false);
+        // browserExtensionConfig on web-app
+        expect(ConfigSchema.safeParse({
+            version: 2, methodology: 'deep', platforms: ['claude-code'],
+            project: { projectType: 'web-app', browserExtensionConfig: { manifestVersion: '3' } },
+        }).success).toBe(false);
+        // dataPipelineConfig on ml
+        expect(ConfigSchema.safeParse({
+            version: 2, methodology: 'deep', platforms: ['claude-code'],
+            project: { projectType: 'ml', dataPipelineConfig: { processingModel: 'batch' } },
+        }).success).toBe(false);
+    });
+    it('ml inference projects must specify a serving pattern', () => {
+        // inference + none → invalid
+        expect(ConfigSchema.safeParse({
+            version: 2, methodology: 'deep', platforms: ['claude-code'],
+            project: { projectType: 'ml', mlConfig: { projectPhase: 'inference', servingPattern: 'none' } },
+        }).success).toBe(false);
+        // inference + realtime → valid
+        expect(ConfigSchema.safeParse({
+            version: 2, methodology: 'deep', platforms: ['claude-code'],
+            project: { projectType: 'ml', mlConfig: { projectPhase: 'inference', servingPattern: 'realtime' } },
+        }).success).toBe(true);
+        // training + serving pattern → invalid
+        expect(ConfigSchema.safeParse({
+            version: 2, methodology: 'deep', platforms: ['claude-code'],
+            project: { projectType: 'ml', mlConfig: { projectPhase: 'training', servingPattern: 'realtime' } },
+        }).success).toBe(false);
+    });
+    it('browser-extension must have at least one capability', () => {
+        // No surfaces, no content script, no background worker → invalid
+        expect(ConfigSchema.safeParse({
+            version: 2, methodology: 'deep', platforms: ['claude-code'],
+            project: {
+                projectType: 'browser-extension',
+                browserExtensionConfig: {
+                    manifestVersion: '3',
+                    uiSurfaces: [],
+                    hasContentScript: false,
+                    hasBackgroundWorker: false,
+                },
+            },
+        }).success).toBe(false);
+        // Just a content script → valid
+        expect(ConfigSchema.safeParse({
+            version: 2, methodology: 'deep', platforms: ['claude-code'],
+            project: {
+                projectType: 'browser-extension',
+                browserExtensionConfig: {
+                    manifestVersion: '3',
+                    uiSurfaces: [],
+                    hasContentScript: true,
+                    hasBackgroundWorker: false,
+                },
+            },
+        }).success).toBe(true);
     });
 });
 //# sourceMappingURL=project-type-overlays.test.js.map