@runwell/shopify-toolkit 0.1.0

package/README.md

@@ -0,0 +1,87 @@
+# @runwell/shopify-toolkit
+
+Reusable Shopify theme modules from Runwell. Each module replaces a typically app-driven e-commerce feature with native Liquid + JS + CSS so the client store ships with zero apps and zero monthly app fees, while every client gets the same polished baseline.
+
+Built initially while shipping the Lushi storefront. Designed to apply across every Shopify client we onboard (Lushi, Lusha, Books and Bourbon, Receptia, and forward).
+
+## What is in here
+
+A collection of modules under `modules/`. Each module is a self-contained folder with everything Shopify needs (sections, snippets, JS, CSS, admin paste blocks) and a `module.json` describing config schema, file layout, and any merchant admin steps.
+
+A sync CLI (`runwell-shopify`) that reads a per-client `runwell.config.json` and copies the right module files (with the right variant and brand vars) into the client's theme directory, ready to push.
+
+## Install
+
+```bash
+npm install -D @runwell/shopify-toolkit
+```
+
+Then in the client theme repo create a `runwell.config.json` (see `examples/`) and run:
+
+```bash
+npx runwell-shopify sync
+```
+
+The CLI writes the module files into `assets/`, `sections/`, `snippets/`, and `templates/` of the target theme. A `runwell-manifest.json` is written so we can track which files the toolkit owns and detect drift.
+
+## Common commands
+
+```bash
+runwell-shopify sync              # apply runwell.config.json to current theme
+runwell-shopify list              # list available + installed modules
+runwell-shopify add <module>      # enable a module in runwell.config.json
+runwell-shopify remove <module>   # disable + clean files
+runwell-shopify doctor            # detect drift between manifest and theme
+runwell-shopify validate          # run @shopify/dev-mcp validators on synced files
+```
+
+## Module list (current)
+
+The full list lives in `modules/INDEX.md` (auto-generated from each module's `module.json`).
+
+Categories at a glance:
+
+- **Conversion**: post-purchase-upsell, exit-intent, sticky-atc, inventory-urgency, delivery-estimate, cart-cross-sell, cart-freeship-progress, cart-usps
+- **Social proof**: testimonials, reviews, press-bar, product-badges
+- **Storefront sections**: editorial-hero, editorial-block, how-it-works, trust-badges, risk-reversal, comparison-table, shipping-bar, faq
+- **PDP**: pdp-trust-checks, pdp-journal-link, pdp-ingredients, recently-viewed
+- **Catalog and pricing**: bundle-builder, quantity-breaks, gift-with-purchase, subscriptions
+- **Customer**: wishlist, quick-view, loyalty-tiers
+
+## Variants
+
+Some modules ship multiple visual treatments. The client config picks one. See [ARCHITECTURE.md](./ARCHITECTURE.md) section 2.0.5 for the full pattern.
+
+For example, `testimonials` ships:
+- `grid-quotes` (default; editorial brands)
+- `carousel-ugc` (DTC, UGC-heavy brands)
+- `single-quote-hero` (high-end, low-density)
+- `masonry`
+
+The client config picks one:
+
+```json
+"testimonials": {
+  "enabled": true,
+  "variant": "carousel-ugc",
+  "config": { "heading": "From the feed.", "autoplay_seconds": 5 }
+}
+```
+
+## Architecture
+
+Full design lives in [ARCHITECTURE.md](./ARCHITECTURE.md). Source of truth is `claude-PM/projects/shopify-agent/runwell-shopify-toolkit-architecture.md`.
+
+## Integration with shopify-agent
+
+This toolkit is the codified output of the Runwell shopify-agent skills. When the agent is asked to add a feature to a client store, it checks this toolkit first before generating one-off Liquid. See `claude-PM/foundation/skills/shopify-storefront/` and `claude-PM/foundation/skills/shopify-cro/` for the routing logic.
+
+## Distribution
+
+- Published as `@runwell/shopify-toolkit` on npmjs (private until v1.0)
+- Authentication: NPM token configured under `runwellsystems` org. Token in `~/.npmrc` and key-manager
+- Private clients install via npm; can also be vendored as a git submodule for offline use
+
+## License
+
+UNLICENSED. Internal Runwell tooling.

package/bin/runwell-shopify

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { sync } from '../lib/sync.js';
+import { list } from '../lib/list.js';
+import { add } from '../lib/add.js';
+import { remove } from '../lib/remove.js';
+import { doctor } from '../lib/doctor.js';
+import { validate } from '../lib/validate.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TOOLKIT_ROOT = path.resolve(__dirname, '..');
+
+const argv = process.argv.slice(2);
+const cmd = argv[0];
+
+function parseFlags(args) {
+  const flags = { positional: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith('--')) {
+      const key = a.slice(2);
+      const next = args[i + 1];
+      if (!next || next.startsWith('--')) {
+        flags[key] = true;
+      } else {
+        flags[key] = next;
+        i++;
+      }
+    } else {
+      flags.positional.push(a);
+    }
+  }
+  return flags;
+}
+
+function help() {
+  console.log(`runwell-shopify <command> [options]
+
+Commands:
+  sync                            Apply runwell.config.json to the target theme
+  list                            List available + installed modules
+  add <module>                    Enable a module in runwell.config.json
+  remove <module>                 Disable + clean a module's files
+  doctor                          Detect drift between manifest and theme
+  validate                        Run @shopify/dev-mcp validators on synced files
+  help                            Show this help
+
+Common options:
+  --config <path>                 Path to runwell.config.json (default ./runwell.config.json)
+  --target <path>                 Target theme dir (default cwd)
+  --dry-run                       Show what would change without writing
+  --verbose                       Verbose logging
+`);
+}
+
+const flags = parseFlags(argv.slice(1));
+flags.toolkitRoot = TOOLKIT_ROOT;
+
+(async () => {
+  try {
+    switch (cmd) {
+      case 'sync':
+        await sync(flags);
+        break;
+      case 'list':
+        await list(flags);
+        break;
+      case 'add':
+        await add(flags);
+        break;
+      case 'remove':
+        await remove(flags);
+        break;
+      case 'doctor':
+        await doctor(flags);
+        break;
+      case 'validate':
+        await validate(flags);
+        break;
+      case undefined:
+      case 'help':
+      case '--help':
+      case '-h':
+        help();
+        break;
+      default:
+        console.error('Unknown command: ' + cmd);
+        help();
+        process.exit(1);
+    }
+  } catch (err) {
+    console.error('Error:', err.message);
+    if (flags.verbose) console.error(err.stack);
+    process.exit(1);
+  }
+})();

