create-contractor-site 2.1.2 → 2.3.0

package/scripts/smoke-test.mjs

@@ -6,10 +6,15 @@
  * 1. Missing target argument
  * 2. Existing non-empty target
  * 3. Target equal to / inside template root
- * 4. Duplicate service input normalization + slug uniqueness + business/services alignment
- * 5. Service-area name parse/dedupe (Chesapeake duplicate-slug case) + areas rebuild
+ * 4. Published DEFAULT_TEMPLATE_REF / CREATE_CONTRACTOR_TEMPLATE_REF contract (v2.3.0)
+ * 5. Duplicate service input normalization + slug uniqueness + business/services alignment
+ * 6. Service-area name parse/dedupe (Chesapeake duplicate-slug case) + areas rebuild
  *    without leaking stale template county/ZIP metadata into new areas
- * 6. Temp-target --yes scaffold (install/validate/build) unless SKIP_CLI_E2E=1
+ * 7. CREATE_CONTRACTOR_SITE_ANSWERS_JSON real CLI spawn (copy+replace, skip setup)
+ * 8. Root workspace isolation vs tools/smart-image capsule (scope, sharp/zod, dist/)
+ * 9. Smart-image wrapper/lifecycle (argv safety, Windows bin, setup/check, no hooks)
+ * 10. Scaffold deny/gitignore/required retention (isDeniedName, check-ignore, copyTemplate)
+ * 11. Temp-target --yes scaffold (install/validate/build) unless SKIP_CLI_E2E=1
  */
 
 import { spawnSync } from 'node:child_process';
@@ -26,10 +31,39 @@ import {
   replaceTargetData,
   slugify,
 } from '../src/replace-data.mjs';
-import { buildAnswers } from '../src/prompts.mjs';
+import {
+  buildAnswers,
+  DEFAULT_FREE_ESTIMATE,
+  DEFAULT_HOURS,
+  DEFAULT_INSURANCE,
+  DEFAULT_LICENSE,
+  DEFAULT_PAYMENT_METHODS,
+  DEFAULT_SITE_TYPE,
+  DEFAULT_YEARS_EXPERIENCE,
+  normalizeDirectories,
+  normalizeHours,
+  normalizePaymentMethods,
+  normalizeSiteType,
+  normalizeSocial,
+  optionalText,
+  requiredText,
+  SITE_TYPES,
+  SOCIAL_NETWORK_KEYS,
+} from '../src/prompts.mjs';
 import { isSameOrInside, validateTarget, TargetValidationError } from '../src/validate-target.mjs';
-import { findLocalTemplateRoot } from '../src/copy-template.mjs';
-import { isVersionAtLeast, resolveCommandPath } from '../src/run-command.mjs';
+import {
+  DEFAULT_TEMPLATE_REF,
+  REQUIRED_AFTER_COPY,
+  assertRequiredCopied,
+  copyTemplate,
+  findLocalTemplateRoot,
+  isDeniedName,
+} from '../src/copy-template.mjs';
+import {
+  isVersionAtLeast,
+  resolveCommandPath,
+  runCommand,
+} from '../src/run-command.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CLI = path.resolve(__dirname, '../bin/create-contractor-site.mjs');
@@ -63,6 +97,32 @@ function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
 
