@mettlecast/domain-cli 0.2.60 → 0.2.62

package/src/__tests__/commands/regenerate-modules-hashes.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, writeFile, mkdir } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { rmSync } from 'node:fs';
+import { runRegenerateModulesHashes } from '../../commands/regenerate-modules-hashes.js';
+
+describe('regenerate-modules-hashes', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'tib-regenerate-modules-hashes-'));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('writes modules-hashes.json with correct version and structure', async () => {
+    await mkdir(join(tempDir, 'infra', 'modules'), { recursive: true });
+
+    const content = 'export const MyStack = {};';
+    await writeFile(join(tempDir, 'infra', 'modules', 'test.ts'), content);
+
+    const manifestPath = await runRegenerateModulesHashes({ projectRoot: tempDir });
+
+    expect(manifestPath).toBe(join(tempDir, '.mc', 'modules-hashes.json'));
+
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    expect(manifest.version).toBe('1');
+    expect(typeof manifest.generatedAt).toBe('string');
+    expect(new Date(manifest.generatedAt).toISOString()).toBe(manifest.generatedAt);
+    expect(manifest.files).toEqual({
+      'infra/modules/test.ts': createHash('sha256').update(content).digest('hex'),
+    });
+  });
+
+  it('computes correct SHA-256 hashes for every file', async () => {
+    await mkdir(join(tempDir, 'infra', 'modules'), { recursive: true });
+
+    const files: Record<string, string> = {
+      'infra/modules/a.ts': 'export const a = 1;',
+      'infra/modules/b.ts': 'export const b = 2;\nexport const c = 3;',
+      'infra/modules/nested/c.ts': 'export const c = "hello world";',
+    };
+
+    await mkdir(join(tempDir, 'infra', 'modules', 'nested'), { recursive: true });
+    for (const [rel, content] of Object.entries(files)) {
+      await writeFile(join(tempDir, rel), content);
+    }
+
+    const manifestPath = await runRegenerateModulesHashes({ projectRoot: tempDir });
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+
+    expect(Object.keys(manifest.files).sort()).toEqual(Object.keys(files).sort());
+    for (const [rel, content] of Object.entries(files)) {
+      const expected = createHash('sha256').update(content).digest('hex');
+      expect(manifest.files[rel]).toBe(expected);
+    }
+  });
+
+  it('skips node_modules, dist, cdk.out, package-lock.json, and .npmrc', async () => {
+    const root = tempDir;
+    const modules = join(root, 'infra', 'modules');
+    await mkdir(modules, { recursive: true });
+
+    // Real file we want hashed
+    await writeFile(join(modules, 'real.ts'), 'export const real = true;');
+
+    // Files/dirs that must be excluded
+    await mkdir(join(modules, 'node_modules', 'pkg'), { recursive: true });
+    await writeFile(join(modules, 'node_modules', 'pkg', 'index.js'), 'module.exports = {};');
+
+    await mkdir(join(modules, 'dist'), { recursive: true });
+    await writeFile(join(modules, 'dist', 'bundle.js'), 'var x = 1;');
+
+    await mkdir(join(modules, 'cdk.out'), { recursive: true });
+    await writeFile(join(modules, 'cdk.out', 'template.json'), '{}');
+
+    await writeFile(join(modules, 'package-lock.json'), '{}');
+    await writeFile(join(modules, '.npmrc'), 'registry=https://example.com');
+
+    // Also nested exclude
+    await mkdir(join(modules, 'sub', 'node_modules'), { recursive: true });
+    await writeFile(join(modules, 'sub', 'node_modules', 'dep.js'), '// skip');
+
+    await writeFile(join(modules, 'sub', 'kept.ts'), 'export const kept = 1;');
+
+    const manifestPath = await runRegenerateModulesHashes({ projectRoot: root });
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+
+    expect(manifest.files).toEqual({
+      'infra/modules/real.ts': createHash('sha256').update('export const real = true;').digest('hex'),
+      'infra/modules/sub/kept.ts': createHash('sha256').update('export const kept = 1;').digest('hex'),
+    });
+
+    // None of the excluded entries appear
+    const keys = Object.keys(manifest.files);
+    expect(keys.some((k) => k.includes('node_modules'))).toBe(false);
+    expect(keys.some((k) => k.includes('dist/'))).toBe(false);
+    expect(keys.some((k) => k.includes('cdk.out/'))).toBe(false);
+    expect(keys.some((k) => k.endsWith('package-lock.json'))).toBe(false);
+    expect(keys.some((k) => k.endsWith('.npmrc'))).toBe(false);
+  });
+
+  it('handles empty infra/modules/ directory by emitting empty files map', async () => {
+    await mkdir(join(tempDir, 'infra', 'modules'), { recursive: true });
+
+    const manifestPath = await runRegenerateModulesHashes({ projectRoot: tempDir });
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+
+    expect(manifest.version).toBe('1');
+    expect(typeof manifest.generatedAt).toBe('string');
+    expect(manifest.files).toEqual({});
+  });
+
+  it('handles missing infra/modules/ directory gracefully', async () => {
+    // Do NOT create infra/modules/ — only the project root exists
+    const manifestPath = await runRegenerateModulesHashes({ projectRoot: tempDir });
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+
+    expect(manifestPath).toBe(join(tempDir, '.mc', 'modules-hashes.json'));
+    expect(manifest.version).toBe('1');
+    expect(typeof manifest.generatedAt).toBe('string');
+    expect(manifest.files).toEqual({});
+  });
+
+  it('is idempotent — second run produces identical file map and structure', async () => {
+    await mkdir(join(tempDir, 'infra', 'modules'), { recursive: true });
+
+    await writeFile(join(tempDir, 'infra', 'modules', 'a.ts'), 'export const a = 1;');
+    await mkdir(join(tempDir, 'infra', 'modules', 'sub'), { recursive: true });
+    await writeFile(join(tempDir, 'infra', 'modules', 'sub', 'b.ts'), 'export const b = 2;');
+
+    const firstPath = await runRegenerateModulesHashes({ projectRoot: tempDir });
+    const first = JSON.parse(readFileSync(firstPath, 'utf8'));
+
+    // Wait long enough that a fresh ISO timestamp would differ
+    await new Promise((r) => setTimeout(r, 10));
+
+    const secondPath = await runRegenerateModulesHashes({ projectRoot: tempDir });
+    const second = JSON.parse(readFileSync(secondPath, 'utf8'));
+
+    expect(secondPath).toBe(firstPath);
+    expect(second.version).toBe(first.version);
+    expect(second.files).toEqual(first.files);
+
+    // Timestamps may differ, but the structure (ignoring generatedAt) is identical
+    const { generatedAt: _g1, ...firstRest } = first;
+    const { generatedAt: _g2, ...secondRest } = second;
+    expect(secondRest).toEqual(firstRest);
+  });
+
+  it('includes deeply nested files under infra/modules/', async () => {
+    await mkdir(join(tempDir, 'infra', 'modules', 'flows', 'sub'), { recursive: true });
+
+    const nestedContent = 'export const nested = true;';
+    const nestedPath = join(tempDir, 'infra', 'modules', 'flows', 'sub', 'nested.ts');
+    await writeFile(nestedPath, nestedContent);
+
+    const manifestPath = await runRegenerateModulesHashes({ projectRoot: tempDir });
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+
+    expect(manifest.files['infra/modules/flows/sub/nested.ts']).toBe(
+      createHash('sha256').update(nestedContent).digest('hex'),
+    );
+  });
+});