package/lib/add.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadModuleManifest } from './config-loader.js';
+
+export async function add(flags) {
+  const moduleName = flags.positional[0];
+  if (!moduleName) throw new Error('Usage: runwell-shopify add <module-name>');
+
+  const configPath = path.resolve(flags.config || './runwell.config.json');
+  let config;
+  if (fs.existsSync(configPath)) {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } else {
+    config = bootstrapConfig();
+    console.log(`Created new config at ${configPath}`);
+  }
+
+  const manifest = loadModuleManifest(flags.toolkitRoot, moduleName);
+  config.modules = config.modules || {};
+  if (config.modules[moduleName] && config.modules[moduleName].enabled) {
+    console.log(`${moduleName} is already enabled in config.`);
+    return;
+  }
+
+  const defaults = {};
+  if (manifest.config && manifest.config.schema) {
+    for (const [key, spec] of Object.entries(manifest.config.schema)) {
+      if (spec.default !== undefined) defaults[key] = spec.default;
+    }
+  }
+
+  config.modules[moduleName] = {
+    enabled: true,
+    config: defaults
+  };
+  if (manifest.default_variant) {
+    config.modules[moduleName].variant = manifest.default_variant;
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`Added ${moduleName} to ${path.relative(process.cwd(), configPath)}`);
+  if (manifest.admin_steps && manifest.admin_steps.length) {
+    console.log(`\nAdmin steps required for this module:`);
+    manifest.admin_steps.forEach((s, i) => {
+      console.log(`  ${i + 1}. ${s.label}`);
+      if (s.summary) console.log(`     ${s.summary}`);
+    });
+  }
+  console.log(`\nNext: runwell-shopify sync`);
+}
+
+function bootstrapConfig() {
+  return {
+    $schema: 'https://github.com/runwellsystems/runwell-shopify-toolkit/raw/main/schemas/runwell.config.schema.json',
+    client: 'unknown',
+    store: 'unknown.myshopify.com',
+    theme_path: '.',
+    toolkit_version: '^0.1.0',
+    brand: {
+      primary: '#000000',
+      accent: '#000000',
+      currency: 'USD'
+    },
+    modules: {}
+  };
+}