+/** @param {string} file */
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+/** Seed template data files into a temp target. @param {string} prefix */
+function seedDataDir(prefix) {
+  assert(REPO_ROOT, 'expected local template root');
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  const dataSrc = path.join(REPO_ROOT, 'src', 'data');
+  const dataDst = path.join(tmp, 'src', 'data');
+  fs.mkdirSync(dataDst, { recursive: true });
+  for (const f of [
+    'business.json',
+    'site.json',
+    'services.json',
+    'areas.json',
+    'navigation.json',
+    'landings.json',
+    'directories.json',
+  ]) {
+    fs.copyFileSync(path.join(dataSrc, f), path.join(dataDst, f));
+  }
+  return { tmp, dataDst };
+}
+
 /**
  * @param {string[]} args
  * @param {{ env?: NodeJS.ProcessEnv, cwd?: string }} [opts]
@@ -95,6 +155,43 @@ async function main() {
     assert(!isVersionAtLeast('10.9.9', '11.1.2'), 'older major should fail');
   });
 
+  await test(
+    'DEFAULT_TEMPLATE_REF / CREATE_CONTRACTOR_TEMPLATE_REF published contract is v2.3.0',
+    () => {
+      const copySrcPath = path.join(PKG_ROOT, 'src', 'copy-template.mjs');
+      const copySrc = fs.readFileSync(copySrcPath, 'utf8');
+      // Pin the source fallback so a silent ref bump cannot ship without updating this test.
+      assert(
+        /CREATE_CONTRACTOR_TEMPLATE_REF\s*\|\|\s*['"]v2\.3\.0['"]/.test(copySrc),
+        'copy-template.mjs DEFAULT_TEMPLATE_REF fallback must be v2.3.0',
+      );
+      const expected =
+        process.env.CREATE_CONTRACTOR_TEMPLATE_REF || 'v2.3.0';
+      assert(
+        DEFAULT_TEMPLATE_REF === expected,
+        `DEFAULT_TEMPLATE_REF must equal CREATE_CONTRACTOR_TEMPLATE_REF or v2.3.0 (got ${DEFAULT_TEMPLATE_REF})`,
+      );
+      if (!process.env.CREATE_CONTRACTOR_TEMPLATE_REF) {
+        assert(
+          DEFAULT_TEMPLATE_REF === 'v2.3.0',
+          `published default template ref must be v2.3.0 (got ${DEFAULT_TEMPLATE_REF})`,
+        );
+      }
+
+      const help = runCli(['--help']);
+      assert(help.status === 0, `help exit 0, got ${help.status}`);
+      const helpOut = `${help.stdout}\n${help.stderr}`;
+      assert(
+        /CREATE_CONTRACTOR_TEMPLATE_REF/i.test(helpOut),
+        'help must document CREATE_CONTRACTOR_TEMPLATE_REF',
+      );
+      assert(
+        /v2\.3\.0/.test(helpOut),
+        'help must document default template ref v2.3.0',
+      );
+    },
+  );
+
   await test('missing target argument exits 1 with usage', () => {
     const result = runCli([]);
     assert(result.status === 1, `expected exit 1, got ${result.status}`);
@@ -299,6 +396,7 @@ async function main() {
       'areas.json',
       'navigation.json',
       'landings.json',
+      'directories.json',
     ]) {
       fs.copyFileSync(path.join(dataSrc, file), path.join(dataDst, file));
     }
@@ -376,6 +474,594 @@ async function main() {
     fs.rmSync(tmp, { recursive: true, force: true });
   });
 
+  await test('buildAnswers normalizes blank text trust fields and foundedYear', () => {
+    const answers = buildAnswers({
+      businessName: 'Trust Co',
+      primaryServices: ['Masonry'],
+      freeEstimate: '   ',
+      yearsExperience: '\t',
+      license: '',
+      insurance: null,
+      foundedYear: '  ',
+    });
+    assert(answers.freeEstimate === DEFAULT_FREE_ESTIMATE, 'freeEstimate default');
+    assert(answers.yearsExperience === DEFAULT_YEARS_EXPERIENCE, 'yearsExperience default');
+    assert(answers.license === DEFAULT_LICENSE, 'license default');
+    assert(answers.insurance === DEFAULT_INSURANCE, 'insurance default');
+    assert(answers.foundedYear === '', 'foundedYear blank → ""');
+    assert(requiredText('  x  ', 'y') === 'x', 'requiredText trims');
+    assert(optionalText('  2012 ') === '2012', 'optionalText trims');
+    assert(optionalText(undefined) === '', 'optionalText missing → ""');
+  });
+
+  await test('normalizePaymentMethods CSV/array blank → defaults never []', () => {
+    assert(
+      JSON.stringify(normalizePaymentMethods('Cash,  Check , ,Credit Card')) ===
+        JSON.stringify(['Cash', 'Check', 'Credit Card']),
+      'CSV trims and drops blanks',
+    );
+    assert(
+      JSON.stringify(normalizePaymentMethods(['  Visa ', '', 'Cash'])) ===
+        JSON.stringify(['Visa', 'Cash']),
+      'array trims and drops blanks',
+    );
+    assert(
+      JSON.stringify(normalizePaymentMethods('   ')) ===
+        JSON.stringify(DEFAULT_PAYMENT_METHODS),
+      'whitespace CSV → defaults',
+    );
+    assert(
+      JSON.stringify(normalizePaymentMethods([])) ===
+        JSON.stringify(DEFAULT_PAYMENT_METHODS),
+      'empty array → defaults',
+    );
+    assert(
+      JSON.stringify(normalizePaymentMethods(null)) ===
+        JSON.stringify(DEFAULT_PAYMENT_METHODS),
+      'null → defaults',
+    );
+    assert(normalizePaymentMethods('').length > 0, 'never empty list');
+  });
+
+  await test('normalizeHours keeps 3-row {days,time} shape with safe defaults', () => {
+    const fromBlank = normalizeHours(undefined);
+    assert(fromBlank.length === 3, 'default length 3');
+    assert(
+      JSON.stringify(fromBlank) === JSON.stringify(DEFAULT_HOURS),
+      'missing → DEFAULT_HOURS',
+    );
+    assert(
+      JSON.stringify(normalizeHours([])) === JSON.stringify(DEFAULT_HOURS),
+      'empty array → defaults',
+    );
+
+    const partial = normalizeHours([
+      { days: '  ', time: '9:00 AM - 5:00 PM' },
+      '  10:00 AM - 1:00 PM ',
+      { days: 'Sunday', time: '  ' },
+    ]);
+    assert(partial.length === 3, 'partial still length 3');
+    assert(partial[0].days === DEFAULT_HOURS[0].days, 'blank days → default days');
+    assert(partial[0].time === '9:00 AM - 5:00 PM', 'weekday time kept');
+    assert(partial[1].days === DEFAULT_HOURS[1].days, 'string row uses default days');
+    assert(partial[1].time === '10:00 AM - 1:00 PM', 'string row trims time');
+    assert(partial[2].days === 'Sunday', 'sunday days kept');
+    assert(partial[2].time === DEFAULT_HOURS[2].time, 'blank time → default');
+
+    const compact = buildAnswers({
+      businessName: 'Hours Co',
+      primaryServices: ['Masonry'],
+      hoursWeekday: '8-5',
+      hoursSaturday: '  ',
+      hoursSunday: 'Closed',
+    });
+    assert(compact.hours.length === 3, 'compact → 3 rows');
+    assert(compact.hours[0].time === '8-5', 'compact weekday');
+    assert(compact.hours[1].time === DEFAULT_HOURS[1].time, 'blank sat → default');
+    assert(compact.hours[2].time === 'Closed', 'compact sunday');
+    assert(
+      JSON.stringify(compact.paymentMethods) === JSON.stringify(DEFAULT_PAYMENT_METHODS),
+      'omitted payments → defaults',
+    );
+  });
+
+  await test('replaceTargetData writes trust + payment + hours + empty social', () => {
+    assert(REPO_ROOT, 'expected local template root');
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-trust-'));
+    const dataSrc = path.join(REPO_ROOT, 'src', 'data');
+    const dataDst = path.join(tmp, 'src', 'data');
+    fs.mkdirSync(dataDst, { recursive: true });
+    for (const file of [
+      'business.json',
+      'site.json',
+      'services.json',
+      'areas.json',
+      'navigation.json',
+      'landings.json',
+      'directories.json',
+    ]) {
+      fs.copyFileSync(path.join(dataSrc, file), path.join(dataDst, file));
+    }
+
+    const original = JSON.parse(
+      fs.readFileSync(path.join(dataDst, 'business.json'), 'utf8'),
+    );
+    const originalDirs = JSON.parse(
+      fs.readFileSync(path.join(dataDst, 'directories.json'), 'utf8'),
+    );
+
+    const answers = buildAnswers({
+      businessName: 'Trust Builders',
+      primaryServices: ['Masonry'],
+      freeEstimate: 'Free Quote Today',
+      yearsExperience: '20+',
+      license: 'VA Class A #12345',
+      insurance: 'Bonded and insured.',
+      foundedYear: '',
+      paymentMethods: 'Cash, Zelle',
+      hours: [
+        { days: 'Monday - Friday', time: '8:00 AM - 4:00 PM' },
+        { days: 'Saturday', time: 'Closed' },
+        { days: 'Sunday', time: 'Closed' },
+      ],
+    });
+    replaceTargetData(tmp, answers);
+
+    const business = JSON.parse(
+      fs.readFileSync(path.join(dataDst, 'business.json'), 'utf8'),
+    );
+    const site = JSON.parse(fs.readFileSync(path.join(dataDst, 'site.json'), 'utf8'));
+    const directories = JSON.parse(
+      fs.readFileSync(path.join(dataDst, 'directories.json'), 'utf8'),
+    );
+    assert(business._instructions, '_instructions preserved');
+    assert(
+      JSON.stringify(Object.keys(business._instructions)) ===
+        JSON.stringify(Object.keys(original._instructions)),
+      '_instructions keys stable',
+    );
+    assert(business.free_estimate === 'Free Quote Today', 'free_estimate written');
+    assert(business.years_experience === '20+', 'years_experience written');
+    assert(business.license === 'VA Class A #12345', 'license written');
+    assert(business.insurance === 'Bonded and insured.', 'insurance written');
+    assert(
+      Object.prototype.hasOwnProperty.call(business, 'founded_year'),
+      'founded_year key must remain',
+    );
+    assert(business.founded_year === '', 'founded_year skip → ""');
+    assert(
+      JSON.stringify(business.payment_methods) === JSON.stringify(['Cash', 'Zelle']),
+      'payment_methods written',
+    );
+    assert(Array.isArray(business.hours) && business.hours.length === 3, 'hours length 3');
+    assert(business.hours[0].days === 'Monday - Friday', 'hours days shape');
+    assert(business.hours[0].time === '8:00 AM - 4:00 PM', 'hours time written');
+    assert(business.hours[1].time === 'Closed', 'saturday closed');
+    assert(JSON.stringify(business.social) === '{}', 'omitted social → {}');
+    assert(site.features.enable_directories === false, 'no dirs → enable false');
+    assert(directories.directories.length >= 1, 'directories min(1) when none');
+    assert(directories.directories.length === originalDirs.directories.length);
+    assert(directories._instructions && directories.variant === originalDirs.variant);
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
+
+  await test('normalizeSocial/directories + replace populate/none parity', () => {
+    // Social blank omission + population (object + compact CSV)
+    assert(JSON.stringify(normalizeSocial(undefined)) === '{}', 'missing social → {}');
+    assert(
+      JSON.stringify(normalizeSocial({ facebook: '  ', instagram: null, x: '' })) === '{}',
+      'blank social keys omitted',
+    );
+    const populated = normalizeSocial({
+      facebook: ' https://facebook.com/acme ',
+      instagram: '',
+      youtube: 'https://youtube.com/@acme',
+      unknown: 'https://nope.example',
+    });
+    assert(
+      JSON.stringify(populated) ===
+        JSON.stringify({
+          facebook: 'https://facebook.com/acme',
+          youtube: 'https://youtube.com/@acme',
+        }),
+    );
+    const compact = normalizeSocial(
+      'facebook=https://facebook.com/a, google-business=https://g.co/a, ,tiktok=',
+    );
+    assert(compact.facebook === 'https://facebook.com/a' && compact.google_business === 'https://g.co/a');
+    assert(!Object.prototype.hasOwnProperty.call(compact, 'tiktok'));
+    assert(SOCIAL_NETWORK_KEYS.includes('linkedin'));
+
+    // Directories provided vs none
+    assert(normalizeDirectories(undefined).length === 0);
+    assert(normalizeDirectories([]).length === 0);
+    const fromCsv = normalizeDirectories(
+      'Google Business|https://g.co/acme,  BBB|https://bbb.org/acme ,badrow',
+    );
+    assert(fromCsv.length === 2 && fromCsv[0].url === 'https://g.co/acme' && fromCsv[0].initials);
+    const fromRows = normalizeDirectories([
+      { name: 'Angi', url: 'https://angi.com/x', initials: 'A' },
+      { name: '  ', url: 'https://skip.example' },
+      { name: 'Houzz', url: '  ' },
+    ]);
+    assert(fromRows.length === 1 && fromRows[0].initials === 'A');
+
+    const none = buildAnswers({ businessName: 'No Social', primaryServices: ['Masonry'] });
+    assert(JSON.stringify(none.social) === '{}' && none.directories.length === 0);
+    assert(none.enableDirectories === false);
+    const withDirs = buildAnswers({
+      businessName: 'With Dirs',
+      primaryServices: ['Masonry'],
+      social: { facebook: 'https://facebook.com/x', instagram: '  ' },
+      directories: 'Google|https://g.co/x',
+    });
+    assert(withDirs.social.facebook === 'https://facebook.com/x');
+    assert(!Object.prototype.hasOwnProperty.call(withDirs.social, 'instagram'));
+    assert(withDirs.directories.length === 1 && withDirs.enableDirectories === true);
+
+    // directories:[] + enableDirectories:true → feature false
+    const forcedEmpty = buildAnswers({
+      businessName: 'Forced Empty Dirs',
+      primaryServices: ['Masonry'],
+      directories: [],
+      enableDirectories: true,
+    });
+    assert(forcedEmpty.directories.length === 0 && forcedEmpty.enableDirectories === false);
+
+    // replace: populated social + directories
+    const seeded = seedDataDir('ccs-social-');
+    replaceTargetData(
+      seeded.tmp,
+      buildAnswers({
+        businessName: 'Social Co',
+        primaryServices: ['Patios'],
+        social: {
+          facebook: 'https://facebook.com/socialco',
+          instagram: '',
+          youtube: 'https://youtube.com/@socialco',
+        },
+        directories: [
+          { name: 'Google Business', url: 'https://g.co/socialco', initials: 'G' },
+          { name: 'Angi', url: 'https://angi.com/socialco' },
+        ],
+      }),
+    );
+    const business = readJson(path.join(seeded.dataDst, 'business.json'));
+    const site = readJson(path.join(seeded.dataDst, 'site.json'));
+    const directories = readJson(path.join(seeded.dataDst, 'directories.json'));
+    assert(
+      JSON.stringify(business.social) ===
+        JSON.stringify({
+          facebook: 'https://facebook.com/socialco',
+          youtube: 'https://youtube.com/@socialco',
+        }),
+    );
+    assert(site.features.enable_directories === true);
+    assert(directories.directories.length === 2 && directories.directories[0].initials === 'G');
+    assert(directories.directories[1].initials && directories._instructions);
+
+    // replace: directories:[] + enable true → flag false + min(1) placeholder rows
+    const forced = seedDataDir('ccs-dirs-force-');
+    const origLen = readJson(path.join(forced.dataDst, 'directories.json')).directories.length;
+    replaceTargetData(
+      forced.tmp,
+      buildAnswers({
+        businessName: 'Force Enable Empty',
+        primaryServices: ['Masonry'],
+        directories: [],
+        enableDirectories: true,
+      }),
+    );
+    const siteForced = readJson(path.join(forced.dataDst, 'site.json'));
+    const dirsForced = readJson(path.join(forced.dataDst, 'directories.json'));
+    assert(siteForced.features.enable_directories === false, 'empty+force → enable false');
+    assert(dirsForced.directories.length >= 1 && dirsForced.directories.length === origLen);
+    fs.rmSync(forced.tmp, { recursive: true, force: true });
+    fs.rmSync(seeded.tmp, { recursive: true, force: true });
+  });
+
+  await test('normalizeSiteType canonical + human-ish aliases; invalid → multipage', () => {
+    assert(DEFAULT_SITE_TYPE === 'multipage', 'default site type is multipage');
+    assert(JSON.stringify(SITE_TYPES) === JSON.stringify(['one-page', 'multipage', 'seo']));
+    assert(normalizeSiteType(undefined) === 'multipage', 'missing → multipage');
+    assert(normalizeSiteType('') === 'multipage', 'blank → multipage');
+    assert(normalizeSiteType('  ') === 'multipage', 'whitespace → multipage');
+    assert(normalizeSiteType('one-page') === 'one-page');
+    assert(normalizeSiteType('multipage') === 'multipage');
+    assert(normalizeSiteType('seo') === 'seo');
+    assert(normalizeSiteType('one page') === 'one-page', 'one page alias');
+    assert(normalizeSiteType('onepage') === 'one-page', 'onepage alias');
+    assert(normalizeSiteType('multi page') === 'multipage', 'multi page alias');
+    assert(normalizeSiteType('multi-page') === 'multipage', 'multi-page alias');
+    assert(normalizeSiteType('SEO') === 'seo', 'case fold');
+    assert(normalizeSiteType('not-a-type') === 'multipage', 'invalid → multipage');
+    assert(normalizeSiteType('blog') === 'multipage', 'unknown → multipage');
+
+    const omitted = buildAnswers({ businessName: 'Type Co', primaryServices: ['Masonry'] });
+    assert(omitted.siteType === 'multipage', 'buildAnswers omits → multipage');
+    assert(buildAnswers({
+      businessName: 'One Page Co',
+      primaryServices: ['Masonry'],
+      siteType: 'one page',
+    }).siteType === 'one-page');
+    assert(buildAnswers({
+      businessName: 'SEO Co',
+      primaryServices: ['Masonry'],
+      siteType: 'seo',
+    }).siteType === 'seo');
+  });
+
+  await test('replaceTargetData writes site_type from answers (default multipage)', () => {
+    assert(REPO_ROOT, 'expected local template root');
+    const seeded = seedDataDir('ccs-sitetype-');
+    try {
+      const originalSite = readJson(path.join(seeded.dataDst, 'site.json'));
+      replaceTargetData(
+        seeded.tmp,
+        buildAnswers({ businessName: 'Type Default Co', primaryServices: ['Masonry'] }),
+      );
+      const siteDefault = readJson(path.join(seeded.dataDst, 'site.json'));
+      assert(siteDefault.site_type === 'multipage', `default write multipage, got ${siteDefault.site_type}`);
+      assert(siteDefault._instructions, '_instructions preserved');
+      assert(
+        JSON.stringify(Object.keys(siteDefault._instructions)) ===
+          JSON.stringify(Object.keys(originalSite._instructions)),
+        '_instructions keys stable',
+      );
+
+      // one-page
+      const one = seedDataDir('ccs-sitetype-one-');
+      replaceTargetData(
+        one.tmp,
+        buildAnswers({
+          businessName: 'One Page Site',
+          primaryServices: ['Patios'],
+          siteType: 'one-page',
+        }),
+      );
+      assert(readJson(path.join(one.dataDst, 'site.json')).site_type === 'one-page');
+      fs.rmSync(one.tmp, { recursive: true, force: true });
+
+      // seo
+      const seo = seedDataDir('ccs-sitetype-seo-');
+      replaceTargetData(
+        seo.tmp,
+        buildAnswers({
+          businessName: 'SEO Site',
+          primaryServices: ['Patios'],
+          siteType: 'seo',
+        }),
+      );
+      assert(readJson(path.join(seo.dataDst, 'site.json')).site_type === 'seo');
+      fs.rmSync(seo.tmp, { recursive: true, force: true });
+    } finally {
+      fs.rmSync(seeded.tmp, { recursive: true, force: true });
+    }
+  });
+
+  await test('--help documents trust/payment/hours/social/directories/siteType defaults', () => {
+    const help = runCli(['--help']);
+    assert(help.status === 0, `help exit 0, got ${help.status}`);
+    const helpOut = `${help.stdout}\n${help.stderr}`;
+    assert(/freeEstimate/i.test(helpOut), 'help lists freeEstimate');
+    assert(/foundedYear/i.test(helpOut), 'help lists foundedYear');
+    assert(/empty string/i.test(helpOut), 'help documents foundedYear empty string');
+    assert(/paymentMethods/i.test(helpOut), 'help lists paymentMethods');
+    assert(/hoursWeekday/i.test(helpOut), 'help lists compact hours keys');
+    assert(/social/i.test(helpOut), 'help lists social');
+    assert(/directories/i.test(helpOut), 'help lists directories');
+    assert(/enable_directories/i.test(helpOut), 'help mentions enable_directories');
+    assert(/siteType/i.test(helpOut), 'help lists siteType');
+    assert(/multipage/i.test(helpOut), 'help documents multipage default');
+    assert(/one-page/i.test(helpOut), 'help lists one-page');
+    assert(/CREATE_CONTRACTOR_SITE_ANSWERS_JSON/i.test(helpOut), 'help lists JSON env');
+  });
+
+  await test('CREATE_CONTRACTOR_SITE_ANSWERS_JSON CLI path defaults intake and siteType', () => {
+    assert(REPO_ROOT, 'expected local template root');
+    // Fresh non-existent target (CLI rejects existing dirs that are non-empty).
+    const targetDir = path.join(
+      fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-jsonenv-parent-')),
+      'site',
+    );
+
+    const payload = {
+      businessName: 'JSON Env Masonry',
+      primaryServices: ['Patios'],
+      // Blank/whitespace trust fields → buildAnswers defaults; foundedYear → ""
+      freeEstimate: '   ',
+      yearsExperience: '\t',
+      license: '',
+      insurance: null,
+      foundedYear: '   ',
+      // Blank payments + empty hours → defaults (never [])
+      paymentMethods: '  ,  ',
+      hours: [],
+      social: { facebook: '  ', instagram: '' }, // blank → {}
+      directories: [], // none → enable false + min(1)
+    };
+
+    const result = runCli([targetDir], {
+      env: {
+        CREATE_CONTRACTOR_TEMPLATE_ROOT: REPO_ROOT,
+        CREATE_CONTRACTOR_SITE_ANSWERS_JSON: JSON.stringify(payload),
+        NODE_ENV: 'test',
+        CREATE_CONTRACTOR_SITE_SKIP_SETUP: '1',
+      },
+    });
+
+    const out = `${result.stdout}\n${result.stderr}`;
+    try {
+      assert(result.status === 0, `CLI exit 0, got ${result.status}:\n${out.slice(-2000)}`);
+      assert(/Data replace complete/i.test(out), 'expected skip-setup success banner');
+
+      const businessPath = path.join(targetDir, 'src/data/business.json');
+      assert(fs.existsSync(businessPath), 'expected generated business.json');
+      const business = JSON.parse(fs.readFileSync(businessPath, 'utf8'));
+      const site = readJson(path.join(targetDir, 'src/data/site.json'));
+      const directories = readJson(path.join(targetDir, 'src/data/directories.json'));
+
+      assert(business.name === 'JSON Env Masonry', 'env business name via CLI');
+      assert(
+        business.free_estimate === DEFAULT_FREE_ESTIMATE,
+        `free_estimate default via CLI, got ${business.free_estimate}`,
+      );
+      assert(
+        business.years_experience === DEFAULT_YEARS_EXPERIENCE,
+        `years_experience default via CLI, got ${business.years_experience}`,
+      );
+      assert(
+        business.license === DEFAULT_LICENSE,
+        `license default via CLI, got ${business.license}`,
+      );
+      assert(
+        business.insurance === DEFAULT_INSURANCE,
+        `insurance default via CLI, got ${business.insurance}`,
+      );
+      assert(
+        Object.prototype.hasOwnProperty.call(business, 'founded_year'),
+        'founded_year key must remain',
+      );
+      assert(business.founded_year === '', 'CLI founded_year blank → ""');
+      assert(
+        JSON.stringify(business.payment_methods) === JSON.stringify(DEFAULT_PAYMENT_METHODS),
+        'CLI blank payments → defaults',
+      );
+      assert(business.payment_methods.length > 0, 'payment_methods never []');
+      assert(
+        JSON.stringify(business.hours) === JSON.stringify(DEFAULT_HOURS),
+        'CLI empty hours → DEFAULT_HOURS',
+      );
+      assert(business.hours.every((h) => h.days && h.time), 'hours rows shaped');
+      assert(JSON.stringify(business.social) === '{}', 'CLI blank social → {}');
+      assert(site.features.enable_directories === false, 'CLI no dirs → enable false');
+      assert(directories.directories.length >= 1, 'CLI directories min(1)');
+      assert(site.site_type === 'multipage', `CLI omitted siteType → multipage, got ${site.site_type}`);
+    } finally {
+      const parent = path.dirname(targetDir);
+      try {
+        fs.rmSync(parent, { recursive: true, force: true });
+      } catch {
+        console.warn(`    (could not fully remove ${parent})`);
+      }
+    }
+  });
+
+  await test('CREATE_CONTRACTOR_SITE_ANSWERS_JSON can set siteType one-page and seo', () => {
+    assert(REPO_ROOT, 'expected local template root');
+
+    for (const { label, siteType, expected } of [
+      { label: 'one-page', siteType: 'one page', expected: 'one-page' },
+      { label: 'seo', siteType: 'seo', expected: 'seo' },
+    ]) {
+      const targetDir = path.join(
+        fs.mkdtempSync(path.join(os.tmpdir(), `ccs-sitetype-${label}-`)),
+        'site',
+      );
+      const result = runCli([targetDir], {
+        env: {
+          CREATE_CONTRACTOR_TEMPLATE_ROOT: REPO_ROOT,
+          CREATE_CONTRACTOR_SITE_ANSWERS_JSON: JSON.stringify({
+            businessName: `JSON ${label}`,
+            primaryServices: ['Patios'],
+            siteType,
+          }),
+          NODE_ENV: 'test',
+          CREATE_CONTRACTOR_SITE_SKIP_SETUP: '1',
+        },
+      });
+      const out = `${result.stdout}\n${result.stderr}`;
+      try {
+        assert(result.status === 0, `CLI ${label} exit 0, got ${result.status}:\n${out.slice(-1500)}`);
+        const site = readJson(path.join(targetDir, 'src/data/site.json'));
+        assert(site.site_type === expected, `CLI ${label} site_type, got ${site.site_type}`);
+      } finally {
+        try {
+          fs.rmSync(path.dirname(targetDir), { recursive: true, force: true });
+        } catch {
+          console.warn(`    (could not fully remove ${path.dirname(targetDir)})`);
+        }
+      }
+    }
+  });
+
+  await test('CREATE_CONTRACTOR_SITE_ANSWERS_JSON compact payment/hours/social/dirs path', () => {
+    assert(REPO_ROOT, 'expected local template root');
+    const targetDir = path.join(
+      fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-jsoncompact-parent-')),
+      'site',
+    );
+
+    const payload = {
+      businessName: 'Compact Hours Co',
+      primaryServices: ['Patios'],
+      paymentMethods: ['Cash', '  ', 'ACH'],
+      hoursWeekday: '9:00 AM - 5:00 PM',
+      hoursSaturday: 'Closed',
+      hoursSunday: 'Closed',
+      social: 'facebook=https://facebook.com/compact,instagram=https://instagram.com/compact',
+      directories: 'Google Business|https://g.co/compact,BBB|https://bbb.org/compact',
+    };
+
+    const result = runCli([targetDir], {
+      env: {
+        CREATE_CONTRACTOR_TEMPLATE_ROOT: REPO_ROOT,
+        CREATE_CONTRACTOR_SITE_ANSWERS_JSON: JSON.stringify(payload),
+        NODE_ENV: 'test',
+        CREATE_CONTRACTOR_SITE_SKIP_SETUP: '1',
+      },
+    });
+
+    const out = `${result.stdout}\n${result.stderr}`;
+    try {
+      assert(result.status === 0, `CLI exit 0, got ${result.status}:\n${out.slice(-2000)}`);
+      const business = JSON.parse(
+        fs.readFileSync(path.join(targetDir, 'src/data/business.json'), 'utf8'),
+      );
+      const site = readJson(path.join(targetDir, 'src/data/site.json'));
+      const directories = readJson(path.join(targetDir, 'src/data/directories.json'));
+      assert(
+        JSON.stringify(business.payment_methods) === JSON.stringify(['Cash', 'ACH']),
+        `compact payments, got ${JSON.stringify(business.payment_methods)}`,
+      );
+      assert(business.hours.length === 3, 'compact hours length');
+      assert(business.hours[0].days === 'Monday - Friday', 'weekday days label');
+      assert(business.hours[0].time === '9:00 AM - 5:00 PM', 'compact weekday time');
+      assert(business.hours[1].time === 'Closed', 'compact saturday');
+      assert(business.hours[2].time === 'Closed', 'compact sunday');
+      // Trust defaults still apply when omitted
+      assert(business.free_estimate === DEFAULT_FREE_ESTIMATE, 'trust default still works');
+      assert(business.founded_year === '', 'founded_year still ""');
+      assert(business.social.facebook === 'https://facebook.com/compact');
+      assert(business.social.instagram === 'https://instagram.com/compact');
+      assert(site.features.enable_directories === true, 'compact dirs → enable true');
+      assert(directories.directories.length === 2);
+      assert(directories.directories[0].url === 'https://g.co/compact');
+    } finally {
+      const parent = path.dirname(targetDir);
+      try {
+        fs.rmSync(parent, { recursive: true, force: true });
+      } catch {
+        console.warn(`    (could not fully remove ${parent})`);
+      }
+    }
+  });
+
+  await test('skip setup guard requires NODE_ENV test', () => {
+    const parent = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-skip-guard-'));
+    const targetDir = path.join(parent, 'site');
+    try {
+      const result = runCli(['--yes', targetDir], {
+        env: { CREATE_CONTRACTOR_TEMPLATE_ROOT: REPO_ROOT || '', CREATE_CONTRACTOR_SITE_SKIP_SETUP: '1', NODE_ENV: '' },
+      });
+      const out = `${result.stdout}\n${result.stderr}`;
+      assert(result.status === 1, `expected guard failure, got ${result.status}`);
+      assert(/requires NODE_ENV=test/i.test(out), `expected guard message:\n${out}`);
+    } finally {
+      fs.rmSync(parent, { recursive: true, force: true });
+    }
+  });
+
   await test('replaceTargetData Chesapeake case keeps unique area slugs', () => {
     assert(REPO_ROOT, 'expected local template root');
     const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-areas-'));
@@ -389,6 +1075,7 @@ async function main() {
       'areas.json',
       'navigation.json',
       'landings.json',
+      'directories.json',
     ]) {
       fs.copyFileSync(path.join(dataSrc, file), path.join(dataDst, file));
     }
@@ -429,10 +1116,521 @@ async function main() {
     fs.rmSync(tmp, { recursive: true, force: true });
   });
 
+  // --- image-tooling capsule isolation (Unit 1) ---
+  await test('root workspace stays two projects and excludes tools/*', () => {
+    assert(REPO_ROOT, 'expected local template root');
+    const wsPath = path.join(REPO_ROOT, 'pnpm-workspace.yaml');
+    const wsText = fs.readFileSync(wsPath, 'utf8');
+    assert(/\n\s*-\s*\.\s*$/m.test(wsText) || /packages:\s*\n\s*-\s*\./.test(wsText),
+      'root workspace must include "."');
+    assert(/-\s*packages\/\*/.test(wsText), 'root workspace must include packages/*');
+    assert(!/tools\//.test(wsText), 'root workspace must not absorb tools/*');
+    assert(
+      !/better-sqlite3/.test(wsText),
+      'root pnpm-workspace.yaml must not declare allowBuilds.better-sqlite3',
+    );
+
+    const list = runCommand('pnpm', ['list', '-r', '--depth', '-1'], {
+      cwd: REPO_ROOT,
+      stdio: 'pipe',
+    });
+    // pnpm prints one name@version line per workspace package
+    const names = (list.stdout || '').match(/^[^\s].*@\d/gm) || [];
+    assert(
+      names.length === 2,
+      `expected exactly 2 root workspace projects, got ${names.length}: ${names.join(', ')}`,
+    );
+    assert(
+      !/smart-image/i.test(list.stdout || ''),
+      'root workspace listing must not include smart-image capsule',
+    );
+  });
+
+  await test('root sharp/zod ranges stay unchanged with no overrides', () => {
+    assert(REPO_ROOT, 'expected local template root');
+    const pkg = readJson(path.join(REPO_ROOT, 'package.json'));
+    const sharp = pkg.devDependencies?.sharp ?? pkg.dependencies?.sharp;
+    const zod = pkg.devDependencies?.zod ?? pkg.dependencies?.zod;
+    assert(sharp === '^0.34.5', `root sharp range must stay ^0.34.5, got ${sharp}`);
+    assert(zod === '^4.1.5', `root zod range must stay ^4.1.5, got ${zod}`);
+    assert(pkg.overrides == null, 'root package.json must not declare overrides');
+    assert(
+      pkg.pnpm?.overrides == null,
+      'root package.json must not declare pnpm.overrides',
+    );
+    assert(
+      !pkg.dependencies?.['smart-image-cli'] && !pkg.devDependencies?.['smart-image-cli'],
+      'root package.json must not depend on smart-image-cli',
+    );
+  });
+
+  await test('dist holds zero capsule or smart-image-cli references', () => {
+    assert(REPO_ROOT, 'expected local template root');
+    const distDir = path.join(REPO_ROOT, 'dist');
+    if (!fs.existsSync(distDir)) {
+      console.log('    (dist/ absent — skip content scan; build harness covers post-build)');
+      return;
+    }
+    /** @type {string[]} */
+    const hits = [];
+    const needles = ['smart-image-cli', 'better-sqlite3', 'tools/smart-image', 'tools\\smart-image'];
+    /**
+     * @param {string} dir
+     */
+    function walk(dir) {
+      for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, ent.name);
+        if (ent.isDirectory()) {
+          walk(full);
+          continue;
+        }
+        // Skip large binary assets; scan text-ish build outputs only.
+        if (!/\.(html|js|mjs|cjs|css|json|txt|xml|svg|map)$/i.test(ent.name)) continue;
+        let text;
+        try {
+          text = fs.readFileSync(full, 'utf8');
+        } catch {
+          continue;
+        }
+        for (const n of needles) {
+          if (text.includes(n)) hits.push(`${path.relative(distDir, full)}:${n}`);
+        }
+      }
+    }
+    walk(distDir);
+    assert(hits.length === 0, `dist/ must not reference capsule/CLI: ${hits.slice(0, 10).join(', ')}`);
+  });
+
+  // --- image-tooling wrapper + lifecycle (Unit 2) ---
+  const capDir = REPO_ROOT ? path.join(REPO_ROOT, 'tools', 'smart-image') : '';
+  const runJs = capDir ? path.join(capDir, 'run.mjs') : '';
+  const checkJs = capDir ? path.join(capDir, 'check.mjs') : '';
+
+  /** @param {string} v */
+  const qCmd = (v) =>
+    v === '' ? '""' : /[\s"&<>|^%!]/.test(v) ? `"${String(v).replace(/"/g, '""')}"` : v;
+
+  /**
+   * @param {string} cmd
+   * @param {string[]} args
+   * @param {{ env?: NodeJS.ProcessEnv, cwd?: string }} [o]
+   */
+  function spawnArgv(cmd, args, o = {}) {
+    let c = cmd;
+    let a = [...args];
+    let verbatim = false;
+    if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(cmd)) {
+      c = process.env.ComSpec || 'cmd.exe';
+      a = ['/d', '/s', '/c', `"${[cmd, ...args].map(qCmd).join(' ')}"`];
+      verbatim = true;
+    }
+    return spawnSync(c, a, {
+      encoding: 'utf8',
+      cwd: o.cwd || REPO_ROOT || process.cwd(),
+      env: { ...process.env, ...(o.env || {}) },
+      shell: false,
+      windowsHide: true,
+      windowsVerbatimArguments: verbatim,
+    });
+  }
+
+  /** @param {string[]} args @param {{ env?: NodeJS.ProcessEnv, cwd?: string }} [o] */
+  function runPnpm(args, o = {}) {
+    const bin = resolveCommandPath('pnpm');
+    assert(Boolean(bin), 'pnpm required');
+    return spawnArgv(/** @type {string} */ (bin), args, o);
+  }
+  /** @param {string[]} args @param {{ env?: NodeJS.ProcessEnv }} [o] */
+  const imgRun = (args, o = {}) =>
+    spawnSync(process.execPath, [runJs, ...args], {
+      encoding: 'utf8',
+      cwd: REPO_ROOT,
+      env: { ...process.env, ...(o.env || {}) },
+      shell: false,
+      windowsHide: true,
+    });
+  /** @param {{ env?: NodeJS.ProcessEnv }} [o] */
+  const imgCheck = (o = {}) =>
+    spawnSync(process.execPath, [checkJs], {
+      encoding: 'utf8',
+      cwd: REPO_ROOT,
+      env: { ...process.env, ...(o.env || {}) },
+      shell: false,
+      windowsHide: true,
+    });
+  /** @param {import('node:child_process').SpawnSyncReturns<string>} r */
+  const out = (r) => `${r.stdout || ''}\n${r.stderr || ''}`;
+
+  await test('images:run passes shell metacharacters as literal argv (exit 3, no side effects)', () => {
+    assert(REPO_ROOT && fs.existsSync(runJs), 'run.mjs required');
+    const marker = path.join(os.tmpdir(), `si-side-${process.pid}.txt`);
+    if (fs.existsSync(marker)) fs.rmSync(marker, { force: true });
+    for (const payload of [
+      '--json; rm -rf /',
+      `$(echo pwned > "${marker}")`,
+      `&& echo pwned > "${marker}"`,
+    ]) {
+      for (const r of [runPnpm(['run', 'images:run', '--', payload]), imgRun([payload])]) {
+        assert(r.status === 3, `exit 3 expected, got ${r.status}: ${out(r).slice(0, 300)}`);
+        assert(/invalid_input|unknown|error/i.test(out(r)), `invalid_input for ${payload}`);
+      }
+      assert(!fs.existsSync(marker), `no side-effect file for ${payload}`);
+    }
+  });
+
+  await test('Windows smart-img bin is silent while wrapper emits parseable doctor JSON', () => {
+    assert(REPO_ROOT && fs.existsSync(runJs), 'run.mjs required');
+    const binCmd = path.join(capDir, 'node_modules', '.bin', 'smart-img.CMD');
+    assert(
+      fs.existsSync(binCmd) || fs.existsSync(path.join(capDir, 'node_modules', '.bin', 'smart-img')),
+      'smart-img bin required',
+    );
+    if (process.platform === 'win32' && fs.existsSync(binCmd)) {
+      const bin = spawnArgv(binCmd, ['doctor', '--json']);
+      assert(
+        `${bin.stdout || ''}${bin.stderr || ''}`.trim().length === 0,
+        `bin must be silent, got ${out(bin).slice(0, 200)}`,
+      );
+    }
+    for (const wrap of [runPnpm(['run', 'images:run', '--', 'doctor', '--json']), imgRun(['doctor', '--json'])]) {
+      assert(wrap.status === 0, `wrapper exit 0, got ${wrap.status}: ${wrap.stderr}`);
+      const parsed = JSON.parse((wrap.stdout || '').trim());
+      assert(parsed.command === 'doctor' || parsed.ok === true, 'doctor JSON');
+      assert(Array.isArray(parsed.details?.checks) || parsed.status === 'success', 'doctor checks');
+    }
+  });
+
+  await test('images:* never hooked from install/build/validate/CI; scripts exist', () => {
+    assert(REPO_ROOT, 'repo root');
+    const pkg = readJson(path.join(REPO_ROOT, 'package.json'));
+    const s = pkg.scripts || {};
+    assert(/frozen-lockfile/.test(s['images:setup'] || '') && /tools\/smart-image/.test(s['images:setup'] || ''));
+    assert(/tools\/smart-image\/run\.mjs/.test(s['images:run'] || ''));
+    assert(/tools\/smart-image\/check\.mjs/.test(s['images:check'] || ''));
+    for (const k of ['preinstall', 'postinstall', 'prepare', 'prepublishOnly', 'build', 'validate:data', 'ci:install']) {
+      assert(!/images:/.test(s[k] || ''), `${k} must not reference images:`);
+    }
+    const ci = path.join(REPO_ROOT, '.github');
+    if (fs.existsSync(ci)) {
+      /** @param {string} d */
+      const walk = (d) => {
+        for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+          const f = path.join(d, e.name);
+          if (e.isDirectory()) walk(f);
+          else if (/\.ya?ml$/i.test(e.name)) {
+            assert(!/images:(check|setup|run)/.test(fs.readFileSync(f, 'utf8')), `CI ${f}`);
+          }
+        }
+      };
+      walk(ci);
+    }
+  });
+
+  await test('missing capsule / corrupt lock / offline setup remediate; provider is warning', () => {
+    assert(REPO_ROOT && fs.existsSync(checkJs) && fs.existsSync(capDir), 'capsule required');
+    for (const p of [
+      path.join(REPO_ROOT, 'tools', 'smart-image-MISSING', 'check.mjs'),
+      path.join(REPO_ROOT, 'tools', 'smart-image-MISSING', 'run.mjs'),
+    ]) {
+      const r = spawnSync(process.execPath, [p], { encoding: 'utf8', shell: false, windowsHide: true });
+      assert(r.error || r.status !== 0, `missing path must fail: ${p}`);
+    }
+
+    const tmpCap = fs.mkdtempSync(path.join(os.tmpdir(), 'si-cap-'));
+    const emptyStore = fs.mkdtempSync(path.join(os.tmpdir(), 'si-store-'));
+    try {
+      for (const f of ['package.json', 'pnpm-workspace.yaml', 'pnpm-lock.yaml', 'check.mjs', 'run.mjs']) {
+        fs.copyFileSync(path.join(capDir, f), path.join(tmpCap, f));
+      }
+      const noNm = spawnSync(process.execPath, [path.join(tmpCap, 'check.mjs')], {
+        encoding: 'utf8',
+        shell: false,
+        windowsHide: true,
+      });
+      assert(noNm.status === 1 && /images:setup|not ready|not installed/i.test(out(noNm)));
+      const noRun = spawnSync(process.execPath, [path.join(tmpCap, 'run.mjs'), 'doctor', '--json'], {
+        encoding: 'utf8',
+        shell: false,
+        windowsHide: true,
+      });
+      assert(noRun.status === 1 && /images:setup/i.test(out(noRun)));
+      const offline = runPnpm(
+        ['install', '--frozen-lockfile', '--dir', tmpCap, '--offline', '--store-dir', emptyStore],
+      );
+      assert(offline.status !== 0 && /ERR_|error|failed|offline|not found|ENOENT/i.test(out(offline)));
+    } finally {
+      fs.rmSync(tmpCap, { recursive: true, force: true });
+      fs.rmSync(emptyStore, { recursive: true, force: true });
+    }
+
+    const lockPath = path.join(capDir, 'pnpm-lock.yaml');
+    const lockOrig = fs.readFileSync(lockPath);
+    try {
+      fs.writeFileSync(lockPath, 'this: is: not: valid: lockfile\n');
+      const setup = runPnpm(['run', 'images:setup']);
+      assert(setup.status !== 0 && /ERR_|error|failed|lock/i.test(out(setup)));
+      const bad = imgCheck();
+      assert(bad.status === 1 && /corrupt|lockfile|not ready|Remediation|images:setup/i.test(out(bad)));
+    } finally {
+      fs.writeFileSync(lockPath, lockOrig);
+    }
+
+    const healthy = imgCheck();
+    assert(healthy.status === 0 && /ready/i.test(healthy.stdout || ''));
+
+    const emptyCfg = fs.mkdtempSync(path.join(os.tmpdir(), 'si-cfg-'));
+    try {
+      const env = {
+        ...process.env,
+        APPDATA: emptyCfg,
+        XDG_CONFIG_HOME: emptyCfg,
+        HOME: emptyCfg,
+        USERPROFILE: emptyCfg,
+      };
+      const warn = imgCheck({ env });
+      assert(warn.status === 0 && /ready/i.test(warn.stdout || ''));
+      assert(/warning:.*provider/i.test(warn.stderr || ''), warn.stderr);
+      const pick = imgRun(
+        [
+          'pick',
+          REPO_ROOT,
+          '--source',
+          'pixabay',
+          '--category',
+          'exterior',
+          '--orientation',
+          'landscape',
+          '--width',
+          '800',
+          '--height',
+          '600',
+          '--json',
+        ],
+        { env },
+      );
+      assert(pick.status !== 0, `provider pick must fail, got ${pick.status}`);
+      assert(
+        pick.status === 4 || /provider|api.?key|pixabay|failed|error/i.test(out(pick)),
+        out(pick).slice(0, 300),
+      );
+    } finally {
+      fs.rmSync(emptyCfg, { recursive: true, force: true });
+    }
+  });
+
+  // --- image-tooling scaffold / git isolation (Unit 3) ---
+  await test('isDeniedName covers every deny entry, rules, and near-miss negatives', () => {
+    const denyDirs = [
+      'node_modules',
+      'dist',
+      '.astro',
+      '.git',
+      '.codegraph',
+      'docs_trash',
+      'openspec',
+      'logs',
+      'packages',
+      '.atl',
+      'CUSTOMER-IMAGES',
+      '.img-ia',
+    ];
+    const denyFiles = ['package-lock.json'];
+    for (const name of denyDirs) {
+      assert(isDeniedName(name) === true, `deny dir ${name}`);
+    }
+    for (const name of denyFiles) {
+      assert(isDeniedName(name) === true, `deny file ${name}`);
+    }
+    assert(isDeniedName('debug.log') === true, '*.log rule');
+    assert(isDeniedName('app.log') === true, '*.log rule (app.log)');
+    assert(isDeniedName('.env') === true, '.env* rule');
+    assert(isDeniedName('.env.local') === true, '.env* rule (.env.local)');
+    assert(isDeniedName('.env.production') === true, '.env* rule (.env.production)');
+    // Near-miss / unrelated basenames must stay allowed
+    assert(isDeniedName('CUSTOMER-IMAGES.md') === false, 'CUSTOMER-IMAGES.md near-miss');
+    assert(isDeniedName('my-CUSTOMER-IMAGES') === false, 'my-CUSTOMER-IMAGES near-miss');
+    assert(isDeniedName('tools') === false, 'tools must never be denied');
+    assert(isDeniedName('smart-image') === false, 'smart-image basename allowed');
+    assert(isDeniedName('_out') === false, 'bare _out must never be denied');
+    assert(isDeniedName('README.sh') === false, 'README.sh alone is not denied');
+  });
+
+  await test('git check-ignore is root-relative for state and capsule node_modules only', () => {
+    assert(REPO_ROOT, 'expected local template root');
+    /**
+     * @param {string} rel
+     * @returns {boolean} true when git treats path as ignored
+     */
+    function isIgnored(rel) {
+      const r = spawnSync('git', ['check-ignore', '-q', '--', rel], {
+        cwd: REPO_ROOT,
+        encoding: 'utf8',
+        shell: false,
+        windowsHide: true,
+      });
+      if (r.error) throw r.error;
+      return r.status === 0;
+    }
+
+    // Directory patterns use trailing slash; also prove bare dir names when they exist.
+    assert(isIgnored('CUSTOMER-IMAGES/') === true, 'root CUSTOMER-IMAGES/ ignored');
+    assert(isIgnored('.img-ia/') === true, 'root .img-ia/ ignored');
+    assert(isIgnored('tools/smart-image/node_modules') === true, 'capsule node_modules ignored');
+    assert(isIgnored('tools/smart-image/node_modules/') === true, 'capsule node_modules/ ignored');
+
+    const probeCi = path.join(REPO_ROOT, 'CUSTOMER-IMAGES');
+    const probeImg = path.join(REPO_ROOT, '.img-ia');
+    /** @type {string[]} */
+    const probes = [];
+    try {
+      if (!fs.existsSync(probeCi)) {
+        fs.mkdirSync(probeCi, { recursive: true });
+        probes.push(probeCi);
+      }
+      if (!fs.existsSync(probeImg)) {
+        fs.mkdirSync(probeImg, { recursive: true });
+        probes.push(probeImg);
+      }
+      assert(isIgnored('CUSTOMER-IMAGES') === true, 'root CUSTOMER-IMAGES dir ignored');
+      assert(isIgnored('.img-ia') === true, 'root .img-ia dir ignored');
+      assert(isIgnored('CUSTOMER-IMAGES/secret.jpg') === true, 'root CUSTOMER-IMAGES child ignored');
+      assert(isIgnored('.img-ia/_out/x.png') === true, 'root .img-ia child ignored');
+    } finally {
+      for (const p of probes) {
+        try {
+          fs.rmSync(p, { recursive: true, force: true });
+        } catch {
+          // ignore
+        }
+      }
+    }
+
+    // Nested lookalikes remain trackable (root-anchored / patterns only).
+    // Avoid bare trailing-slash probes here: CRLF blank gitignore lines can
+    // confuse check-ignore's directory-only matching on some Windows git builds.
+    assert(isIgnored('src/CUSTOMER-IMAGES') === false, 'nested CUSTOMER-IMAGES trackable');
+    assert(isIgnored('src/CUSTOMER-IMAGES/photo.jpg') === false, 'nested CUSTOMER-IMAGES file trackable');
+    assert(isIgnored('docs/.img-ia') === false, 'nested .img-ia trackable');
+    assert(isIgnored('docs/.img-ia/readme') === false, 'nested .img-ia child trackable');
+    assert(isIgnored('packages/create-contractor-site/.img-ia') === false, 'nested package .img-ia trackable');
+
+    // Capsule source / manifest / lock / wrapper remain trackable
+    for (const rel of [
+      'tools/smart-image/package.json',
+      'tools/smart-image/pnpm-workspace.yaml',
+      'tools/smart-image/pnpm-lock.yaml',
+      'tools/smart-image/run.mjs',
+      'tools/smart-image/check.mjs',
+    ]) {
+      assert(isIgnored(rel) === false, `${rel} must remain trackable`);
+    }
+  });
+
+  await test('copyTemplate excludes denied parents, keeps unrelated _out, required misses loud', () => {
+    const src = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-deny-src-'));
+    const dest = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-deny-dst-'));
+    try {
+      // Minimal template-shaped tree
+      fs.writeFileSync(path.join(src, 'keep.txt'), 'safe');
+      fs.mkdirSync(path.join(src, 'CUSTOMER-IMAGES'), { recursive: true });
+      fs.writeFileSync(path.join(src, 'CUSTOMER-IMAGES', 'secret.jpg'), 'NOCOPY');
+      fs.mkdirSync(path.join(src, '.img-ia', '_out'), { recursive: true });
+      fs.writeFileSync(path.join(src, '.img-ia', 'README.sh'), '#!/bin/sh\necho leak\n');
+      fs.writeFileSync(path.join(src, '.img-ia', '_out', 'candidate.png'), 'NOCOPY');
+      fs.mkdirSync(path.join(src, '_out'), { recursive: true });
+      fs.writeFileSync(path.join(src, '_out', 'client-keep.txt'), 'KEEP');
+      fs.mkdirSync(path.join(src, 'tools', 'smart-image'), { recursive: true });
+      fs.writeFileSync(path.join(src, 'tools', 'smart-image', 'run.mjs'), '// wrapper');
+
+      const { skipped } = copyTemplate(src, dest);
+      const skippedNorm = skipped.map((s) => s.replaceAll('\\', '/'));
+
+      assert(fs.existsSync(path.join(dest, 'keep.txt')), 'unrelated file copies');
+      assert(fs.existsSync(path.join(dest, '_out', 'client-keep.txt')), 'unrelated _out copies');
+      assert(fs.existsSync(path.join(dest, 'tools', 'smart-image', 'run.mjs')), 'tools/smart-image retained');
+      assert(!fs.existsSync(path.join(dest, 'CUSTOMER-IMAGES')), 'CUSTOMER-IMAGES excluded');
+      assert(!fs.existsSync(path.join(dest, '.img-ia')), '.img-ia excluded (parent deny)');
+      assert(
+        !fs.existsSync(path.join(dest, '.img-ia', 'README.sh')),
+        '.img-ia/README.sh absent — no recurse into denied parent',
+      );
+      assert(
+        !fs.existsSync(path.join(dest, '.img-ia', '_out', 'candidate.png')),
+        '.img-ia/_out bytes never copied',
+      );
+      assert(skippedNorm.includes('CUSTOMER-IMAGES'), 'skipped lists CUSTOMER-IMAGES');
+      assert(skippedNorm.includes('.img-ia'), 'skipped lists .img-ia');
+      assert(!skippedNorm.some((s) => s === '_out' || s.startsWith('_out/')), '_out not skipped');
+
+      // assertRequiredCopied: every required capsule/wrapper/skill path missing is reported
+      const stubRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-req-'));
+      try {
+        for (const rel of REQUIRED_AFTER_COPY) {
+          const full = path.join(stubRoot, ...rel.split('/'));
+          const looksFile = path.extname(rel) !== '' || rel.endsWith('package.json');
+          if (looksFile) {
+            fs.mkdirSync(path.dirname(full), { recursive: true });
+            fs.writeFileSync(full, 'x');
+          } else {
+            fs.mkdirSync(full, { recursive: true });
+          }
+        }
+        assert(assertRequiredCopied(stubRoot).length === 0, 'full stub must pass required check');
+
+        const requiredMustExist = [
+          'tools/smart-image/package.json',
+          'tools/smart-image/pnpm-workspace.yaml',
+          'tools/smart-image/pnpm-lock.yaml',
+          'tools/smart-image/run.mjs',
+          'tools/smart-image/check.mjs',
+          '.agents/skills/smart-image-cli/SKILL.md',
+        ];
+        for (const rel of requiredMustExist) {
+          assert(
+            REQUIRED_AFTER_COPY.includes(rel),
+            `REQUIRED_AFTER_COPY must list ${rel}`,
+          );
+        }
+
+        for (const rel of requiredMustExist) {
+          const full = path.join(stubRoot, ...rel.split('/'));
+          fs.rmSync(full, { force: true });
+          const missing = assertRequiredCopied(stubRoot);
+          assert(missing.includes(rel), `missing must report ${rel}, got ${missing.join(',')}`);
+          // restore for next iteration
+          fs.mkdirSync(path.dirname(full), { recursive: true });
+          fs.writeFileSync(full, 'x');
+        }
+      } finally {
+        fs.rmSync(stubRoot, { recursive: true, force: true });
+      }
+    } finally {
+      fs.rmSync(src, { recursive: true, force: true });
+      fs.rmSync(dest, { recursive: true, force: true });
+    }
+  });
+
   const skipE2E = process.env.SKIP_CLI_E2E === '1';
   if (skipE2E) {
     console.log('\n  ↷ SKIP_CLI_E2E=1 — skipping temp-target full scaffold');
   } else {
+    /** @type {string[]} */
+    const e2eSeeds = [];
+    if (REPO_ROOT) {
+      const seedCi = path.join(REPO_ROOT, 'CUSTOMER-IMAGES');
+      const seedImgIaRoot = path.join(REPO_ROOT, '.img-ia');
+      if (!fs.existsSync(seedCi)) {
+        fs.mkdirSync(seedCi, { recursive: true });
+        fs.writeFileSync(path.join(seedCi, 'e2e-secret.jpg'), 'NOCOPY');
+        e2eSeeds.push(seedCi);
+      }
+      if (!fs.existsSync(seedImgIaRoot)) {
+        fs.mkdirSync(path.join(seedImgIaRoot, '_out'), { recursive: true });
+        fs.writeFileSync(path.join(seedImgIaRoot, '_out', 'e2e-candidate.png'), 'NOCOPY');
+        e2eSeeds.push(seedImgIaRoot);
+      }
+    }
+    try {
     await test('temp-target --yes scaffold install/validate/build/git', () => {
       assert(REPO_ROOT, 'expected local template root for E2E');
       const target = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-e2e-'));
@@ -462,11 +1660,58 @@ async function main() {
         !fs.existsSync(path.join(targetDir, 'packages')),
         'packages/ must not be copied',
       );
+      assert(!fs.existsSync(path.join(targetDir, 'CUSTOMER-IMAGES')), 'CUSTOMER-IMAGES excluded');
+      assert(!fs.existsSync(path.join(targetDir, '.img-ia')), '.img-ia excluded');
+      assert(fs.existsSync(path.join(targetDir, 'tools', 'smart-image', 'package.json')), 'capsule manifest');
+      assert(fs.existsSync(path.join(targetDir, 'tools', 'smart-image', 'pnpm-workspace.yaml')), 'capsule workspace');
+      assert(fs.existsSync(path.join(targetDir, 'tools', 'smart-image', 'pnpm-lock.yaml')), 'capsule lock');
+      assert(fs.existsSync(path.join(targetDir, 'tools', 'smart-image', 'run.mjs')), 'wrapper run.mjs');
+      assert(fs.existsSync(path.join(targetDir, 'tools', 'smart-image', 'check.mjs')), 'wrapper check.mjs');
+      assert(
+        fs.existsSync(path.join(targetDir, '.agents', 'skills', 'smart-image-cli', 'SKILL.md')),
+        'skill retained',
+      );
+      const tgtPkg = JSON.parse(fs.readFileSync(path.join(targetDir, 'package.json'), 'utf8'));
+      for (const k of ['images:check', 'images:setup', 'images:run']) {
+        assert(typeof tgtPkg.scripts?.[k] === 'string', `scaffold scripts must include ${k}`);
+      }
 
       const business = JSON.parse(
         fs.readFileSync(path.join(targetDir, 'src/data/business.json'), 'utf8'),
       );
       assert(business.name === 'Acme Masonry', 'expected replaced business name');
+      // --yes omits trust/payment/hours → buildAnswers defaults (not sample-specific facts)
+      assert(business.free_estimate === DEFAULT_FREE_ESTIMATE, 'E2E free_estimate default');
+      assert(
+        business.years_experience === DEFAULT_YEARS_EXPERIENCE,
+        'E2E years_experience default',
+      );
+      assert(business.license === DEFAULT_LICENSE, 'E2E license default');
+      assert(business.insurance === DEFAULT_INSURANCE, 'E2E insurance default');
+      assert(business.founded_year === '', 'E2E founded_year omitted → ""');
+      assert(
+        JSON.stringify(business.payment_methods) === JSON.stringify(DEFAULT_PAYMENT_METHODS),
+        'E2E payment_methods defaults',
+      );
+      assert(business.payment_methods.length > 0, 'E2E payment_methods never []');
+      assert(
+        JSON.stringify(business.hours) === JSON.stringify(DEFAULT_HOURS),
+        'E2E hours defaults',
+      );
+      assert(
+        business.hours.every((h) => typeof h.days === 'string' && typeof h.time === 'string'),
+        'E2E hours shape',
+      );
+      assert(JSON.stringify(business.social) === '{}', 'E2E omitted social → {}');
+      const siteE2E = readJson(path.join(targetDir, 'src/data/site.json'));
+      const dirsE2E = readJson(path.join(targetDir, 'src/data/directories.json'));
+      assert(siteE2E.features.enable_directories === false, 'E2E no dirs → enable false');
+      assert(dirsE2E.directories.length >= 1, 'E2E directories min(1)');
+      assert(
+        siteE2E.site_type === 'multipage',
+        `E2E --yes site_type multipage, got ${siteE2E.site_type}`,
+      );
+      // Full scaffold already ran validate:data + build (includes route gate) successfully.
 
       const services = JSON.parse(
         fs.readFileSync(path.join(targetDir, 'src/data/services.json'), 'utf8'),
@@ -490,6 +1735,15 @@ async function main() {
         console.warn(`    (could not fully remove ${targetDir})`);
       }
     });
+    } finally {
+      for (const p of e2eSeeds) {
+        try {
+          fs.rmSync(p, { recursive: true, force: true });
+        } catch {
+          // ignore seed cleanup failures
+        }
+      }
+    }
   }
 
   console.log(`\n${passed} passed, ${failed} failed`);