qa-flowkit 0.4.0-alpha.0

package/.qa-ai/scripts/smoke-npm-pack.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const sourceRoot = process.cwd();
+const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const node = process.execPath;
+const npmExecPath = process.env.npm_execpath || '';
+
+function run(command, args, { cwd, env = {}, expectFailure = false, shell = false } = {}) {
+  const childEnv = {
+    ...process.env,
+    npm_config_update_notifier: 'false',
+    npm_config_fund: 'false',
+    npm_config_audit: 'false'
+  };
+  if (env.npm_config_cache) childEnv.npm_config_cache = env.npm_config_cache;
+
+  const result = spawnSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    shell,
+    env: childEnv
+  });
+  const failed = result.status !== 0;
+  if (expectFailure ? !failed : failed) {
+    throw new Error([
+      `Command ${expectFailure ? 'succeeded unexpectedly' : 'failed'} (${result.status}): ${command} ${args.join(' ')}`,
+      result.error?.message,
+      result.stdout,
+      result.stderr
+    ].filter(Boolean).join('\n'));
+  }
+  return result;
+}
+
+function runNpm(args, options = {}) {
+  if (npmExecPath) return run(node, [npmExecPath, ...args], options);
+  return run(npmCommand, args, {
+    ...options,
+    shell: process.platform === 'win32'
+  });
+}
+
+async function assertExists(filePath, label = filePath) {
+  try {
+    await fs.access(filePath);
+  } catch {
+    throw new Error(`Expected ${label} to exist.`);
+  }
+}
+
+async function assertMissing(filePath, label = filePath) {
+  try {
+    await fs.access(filePath);
+  } catch (error) {
+    if (error.code === 'ENOENT') return;
+    throw error;
+  }
+  throw new Error(`Expected ${label} to be absent.`);
+}
+
+function parsePackOutput(stdout) {
+  const parsed = JSON.parse(stdout);
+  const item = Array.isArray(parsed) ? parsed[0] : parsed;
+  if (!item?.filename || !Array.isArray(item.files)) {
+    throw new Error('Unexpected npm pack --json output.');
+  }
+  return item;
+}
+
+function validatePackFileList(files) {
+  const names = files.map((file) => file.path).sort();
+  const required = [
+    'bin/qa-flowkit.mjs',
+    '.qa-ai/scripts/init.mjs',
+    '.qa-ai/scripts/doctor.mjs',
+    '.qa-ai/adapters/opencode/commands/qa-init.md',
+    'README.md',
+    'README.es.md',
+    'LICENSE',
+    'package.json'
+  ];
+  const forbiddenPrefixes = [
+    '.github/',
+    '.claude/',
+    '.opencode/',
+    '.npm-cache/',
+    'qa-ai-output/',
+    'features/',
+    'tests/'
+  ];
+  const forbiddenExact = [
+    'qa-ai.config.yaml',
+    '.qa-ai/state/init-manifest.json',
+    '.qa-ai/agents/specialists/active.md'
+  ];
+
+  for (const relPath of required) {
+    if (!names.includes(relPath)) throw new Error(`Pack file list is missing required path: ${relPath}`);
+  }
+  for (const relPath of names) {
+    if (forbiddenExact.includes(relPath) || forbiddenPrefixes.some((prefix) => relPath.startsWith(prefix))) {
+      throw new Error(`Pack file list includes forbidden path: ${relPath}`);
+    }
+  }
+}
+
+function cliPath(targetRoot) {
+  return path.join(targetRoot, 'node_modules', 'qa-flowkit', 'bin', 'qa-flowkit.mjs');
+}
+
+function runCli(targetRoot, args, options = {}) {
+  return run(node, [cliPath(targetRoot), ...args], {
+    cwd: targetRoot,
+    env: options.env,
+    expectFailure: options.expectFailure
+  });
+}
+
+async function installPackedCli(targetRoot, tarball, npmCache) {
+  runNpm(['install', '--prefix', targetRoot, '--ignore-scripts', '--package-lock=false', '--no-save', tarball], {
+    cwd: sourceRoot,
+    env: { npm_config_cache: npmCache }
+  });
+}
+
+async function main() {
+  const tempRoot = await fs.mkdtemp(path.join(sourceRoot, '.qa-flowkit-npm-smoke-'));
+  const packDir = path.join(tempRoot, 'pack');
+  const npmCache = path.join(tempRoot, 'npm-cache');
+  let initTarget = null;
+  let updateTarget = null;
+
+  try {
+    await fs.mkdir(packDir, { recursive: true });
+    await fs.mkdir(npmCache, { recursive: true });
+
+    const packResult = runNpm(['pack', '--pack-destination', packDir, '--json'], {
+      cwd: sourceRoot,
+      env: { npm_config_cache: npmCache }
+    });
+    const packInfo = parsePackOutput(packResult.stdout);
+    validatePackFileList(packInfo.files);
+    const tarball = path.join(packDir, packInfo.filename);
+    await assertExists(tarball, 'packed tarball');
+
+    initTarget = path.join(tempRoot, 'init-target');
+    await fs.mkdir(initTarget, { recursive: true });
+    await installPackedCli(initTarget, tarball, npmCache);
+    runCli(initTarget, ['init', '--skip-doctor']);
+    await assertExists(path.join(initTarget, '.qa-ai', 'scripts', 'init.mjs'), '.qa-ai framework');
+    await assertExists(path.join(initTarget, 'qa-ai.config.yaml'), 'generated config');
+    await assertExists(path.join(initTarget, 'features'), 'features directory');
+    await assertExists(path.join(initTarget, 'qa-ai-output'), 'qa-ai-output directory');
+    await assertExists(path.join(initTarget, '.opencode', 'commands', 'qa-init.md'), 'default OpenCode adapter');
+    runCli(initTarget, ['init', '--skip-doctor'], { expectFailure: true });
+    runCli(initTarget, ['doctor']);
+    runCli(initTarget, ['validate-target', '--allow-empty', '--allow-missing', '--no-strict-doctor']);
+
+    updateTarget = path.join(tempRoot, 'update-target');
+    await fs.mkdir(updateTarget, { recursive: true });
+    await installPackedCli(updateTarget, tarball, npmCache);
+    runCli(updateTarget, ['init', '--skip-doctor']);
+    await fs.mkdir(path.join(updateTarget, '.qa-ai', 'state'), { recursive: true });
+    await fs.mkdir(path.join(updateTarget, '.qa-ai', 'config-profiles'), { recursive: true });
+    await fs.writeFile(path.join(updateTarget, '.qa-ai', 'state', 'keep.json'), '{}\n', 'utf8');
+    await fs.writeFile(path.join(updateTarget, '.qa-ai', 'config-profiles', 'team.yaml'), 'version: 1\n', 'utf8');
+    await fs.writeFile(path.join(updateTarget, '.qa-ai', 'obsolete.txt'), 'old\n', 'utf8');
+    await fs.writeFile(path.join(updateTarget, 'qa-ai-output', 'user.md'), 'USER\n', 'utf8');
+    runCli(updateTarget, ['update', '--skip-doctor']);
+    await assertExists(path.join(updateTarget, '.qa-ai', 'state', 'keep.json'), 'preserved state');
+    await assertExists(path.join(updateTarget, '.qa-ai', 'config-profiles', 'team.yaml'), 'preserved config profile');
+    await assertMissing(path.join(updateTarget, '.qa-ai', 'obsolete.txt'), 'obsolete framework file');
+    await assertExists(path.join(updateTarget, 'qa-ai-output', 'user.md'), 'target output artifact');
+
+    console.log('npm pack smoke tests passed.');
+  } finally {
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/.qa-ai/scripts/smoke-test.mjs

@@ -0,0 +1,465 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { parseSimpleYaml, readText } from './lib/utils.mjs';
+
+const sourceRoot = process.cwd();
+const node = process.execPath;
+
+function run(cwd, args, { expectFailure = false } = {}) {
+  const result = spawnSync(node, args, {
+    cwd,
+    encoding: 'utf8',
+    shell: false
+  });
+  const failed = result.status !== 0;
+  if (expectFailure ? !failed : failed) {
+    throw new Error([
+      `Command ${expectFailure ? 'succeeded unexpectedly' : 'failed'}: node ${args.join(' ')}`,
+      result.stdout,
+      result.stderr
+    ].filter(Boolean).join('\n'));
+  }
+  return result;
+}
+
+async function copyFramework(targetRoot) {
+  await fs.cp(path.join(sourceRoot, '.qa-ai'), path.join(targetRoot, '.qa-ai'), {
+    recursive: true,
+    force: false
+  });
+}
+
+async function main() {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-smoke-'));
+  let unsafeRoot = null;
+  let defaultTarget = null;
+  let geminiTarget = null;
+  let qaContextTarget = null;
+  let optionalDocsTarget = null;
+  let strictTarget = null;
+  let quickStrictTarget = null;
+  let importProfileTarget = null;
+  let validatorTarget = null;
+  try {
+    await copyFramework(tempRoot);
+
+    run(tempRoot, [
+      '.qa-ai/scripts/init.mjs',
+      '--preset', 'webdriverio-playwright-api',
+      '--interface-language', 'en',
+      '--gherkin-language', 'en',
+      '--ui-framework', 'webdriverio',
+      '--api-framework', 'playwright-api',
+      '--adapters', 'generic'
+    ]);
+
+    const config = parseSimpleYaml(await readText(path.join(tempRoot, 'qa-ai.config.yaml')));
+    if (config.automation.ui.specsPath !== 'tests/wdio/specs') {
+      throw new Error(`Expected preset UI path tests/wdio/specs, got ${config.automation.ui.specsPath}`);
+    }
+    if (config.automation.api.specsPath !== 'tests/api/specs') {
+      throw new Error(`Expected preset API path tests/api/specs, got ${config.automation.api.specsPath}`);
+    }
+
+    run(tempRoot, [
+      '.qa-ai/scripts/config.mjs',
+      '--export', '.qa-ai/config-profiles/team.yaml'
+    ]);
+    importProfileTarget = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-import-'));
+    await copyFramework(importProfileTarget);
+    await fs.mkdir(path.join(importProfileTarget, '.qa-ai/config-profiles'), { recursive: true });
+    await fs.copyFile(
+      path.join(tempRoot, '.qa-ai/config-profiles/team.yaml'),
+      path.join(importProfileTarget, '.qa-ai/config-profiles/team.yaml')
+    );
+    run(importProfileTarget, [
+      '.qa-ai/scripts/config.mjs',
+      '--import', '.qa-ai/config-profiles/team.yaml'
+    ]);
+    const importedConfig = parseSimpleYaml(await readText(path.join(importProfileTarget, 'qa-ai.config.yaml')));
+    if (importedConfig.automation.ui.specsPath !== 'tests/wdio/specs') {
+      throw new Error(`Imported config did not preserve UI specs path, got ${importedConfig.automation.ui.specsPath}`);
+    }
+    const expectedImportPaths = [
+      '.qa-ai/agents/specialists/active.md',
+      'features',
+      'qa-ai-output',
+      'tests/wdio/specs',
+      'tests/api/specs'
+    ];
+    for (const relPath of expectedImportPaths) {
+      try {
+        await fs.access(path.join(importProfileTarget, relPath));
+      } catch {
+        throw new Error(`Config import did not create expected path: ${relPath}`);
+      }
+    }
+
+    defaultTarget = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-default-'));
+    await copyFramework(defaultTarget);
+    run(defaultTarget, ['.qa-ai/scripts/init.mjs']);
+    const expectedDefaultPaths = [
+      '.opencode/README.md',
+      '.opencode/commands/qa-init.md',
+      'qa-ai.config.yaml',
+      'qa-ai-output',
+      'features'
+    ];
+    for (const relPath of expectedDefaultPaths) {
+      try {
+        await fs.access(path.join(defaultTarget, relPath));
+      } catch {
+        throw new Error(`Default init did not create expected path: ${relPath}`);
+      }
+    }
+    const unexpectedDefaultPaths = [
+      '.claude',
+      '.codex',
+      'qa-ai-output/requirement-analysis.md',
+      'qa-ai-output/test-management-mapping.json'
+    ];
+    for (const relPath of unexpectedDefaultPaths) {
+      try {
+        await fs.access(path.join(defaultTarget, relPath));
+        throw new Error(`Default init created unexpected path: ${relPath}`);
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error;
+      }
+    }
+    run(defaultTarget, ['.qa-ai/scripts/doctor.mjs']);
+
+    geminiTarget = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-gemini-'));
+    await copyFramework(geminiTarget);
+    run(geminiTarget, [
+      '.qa-ai/scripts/init.mjs',
+      '--adapters', 'gemini'
+    ]);
+    const expectedGeminiPaths = [
+      'AGENTS.md',
+      'GEMINI.md'
+    ];
+    for (const relPath of expectedGeminiPaths) {
+      try {
+        await fs.access(path.join(geminiTarget, relPath));
+      } catch {
+        throw new Error(`Gemini adapter init did not create expected path: ${relPath}`);
+      }
+    }
+
+    qaContextTarget = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-context-'));
+    await copyFramework(qaContextTarget);
+    await fs.mkdir(path.join(qaContextTarget, 'qa-ai-knowledge'), { recursive: true });
+    await fs.writeFile(
+      path.join(qaContextTarget, 'qa-ai-knowledge', 'qa-process.md'),
+      '# QA Process\n\nUse Jira, TestRail and English Gherkin.\n',
+      'utf8'
+    );
+    run(qaContextTarget, [
+      '.qa-ai/scripts/init.mjs',
+      '--qa-context', 'qa-ai-knowledge',
+      '--no-adapters'
+    ]);
+    const qaContextConfig = parseSimpleYaml(await readText(path.join(qaContextTarget, 'qa-ai.config.yaml')));
+    if (qaContextConfig.knowledge.enabled !== true) {
+      throw new Error('QA context init did not enable knowledge config.');
+    }
+    if (qaContextConfig.knowledge.sourcePath !== 'qa-ai-knowledge') {
+      throw new Error(`QA context init did not preserve sourcePath, got ${qaContextConfig.knowledge.sourcePath}`);
+    }
+
+    optionalDocsTarget = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-docs-'));
+    await copyFramework(optionalDocsTarget);
+    run(optionalDocsTarget, [
+      '.qa-ai/scripts/init.mjs',
+      '--with-doc-templates',
+      '--with-test-management-mapping',
+      '--no-adapters'
+    ]);
+    const expectedOptionalDocPaths = [
+      'qa-ai-output/requirement-analysis.md',
+      'qa-ai-output/test-design-system.md',
+      'qa-ai-output/test-design-proposal.md',
+      'qa-ai-output/traceability-matrix.md',
+      'qa-ai-output/test-management-mapping.json'
+    ];
+    for (const relPath of expectedOptionalDocPaths) {
+      try {
+        await fs.access(path.join(optionalDocsTarget, relPath));
+      } catch {
+        throw new Error(`Optional doc init did not create expected path: ${relPath}`);
+      }
+    }
+
+    strictTarget = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-strict-'));
+    await copyFramework(strictTarget);
+    run(strictTarget, [
+      '.qa-ai/scripts/init.mjs',
+      '--preset', 'webdriverio-playwright-api',
+      '--with-doc-templates',
+      '--with-test-management-mapping',
+      '--adapters', 'generic'
+    ]);
+    await fs.writeFile(path.join(strictTarget, 'wdio.conf.js'), 'export const config = {};\n', 'utf8');
+    await fs.writeFile(path.join(strictTarget, 'playwright.config.js'), 'export default {};\n', 'utf8');
+    run(strictTarget, ['.qa-ai/scripts/doctor.mjs', '--strict']);
+    await fs.rm(path.join(strictTarget, 'qa-ai-output', 'traceability-matrix.md'), { force: true });
+    run(strictTarget, ['.qa-ai/scripts/doctor.mjs', '--strict'], { expectFailure: true });
+
+    quickStrictTarget = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-quick-strict-'));
+    await copyFramework(quickStrictTarget);
+    run(quickStrictTarget, [
+      '.qa-ai/scripts/init.mjs',
+      '--preset', 'manual-only',
+      '--no-adapters'
+    ]);
+    await fs.writeFile(
+      path.join(quickStrictTarget, 'qa-ai-output', 'requirement-analysis.md'),
+      '# Requirement Analysis\n\nRF-101 login.\n',
+      'utf8'
+    );
+    await fs.writeFile(
+      path.join(quickStrictTarget, 'qa-ai-output', 'traceability-matrix.md'),
+      '# Traceability Matrix\n\n| Requirement Source | RF | CA | Feature File | Test Management Case ID | Type | Priority | Automation Status | Automation File |\n|---|---|---|---|---|---|---|---|---|\n',
+      'utf8'
+    );
+    await fs.writeFile(
+      path.join(quickStrictTarget, 'qa-ai-output', 'pr-summary.md'),
+      '# PR Summary\n\nQuick track summary.\n',
+      'utf8'
+    );
+    run(quickStrictTarget, ['.qa-ai/scripts/doctor.mjs', '--strict']);
+
+    validatorTarget = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-validators-'));
+    await copyFramework(validatorTarget);
+    run(validatorTarget, [
+      '.qa-ai/scripts/init.mjs',
+      '--preset', 'manual-only',
+      '--no-adapters'
+    ]);
+    await fs.mkdir(path.join(validatorTarget, 'features', 'functional'), { recursive: true });
+    await fs.writeFile(
+      path.join(validatorTarget, 'features', 'functional', 'RF-101-TC-001-login.feature'),
+      [
+        '@priority:high @type:functional @manual:false @id:TC-001',
+        'Feature: RF-101 Login',
+        '',
+        'Acceptance Criteria:',
+        '- User can sign in with valid credentials.',
+        '',
+        'Scenario: RF-101 TC-001 Valid login',
+        '  Given a registered user',
+        '  When the user signs in',
+        '  Then the dashboard is displayed',
+        ''
+      ].join('\n'),
+      'utf8'
+    );
+    await fs.writeFile(
+      path.join(validatorTarget, 'qa-ai-output', 'traceability-matrix.md'),
+      [
+        '# Traceability Matrix',
+        '',
+        '| Requirement Source | RF | CA | Feature File | Test Management Case ID | Type | Priority | Automation Status | Automation File |',
+        '|---|---|---|---|---|---|---|---|---|',
+        '| Jira | RF-101 | User can sign in with valid credentials. | features/functional/RF-101-TC-001-login.feature | TC-001 | functional | high | automated | tests/login.spec.js |',
+        ''
+      ].join('\n'),
+      'utf8'
+    );
+    await fs.writeFile(path.join(validatorTarget, 'qa-ai-output', 'requirement-analysis.md'), '# Requirement Analysis\n\nRF-101 login.\n', 'utf8');
+    await fs.writeFile(
+      path.join(validatorTarget, 'qa-ai-output', 'test-design-proposal.md'),
+      [
+        '# Test Design Proposal (per RF / epic)',
+        '',
+        '## Official RF ID',
+        'RF-101',
+        '',
+        '## Scope',
+        'Login for RF-101.',
+        '',
+        '## Proposed tests',
+        '| RF | CA | Test ID | Title | Type | Priority | Manual | Action |',
+        '|---|---|---|---|---|---|---|---|',
+        '| RF-101 | Valid login | TC-001 | Valid login | functional | high | false | create |',
+        '',
+        '## Existing tests to reuse',
+        'None.',
+        '',
+        '## Existing tests requiring modification',
+        'None.',
+        '',
+        '## New tests to create',
+        'TC-001.',
+        '',
+        '## Ambiguities requiring user decision',
+        'None.',
+        '',
+        '## Approval request',
+        'Approve TC-001 feature generation.',
+        ''
+      ].join('\n'),
+      'utf8'
+    );
+    await fs.writeFile(path.join(validatorTarget, 'qa-ai-output', 'testrail-coverage-analysis.md'), '# TestRail Coverage Analysis\n\nRF-101 coverage.\n', 'utf8');
+    await fs.writeFile(path.join(validatorTarget, 'qa-ai-output', 'pr-summary.md'), '# PR Summary\n\nValidation pending.\n', 'utf8');
+    await fs.writeFile(
+      path.join(validatorTarget, 'qa-ai-output', 'testrail-sync-plan.md'),
+      [
+        '# TestRail Sync Plan',
+        '',
+        'Approval is required before any external write.',
+        '',
+        '| ID | Proposed action | Approval status | Target section | Notes |',
+        '|---|---|---|---|---|',
+        '| RF-101 | Review coverage | Pending approval | Login | Requirement coverage check |',
+        '| TC-001 | Propose create/update only | Approval required | Login | Do not sync without approval |',
+        ''
+      ].join('\n'),
+      'utf8'
+    );
+    await fs.writeFile(
+      path.join(validatorTarget, 'qa-ai-output', 'test-management-mapping.json'),
+      `${JSON.stringify({
+        'TC-001': {
+          externalId: 'C123',
+          section: 'Login',
+          suite: 'Regression',
+          status: 'planned',
+          lastReviewedAt: '2026-05-25',
+          notes: 'Mapped from validated sync proposal.'
+        }
+      }, null, 2)}\n`,
+      'utf8'
+    );
+    run(validatorTarget, ['.qa-ai/scripts/validate-features.mjs']);
+    run(validatorTarget, ['.qa-ai/scripts/validate-traceability.mjs']);
+    run(validatorTarget, ['.qa-ai/scripts/validate-target.mjs']);
+    await fs.rm(path.join(validatorTarget, 'qa-ai-output', 'traceability-matrix.md'), { force: true });
+    run(validatorTarget, ['.qa-ai/scripts/validate-target.mjs'], { expectFailure: true });
+    await fs.writeFile(
+      path.join(validatorTarget, 'qa-ai-output', 'traceability-matrix.md'),
+      [
+        '# Traceability Matrix',
+        '',
+        '| Requirement Source | RF | CA | Feature File | Test Management Case ID | Type | Priority | Automation Status | Automation File |',
+        '|---|---|---|---|---|---|---|---|---|',
+        '| Jira | RF-101 | User can sign in with valid credentials. | features/functional/RF-101-TC-001-login.feature | TC-001 | functional | high | automated | tests/login.spec.js |',
+        ''
+      ].join('\n'),
+      'utf8'
+    );
+    await fs.writeFile(
+      path.join(validatorTarget, 'qa-ai-output', 'traceability-matrix.md'),
+      [
+        '# Traceability Matrix',
+        '',
+        '| Requirement Source | RF | CA | Feature File | Test Management Case ID | Type | Priority | Automation Status | Automation File |',
+        '|---|---|---|---|---|---|---|---|---|',
+        '| Jira | RF-101 | User can sign in with valid credentials. | features/functional/RF-101-TC-001-login.feature | TC-001 | functional | high | automated | tests/login.spec.js |',
+        '| Jira | RF-101 | User can sign in with valid credentials. | features/functional/RF-101-TC-001-login.feature | TC-001 | functional | high | automated | tests/login.spec.js |',
+        ''
+      ].join('\n'),
+      'utf8'
+    );
+    run(validatorTarget, ['.qa-ai/scripts/validate-traceability.mjs'], { expectFailure: true });
+    run(validatorTarget, ['.qa-ai/scripts/validate-sync-plan.mjs']);
+    await fs.writeFile(
+      path.join(validatorTarget, 'qa-ai-output', 'testrail-sync-plan.md'),
+      [
+        '# TestRail Sync Plan',
+        '',
+        'Approval is required before any external write.',
+        '',
+        '| ID | Proposed action | Approval status | Target section | Notes |',
+        '|---|---|---|---|---|',
+        '| TC-001 | Created in TestRail | Done | Login | Direct write claim |',
+        '| TC-001 | Updated in TestRail | Done | Login | Duplicate direct write claim |',
+        ''
+      ].join('\n'),
+      'utf8'
+    );
+    run(validatorTarget, ['.qa-ai/scripts/validate-sync-plan.mjs'], { expectFailure: true });
+    await fs.writeFile(
+      path.join(validatorTarget, 'qa-ai-output', 'testrail-sync-plan.md'),
+      [
+        '# TestRail Sync Plan',
+        '',
+        'Approval is required before any external write.',
+        '',
+        '| ID | Proposed action | Approval status | Target section | Notes |',
+        '|---|---|---|---|---|',
+        '| RF-101 | Review coverage | Pending approval | Login | Requirement coverage check |',
+        '| TC-001 | Propose create/update only | Approval required | Login | Do not sync without approval |',
+        ''
+      ].join('\n'),
+      'utf8'
+    );
+    await fs.writeFile(
+      path.join(validatorTarget, 'qa-ai-output', 'test-management-mapping.json'),
+      `${JSON.stringify({
+        'TC-001': { externalId: 'C123' },
+        'TC-002': { externalId: 'C123' }
+      }, null, 2)}\n`,
+      'utf8'
+    );
+    run(validatorTarget, ['.qa-ai/scripts/validate-sync-plan.mjs'], { expectFailure: true });
+    run(validatorTarget, ['.qa-ai/scripts/validate-active-specialists.mjs']);
+
+    const preservedPath = path.join(tempRoot, 'qa-ai-output', 'requirement-analysis.md');
+    await fs.mkdir(path.dirname(preservedPath), { recursive: true });
+    await fs.writeFile(preservedPath, 'USER EDIT\n', 'utf8');
+    run(tempRoot, [
+      '.qa-ai/scripts/init.mjs',
+      '--preset', 'webdriverio-playwright-api',
+      '--interface-language', 'en',
+      '--gherkin-language', 'en',
+      '--adapters', 'generic'
+    ]);
+    const preservedContent = await readText(preservedPath);
+    if (preservedContent !== 'USER EDIT\n') {
+      throw new Error('requirement-analysis.md was overwritten without --force.');
+    }
+    const activePath = path.join(tempRoot, '.qa-ai/agents/specialists/active.md');
+    const activeContent = await readText(activePath);
+    if (!activeContent.includes('Active QA AI Specialists')) {
+      throw new Error('active.md was not regenerated from init config.');
+    }
+
+    unsafeRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'qa-flowkit-unsafe-'));
+    await copyFramework(unsafeRoot);
+    run(unsafeRoot, [
+      '.qa-ai/scripts/init.mjs',
+      '--preset', 'manual-only',
+      '--set', 'traceability.matrixPath=../traceability.md',
+      '--no-adapters'
+    ], { expectFailure: true });
+    run(unsafeRoot, [
+      '.qa-ai/scripts/init.mjs',
+      '--preset', 'manual-only',
+      '--qa-context', '../qa-knowledge',
+      '--no-adapters'
+    ], { expectFailure: true });
+
+    console.log('Smoke tests passed.');
+  } finally {
+    await fs.rm(tempRoot, { recursive: true, force: true });
+    if (unsafeRoot) await fs.rm(unsafeRoot, { recursive: true, force: true });
+    if (defaultTarget) await fs.rm(defaultTarget, { recursive: true, force: true });
+    if (geminiTarget) await fs.rm(geminiTarget, { recursive: true, force: true });
+    if (qaContextTarget) await fs.rm(qaContextTarget, { recursive: true, force: true });
+    if (optionalDocsTarget) await fs.rm(optionalDocsTarget, { recursive: true, force: true });
+    if (strictTarget) await fs.rm(strictTarget, { recursive: true, force: true });
+    if (quickStrictTarget) await fs.rm(quickStrictTarget, { recursive: true, force: true });
+    if (importProfileTarget) await fs.rm(importProfileTarget, { recursive: true, force: true });
+    if (validatorTarget) await fs.rm(validatorTarget, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});