package/src/__tests__/commands/update-all.test.ts

@@ -0,0 +1,322 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtemp } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { rmSync } from 'node:fs';
+
+vi.mock('../../commands/build.js', () => ({
+  runBuild: vi.fn(),
+}));
+
+vi.mock('../../commands/build-catalog.js', () => ({
+  runBuildCatalog: vi.fn(),
+}));
+
+vi.mock('../../commands/build-flows.js', () => ({
+  runBuildFlows: vi.fn(),
+}));
+
+vi.mock('../../commands/build-ui.js', () => ({
+  runBuildUi: vi.fn(),
+}));
+
+vi.mock('../../commands/regenerate-modules-hashes.js', () => ({
+  runRegenerateModulesHashes: vi.fn(),
+}));
+
+vi.mock('../../commands/doctor.js', () => ({
+  runDoctor: vi.fn(),
+}));
+
+vi.mock('../../utils/scaffold-config.js', () => ({
+  readScaffoldConfig: vi.fn(),
+}));
+
+import { runUpdateAll } from '../../commands/update-all.js';
+import { runBuild } from '../../commands/build.js';
+import { runBuildCatalog } from '../../commands/build-catalog.js';
+import { runBuildFlows } from '../../commands/build-flows.js';
+import { runBuildUi } from '../../commands/build-ui.js';
+import { runRegenerateModulesHashes } from '../../commands/regenerate-modules-hashes.js';
+import { runDoctor } from '../../commands/doctor.js';
+import { readScaffoldConfig } from '../../utils/scaffold-config.js';
+
+const mockRunBuild = vi.mocked(runBuild);
+const mockRunBuildCatalog = vi.mocked(runBuildCatalog);
+const mockRunBuildFlows = vi.mocked(runBuildFlows);
+const mockRunBuildUi = vi.mocked(runBuildUi);
+const mockRunRegenerateModulesHashes = vi.mocked(runRegenerateModulesHashes);
+const mockRunDoctor = vi.mocked(runDoctor);
+const mockReadScaffoldConfig = vi.mocked(readScaffoldConfig);
+
+/** Build a minimal but valid DoctorReport. */
+function makeDoctorReport(pass: boolean) {
+  return {
+    checks: [
+      {
+        name: 'sample-check',
+        status: pass ? 'PASS' : 'FAIL',
+        message: pass ? 'all good' : 'something failed',
+      },
+    ],
+    exitCode: pass ? 0 : 1,
+    pass,
+  };
+}
+
+/** Build a minimal but valid ScaffoldConfig with the given domainIds. */
+function makeScaffoldConfig(domainIds: string[]) {
+  return {
+    scaffoldVersion: '1.0.0',
+    enabledModules: ['core'],
+    projectName: 'test-project',
+    awsRegion: 'eu-north-1',
+    awsAccountId: '123456789012',
+    domainIds,
+    flowIds: [],
+    scaffoldBucket: 'mc-scaffold',
+  };
+}
+
+describe('update-all command', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'tib-update-all-'));
+    vi.clearAllMocks();
+
+    // Default mocks so each test only needs to override what's relevant.
+    mockRunBuild.mockResolvedValue('/tmp/.mc/domain-registry.json');
+    mockRunBuildCatalog.mockResolvedValue({
+      version: 2,
+      generatedAt: new Date().toISOString(),
+      domains: [],
+      actions: [],
+      events: [],
+      subscribers: [],
+      jobs: [],
+      schedules: [],
+      integrations: [],
+    });
+    mockRunBuildFlows.mockResolvedValue('/tmp/.mc/flows-registry.json');
+    mockRunBuildUi.mockResolvedValue(undefined);
+    mockRunRegenerateModulesHashes.mockResolvedValue('/tmp/.mc/modules-hashes.json');
+    mockRunDoctor.mockResolvedValue(makeDoctorReport(true));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('reads scaffold-config from the project root', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig([]));
+
+    await runUpdateAll({ projectRoot: tempDir });
+
+    expect(mockReadScaffoldConfig).toHaveBeenCalledTimes(1);
+    expect(mockReadScaffoldConfig).toHaveBeenCalledWith(tempDir);
+  });
+
+  it('builds all domains from scaffold-config', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(
+      makeScaffoldConfig(['auth', 'data-management', 'orgs']),
+    );
+
+    await runUpdateAll({ projectRoot: tempDir });
+
+    expect(mockRunBuild).toHaveBeenCalledTimes(3);
+    expect(mockRunBuild).toHaveBeenCalledWith({
+      domainRoot: join(tempDir, 'domains', 'auth'),
+    });
+    expect(mockRunBuild).toHaveBeenCalledWith({
+      domainRoot: join(tempDir, 'domains', 'data-management'),
+    });
+    expect(mockRunBuild).toHaveBeenCalledWith({
+      domainRoot: join(tempDir, 'domains', 'orgs'),
+    });
+  });
+
+  it('runs build-catalog after all domains are built', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig(['auth', 'orgs']));
+
+    await runUpdateAll({ projectRoot: tempDir });
+
+    expect(mockRunBuildCatalog).toHaveBeenCalledTimes(1);
+    expect(mockRunBuildCatalog).toHaveBeenCalledWith(join(tempDir, '.mc'));
+
+    // build-catalog must come after every runBuild call.
+    const catalogOrder = mockRunBuildCatalog.mock.invocationCallOrder[0]!;
+    for (const order of mockRunBuild.mock.invocationCallOrder) {
+      expect(order).toBeLessThan(catalogOrder);
+    }
+  });
+
+  it('runs build-flows after build-catalog', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig(['auth']));
+
+    await runUpdateAll({ projectRoot: tempDir });
+
+    expect(mockRunBuildFlows).toHaveBeenCalledTimes(1);
+    expect(mockRunBuildFlows).toHaveBeenCalledWith({ projectRoot: tempDir });
+
+    const flowsOrder = mockRunBuildFlows.mock.invocationCallOrder[0]!;
+    const catalogOrder = mockRunBuildCatalog.mock.invocationCallOrder[0]!;
+    expect(catalogOrder).toBeLessThan(flowsOrder);
+  });
+
+  it('runs build-ui after build-flows', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig(['auth']));
+
+    await runUpdateAll({ projectRoot: tempDir });
+
+    expect(mockRunBuildUi).toHaveBeenCalledTimes(1);
+    expect(mockRunBuildUi).toHaveBeenCalledWith({ projectRoot: tempDir });
+
+    const uiOrder = mockRunBuildUi.mock.invocationCallOrder[0]!;
+    const flowsOrder = mockRunBuildFlows.mock.invocationCallOrder[0]!;
+    expect(flowsOrder).toBeLessThan(uiOrder);
+  });
+
+  it('runs regenerate-modules-hashes after build-ui', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig(['auth']));
+
+    await runUpdateAll({ projectRoot: tempDir });
+
+    expect(mockRunRegenerateModulesHashes).toHaveBeenCalledTimes(1);
+    expect(mockRunRegenerateModulesHashes).toHaveBeenCalledWith({
+      projectRoot: tempDir,
+    });
+
+    const hashesOrder = mockRunRegenerateModulesHashes.mock.invocationCallOrder[0]!;
+    const uiOrder = mockRunBuildUi.mock.invocationCallOrder[0]!;
+    expect(uiOrder).toBeLessThan(hashesOrder);
+  });
+
+  it('runs doctor as the final step and returns success when doctor passes', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig(['auth']));
+    mockRunDoctor.mockResolvedValue(makeDoctorReport(true));
+
+    const result = await runUpdateAll({ projectRoot: tempDir });
+
+    expect(mockRunDoctor).toHaveBeenCalledTimes(1);
+    expect(mockRunDoctor).toHaveBeenCalledWith({ projectRoot: tempDir });
+
+    // doctor must be the last command invoked.
+    const doctorOrder = mockRunDoctor.mock.invocationCallOrder[0]!;
+    for (const call of [
+      mockRunBuild,
+      mockRunBuildCatalog,
+      mockRunBuildFlows,
+      mockRunBuildUi,
+      mockRunRegenerateModulesHashes,
+    ]) {
+      const order = call.mock.invocationCallOrder[0];
+      if (order !== undefined) {
+        expect(order).toBeLessThan(doctorOrder);
+      }
+    }
+
+    expect(result.success).toBe(true);
+  });
+
+  it('returns success: false when doctor fails', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig(['auth']));
+    mockRunDoctor.mockResolvedValue(makeDoctorReport(false));
+
+    const result = await runUpdateAll({ projectRoot: tempDir });
+
+    expect(result.success).toBe(false);
+  });
+
+  it('continues building remaining domains after one domain build fails', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(
+      makeScaffoldConfig(['auth', 'broken', 'orgs']),
+    );
+
+    // The middle domain throws; the others should still be built.
+    mockRunBuild.mockImplementation(async (options: { domainRoot: string }) => {
+      if (options.domainRoot.endsWith('broken')) {
+        throw new Error('synthetic build failure');
+      }
+      return '/tmp/.mc/domain-registry.json';
+    });
+
+    const result = await runUpdateAll({ projectRoot: tempDir });
+
+    // All three domains are attempted even though one throws.
+    expect(mockRunBuild).toHaveBeenCalledTimes(3);
+    expect(mockRunBuild).toHaveBeenCalledWith({
+      domainRoot: join(tempDir, 'domains', 'auth'),
+    });
+    expect(mockRunBuild).toHaveBeenCalledWith({
+      domainRoot: join(tempDir, 'domains', 'broken'),
+    });
+    expect(mockRunBuild).toHaveBeenCalledWith({
+      domainRoot: join(tempDir, 'domains', 'orgs'),
+    });
+
+    // The remaining pipeline still runs to completion.
+    expect(mockRunBuildCatalog).toHaveBeenCalledTimes(1);
+    expect(mockRunBuildFlows).toHaveBeenCalledTimes(1);
+    expect(mockRunBuildUi).toHaveBeenCalledTimes(1);
+    expect(mockRunRegenerateModulesHashes).toHaveBeenCalledTimes(1);
+    expect(mockRunDoctor).toHaveBeenCalledTimes(1);
+    expect(result.success).toBe(true);
+  });
+
+  it('propagates upstream failures (catalog/flows/ui/hashes) instead of swallowing them', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig(['auth']));
+    mockRunBuildCatalog.mockRejectedValue(new Error('catalog boom'));
+
+    await expect(runUpdateAll({ projectRoot: tempDir })).rejects.toThrow(
+      /catalog boom/,
+    );
+    // Pipeline stops before later stages.
+    expect(mockRunBuildFlows).not.toHaveBeenCalled();
+    expect(mockRunBuildUi).not.toHaveBeenCalled();
+    expect(mockRunRegenerateModulesHashes).not.toHaveBeenCalled();
+    expect(mockRunDoctor).not.toHaveBeenCalled();
+  });
+
+  it('handles empty domainIds gracefully', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig([]));
+
+    const result = await runUpdateAll({ projectRoot: tempDir });
+
+    // No per-domain builds run.
+    expect(mockRunBuild).not.toHaveBeenCalled();
+
+    // Downstream pipeline still completes.
+    expect(mockRunBuildCatalog).toHaveBeenCalledTimes(1);
+    expect(mockRunBuildFlows).toHaveBeenCalledTimes(1);
+    expect(mockRunBuildUi).toHaveBeenCalledTimes(1);
+    expect(mockRunRegenerateModulesHashes).toHaveBeenCalledTimes(1);
+    expect(mockRunDoctor).toHaveBeenCalledTimes(1);
+
+    expect(result.success).toBe(true);
+  });
+
+  it('returns a structured summary that includes the domain count and doctor result', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(
+      makeScaffoldConfig(['auth', 'data-management', 'orgs']),
+    );
+    mockRunDoctor.mockResolvedValue(makeDoctorReport(true));
+
+    const result = await runUpdateAll({ projectRoot: tempDir });
+
+    expect(result).toEqual({
+      success: true,
+      summary: 'Updated 3 domains; doctor PASS',
+    });
+  });
+
+  it('reports zero domains in the summary when scaffold-config has none', async () => {
+    mockReadScaffoldConfig.mockResolvedValue(makeScaffoldConfig([]));
+    mockRunDoctor.mockResolvedValue(makeDoctorReport(false));
+
+    const result = await runUpdateAll({ projectRoot: tempDir });
+
+    expect(result.summary).toBe('Updated 0 domains; doctor FAIL');
+    expect(result.success).toBe(false);
+  });
+});