package/lib/config-loader.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function loadConfig(configPath) {
+  const abs = path.resolve(configPath);
+  if (!fs.existsSync(abs)) {
+    throw new Error(`Config not found at ${abs}. Run "runwell-shopify add <module>" to bootstrap one.`);
+  }
+  const raw = fs.readFileSync(abs, 'utf8');
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Failed to parse ${abs}: ${e.message}`);
+  }
+  if (!parsed.client) throw new Error('Config missing required field "client"');
+  if (!parsed.brand) parsed.brand = {};
+  if (!parsed.modules) parsed.modules = {};
+  return { config: parsed, path: abs };
+}
+
+export function loadModuleManifest(toolkitRoot, moduleName) {
+  const manifestPath = path.join(toolkitRoot, 'modules', moduleName, 'module.json');
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`Module "${moduleName}" not found at ${manifestPath}`);
+  }
+  return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+}
+
+export function listAvailableModules(toolkitRoot) {
+  const modulesDir = path.join(toolkitRoot, 'modules');
+  if (!fs.existsSync(modulesDir)) return [];
+  return fs.readdirSync(modulesDir)
+    .filter(name => !name.startsWith('_') && !name.startsWith('.'))
+    .filter(name => fs.existsSync(path.join(modulesDir, name, 'module.json')));
+}
+
+export function resolveVariant(manifest, requested) {
+  if (!manifest.variants) return null;
+  const variantName = requested || manifest.default_variant;
+  if (!variantName) return null;
+  const variant = manifest.variants[variantName];
+  if (!variant) {
+    throw new Error(`Variant "${variantName}" not found in module ${manifest.name}. Available: ${Object.keys(manifest.variants).join(', ')}`);
+  }
+  return { name: variantName, ...variant };
+}

package/lib/doctor.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { loadConfig, loadModuleManifest, resolveVariant } from './config-loader.js';
+import { interpolate } from './template.js';
+
+export async function doctor(flags) {
+  const targetDir = path.resolve(flags.target || process.cwd());
+  const manifestPath = path.join(targetDir, 'runwell-manifest.json');
+  if (!fs.existsSync(manifestPath)) {
+    console.log('No runwell-manifest.json found. Run "runwell-shopify sync" first.');
+    return;
+  }
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  const { config } = loadConfig(flags.config || './runwell.config.json');
+
+  let cleanFiles = 0;
+  let driftFiles = 0;
+  let missingFiles = 0;
+
+  for (const tracked of manifest.files) {
+    const targetPath = path.join(targetDir, tracked.path);
+    if (!fs.existsSync(targetPath)) {
+      console.log(`  [missing] ${tracked.path}`);
+      missingFiles++;
+      continue;
+    }
+
+    const moduleManifest = loadModuleManifest(flags.toolkitRoot, tracked.module);
+    const cfgEntry = config.modules[tracked.module];
+    const variant = resolveVariant(moduleManifest, cfgEntry && cfgEntry.variant);
+    const interpolationVars = {
+      config: (cfgEntry && cfgEntry.config) || {},
+      brand: config.brand,
+      client: { name: config.client, store: config.store }
+    };
+
+    // Resolve original source path
+    const filename = path.basename(tracked.path);
+    const fileGroups = (variant && variant.files) || moduleManifest.files || {};
+    const bucketFiles = fileGroups[tracked.bucket] || [];
+    const sourceRel = bucketFiles.find(s => path.basename(s) === filename);
+    if (!sourceRel) continue;
+    const sourcePath = path.join(flags.toolkitRoot, 'modules', tracked.module, sourceRel);
+    if (!fs.existsSync(sourcePath)) continue;
+
+    const expected = interpolate(fs.readFileSync(sourcePath, 'utf8'), interpolationVars);
+    const actual = fs.readFileSync(targetPath, 'utf8');
+    if (hash(expected) === hash(actual)) {
+      cleanFiles++;
+    } else {
+      console.log(`  [drift]   ${tracked.path}`);
+      driftFiles++;
+    }
+  }
+
+  console.log(`\n${cleanFiles} clean, ${driftFiles} drifted, ${missingFiles} missing.`);
+  if (driftFiles > 0) {
+    console.log('Run "runwell-shopify sync" to overwrite drifted files.');
+    console.log('If the drift is intentional, move the changes into module config or a custom client section.');
+  }
+}
+
+function hash(str) {
+  return crypto.createHash('sha256').update(str).digest('hex');
+}

package/lib/list.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { listAvailableModules, loadModuleManifest, loadConfig } from './config-loader.js';
+
+export async function list(flags) {
+  const available = listAvailableModules(flags.toolkitRoot);
+
+  let installed = new Set();
+  try {
+    const { config } = loadConfig(flags.config || './runwell.config.json');
+    installed = new Set(Object.keys(config.modules || {}).filter(m => config.modules[m].enabled !== false));
+  } catch {
+    // no config in cwd; show available only
+  }
+
+  console.log('Runwell Shopify Toolkit modules:\n');
+  console.log('  Status   Name                          Category        Variants');
+  console.log('  -------  ----------------------------  --------------  --------------');
+
+  for (const name of available.sort()) {
+    let manifest;
+    try { manifest = loadModuleManifest(flags.toolkitRoot, name); }
+    catch { continue; }
+    const status = installed.has(name) ? '[on]   ' : '[ ]    ';
+    const cat = (manifest.category || '').padEnd(14);
+    const variants = manifest.variants ? Object.keys(manifest.variants).join(', ') : '(no variants)';
+    console.log(`  ${status}  ${name.padEnd(28)}  ${cat}  ${variants}`);
+  }
+
+  console.log(`\nTotal: ${available.length} modules. Installed in current config: ${installed.size}.`);
+}

package/lib/remove.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export async function remove(flags) {
+  const moduleName = flags.positional[0];
+  if (!moduleName) throw new Error('Usage: runwell-shopify remove <module-name>');
+
+  const configPath = path.resolve(flags.config || './runwell.config.json');
+  const targetDir = path.resolve(flags.target || process.cwd());
+  if (!fs.existsSync(configPath)) throw new Error(`No runwell.config.json at ${configPath}`);
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  if (!config.modules || !config.modules[moduleName]) {
+    console.log(`${moduleName} not in config; nothing to remove.`);
+    return;
+  }
+
+  // Read manifest to know which files this module owns
+  const manifestPath = path.join(targetDir, 'runwell-manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const owned = manifest.files.filter(f => f.module === moduleName);
+    for (const f of owned) {
+      const abs = path.join(targetDir, f.path);
+      if (fs.existsSync(abs)) {
+        fs.unlinkSync(abs);
+        console.log(`  - ${f.path}`);
+      }
+    }
+    manifest.files = manifest.files.filter(f => f.module !== moduleName);
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  }
+
+  config.modules[moduleName].enabled = false;
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`Disabled ${moduleName}.`);
+}

package/lib/sync.js

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig, loadModuleManifest, listAvailableModules, resolveVariant } from './config-loader.js';
+import { interpolate } from './template.js';
+
+export async function sync(flags) {
+  const configPath = flags.config || './runwell.config.json';
+  const targetDir = path.resolve(flags.target || process.cwd());
+  const dryRun = !!flags['dry-run'] || !!flags.dryRun;
+  const verbose = !!flags.verbose;
+
+  const { config, path: configFullPath } = loadConfig(configPath);
+  console.log(`Sync target:  ${targetDir}`);
+  console.log(`Config:       ${configFullPath}`);
+  console.log(`Client:       ${config.client}`);
+  if (dryRun) console.log('Dry run: no files will be written.');
+
+  const writtenFiles = [];
+  const removedFiles = [];
+
+  const moduleNames = Object.keys(config.modules);
+  for (const moduleName of moduleNames) {
+    const cfgEntry = config.modules[moduleName];
+    if (cfgEntry.enabled === false) {
+      if (verbose) console.log(`[skip] ${moduleName} (disabled)`);
+      continue;
+    }
+    const manifest = loadModuleManifest(flags.toolkitRoot, moduleName);
+    const variant = resolveVariant(manifest, cfgEntry.variant);
+    const moduleConfig = cfgEntry.config || {};
+
+    // Determine which files to copy: variant files override base files when present
+    const fileGroups = (variant && variant.files) || manifest.files || {};
+
+    const interpolationVars = {
+      config: moduleConfig,
+      brand: config.brand,
+      client: { name: config.client, store: config.store }
+    };
+
+    console.log(`\n[${moduleName}${variant ? ' / ' + variant.name : ''}]`);
+
+    for (const [bucket, fileList] of Object.entries(fileGroups)) {
+      if (!Array.isArray(fileList)) continue;
+      const targetSubdir = bucketToTargetDir(bucket, targetDir);
+      if (!targetSubdir) continue;
+      for (const relSrc of fileList) {
+        const sourcePath = path.join(flags.toolkitRoot, 'modules', moduleName, relSrc);
+        if (!fs.existsSync(sourcePath)) {
+          console.warn(`  [warn] missing source: ${sourcePath}`);
+          continue;
+        }
+        const filename = path.basename(relSrc);
+        const targetPath = path.join(targetSubdir, filename);
+        const isText = isTextFile(filename);
+        let content = fs.readFileSync(sourcePath, isText ? 'utf8' : null);
+        if (isText) content = interpolate(content, interpolationVars);
+
+        if (!dryRun) {
+          fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+          fs.writeFileSync(targetPath, content);
+        }
+        console.log(`  + ${path.relative(targetDir, targetPath)}`);
+        writtenFiles.push({ module: moduleName, target: targetPath, bucket });
+      }
+    }
+  }
+
+  // Manifest
+  const manifestPath = path.join(targetDir, 'runwell-manifest.json');
+  const manifestData = {
+    generated_at: new Date().toISOString(),
+    toolkit_version: getToolkitVersion(flags.toolkitRoot),
+    client: config.client,
+    files: writtenFiles.map(f => ({
+      module: f.module,
+      bucket: f.bucket,
+      path: path.relative(targetDir, f.target)
+    }))
+  };
+  if (!dryRun) fs.writeFileSync(manifestPath, JSON.stringify(manifestData, null, 2));
+  console.log(`\nManifest:     ${path.relative(targetDir, manifestPath)}`);
+  console.log(`Total files:  ${writtenFiles.length}`);
+}
+
+function bucketToTargetDir(bucket, targetDir) {
+  switch (bucket) {
+    case 'assets':         return path.join(targetDir, 'assets');
+    case 'snippets':       return path.join(targetDir, 'snippets');
+    case 'sections':       return path.join(targetDir, 'sections');
+    case 'templates':      return path.join(targetDir, 'templates');
+    case 'admin_blocks':   return path.join(targetDir, 'runwell-admin');
+    default: return null;
+  }
+}
+
+function isTextFile(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  return ['.liquid', '.js', '.css', '.json', '.html', '.svg', '.md', '.txt'].includes(ext);
+}
+
+function getToolkitVersion(toolkitRoot) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(toolkitRoot, 'package.json'), 'utf8'));
+    return pkg.version;
+  } catch { return 'unknown'; }
+}

package/lib/template.js

@@ -0,0 +1,57 @@
+/* Template interpolation for Runwell Shopify Toolkit module files.
+
+   Modules use {{config.X}} and {{brand.Y}} placeholders to inject
+   per-client values. Liquid placeholders that should pass through to
+   Shopify ({{ product.title }}) are escaped using a sentinel pattern:
+
+   In source files:   %LIQUID%{{ product.title }}%LIQUID_END%
+   After interpolate: {{ product.title }}
+
+   This keeps Shopify Liquid intact through the toolkit's templating
+   step, regardless of how aggressive the placeholder resolver is.
+*/
+
+const LIQUID_OPEN = '%LIQUID%';
+const LIQUID_CLOSE = '%LIQUID_END%';
+
+export function interpolate(source, vars) {
+  if (typeof source !== 'string') return source;
+
+  // First pass: protect Liquid pass-through using sentinels
+  let working = source;
+
+  // Second pass: substitute {{config.X}} and {{brand.Y}} and {{client.Z}}
+  working = working.replace(/\{\{\s*([a-zA-Z][a-zA-Z0-9_.]*)\s*\}\}/g, (match, key) => {
+    // If the key starts with a Liquid keyword, leave it alone (it is Shopify Liquid)
+    const liquidKeywords = new Set([
+      'product', 'collection', 'cart', 'customer', 'shop', 'request',
+      'template', 'page', 'blog', 'article', 'section', 'block',
+      'forloop', 'tablerow', 'paginate', 'comment', 'paginate',
+      'settings', 'routes', 'localization', 'order', 'line_item',
+      'address', 'recommendations', 'predictive_search', 'theme',
+      'all_products', 'collections', 'pages', 'articles', 'blogs',
+      'images', 'image', 'media', 'video', 'metafields'
+    ]);
+    const root = key.split('.')[0];
+    if (liquidKeywords.has(root)) return match;
+
+    // Resolve from vars (config.foo, brand.bar, client.baz)
+    const parts = key.split('.');
+    let val = vars;
+    for (const p of parts) {
+      if (val == null) return match;
+      val = val[p];
+    }
+    if (val == null) return match;
+    return String(val);
+  });
+
+  // Third pass: convert sentinels back to Liquid braces
+  working = working.split(LIQUID_OPEN).join('{{').split(LIQUID_CLOSE).join('}}');
+
+  return working;
+}
+
+export function interpolateFile(content, vars) {
+  return interpolate(content, vars);
+}

package/lib/validate.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+/* validate: runs Shopify theme-check via shopify CLI on the target theme.
+   Falls back to a simple Liquid syntax check if the CLI is not available.
+*/
+export async function validate(flags) {
+  const targetDir = path.resolve(flags.target || process.cwd());
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn('shopify', ['theme', 'check', '--path', targetDir], { stdio: 'inherit' });
+    proc.on('error', err => {
+      console.log('shopify CLI not available; skipping deep validation.');
+      console.log('Install Shopify CLI to enable theme-check: https://shopify.dev/docs/themes/tools/cli');
+      resolve();
+    });
+    proc.on('exit', code => {
+      if (code !== 0 && code != null) reject(new Error(`theme check exited ${code}`));
+      else resolve();
+    });
+  });
+}

package/modules/comparison-table/README.md

@@ -0,0 +1,17 @@
+# comparison-table
+
+Lushi comparison table. Migrated from Lushi (`sections/lushi-comparison-table.liquid`) into the Runwell Shopify Toolkit.
+
+Category: `pdp`
+
+## Files
+
+- `sections/runwell-comparison-table.liquid`
+
+## Config
+
+See `module.json` config schema. Defaults match the original Lushi defaults; override per client in `runwell.config.json`.
+
+## Lineage
+
+This module was extracted from the Lushi build (Capital V) and generalised. The original lives at `lushi-shopify/sections/lushi-comparison-table.liquid`. The toolkit version uses `runwell-` class prefixes and pulls brand vars from the client config.