package/src/__tests__/doctor.test.ts

@@ -621,4 +621,77 @@ describe('runDoctor', () => {
       expect(reportPlain.exitCode).toBe(1);
     });
   });
+
+  describe('scaffold-config.json missing and root-level flows', () => {
+    it('reports WARN when scaffold-config.json is missing (friendly skip, not FAIL)', async () => {
+      // Set up minimal project but omit .mc/scaffold-config.json.
+      await mkdir(join(tempDir, '.mc'), { recursive: true });
+      await mkdir(join(tempDir, 'domains'), { recursive: true });
+      await mkdir(join(tempDir, '.husky'), { recursive: true });
+      await writeFile(join(tempDir, '.husky', 'pre-commit'), '#!/bin/sh');
+
+      const report = await runDoctor({ projectRoot: tempDir });
+
+      const check = report.checks.find(c => c.name === 'scaffold-config.json matches on-disk');
+      expect(check).toBeDefined();
+      expect(check?.status).toBe('WARN');
+      expect(check?.status).not.toBe('FAIL');
+      // Doctor exits 0 — WARNs are non-fatal.
+      // (Other checks may FAIL on this minimal scaffold, so we don't assert
+      // exitCode === 0 — we only assert that THIS check is a WARN, not FAIL.)
+    });
+
+    it('reports FAIL when root-level flows/ contains .ts files', async () => {
+      // Create root-level flows/ with a .ts file (and a .json file for
+      // completeness — both should be detected).
+      await mkdir(join(tempDir, '.mc'), { recursive: true });
+      await mkdir(join(tempDir, 'domains'), { recursive: true });
+      await mkdir(join(tempDir, '.husky'), { recursive: true });
+      await writeFile(
+        join(tempDir, '.mc', 'scaffold-config.json'),
+        JSON.stringify({ domainIds: [] })
+      );
+      await writeFile(join(tempDir, '.husky', 'pre-commit'), '#!/bin/sh');
+
+      const flowsDir = join(tempDir, 'flows');
+      await mkdir(flowsDir, { recursive: true });
+      // Minimal but valid TS file. Content is irrelevant — the check just
+      // looks for the file extension.
+      await writeFile(
+        join(flowsDir, 'legacy-flow.ts'),
+        'export const legacy = {};\n'
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+
+      const check = report.checks.find(c => c.name === 'No root-level flows (deprecated)');
+      expect(check).toBeDefined();
+      expect(check?.status).toBe('FAIL');
+      expect(check?.message).toMatch(/legacy-flow\.ts/);
+      expect(report.exitCode).toBe(1);
+    });
+
+    it('reports PASS when no root-level flows/ directory exists', async () => {
+      // Default project — no flows/ at the root.
+      await mkdir(join(tempDir, '.mc'), { recursive: true });
+      await mkdir(join(tempDir, 'domains'), { recursive: true });
+      await mkdir(join(tempDir, '.husky'), { recursive: true });
+      await writeFile(
+        join(tempDir, '.mc', 'scaffold-config.json'),
+        JSON.stringify({ domainIds: [] })
+      );
+      await writeFile(join(tempDir, '.husky', 'pre-commit'), '#!/bin/sh');
+
+      // Do NOT create flows/.
+      const flowsDir = join(tempDir, 'flows');
+      const { existsSync } = await import('node:fs');
+      expect(existsSync(flowsDir)).toBe(false);
+
+      const report = await runDoctor({ projectRoot: tempDir });
+
+      const check = report.checks.find(c => c.name === 'No root-level flows (deprecated)');
+      expect(check).toBeDefined();
+      expect(check?.status).toBe('PASS');
+    });
+  });
 });