shopify-agentic-dev-workflow 0.1.0

package/bin/shopify-agent.js

@@ -0,0 +1,2786 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const readline = require("readline");
+const { spawnSync } = require("child_process");
+
+const root = process.cwd();
+const configDir = path.join(root, ".shopify-agent");
+const profilesDir = path.join(configDir, "profiles");
+const configPath = path.join(configDir, "config.json");
+const activeProfilePath = path.join(configDir, "active-profile");
+const envPath = path.join(root, ".env");
+
+const DEFAULT_API_VERSION = "2026-04";
+const DEFAULT_STORE_SCOPES = [
+  // Products, variants, collections, metafields on products
+  "read_products", "write_products",
+  // Orders + cancellations + closures
+  "read_orders", "write_orders",
+  // Inventory levels + adjustments
+  "read_inventory", "write_inventory",
+  // Customers + tags
+  "read_customers", "write_customers",
+  // Discount codes + price rules
+  "read_discounts", "write_discounts",
+  "read_price_rules", "write_price_rules",
+  // Pages, blogs, articles, URL redirects
+  "read_content", "write_content",
+  // URL redirects and online store navigation
+  "read_online_store_navigation", "write_online_store_navigation",
+  // Gift cards
+  "read_gift_cards", "write_gift_cards",
+  // Locations (for inventory:list, store:locations)
+  "read_locations",
+  // Metaobjects
+  "read_metaobjects", "write_metaobjects",
+  "read_metaobject_definitions"
+].join(",");
+const MIN_NODE_MAJOR = 18;
+
+const YES_FLAG = process.argv.includes("--yes") || process.argv.includes("-y");
+
+// Enforce Node version early so the error is readable, not a syntax crash.
+const nodeMajor = Number.parseInt(process.version.slice(1).split(".")[0], 10);
+if (nodeMajor < MIN_NODE_MAJOR) {
+  process.stderr.write(`shopify-agent requires Node.js ${MIN_NODE_MAJOR}+. You have ${process.version}.\nInstall the latest LTS from https://nodejs.org or via: brew install node\n`);
+  process.exit(1);
+}
+
+const AGENT_FILES = {
+  codex: "AGENTS.md",
+  claude: "CLAUDE.md",
+  cursor: path.join(".cursor", "rules", "shopify-agentic-dev.mdc"),
+  gemini: "GEMINI.md"
+};
+
+function printHelp() {
+  console.log(`
+shopify-agent
+
+Commands:
+  init              Interactive auth, store, theme, and profile setup
+  auth              Log in with Shopify CLI
+  doctor            Check local Shopify agent development prerequisites
+  capabilities      Show detected Shopify CLI capabilities
+  mcp:install       Add Shopify Dev MCP server to ~/.codex/config.toml
+
+  agents:install    Install Codex/Claude/Cursor/Gemini guardrail files
+  profile:list      List local Shopify project profiles
+  profile:use       Switch active profile
+  store:list        List Shopify organizations and stores linked to your account
+  store:auth        Authenticate store commands with selected Admin scopes
+  theme:list        List themes for the active store
+  theme:select      Select active theme from Shopify theme list
+  theme:pull        Pull theme files with Shopify CLI
+  theme:dev         Start Shopify theme dev preview
+  theme:check       Run Shopify Theme Check
+  theme:push        Push to configured unpublished/staging theme
+  theme:publish     Publish configured theme after explicit confirmation
+
+  app:dev           Start Shopify app dev
+  app:deploy        Deploy Shopify app config and extensions
+
+  admin:query  <file>   Execute a read-only GraphQL file
+  admin:mutate <file>   Execute a mutation (prompts for confirmation)
+
+── Catalog (for developers & catalogers) ──
+  products:list         List products  [--status active|draft|archived] [--limit N]
+  products:get          Interactive product detail viewer
+  products:create       Wizard to create a product
+  products:publish      Set a product to Active (visible)
+  products:archive      Set a product to Archived
+  products:draft        Set a product back to Draft
+  products:delete       Delete a product (with confirmation)
+  variants:list         List variants for a selected product
+  variants:update       Update price, SKU, barcode for a variant
+  collections:list      List all collections
+  collections:create    Wizard to create a manual or smart collection
+
+── Inventory ──
+  inventory:list        List all inventory levels across locations
+  inventory:set <qty>   Set ALL product variants to <qty> (bulk)
+  inventory:adjust      Adjust a single variant by delta (+5, -3) or absolute (=10)
+
+── Orders (for business admins) ──
+  orders:list           List orders  [--status open|closed|cancelled|any] [--limit N]
+  orders:get            Full order detail with line items + tracking
+  orders:cancel         Cancel an open order (choose reason, refund, restock)
+  orders:close          Mark an order as closed
+
+── Customers ──
+  customers:list        List customers  [--limit N]
+  customers:search      Search by name, email, phone, or tag
+  customers:get         Full customer detail with order history
+  customers:create      Wizard to create a customer
+  customers:tags        Add or remove tags on a customer
+
+── Discounts & Gift Cards (for marketing teams) ──
+  discounts:list        List all discount codes with usage stats
+  discounts:create      Interactive wizard to create a discount code
+  discounts:delete      Delete a discount code
+  discounts:enable      Re-activate a disabled discount
+  discounts:disable     Deactivate a discount without deleting
+  gift-cards:list       List all gift cards
+  gift-cards:create     Create a gift card (with optional customer assignment)
+
+── Store ──
+  store:info            Store name, plan, currency, timezone
+  store:locations       List locations with fulfillment status
+  store:dashboard       Snapshot: open orders + low stock + active discounts
+  dashboard             Alias for store:dashboard
+
+── Content ──
+  pages:list            List all pages
+  pages:create          Wizard to create a page
+  blogs:list            List blogs with recent articles
+  articles:list         List articles in a blog
+  redirects:list        List all URL redirects
+  redirects:create      Create a URL redirect
+
+── Metafields ──
+  metafields:list       List metafields for any resource (product, customer, order, etc.)
+  metafields:set        Create or update a metafield on any resource
+
+Flags:
+  --yes, -y             Auto-confirm all prompts (useful for scripting)
+  --status <s>          Filter by status where supported
+  --limit <n>           Limit result count where supported
+
+Examples:
+  npx shopify-agentic-dev-workflow init
+  shopify-agent doctor
+  shopify-agent agents:install
+  node ./bin/shopify-agent.js theme:select
+  shopify-agent admin:query templates/graphql/shop-query.graphql
+`);
+}
+
+function loadDotEnv() {
+  if (!fs.existsSync(envPath)) return {};
+  const out = {};
+  for (const line of fs.readFileSync(envPath, "utf8").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const idx = trimmed.indexOf("=");
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1).trim();
+    out[key] = value;
+  }
+  return out;
+}
+
+function loadConfig() {
+  const env = { ...loadDotEnv(), ...process.env };
+  let file = {};
+  if (fs.existsSync(configPath)) {
+    file = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  }
+  const profile = loadActiveProfile();
+  return {
+    profile: profile.name || file.profile || "default",
+    store: env.SHOPIFY_STORE || profile.store || file.store || "",
+    themeId: env.SHOPIFY_THEME_ID || profile.themeId || file.themeId || "",
+    themeName: profile.themeName || file.themeName || "",
+    themeRole: profile.themeRole || file.themeRole || "",
+    themeToken: env.SHOPIFY_CLI_THEME_TOKEN || profile.themeToken || "",
+    appConfig: env.SHOPIFY_APP_CONFIG || profile.appConfig || file.appConfig || "",
+    appClientId: env.SHOPIFY_APP_CLIENT_ID || profile.appClientId || file.appClientId || "",
+    storeScopes: env.SHOPIFY_STORE_SCOPES || profile.storeScopes || file.storeScopes || DEFAULT_STORE_SCOPES,
+    apiVersion: env.SHOPIFY_API_VERSION || profile.apiVersion || file.apiVersion || DEFAULT_API_VERSION
+  };
+}
+
+function ensureConfigDir() {
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.mkdirSync(profilesDir, { recursive: true });
+}
+
+function ask(question, defaultValue = "") {
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+async function confirm(question, defaultValue = false) {
+  if (YES_FLAG) { console.log(`${question} → yes (--yes flag)`); return true; }
+  const marker = defaultValue ? "Y/n" : "y/N";
+  const answer = (await ask(`${question} [${marker}]`, "")).toLowerCase();
+  if (!answer) return defaultValue;
+  return ["y", "yes"].includes(answer);
+}
+
+async function choose(question, choices, labeler = (item) => String(item), defaultIndex = 0) {
+  if (!choices.length) return null;
+  console.log(`\n${question}`);
+  choices.forEach((choice, index) => {
+    const marker = index === defaultIndex ? " *" : "  ";
+    console.log(`${marker} ${index + 1}. ${labeler(choice)}`);
+  });
+  while (true) {
+    const answer = await ask("Select number", String(defaultIndex + 1));
+    const index = Number.parseInt(answer, 10) - 1;
+    if (index >= 0 && index < choices.length) return choices[index];
+    console.log("Invalid selection.");
+  }
+}
+
+async function multiChoose(question, choices, labeler = (item) => String(item), defaults = []) {
+  console.log(`\n${question}`);
+  choices.forEach((choice, index) => {
+    const selected = defaults.includes(choice) ? "*" : " ";
+    console.log(`  ${index + 1}. [${selected}] ${labeler(choice)}`);
+  });
+  const answer = await ask("Select numbers comma-separated, or 'all'", defaults.length ? defaults.map((item) => choices.indexOf(item) + 1).join(",") : "all");
+  if (answer.toLowerCase() === "all") return choices;
+  return answer
+    .split(",")
+    .map((part) => Number.parseInt(part.trim(), 10) - 1)
+    .filter((index) => index >= 0 && index < choices.length)
+    .map((index) => choices[index]);
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    stdio: options.input ? ["pipe", "inherit", "inherit"] : "inherit",
+    input: options.input,
+    env: { ...process.env, ...options.env },
+    cwd: options.cwd || root
+  });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  process.exitCode = result.status || 0;
+  return result.status || 0;
+}
+
+function runShopify(args, options = {}) {
+  run("shopify", args, options);
+}
+
+function ensureCleanGitWorktree(actionLabel) {
+  const inside = capture("git", ["rev-parse", "--is-inside-work-tree"]);
+  if (!inside.ok || inside.stdout.trim() !== "true") {
+    console.error(`Git guard blocked ${actionLabel}.`);
+    console.error("\nThis command must run inside a Git repository so theme code is version-controlled.");
+    console.error("\nRun:");
+    console.error("  git init");
+    console.error("  git add assets config layout locales sections snippets templates package.json README.md");
+    console.error("  git commit -m \"Initial theme snapshot\"");
+    process.exit(1);
+  }
+
+  const rootResult = capture("git", ["rev-parse", "--show-toplevel"]);
+  const gitRoot = rootResult.ok ? rootResult.stdout.trim() : root;
+  const status = capture("git", ["status", "--short"], { cwd: gitRoot });
+  if (!status.ok) {
+    console.error(`Git guard blocked ${actionLabel}.`);
+    console.error(status.output || "Could not read Git status.");
+    process.exit(1);
+  }
+
+  if (status.stdout.trim()) {
+    console.error(`Git guard blocked ${actionLabel}: uncommitted changes detected.`);
+    console.error("\nCommit or stash your current work before pulling/pushing Shopify theme files.");
+    console.error("\nCurrent changes:");
+    console.error(status.stdout.trim());
+    console.error("\nRun:");
+    console.error("  git add .");
+    console.error("  git commit -m \"Describe the theme change\"");
+    console.error("\nOr:");
+    console.error("  git stash push -u -m \"WIP before Shopify theme operation\"");
+    process.exit(1);
+  }
+}
+
+function themeDirectorySlug(cfg) {
+  const themeName = cfg.themeName || "theme";
+  const slug = String(themeName)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 60) || "theme";
+  return `${slug}-${cfg.themeId || "unknown"}`;
+}
+
+function themeDirectory(cfg) {
+  if (!cfg.themeId) {
+    console.error("Missing SHOPIFY_THEME_ID. Run `shopify-agent theme:select` first.");
+    process.exit(1);
+  }
+  return path.join(root, "themes", themeDirectorySlug(cfg));
+}
+
+function themeMetadataPath(themePath) {
+  return path.join(themePath, ".shopify-theme.json");
+}
+
+function writeThemeMetadata(themePath, cfg) {
+  fs.mkdirSync(themePath, { recursive: true });
+  const metadata = {
+    store: cfg.store,
+    themeId: cfg.themeId,
+    themeName: cfg.themeName || "",
+    role: cfg.themeRole || "",
+    pulledAt: new Date().toISOString()
+  };
+  fs.writeFileSync(themeMetadataPath(themePath), JSON.stringify(metadata, null, 2) + "\n");
+}
+
+function assertThemeDirectoryMatches(themePath, cfg) {
+  const metadataFile = themeMetadataPath(themePath);
+  if (!fs.existsSync(metadataFile)) return;
+  const metadata = JSON.parse(fs.readFileSync(metadataFile, "utf8"));
+  if (metadata.store && metadata.store !== cfg.store) {
+    console.error(`Theme folder belongs to store ${metadata.store}, not ${cfg.store}.`);
+    process.exit(1);
+  }
+  if (metadata.themeId && String(metadata.themeId) !== String(cfg.themeId)) {
+    console.error(`Theme folder belongs to theme ${metadata.themeId}, not ${cfg.themeId}.`);
+    process.exit(1);
+  }
+}
+
+function requirePulledThemeDirectory(cfg, actionLabel) {
+  const themePath = themeDirectory(cfg);
+  if (!fs.existsSync(themePath)) {
+    console.error(`${actionLabel} requires a pulled theme folder.`);
+    console.error(`\nExpected: ${path.relative(root, themePath)}`);
+    console.error("\nRun:");
+    console.error("  shopify-agent theme:pull");
+    console.error("  git add themes");
+    console.error("  git commit -m \"Pull Shopify theme\"");
+    process.exit(1);
+  }
+  assertThemeDirectoryMatches(themePath, cfg);
+  return themePath;
+}
+
+// Strip ANSI escape codes from a string so JSON.parse works on captured output.
+function stripAnsi(str) {
+  // eslint-disable-next-line no-control-regex
+  return (str || "").replace(/\x1B\[[0-9;]*[mGKHF]/g, "");
+}
+
+function capture(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    input: options.input,
+    env: { FORCE_COLOR: "0", ...process.env, ...options.env },
+    cwd: options.cwd || root
+  });
+  const stdout = stripAnsi(result.stdout || "");
+  const stderr = stripAnsi(result.stderr || "");
+  return {
+    ok: result.status === 0,
+    status: result.status || 0,
+    stdout,
+    stderr,
+    output: `${stdout}${stderr}`.trim(),
+    error: result.error
+  };
+}
+
+function captureShopify(args, options = {}) {
+  return capture("shopify", args, options);
+}
+
+function check(command, args = ["--version"]) {
+  const result = capture(command, args);
+  if (result.error) return { ok: false, output: result.error.message };
+  return { ok: result.ok, output: result.output };
+}
+
+function sanitizeProfileName(name) {
+  return (name || "default").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "default";
+}
+
+function profileFile(name) {
+  return path.join(profilesDir, `${sanitizeProfileName(name)}.json`);
+}
+
+function listProfiles() {
+  if (!fs.existsSync(profilesDir)) return [];
+  return fs
+    .readdirSync(profilesDir)
+    .filter((file) => file.endsWith(".json"))
+    .map((file) => {
+      const fullPath = path.join(profilesDir, file);
+      try {
+        return JSON.parse(fs.readFileSync(fullPath, "utf8"));
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function loadProfile(name) {
+  const file = profileFile(name);
+  if (!fs.existsSync(file)) return {};
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function loadActiveProfileName() {
+  if (!fs.existsSync(activeProfilePath)) return "";
+  return fs.readFileSync(activeProfilePath, "utf8").trim();
+}
+
+function loadActiveProfile() {
+  const name = loadActiveProfileName();
+  if (!name) return {};
+  return loadProfile(name);
+}
+
+function saveProfile(profile) {
+  ensureConfigDir();
+  const name = sanitizeProfileName(profile.name || profile.store || "default");
+  const saved = { ...profile, name };
+  fs.writeFileSync(profileFile(name), JSON.stringify(saved, null, 2) + "\n");
+  fs.writeFileSync(activeProfilePath, `${name}\n`);
+  return saved;
+}
+
+function writeLocalEnv(profile, themeToken = "") {
+  const managed = {
+    SHOPIFY_STORE: profile.store || "",
+    SHOPIFY_CLI_THEME_TOKEN: themeToken || "",
+    SHOPIFY_THEME_ID: profile.themeId || "",
+    SHOPIFY_APP_CONFIG: profile.appConfig || "",
+    SHOPIFY_APP_CLIENT_ID: profile.appClientId || "",
+    SHOPIFY_STORE_SCOPES: profile.storeScopes || DEFAULT_STORE_SCOPES,
+    SHOPIFY_API_VERSION: profile.apiVersion || DEFAULT_API_VERSION
+  };
+
+  if (!fs.existsSync(envPath)) {
+    const content = Object.entries(managed).map(([k, v]) => `${k}=${v}`).join("\n") + "\n";
+    fs.writeFileSync(envPath, content);
+    return "created";
+  }
+
+  // Merge-update: preserve existing lines and user-added keys, only update managed keys.
+  const existing = fs.readFileSync(envPath, "utf8").split(/\r?\n/);
+  const updated = new Set();
+  const result = existing.map((line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return line;
+    const idx = trimmed.indexOf("=");
+    if (idx === -1) return line;
+    const key = trimmed.slice(0, idx).trim();
+    if (key in managed) {
+      updated.add(key);
+      return `${key}=${managed[key]}`;
+    }
+    return line;
+  });
+  // Append any managed keys that were not already in the file.
+  for (const [key, val] of Object.entries(managed)) {
+    if (!updated.has(key)) result.push(`${key}=${val}`);
+  }
+  fs.writeFileSync(envPath, result.join("\n").trimEnd() + "\n");
+  return "updated";
+}
+
+function normalizeStoreDomain(input) {
+  const value = (input || "").trim().replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+  if (!value) return "";
+  return value.includes(".") ? value : `${value}.myshopify.com`;
+}
+
+function themeEnv(cfg) {
+  const env = {};
+  if (cfg.themeToken) env.SHOPIFY_CLI_THEME_TOKEN = cfg.themeToken;
+  return env;
+}
+
+function parseThemes(raw) {
+  const parsed = JSON.parse(raw);
+  const themes = Array.isArray(parsed) ? parsed : parsed.themes || parsed.result || [];
+  return themes.map((theme) => ({
+    id: String(theme.id || theme.theme_id || ""),
+    name: theme.name || theme.themeName || "",
+    role: theme.role || theme.status || "",
+    raw: theme
+  }));
+}
+
+function fetchThemes(store, env = {}, themeToken = "") {
+  const args = ["theme", "list", "--json", "--store", store];
+  if (themeToken) args.push("--password", themeToken);
+  const result = captureShopify(args, { env });
+  if (!result.ok) {
+    const hint = themeToken
+      ? "Check that your Theme Access token is valid."
+      : "Run `shopify auth login` first, or provide a Theme Access token.";
+    return {
+      ok: false,
+      error: `Unable to list themes. ${hint}\n\nCLI output:\n${result.output || "(no output)"}`
+    };
+  }
+  // CLI 4.x may prefix JSON with informational lines — find the first [ or {
+  const raw = result.stdout || result.output;
+  const jsonStart = Math.min(
+    raw.indexOf("[") !== -1 ? raw.indexOf("[") : Number.POSITIVE_INFINITY,
+    raw.indexOf("{") !== -1 ? raw.indexOf("{") : Number.POSITIVE_INFINITY
+  );
+  const jsonStr = jsonStart !== Number.POSITIVE_INFINITY ? raw.slice(jsonStart) : raw;
+  try {
+    return { ok: true, themes: parseThemes(jsonStr) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Could not parse theme list JSON: ${error.message}\n\nRaw output:\n${raw}`
+    };
+  }
+}
+
+function getShopifyCommands() {
+  const result = captureShopify(["commands"]);
+  return result.ok ? result.output : "";
+}
+
+function fetchOrganizations() {
+  if (!hasShopifyCommand("organization list")) return { ok: false, orgs: [] };
+  const result = captureShopify(["organization", "list", "--json"]);
+  if (!result.ok) return { ok: false, orgs: [] };
+  const raw = result.stdout || result.output;
+  const jsonStart = raw.indexOf("[") !== -1 ? raw.indexOf("[") : raw.indexOf("{");
+  if (jsonStart === -1) return { ok: false, orgs: [] };
+  try {
+    const parsed = JSON.parse(raw.slice(jsonStart));
+    const orgs = Array.isArray(parsed) ? parsed : parsed.organizations || [];
+    return { ok: true, orgs };
+  } catch {
+    return { ok: false, orgs: [] };
+  }
+}
+
+const commandCapabilityCache = new Map();
+
+function hasShopifyCommand(commandId) {
+  if (commandCapabilityCache.has(commandId)) return commandCapabilityCache.get(commandId);
+  const help = captureShopify([...commandId.split(" "), "--help"]);
+  const ok = help.ok;
+  commandCapabilityCache.set(commandId, ok);
+  return ok;
+}
+
+function operationKind(query) {
+  const cleaned = query
+    .replace(/#[^\n]*/g, "")
+    .replace(/"([^"\\]|\\.)*"/g, "\"\"")
+    .replace(/'([^'\\]|\\.)*'/g, "''");
+  return /\bmutation\b/i.test(cleaned) ? "mutation" : "query";
+}
+
+function agentInstructions(tool) {
+  const cursorPrefix = tool === "cursor" ? "---\ndescription: Shopify agentic development guardrails\nalwaysApply: true\n---\n\n" : "";
+  return `${cursorPrefix}# Shopify Agentic Dev Workflow — Agent Guardrails
+
+This project is managed by \`shopify-agentic-dev-workflow\`.
+All store operations run through the \`shopify-agent\` CLI. Never call Shopify Admin GraphQL directly — always use the commands below.
+
+---
+
+## Hard Rules — Never Bypass These
+
+1. **Never push to a live/published theme without explicit user confirmation.**
+   - Before any \`theme:push\` or \`shopify theme push\`, check if the active theme is live (role: live).
+   - If it is live: STOP, explain the consequences below, and ask the user to choose:
+     a. Push to a NEW staging theme (\`--unpublished\`) — RECOMMENDED
+     b. Push to live (CLI requires typing the store domain to confirm)
+   - If the user chooses staging: run \`shopify-agent theme:push\` and tell them to preview before publishing.
+   - Never silently push to a live theme.
+
+2. **Never publish a theme without explicit user confirmation.**
+   - \`shopify-agent theme:publish\` prompts before going live — never skip or auto-approve on the user's behalf.
+   - Use \`--yes\` only when the user has already previewed and explicitly approved the theme for publication.
+
+3. **Never run any mutation command without explicit user confirmation.**
+   - Every write command (\`inventory:set\`, \`inventory:adjust\`, \`products:create\`, \`products:delete\`,
+     \`variants:update\`, \`orders:cancel\`, \`orders:close\`, \`customers:create\`, \`customers:tags\`,
+     \`discounts:create\`, \`discounts:delete\`, \`discounts:enable\`, \`discounts:disable\`,
+     \`gift-cards:create\`, \`pages:create\`, \`redirects:create\`, \`metafields:set\`,
+     \`collections:create\`, \`admin:mutate\`) prompts for confirmation before executing.
+   - Always show what will change and which store before asking.
+   - Use \`--yes\` only when the user has already reviewed and explicitly approved the operation.
+
+4. **Never commit or print secrets.**
+   - Do not read, log, or include \`.env\`, access tokens, client secrets, or session tokens in any output.
+   - \`.env\` and \`.shopify-agent/\` are git-ignored — never stage them.
+
+5. **Never mix files between themes or pull into the project root.**
+   - Theme code lives under \`themes/<theme-name>-<theme-id>/\`, never directly in the package root.
+   - Before \`theme:pull\`, \`theme:push\`, or \`theme:publish\`, verify the active store, theme ID, theme role, and local theme folder metadata.
+   - If the Git worktree is dirty, stop and ask the user to commit or stash first. Pulling Theme A into Theme B's folder or branch is a release blocker.
+
+---
+
+## Live Theme Consequences (always explain before any live push)
+
+- The storefront updates IMMEDIATELY — customers browsing right now see the new code
+- Liquid errors, broken CSS, or JS issues go live instantly
+- Shopify does NOT auto-revert — rollback requires manually republishing the previous theme
+- A single typo in a section template can render pages blank for real customers
+
+---
+
+## Setup & Diagnostics
+
+\`\`\`bash
+shopify-agent init              # Full interactive setup wizard (connect store, auth, pick theme)
+shopify-agent doctor            # Check tools, show active config + install hints
+shopify-agent capabilities      # Detect which Shopify CLI 4.x commands are available
+shopify-agent auth              # shopify auth login (opens browser)
+shopify-agent agents:install    # Write/update these guardrail files
+shopify-agent mcp:install       # Add Shopify Dev MCP to ~/.codex/config.toml
+shopify-agent profile:list      # List saved profiles
+shopify-agent profile:use       # Switch active profile
+shopify-agent store:list        # Show Shopify orgs linked to your account
+shopify-agent store:auth        # Create Admin API token with selected scopes
+\`\`\`
+
+---
+
+## Theme Development (Developers)
+
+\`\`\`bash
+shopify-agent theme:list        # List themes with roles (live vs unpublished)
+shopify-agent theme:select      # Pick active theme (live ⚠ warning included)
+shopify-agent theme:pull        # Download theme files locally
+shopify-agent theme:dev         # Hot-reload dev server — opens browser automatically
+shopify-agent theme:check       # Liquid linting via Theme Check
+shopify-agent theme:push        # Push to staging (3-option guard if theme is live)
+shopify-agent theme:publish     # Prompts for confirmation before going live
+\`\`\`
+
+Recommended theme dev workflow:
+1. \`shopify-agent init\` → select an UNPUBLISHED staging theme
+2. \`shopify-agent theme:pull\` → download theme files into \`themes/<theme-name>-<theme-id>/\`
+3. \`shopify-agent theme:dev\` → hot-reload dev server
+4. Edit Liquid / CSS / JS files locally
+5. \`shopify-agent theme:check\` → lint after edits
+6. \`shopify-agent theme:push\` → push to staging theme
+7. Preview in Shopify Admin → Themes → Preview
+8. \`shopify-agent theme:publish\` → go live after review
+
+If the user asks to push to a live theme, respond:
+> "The configured theme is LIVE. I recommend \`shopify-agent theme:push\` which will offer a safe staging option. Push directly only after you confirm the store domain."
+
+### Theme Folder and Git Discipline
+
+- Treat each Shopify theme as its own versioned artifact: \`themes/dawn-169809707321/\`, \`themes/brand-refresh-123456789/\`, etc.
+- A pull must write only into the folder for the selected \`SHOPIFY_THEME_ID\`. If files appear in the repo root, stop and fix the command/path before continuing.
+- Commit after every successful pull and before every push. This gives the team a rollback point and prevents accidental Theme A/Theme B overwrites.
+- Do not switch themes by editing files in place. Run \`shopify-agent theme:select\`, then \`shopify-agent theme:pull\`, and let the CLI create or reuse the matching theme folder.
+- Never remove, rewrite, or bypass \`.shopify-theme.json\` metadata in a theme folder; it is the local proof that the folder belongs to the selected store and theme.
+
+### Figma-to-Dawn Build Rules
+
+- Read the Figma file before coding, then map frames to Dawn sections/templates: home, collection/PLP, product/PDP, cart, header, and footer.
+- Build real Shopify Liquid sections with schema settings instead of static HTML where merchants may need control later.
+- Keep design-preview data and live Shopify data separate. Demo store products can break the visual match; add explicit settings such as "Use live collection products" or "Use live product data" before letting catalog data override Figma assets.
+- Make header, menu, product-card, CTA, social, and footer links real and clickable. Fallback links should go to search, collection, product, account, cart, or policy URLs, not dead placeholders.
+- After frontend work, run \`shopify-agent theme:check\` and visually inspect desktop and mobile previews for home, collection, product, header, footer, and horizontal overflow.
+
+---
+
+## App Development (Developers)
+
+\`\`\`bash
+shopify-agent app:dev           # shopify app dev
+shopify-agent app:deploy        # shopify app deploy
+\`\`\`
+
+---
+
+## Raw GraphQL (Developers / Power Users)
+
+\`\`\`bash
+shopify-agent admin:query  <file.graphql>   # Read-only Admin GraphQL
+shopify-agent admin:mutate <file.graphql>   # Mutation (always prompts for confirmation)
+\`\`\`
+
+Pre-built templates in \`templates/graphql/\`:
+- \`shop-query.graphql\`, \`inventory-audit.graphql\`, \`discounts-list.graphql\`, \`products-seo-audit.graphql\`
+- \`products/list.graphql\`, \`products/low-inventory.graphql\`
+- \`orders/list-open.graphql\`, \`orders/revenue-summary.graphql\`
+- \`customers/top-spenders.graphql\`, \`customers/new-customers.graphql\`
+- \`discounts/active-discounts.graphql\`
+- \`store/full-info.graphql\`, \`store/webhooks.graphql\`
+- \`content/pages-list.graphql\`, \`content/redirects-list.graphql\`
+- \`metafields/product-metafields.graphql\`
+
+Schema hygiene:
+- Shopify Admin GraphQL is versioned and fields move or disappear. If a query fails with \`undefinedField\`, treat the template as stale and update it against the configured \`SHOPIFY_API_VERSION\`.
+- Do not assume dashboard, discount, inventory, or product payload shapes from memory. Run the smallest read-only query first, then expand.
+- Keep mutations behind \`admin:mutate\` so the CLI confirmation and store context are visible before anything changes.
+
+---
+
+## Products & Catalog (Catalogers)
+
+\`\`\`bash
+shopify-agent products:list [--status active|draft|archived] [--limit N]
+shopify-agent products:get              # Interactive full product detail viewer
+shopify-agent products:create           # Wizard: title, type, vendor, price, SKU, inventory, status
+shopify-agent products:publish          # Set product to Active (visible in store) — prompts
+shopify-agent products:archive          # Set product to Archived — prompts
+shopify-agent products:draft            # Set product back to Draft — prompts
+shopify-agent products:delete           # Delete a product — prompts with confirmation
+
+shopify-agent variants:list             # Pick a product → see all variants with price/SKU/qty
+shopify-agent variants:update           # Update price, SKU, barcode for a variant — prompts
+
+shopify-agent collections:list          # List all collections (manual + smart)
+shopify-agent collections:create        # Wizard: manual or smart (with rule builder) — prompts
+\`\`\`
+
+---
+
+## Inventory (Catalogers / Operations)
+
+\`\`\`bash
+shopify-agent inventory:list            # List all inventory levels across locations
+shopify-agent inventory:set <qty>       # Set ALL variants to <qty> in bulk — prompts
+shopify-agent inventory:adjust          # Adjust one variant: +5, -3, or =10 — prompts
+\`\`\`
+
+---
+
+## Orders (Business Admins)
+
+\`\`\`bash
+shopify-agent orders:list [--status open|closed|cancelled|any] [--limit N]
+shopify-agent orders:get                # Full order detail: line items, tracking, totals
+shopify-agent orders:cancel             # Cancel an open order (choose reason, refund, restock) — prompts
+shopify-agent orders:close              # Mark an order as closed — prompts
+\`\`\`
+
+---
+
+## Customers (Business Admins / Marketing)
+
+\`\`\`bash
+shopify-agent customers:list [--limit N]
+shopify-agent customers:search          # Search by name, email, phone, or tag
+shopify-agent customers:get             # Full customer profile + recent order history
+shopify-agent customers:create          # Wizard: name, email, phone, tags, marketing opt-in — prompts
+shopify-agent customers:tags            # Add or remove tags on a customer — prompts
+\`\`\`
+
+---
+
+## Discounts & Gift Cards (Marketing)
+
+\`\`\`bash
+shopify-agent discounts:list            # List all discount codes with usage stats
+shopify-agent discounts:create          # Wizard: % off, fixed amount, per-customer limit, expiry — prompts
+shopify-agent discounts:delete          # Delete a discount code — prompts
+shopify-agent discounts:enable          # Re-activate a disabled discount — prompts
+shopify-agent discounts:disable         # Deactivate without deleting — prompts
+
+shopify-agent gift-cards:list           # List all gift cards with balance
+shopify-agent gift-cards:create         # Create a gift card (with optional customer assignment) — prompts
+\`\`\`
+
+---
+
+## Store Info (Business Admins)
+
+\`\`\`bash
+shopify-agent store:info                # Name, plan, currency, timezone, multi-currency
+shopify-agent store:locations           # List locations with fulfillment status
+shopify-agent store:dashboard           # Snapshot: open orders + low-stock + active discounts
+shopify-agent dashboard                 # Alias for store:dashboard
+\`\`\`
+
+---
+
+## Content (Marketing)
+
+\`\`\`bash
+shopify-agent pages:list                # List all pages
+shopify-agent pages:create              # Wizard: title, body HTML, publish immediately — prompts
+shopify-agent blogs:list                # List blogs with 5 recent articles each
+shopify-agent articles:list             # Pick a blog → list articles with author + status
+shopify-agent redirects:list            # List all URL redirects
+shopify-agent redirects:create          # Create a URL redirect (from → to) — prompts
+\`\`\`
+
+---
+
+## Metafields (Developers / Catalogers)
+
+\`\`\`bash
+shopify-agent metafields:list           # List metafields for any resource
+shopify-agent metafields:set            # Create or update a metafield on any resource — prompts
+# Works with: Product, Collection, Customer, Order, Shop
+\`\`\`
+
+---
+
+## Flags
+
+\`\`\`bash
+--yes, -y       Auto-confirm all prompts (scripting / CI — only use after reviewing the operation)
+--status <s>    Filter by status where supported (products:list, orders:list)
+--limit <n>     Limit result count where supported
+\`\`\`
+
+---
+
+## Role-Based Workflow Examples
+
+**Cataloger — bulk inventory reset before a sale:**
+\`\`\`bash
+shopify-agent inventory:list            # review current levels
+shopify-agent inventory:set 50          # bulk-set all variants to 50 (prompts)
+shopify-agent products:list --status active --limit 50  # verify
+\`\`\`
+
+**Marketing — launch a discount campaign:**
+\`\`\`bash
+shopify-agent discounts:list            # check existing codes
+shopify-agent discounts:create          # wizard → 10% off, first order, 7-day expiry (prompts)
+shopify-agent pages:create              # create a landing page for the campaign (prompts)
+\`\`\`
+
+**Business admin — morning dashboard:**
+\`\`\`bash
+shopify-agent dashboard                 # open orders + low-stock + active discounts
+shopify-agent orders:list --status open
+shopify-agent customers:list --limit 10
+\`\`\`
+
+**Developer — theme deploy pipeline:**
+\`\`\`bash
+shopify-agent theme:check               # lint
+shopify-agent theme:push                # push to staging
+# preview in Admin
+shopify-agent theme:publish             # go live (prompts)
+\`\`\`
+`;
+}
+
+async function init() {
+  const existing = loadConfig();
+  console.log("\nShopify Agent — project setup\n");
+
+  // Step 1: Auth — `auth whoami` doesn't exist in CLI 4.x; probe with `organization list` instead.
+  const authProbe = captureShopify(["organization", "list", "--json"]);
+  const alreadyLoggedIn = authProbe.ok;
+  if (alreadyLoggedIn) {
+    console.log("Already logged in to Shopify CLI.\n");
+  } else if (await confirm("Log in with Shopify CLI now (opens browser)", true)) {
+    run("shopify", ["auth", "login"]);
+    console.log();
+  }
+
+  // Step 2: Profile name
+  const profileName = sanitizeProfileName(await ask("Profile name", existing.profile || "default"));
+
+  // Step 3: Store domain — try org list for hints first
+  let suggestedStore = existing.store || "";
+  if (!suggestedStore) {
+    const { ok, orgs } = fetchOrganizations();
+    if (ok && orgs.length) {
+      console.log("\nShopify organizations found:");
+      orgs.forEach((org, i) => console.log(`  ${i + 1}. ${org.businessName || org.name || org.id} (ID: ${org.id})`));
+      console.log("  (Store domains are <store>.myshopify.com — check your Shopify Admin or Partners Dashboard)");
+    }
+  }
+  const store = normalizeStoreDomain(await ask("Shopify store domain", suggestedStore || "your-store.myshopify.com"));
+
+  // Step 4: Auth method
+  console.log("\nTheme access: Shopify CLI session (Partners/staff) or Theme Access token.");
+  console.log("If you have a Theme Access token (from the Theme Access app), enter it now.");
+  console.log("Otherwise leave blank to use your Shopify CLI login session.\n");
+  const themeToken = await ask("Theme Access token (optional)", existing.themeToken || "");
+  const env = themeToken ? { SHOPIFY_CLI_THEME_TOKEN: themeToken } : {};
+
+  // Step 5: Theme selection
+  let themeId = existing.themeId;
+  let themeName = existing.themeName;
+  let themeRole = existing.themeRole || "";
+  if (await confirm("Fetch themes from this store now", true)) {
+    console.log(`\nFetching themes from ${store}...`);
+    const result = fetchThemes(store, {}, themeToken);
+    if (result.ok && result.themes.length) {
+      const unpublished = result.themes.filter((t) => t.role !== "live");
+      const liveThemes = result.themes.filter((t) => t.role === "live");
+      if (unpublished.length) {
+        console.log("Tip: select an UNPUBLISHED theme for safe development. Live themes affect your storefront immediately.\n");
+      }
+      const existingIndex = Math.max(0, result.themes.findIndex((t) => t.id === existing.themeId));
+      const selected = await choose(
+        "Select default staging/unpublished theme",
+        result.themes,
+        (theme) => {
+          const liveWarning = theme.role === "live" ? " ⚠ LIVE" : "";
+          return `${(theme.name || "(unnamed)").padEnd(40)} ID: ${theme.id.padEnd(14)} role: ${theme.role || "unknown"}${liveWarning}`;
+        },
+        existingIndex
+      );
+      if (selected.role === "live") {
+        console.log("\n╔══════════════════════════════════════════════════════════╗");
+        console.log("║  ⚠  LIVE THEME SELECTED — READ BEFORE CONTINUING        ║");
+        console.log("╚══════════════════════════════════════════════════════════╝");
+        console.log("\nConsequences of working on a live theme:");
+        console.log("  • Every `theme:push` will IMMEDIATELY update your public storefront");
+        console.log("  • Customers browsing right now will see any broken Liquid or CSS");
+        console.log("  • Shopify does NOT auto-revert — you must manually republish the previous theme");
+        console.log("  • A single typo in a section template can take your store offline");
+        console.log("\nRecommended: pick an UNPUBLISHED theme for development.");
+        console.log("             When ready, publish it from Shopify Admin or with `theme:publish`.\n");
+        const liveChoice = await choose("What would you like to do?", [
+          "switch",
+          "live"
+        ], (c) => c === "switch"
+          ? `Switch to unpublished theme${unpublished[0] ? ` → ${unpublished[0].name}` : " (pick from list)"}`
+          : "Continue with LIVE theme anyway (I accept the risk)"
+        );
+        if (liveChoice === "switch") {
+          const fallback = unpublished.length > 1
+            ? await choose("Select unpublished theme", unpublished,
+                (t) => `${(t.name || "(unnamed)").padEnd(40)} ID: ${t.id}`)
+            : unpublished[0] || result.themes[0];
+          themeId = fallback.id;
+          themeName = fallback.name;
+          themeRole = fallback.role || "unpublished";
+          console.log(`Switched to: ${themeName} (${themeId})\n`);
+        } else {
+          themeId = selected.id;
+          themeName = selected.name;
+          themeRole = "live";
+          console.log(`Confirmed live theme: ${themeName} (${themeId}). Every push goes live immediately.\n`);
+        }
+      } else {
+        themeId = selected.id;
+        themeName = selected.name;
+        themeRole = selected.role || "unpublished";
+        console.log(`Selected: ${themeName} (${themeId})\n`);
+      }
+    } else {
+      console.log(`\n${result.error}`);
+      console.log("\nTip: Make sure you ran `shopify auth login` and your account has collaborator/staff access.");
+      console.log("     Or set a Theme Access token above.\n");
+      themeId = await ask("Enter theme ID or name manually (or leave blank)", existing.themeId || "");
+      themeName = "";
+      themeRole = "";
+    }
+  } else {
+    themeId = await ask("Default staging theme ID/name", existing.themeId || "");
+    themeName = "";
+    themeRole = "";
+  }
+
+  // Step 6: App and API config
+  console.log("\nApp config (only needed for Shopify app development, not theme work).");
+  console.log("This is the config key in shopify.app.toml, e.g. 'staging' or 'production' (not a display name).\n");
+  const appConfig = await ask("App config key from shopify.app.toml (optional, skip if theme-only)", existing.appConfig || "");
+  const appClientId = await ask("Shopify app client ID (optional, skip if theme-only)", existing.appClientId || "");
+  const storeScopes = await ask("Admin API scopes for `store auth`", existing.storeScopes || DEFAULT_STORE_SCOPES);
+  const apiVersion = await ask("Admin GraphQL API version", existing.apiVersion || DEFAULT_API_VERSION);
+
+  const profile = saveProfile({ name: profileName, store, themeId, themeName, themeRole, themeToken, appConfig, appClientId, storeScopes, apiVersion });
+  fs.writeFileSync(configPath, JSON.stringify({ profile: profile.name }, null, 2) + "\n");
+
+  const envStatus = writeLocalEnv(profile, themeToken);
+  if (envStatus === "created") {
+    console.log("Created .env and .shopify-agent/config.json\n");
+  } else {
+    console.log("Profile saved. .env updated with latest values.\n");
+  }
+
+  // Step 7: Admin API token — required for ALL store commands (dashboard, products, orders, etc.)
+  if (hasShopifyCommand("store auth")) {
+    console.log("─────────────────────────────────────────────────────────────");
+    console.log("Admin API access (required for store commands)");
+    console.log("─────────────────────────────────────────────────────────────");
+    console.log("Commands like dashboard, products:list, orders:list, inventory:set,");
+    console.log("discounts:create and all other store operations need an Admin API token.");
+    console.log("This opens a browser to approve the scopes, then stores the token locally.\n");
+    if (await confirm("Set up Admin API access now (recommended)", true)) {
+      runShopify(["store", "auth", "--store", store, "--scopes", profile.storeScopes || DEFAULT_STORE_SCOPES]);
+      console.log("\nAdmin API token stored. All store commands are now available.\n");
+    } else {
+      console.log("Skipped. Run `shopify-agent store:auth` any time to set this up.\n");
+    }
+  } else {
+    console.log("Note: `shopify store auth` not found in this CLI version.");
+    console.log("      Upgrade with: npm install -g @shopify/cli@latest\n");
+  }
+
+  // Step 8: Agent guardrails
+  if (await confirm("Install agent guardrail files (AGENTS.md / CLAUDE.md etc.) for this project", true)) {
+    await agentsInstall();
+  }
+
+  console.log("\nSetup complete. Next steps:");
+  console.log(`  shopify-agent doctor        # verify everything is configured`);
+  console.log(`  shopify-agent dashboard     # open orders, low-stock, active discounts`);
+  console.log(`  shopify-agent theme:list    # see your themes`);
+  console.log(`  shopify-agent theme:pull    # download theme files`);
+  console.log(`  shopify-agent theme:dev     # start hot-reload dev server`);
+}
+
+function auth() {
+  run("shopify", ["auth", "login"]);
+}
+
+const INSTALL_HINTS = {
+  node: "Install from https://nodejs.org or: brew install node",
+  npm: "Comes with Node.js — reinstall Node from https://nodejs.org",
+  git: "Install from https://git-scm.com or: brew install git",
+  shopify: "Install with: npm install -g @shopify/cli@latest",
+  gh: "Install from https://cli.github.com or: brew install gh  (optional)"
+};
+
+function doctor() {
+  const cfg = loadConfig();
+  const checks = [
+    ["node", ["--version"]],
+    ["npm", ["--version"]],
+    ["git", ["--version"]],
+    ["shopify", ["version"]],
+    ["gh", ["--version"]]
+  ];
+
+  console.log("Shopify agent development doctor\n");
+  let missingRequired = false;
+  for (const [cmd, args] of checks) {
+    const result = check(cmd, args);
+    if (result.ok) {
+      const firstLine = result.output.split(/\r?\n/)[0] || "";
+      console.log(`OK       ${cmd.padEnd(8)} ${firstLine}`);
+      // Extra: check Node version
+      if (cmd === "node") {
+        const major = Number.parseInt((result.output.match(/v(\d+)/) || [])[1] || "0", 10);
+        if (major < MIN_NODE_MAJOR) {
+          console.log(`WARN     node     Version ${result.output.trim()} is below required ${MIN_NODE_MAJOR}+. Upgrade Node.`);
+        }
+      }
+    } else {
+      const hint = INSTALL_HINTS[cmd] || "";
+      const required = cmd !== "gh";
+      console.log(`MISSING  ${cmd.padEnd(8)} ${hint}`);
+      if (required) missingRequired = true;
+    }
+  }
+
+  if (missingRequired) {
+    console.log("\nFix the MISSING tools above, then re-run: shopify-agent doctor");
+    return;
+  }
+
+  console.log("\nConfiguration");
+  console.log(`PROFILE    ${cfg.profile || "default"}`);
+  console.log(`STORE      ${cfg.store || "(not set — run: shopify-agent init)"}`);
+  console.log(`THEME      ${cfg.themeId ? `${cfg.themeId}${cfg.themeName ? ` (${cfg.themeName})` : ""}` : "(not set — run: shopify-agent init)"}`);
+  console.log(`API        ${cfg.apiVersion}`);
+  console.log(`THEME AUTH ${cfg.themeToken ? "Theme Access token" : "Shopify CLI login/session"}`);
+  console.log(`APP CONFIG ${cfg.appConfig || "(not set)"}`);
+
+  // Check store execute availability and whether Admin API token exists for this store
+  const storeExecAvailable = hasShopifyCommand("store execute");
+  if (!storeExecAvailable) {
+    console.log(`ADMIN API  not available — upgrade: npm install -g @shopify/cli@latest`);
+  } else if (cfg.store) {
+    // Probe: run a minimal query to see if stored auth exists
+    const probe = captureShopify(["store", "execute", "--store", cfg.store, "--query", "{ shop { name } }"]);
+    const noAuth = (probe.stderr || probe.output || "").includes("No stored app authentication");
+    if (noAuth) {
+      console.log(`ADMIN API  ✗ not authenticated — run: shopify-agent store:auth`);
+    } else {
+      console.log(`ADMIN API  ✓ authenticated (store execute ready)`);
+    }
+  } else {
+    console.log(`ADMIN API  available (CLI 4.x) — run init to configure store`);
+  }
+}
+
+function capabilities() {
+  const version = check("shopify", ["version"]);
+  console.log(`Shopify CLI: ${version.ok ? version.output.split(/\r?\n/).pop() : "missing"}`);
+  const interesting = [
+    "organization list",
+    "store auth",
+    "store execute",
+    "app execute",
+    "app bulk execute",
+    "app config validate",
+    "theme preview",
+    "theme list",
+    "theme dev",
+    "theme publish"
+  ];
+  for (const commandId of interesting) {
+    console.log(`${hasShopifyCommand(commandId) ? "OK" : "NO"} ${commandId}`);
+  }
+  console.log("\nLatest checked from npm: @shopify/cli@4.0.0 includes organization list, store auth, and store execute.");
+}
+
+async function agentsInstall() {
+  ensureConfigDir();
+  const selected = await multiChoose(
+    "Which agent tools should this project support?",
+    Object.keys(AGENT_FILES),
+    (tool) => `${tool} -> ${AGENT_FILES[tool]}`,
+    ["codex"]
+  );
+  if (!selected.length) {
+    console.log("No agent files selected.");
+    return;
+  }
+  for (const tool of selected) {
+    const target = path.join(root, AGENT_FILES[tool]);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    if (fs.existsSync(target)) {
+      const shouldOverwrite = await confirm(`${AGENT_FILES[tool]} exists. Overwrite`, false);
+      if (!shouldOverwrite) continue;
+    }
+    fs.writeFileSync(target, agentInstructions(tool));
+    console.log(`Wrote ${AGENT_FILES[tool]}`);
+  }
+}
+
+function mcpInstall() {
+  const codexDir = path.join(os.homedir(), ".codex");
+  const codexConfig = path.join(codexDir, "config.toml");
+  const block = [
+    "",
+    "# Shopify Dev MCP: added by shopify-agent",
+    "[mcp_servers.shopify-dev-mcp]",
+    'command = "npx"',
+    'args = ["-y", "@shopify/dev-mcp@latest"]',
+    ""
+  ].join("\n");
+
+  fs.mkdirSync(codexDir, { recursive: true });
+  const existing = fs.existsSync(codexConfig) ? fs.readFileSync(codexConfig, "utf8") : "";
+  if (existing.includes("[mcp_servers.shopify-dev-mcp]")) {
+    console.log("Shopify Dev MCP is already configured in ~/.codex/config.toml");
+    return;
+  }
+  fs.writeFileSync(codexConfig, existing.trimEnd() + block);
+  console.log("Added Shopify Dev MCP to ~/.codex/config.toml. Restart Codex to load it.");
+}
+
+function requireStore(cfg) {
+  if (!cfg.store) {
+    console.error("Missing SHOPIFY_STORE. Run `npm run setup` first.");
+    process.exit(1);
+  }
+}
+
+function shopifyArgsWithStore(cfg, args) {
+  requireStore(cfg);
+  return [...args, "--store", cfg.store];
+}
+
+function profileList() {
+  const active = loadActiveProfileName();
+  const profiles = listProfiles();
+  if (!profiles.length) {
+    console.log("No profiles found. Run `npm run setup` first.");
+    return;
+  }
+  for (const profile of profiles) {
+    const marker = profile.name === active ? "*" : " ";
+    console.log(`${marker} ${profile.name}  ${profile.store || "-"}  ${profile.themeId || "-"}`);
+  }
+}
+
+function storeList() {
+  const version = check("shopify", ["version"]);
+  console.log(`Shopify CLI: ${version.ok ? version.output.split(/\r?\n/).pop() : "missing"}\n`);
+  const { ok, orgs } = fetchOrganizations();
+  if (!ok || !orgs.length) {
+    console.log("No organizations found. Make sure you are logged in with `shopify auth login`.");
+    return;
+  }
+  console.log("Organizations:");
+  for (const org of orgs) {
+    console.log(`  ${org.id}  ${org.businessName || org.name || ""}`);
+    const stores = org.stores || org.devStores || [];
+    for (const s of stores) {
+      console.log(`    - ${s.shopDomain || s.domain || s.name || s.id}`);
+    }
+  }
+  console.log("\nTip: Store domain is <handle>.myshopify.com. Check your Partners Dashboard for non-dev stores.");
+}
+
+function storeAuth() {
+  const cfg = loadConfig();
+  requireStore(cfg);
+  if (!hasShopifyCommand("store auth")) {
+    console.error("Your Shopify CLI does not support `shopify store auth`. Upgrade with `npm install -g @shopify/cli@latest`.");
+    process.exit(1);
+  }
+  runShopify(["store", "auth", "--store", cfg.store, "--scopes", cfg.storeScopes]);
+}
+
+async function profileUse(nameArg) {
+  ensureConfigDir();
+  const profiles = listProfiles();
+  if (!profiles.length) {
+    console.log("No profiles found. Run `npm run setup` first.");
+    return;
+  }
+  let selected = nameArg ? profiles.find((profile) => profile.name === sanitizeProfileName(nameArg)) : null;
+  if (!selected) {
+    selected = await choose("Select profile", profiles, (profile) => `${profile.name} | ${profile.store || "-"}`);
+  }
+  fs.writeFileSync(activeProfilePath, `${selected.name}\n`);
+  fs.writeFileSync(configPath, JSON.stringify({ profile: selected.name }, null, 2) + "\n");
+  console.log(`Active profile: ${selected.name}`);
+}
+
+function themeList() {
+  const cfg = loadConfig();
+  requireStore(cfg);
+  const result = fetchThemes(cfg.store, themeEnv(cfg), cfg.themeToken);
+  if (!result.ok) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  for (const theme of result.themes) {
+    console.log(`${theme.id.padEnd(16)} ${String(theme.role || "").padEnd(13)} ${theme.name}`);
+  }
+}
+
+async function themeSelect() {
+  const cfg = loadConfig();
+  requireStore(cfg);
+  const result = fetchThemes(cfg.store, themeEnv(cfg), cfg.themeToken);
+  if (!result.ok) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log("Tip: choose an UNPUBLISHED theme for safe development.\n");
+  const currentIndex = Math.max(0, result.themes.findIndex((t) => t.id === cfg.themeId));
+  const selected = await choose(
+    "Select active theme",
+    result.themes,
+    (theme) => {
+      const liveWarning = theme.role === "live" ? " ⚠ LIVE" : "";
+      return `${(theme.name || "(unnamed)").padEnd(40)} ID: ${theme.id.padEnd(14)} role: ${theme.role || "unknown"}${liveWarning}`;
+    },
+    currentIndex
+  );
+  let chosenTheme = selected;
+  if (selected.role === "live") {
+    console.log("\n╔══════════════════════════════════════════════════════════╗");
+    console.log("║  ⚠  LIVE THEME SELECTED — READ BEFORE CONTINUING        ║");
+    console.log("╚══════════════════════════════════════════════════════════╝");
+    console.log("\nConsequences:");
+    console.log("  • Every `theme:push` will IMMEDIATELY update your public storefront");
+    console.log("  • Broken Liquid or CSS will be visible to customers instantly");
+    console.log("  • No auto-revert — you must manually republish the previous theme to roll back\n");
+    const unpublished = result.themes.filter((t) => t.role !== "live");
+    const liveChoice = await choose("What would you like to do?", ["switch", "live"],
+      (c) => c === "switch"
+        ? `Switch to unpublished theme${unpublished[0] ? ` → ${unpublished[0].name}` : ""} (RECOMMENDED)`
+        : "Continue with LIVE theme (I accept the risk)"
+    );
+    if (liveChoice === "switch") {
+      if (!unpublished.length) { console.log("No unpublished themes found. Aborting."); process.exit(0); }
+      chosenTheme = unpublished.length > 1
+        ? await choose("Select unpublished theme", unpublished,
+            (t) => `${(t.name || "(unnamed)").padEnd(40)} ID: ${t.id}`)
+        : unpublished[0];
+      console.log(`Switched to: ${chosenTheme.name} (${chosenTheme.id})`);
+    } else {
+      console.log(`Confirmed LIVE theme: ${selected.name}. Every push goes live immediately.`);
+    }
+  }
+  const activeName = cfg.profile || "default";
+  const current = loadProfile(activeName);
+  const saved = saveProfile({ ...current, name: activeName, themeId: chosenTheme.id, themeName: chosenTheme.name, themeRole: chosenTheme.role || "" });
+  fs.writeFileSync(configPath, JSON.stringify({ profile: saved.name }, null, 2) + "\n");
+  const envStatus = writeLocalEnv(saved, saved.themeToken || "");
+  console.log(`\nActive theme: ${chosenTheme.id}${chosenTheme.name ? ` (${chosenTheme.name})` : ""}`);
+  console.log(`.env ${envStatus === "created" ? "created" : "updated"} with new SHOPIFY_THEME_ID.`);
+}
+
+async function themeCommand(kind) {
+  const cfg = loadConfig();
+  const env = themeEnv(cfg);
+  const isLive = cfg.themeRole === "live";
+
+  if (["pull", "push", "publish"].includes(kind)) {
+    ensureCleanGitWorktree(`theme:${kind}`);
+  }
+
+  if (kind === "check") {
+    const themePath = requirePulledThemeDirectory(cfg, "theme:check");
+    run("shopify", ["theme", "check", "--path", themePath], { env });
+  }
+
+  if (kind === "dev") {
+    const themePath = requirePulledThemeDirectory(cfg, "theme:dev");
+    if (isLive) {
+      console.log("\n⚠  Active theme is LIVE. The dev server will sync changes to your public storefront.");
+      console.log("   Run `shopify-agent theme:select` to switch to an unpublished theme first.\n");
+      const ok = await confirm("Start dev server on LIVE theme anyway?", false);
+      if (!ok) { console.log("Aborted. Switch to an unpublished theme first."); process.exit(0); }
+    }
+    const args = shopifyArgsWithStore(cfg, ["theme", "dev"]);
+    if (cfg.themeId) args.push("--theme", cfg.themeId);
+    args.push("--path", themePath);
+    args.push("--allow-live", "--open");
+    run("shopify", args, { env });
+  }
+
+  if (kind === "pull") {
+    const themePath = themeDirectory(cfg);
+    fs.mkdirSync(themePath, { recursive: true });
+    assertThemeDirectoryMatches(themePath, cfg);
+    const args = shopifyArgsWithStore(cfg, ["theme", "pull"]);
+    if (cfg.themeId) args.push("--theme", cfg.themeId);
+    args.push("--path", themePath);
+    const status = run("shopify", args, { env });
+    if (status !== 0) return;
+    writeThemeMetadata(themePath, cfg);
+    console.log(`\nTheme files are in: ${path.relative(root, themePath)}`);
+    console.log("Commit this pull before the next Shopify theme operation:");
+    console.log(`  git add ${path.relative(root, themePath)}`);
+    console.log(`  git commit -m "Pull ${cfg.themeName || cfg.themeId} theme"`);
+  }
+
+  if (kind === "push") {
+    const themePath = requirePulledThemeDirectory(cfg, "theme:push");
+    if (isLive) {
+      console.log("\n╔══════════════════════════════════════════════════════════════╗");
+      console.log("║  ⚠  YOU ARE ABOUT TO PUSH TO YOUR LIVE THEME               ║");
+      console.log("╚══════════════════════════════════════════════════════════════╝");
+      console.log("\n  Theme :  " + (cfg.themeName || cfg.themeId));
+      console.log("  Store :  " + cfg.store);
+      console.log("\nConsequences:");
+      console.log("  • Your public storefront updates IMMEDIATELY after this push");
+      console.log("  • Every customer on your site right now will see the new code");
+      console.log("  • Any Liquid errors, broken CSS, or JS issues go live instantly");
+      console.log("  • To roll back you must manually republish the previous live theme");
+      console.log("\nRecommended: push to a new staging theme → preview → then publish.\n");
+
+      const pushChoice = await choose("How would you like to proceed?", ["staging", "live", "cancel"],
+        (c) => ({
+          staging: "Push to a NEW unpublished staging theme (safe — preview before publishing) [RECOMMENDED]",
+          live:    "Push directly to LIVE theme (I accept full responsibility for the consequences)",
+          cancel:  "Cancel"
+        })[c]
+      );
+
+      if (pushChoice === "cancel") { console.log("Cancelled."); process.exit(0); }
+
+      if (pushChoice === "staging") {
+        console.log("\nCreating new unpublished staging theme from your local files...");
+        const args = shopifyArgsWithStore(cfg, ["theme", "push", "--unpublished"]);
+        args.push("--path", themePath);
+        run("shopify", args, { env });
+        console.log("\nDone. A new unpublished theme has been created on your store.");
+        console.log("Preview it in Shopify Admin → Online Store → Themes.");
+        console.log("When satisfied, publish it with: shopify-agent theme:publish");
+        return;
+      }
+
+      // live push — double confirmation
+      console.log("\nFinal confirmation required.");
+      const typedConfirm = await ask(`Type the store domain to confirm (${cfg.store})`, "");
+      if (typedConfirm.trim() !== cfg.store) {
+        console.log("Store domain did not match. Push cancelled.");
+        process.exit(1);
+      }
+    }
+
+    const args = shopifyArgsWithStore(cfg, ["theme", "push"]);
+    if (cfg.themeId) args.push("--theme", cfg.themeId);
+    args.push("--path", themePath);
+    if (isLive) args.push("--allow-live");
+    run("shopify", args, { env });
+  }
+
+  if (kind === "publish") {
+    if (!cfg.themeId) {
+      console.error("Missing SHOPIFY_THEME_ID. Run `shopify-agent theme:select` first.");
+      process.exit(1);
+    }
+    const themeName = cfg.themeName || cfg.themeId;
+    console.log(`\nPublish theme: ${themeName}`);
+    console.log(`Store:         ${cfg.store}`);
+    console.log("\n⚠️  This will make the theme LIVE for all visitors immediately.");
+    console.log("   There is no auto-revert — to roll back you must manually republish the previous theme.\n");
+    const ok = await confirm("Publish this theme to your live storefront?", false);
+    if (!ok) { console.log("Publish cancelled."); process.exit(0); }
+    console.log(`\nPublishing ${themeName} to ${cfg.store}...`);
+    run("shopify", shopifyArgsWithStore(cfg, ["theme", "publish", "--theme", cfg.themeId]), { env });
+  }
+}
+
+function appCommand(kind) {
+  const cfg = loadConfig();
+  const args = ["app", kind];
+  if (cfg.appConfig) args.push("--config", cfg.appConfig);
+  if (cfg.appClientId) args.push("--client-id", cfg.appClientId);
+  run("shopify", args);
+}
+
+function requireStoreExecute() {
+  if (!hasShopifyCommand("store execute")) {
+    console.error("shopify store execute not available. Upgrade: npm install -g @shopify/cli@latest");
+    process.exit(1);
+  }
+}
+
+function storeExecuteArgs(cfg) {
+  const help = captureShopify(["store", "execute", "--help"]).output;
+  return { help };
+}
+
+function buildStoreExecuteArgs(cfg, queryStr, { allowMutations = false } = {}) {
+  const { help } = storeExecuteArgs(cfg);
+  const tmpFile = path.join(os.tmpdir(), `shopify-agent-gql-${Date.now()}.graphql`);
+  fs.writeFileSync(tmpFile, queryStr, "utf8");
+  const args = ["store", "execute", "--store", cfg.store];
+  if (help.includes("--version")) args.push("--version", cfg.apiVersion);
+  if (help.includes("--query-file")) {
+    args.push("--query-file", tmpFile);
+  } else {
+    args.push("--query", queryStr);
+  }
+  if (allowMutations) args.push("--allow-mutations");
+  return { args, tmpFile };
+}
+
+function captureAdminQuery(queryStr, cfg) {
+  requireStoreExecute();
+  const { args, tmpFile } = buildStoreExecuteArgs(cfg, queryStr);
+  try {
+    const result = captureShopify(args);
+    if (!result.ok) {
+      const out = result.stderr || result.output || "";
+      if (out.includes("No stored app authentication")) {
+        console.error("GraphQL query failed: no Admin API token for " + cfg.store);
+        console.error("\nRun this first to authenticate:\n");
+        console.error("  shopify-agent store:auth\n");
+        console.error("This opens a browser to approve Admin API scopes, then stores the token.\n");
+      } else {
+        console.error("GraphQL query failed:\n" + out);
+      }
+      process.exit(1);
+    }
+    const cleaned = stripAnsi(result.stdout);
+    const jsonStart = cleaned.indexOf("{");
+    if (jsonStart === -1) {
+      console.error("No JSON found in response:\n" + result.output);
+      process.exit(1);
+    }
+    try {
+      const parsed = JSON.parse(cleaned.slice(jsonStart));
+      return Object.prototype.hasOwnProperty.call(parsed, "data") ? parsed : { data: parsed };
+    } catch (e) {
+      console.error("Failed to parse GraphQL response:\n" + result.output);
+      process.exit(1);
+    }
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch {}
+  }
+}
+
+function runAdminMutation(mutationStr, cfg) {
+  requireStoreExecute();
+  const { args, tmpFile } = buildStoreExecuteArgs(cfg, mutationStr, { allowMutations: true });
+  try {
+    const result = captureShopify(args);
+    if (!result.ok) {
+      const out = result.stderr || result.output || "";
+      if (out.includes("No stored app authentication")) {
+        console.error("Mutation failed: no Admin API token for " + cfg.store);
+        console.error("\nRun this first to authenticate:\n");
+        console.error("  shopify-agent store:auth\n");
+        console.error("This opens a browser to approve Admin API scopes, then stores the token.\n");
+      } else {
+        console.error("Mutation failed:\n" + out);
+      }
+      process.exit(1);
+    }
+    // Print any output from the mutation (user errors, result IDs, etc.)
+    const cleaned = stripAnsi(result.stdout || "").trim();
+    if (cleaned) console.log(cleaned);
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch {}
+  }
+}
+
+// ─── Shared Admin Helpers ──────────────────────────────────────────────────
+
+function parseCliFlags() {
+  const args = process.argv.slice(3).filter((a) => a !== "--yes" && a !== "-y");
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      const key = args[i].slice(2);
+      const next = args[i + 1];
+      flags[key] = next && !next.startsWith("-") ? (i++, next) : true;
+    }
+  }
+  return flags;
+}
+
+function extractId(gid) {
+  return gid ? gid.split("/").pop() : "—";
+}
+
+function printTable(rows) {
+  if (!rows.length) return;
+  const headers = Object.keys(rows[0]);
+  const widths = headers.map((h) => Math.max(h.length, ...rows.map((r) => String(r[h] ?? "").length)));
+  const sep = (l, m, r) => l + widths.map((w) => "─".repeat(w + 2)).join(m) + r;
+  const row = (r) => "│" + headers.map((h, i) => ` ${String(r[h] ?? "").padEnd(widths[i])} `).join("│") + "│";
+  console.log(sep("┌", "┬", "┐"));
+  console.log(row(Object.fromEntries(headers.map((h) => [h, h]))));
+  console.log(sep("├", "┼", "┤"));
+  rows.forEach((r) => console.log(row(r)));
+  console.log(sep("└", "┴", "┘"));
+}
+
+function esc(str) { return String(str || "").replace(/\\/g, "\\\\").replace(/"/g, '\\"'); }
+function trunc(str, n = 35) { return String(str || "—").slice(0, n); }
+
+// ─── Products ──────────────────────────────────────────────────────────────
+
+async function productsList() {
+  const flags = parseCliFlags();
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const statusFilter = flags.status ? `, query: "status:${flags.status}"` : "";
+  const limit = parseInt(flags.limit, 10) || 20;
+  const data = captureAdminQuery(`query {
+  products(first: ${limit}${statusFilter}) {
+    edges { node {
+      id title status productType vendor totalInventory
+      priceRangeV2 { minVariantPrice { amount currencyCode } }
+    } }
+  }
+}`, cfg);
+  const items = (data.data?.products?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No products found."); return; }
+  printTable(items.map((p) => ({
+    ID: extractId(p.id), Title: trunc(p.title, 40), Status: p.status,
+    Type: trunc(p.productType || "—", 18), Vendor: trunc(p.vendor || "—", 15),
+    Inventory: p.totalInventory,
+    Price: `${p.priceRangeV2.minVariantPrice.amount} ${p.priceRangeV2.minVariantPrice.currencyCode}`
+  })));
+  console.log(`\n${items.length} products  |  --status active|draft|archived  |  --limit N`);
+}
+
+async function productsGet() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { products(first: 50) { edges { node { id title status } } } }`, cfg);
+  const products = (data.data?.products?.edges || []).map((e) => e.node);
+  if (!products.length) { console.log("No products found."); return; }
+  const p0 = await choose("Select product:", products, (p) => `${p.title} (${p.status})`);
+  const d = captureAdminQuery(`query {
+  product(id: "${p0.id}") {
+    id title descriptionHtml status productType vendor tags totalInventory
+    priceRangeV2 { minVariantPrice { amount currencyCode } maxVariantPrice { amount currencyCode } }
+    variants(first: 20) { edges { node { id title sku price compareAtPrice inventoryQuantity selectedOptions { name value } } } }
+    images(first: 3) { edges { node { url altText } } }
+  }
+}`, cfg);
+  const p = d.data?.product;
+  if (!p) { console.log("Not found."); return; }
+  console.log(`\n${"═".repeat(60)}\n${p.title}\n${"═".repeat(60)}`);
+  console.log(`ID: ${extractId(p.id)}  |  Status: ${p.status}  |  Type: ${p.productType || "—"}  |  Vendor: ${p.vendor || "—"}`);
+  console.log(`Tags: ${(p.tags || []).join(", ") || "—"}  |  Total inventory: ${p.totalInventory}`);
+  console.log(`Price: ${p.priceRangeV2.minVariantPrice.amount}–${p.priceRangeV2.maxVariantPrice.amount} ${p.priceRangeV2.minVariantPrice.currencyCode}`);
+  console.log(`\nVariants:`);
+  p.variants.edges.forEach(({ node: v }) =>
+    console.log(`  ${v.title.padEnd(28)} SKU: ${(v.sku || "—").padEnd(14)} Price: ${String(v.price).padEnd(10)} Qty: ${v.inventoryQuantity}`)
+  );
+}
+
+async function productsCreate() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  console.log("\nNew Product Wizard\n");
+  const title = await ask("Product title", ""); if (!title) { console.error("Title is required."); process.exit(1); }
+  const productType = await ask("Product type (e.g. T-Shirt)", "");
+  const vendor = await ask("Vendor", "");
+  const price = await ask("Price (e.g. 29.99)", "0.00");
+  const sku = await ask("SKU (optional)", "");
+  const qty = parseInt(await ask("Initial inventory quantity", "0"), 10);
+  const status = await choose("Status:", ["DRAFT", "ACTIVE"], (s) => s === "ACTIVE" ? "Active (visible in store)" : "Draft (hidden)", 0);
+  const ok = await confirm(`Create "${title}" at ${price} (${status})?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  const locData = captureAdminQuery(`query { locations(first: 1) { edges { node { id } } } }`, cfg);
+  const locationId = locData.data?.locations?.edges?.[0]?.node?.id;
+  const invBlock = locationId ? `inventoryQuantities: { availableQuantity: ${qty || 0}, locationId: "${locationId}" }` : "";
+  runAdminMutation(`mutation {
+  productCreate(input: {
+    title: "${esc(title)}"
+    ${productType ? `productType: "${esc(productType)}"` : ""}
+    ${vendor ? `vendor: "${esc(vendor)}"` : ""}
+    status: ${status}
+    variants: [{ price: "${price}" ${sku ? `sku: "${esc(sku)}"` : ""} ${invBlock} }]
+  }) {
+    product { id title status }
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+async function productsSetStatus(status) {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const opposite = status === "ACTIVE" ? "draft OR archived" : "active";
+  const data = captureAdminQuery(`query { products(first: 50) { edges { node { id title status } } } }`, cfg);
+  const products = (data.data?.products?.edges || []).map((e) => e.node).filter((p) => p.status !== status);
+  if (!products.length) { console.log("No eligible products found."); return; }
+  const product = await choose(`Select product to ${status === "ACTIVE" ? "publish" : status === "ARCHIVED" ? "archive" : "set to " + status}:`, products, (p) => `${p.title} (${p.status})`);
+  const ok = await confirm(`Set "${product.title}" to ${status}?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation {
+  productUpdate(input: { id: "${product.id}", status: ${status} }) {
+    product { id title status }
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+async function productsDelete() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { products(first: 50) { edges { node { id title status } } } }`, cfg);
+  const products = (data.data?.products?.edges || []).map((e) => e.node);
+  if (!products.length) { console.log("No products found."); return; }
+  const product = await choose("Select product to DELETE:", products, (p) => `${p.title} (${p.status})`);
+  console.log(`\n⚠️  Permanently deleting: "${product.title}". This cannot be undone.`);
+  const ok = await confirm("Delete this product?", false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation {
+  productDelete(input: { id: "${product.id}" }) {
+    deletedProductId
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+// ─── Variants ──────────────────────────────────────────────────────────────
+
+async function variantsList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { products(first: 50) { edges { node { id title } } } }`, cfg);
+  const products = (data.data?.products?.edges || []).map((e) => e.node);
+  if (!products.length) { console.log("No products found."); return; }
+  const product = await choose("Select product:", products, (p) => p.title);
+  const vd = captureAdminQuery(`query { product(id: "${product.id}") {
+    variants(first: 50) { edges { node { id title sku price compareAtPrice inventoryQuantity barcode } } }
+  } }`, cfg);
+  const variants = (vd.data?.product?.variants?.edges || []).map((e) => e.node);
+  if (!variants.length) { console.log("No variants found."); return; }
+  printTable(variants.map((v) => ({
+    ID: extractId(v.id), Title: trunc(v.title, 25), SKU: v.sku || "—",
+    Price: v.price, "Compare At": v.compareAtPrice || "—", Inventory: v.inventoryQuantity, Barcode: v.barcode || "—"
+  })));
+}
+
+async function variantsUpdate() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const pd = captureAdminQuery(`query { products(first: 50) { edges { node { id title } } } }`, cfg);
+  const product = await choose("Select product:", (pd.data?.products?.edges || []).map((e) => e.node), (p) => p.title);
+  const vd = captureAdminQuery(`query { product(id: "${product.id}") { variants(first: 50) { edges { node { id title sku price inventoryQuantity } } } } }`, cfg);
+  const variants = (vd.data?.product?.variants?.edges || []).map((e) => e.node);
+  const variant = await choose("Select variant:", variants, (v) => `${v.title} — ${v.price} — qty: ${v.inventoryQuantity}`);
+  console.log(`\nUpdating: ${variant.title} (leave blank to keep current)`);
+  const price = await ask("New price", variant.price);
+  const sku = await ask("New SKU", variant.sku || "");
+  const compareAtPrice = await ask("Compare-at price (or blank)", "");
+  const barcode = await ask("Barcode (or blank)", "");
+  const ok = await confirm("Apply updates?", false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  const fields = [`id: "${variant.id}"`, `price: "${price}"`];
+  if (sku) fields.push(`sku: "${esc(sku)}"`);
+  if (compareAtPrice) fields.push(`compareAtPrice: "${compareAtPrice}"`);
+  if (barcode) fields.push(`barcode: "${esc(barcode)}"`);
+  runAdminMutation(`mutation {
+  productVariantUpdate(input: { ${fields.join(", ")} }) {
+    productVariant { id title price sku }
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+// ─── Collections ───────────────────────────────────────────────────────────
+
+async function collectionsList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query {
+  collections(first: 30) {
+    edges { node { id title productsCount sortOrder ruleSet { rules { column relation condition } } } }
+  }
+}`, cfg);
+  const items = (data.data?.collections?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No collections found."); return; }
+  printTable(items.map((c) => ({
+    ID: extractId(c.id), Title: trunc(c.title, 40), Products: c.productsCount,
+    Type: c.ruleSet ? "Smart" : "Manual", Sort: c.sortOrder || "—"
+  })));
+}
+
+async function collectionsCreate() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  console.log("\nNew Collection Wizard\n");
+  const title = await ask("Collection title", ""); if (!title) { console.error("Title required."); process.exit(1); }
+  const description = await ask("Description (optional)", "");
+  const type = await choose("Type:", ["manual", "smart"], (t) => t === "smart" ? "Smart (auto rules)" : "Manual (add products yourself)", 0);
+  let ruleSetInput = "";
+  if (type === "smart") {
+    const column = await choose("Rule column:", ["TITLE", "TYPE", "VENDOR", "TAG", "VARIANT_PRICE"], (c) => c, 0);
+    const relation = await choose("Relation:", ["CONTAINS", "EQUALS", "STARTS_WITH", "GREATER_THAN", "LESS_THAN"], (r) => r.toLowerCase(), 0);
+    const condition = await ask("Condition value", "");
+    ruleSetInput = `ruleSet: { appliedDisjunctively: false, rules: [{ column: ${column}, relation: ${relation}, condition: "${esc(condition)}" }] }`;
+  }
+  const ok = await confirm(`Create collection "${title}" (${type})?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation {
+  collectionCreate(input: {
+    title: "${esc(title)}"
+    ${description ? `descriptionHtml: "${esc(description)}"` : ""}
+    ${ruleSetInput}
+  }) {
+    collection { id title productsCount }
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+// ─── Inventory ─────────────────────────────────────────────────────────────
+
+async function inventoryList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query {
+  inventoryItems(first: 50) {
+    edges { node {
+      id sku tracked
+      variant { displayName product { title } }
+      inventoryLevels(first: 5) { edges { node {
+        location { name }
+        quantities(names: ["available"]) { name quantity }
+      } } }
+    } }
+  }
+}`, cfg);
+  const items = (data.data?.inventoryItems?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No inventory items found."); return; }
+  printTable(items.map((item) => {
+    const levels = (item.inventoryLevels?.edges || []).map((l) => `${l.node.location.name}: ${l.node.quantities?.[0]?.quantity ?? "?"}`).join(" | ");
+    return {
+      SKU: item.sku || "—", Product: trunc(item.variant?.product?.title || "—", 30),
+      Variant: trunc(item.variant?.displayName || "—", 20), Tracked: item.tracked ? "Yes" : "No", Stock: levels || "—"
+    };
+  }));
+}
+
+async function inventoryAdjust() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query {
+  products(first: 250) { edges { node { title variants(first: 100) { edges { node { title inventoryItem { id } inventoryQuantity } } } } } }
+  locations(first: 10) { edges { node { id name isActive } } }
+}`, cfg);
+  const locations = (data.data?.locations?.edges || []).map((e) => e.node).filter((l) => l.isActive);
+  if (!locations.length) { console.error("No active locations."); process.exit(1); }
+  const location = locations.length === 1 ? locations[0] : await choose("Select location:", locations, (l) => l.name);
+  const allVariants = [];
+  for (const { node: p } of (data.data?.products?.edges || []))
+    for (const { node: v } of p.variants.edges)
+      allVariants.push({ ...v, productTitle: p.title });
+  const variant = await choose("Select variant:", allVariants, (v) => `${v.productTitle} / ${v.title} (current: ${v.inventoryQuantity})`);
+  const deltaStr = await ask("Adjustment: +5, -3, or =10 (= sets absolute)", "");
+  if (deltaStr.startsWith("=")) {
+    const qty = parseInt(deltaStr.slice(1), 10);
+    const ok = await confirm(`Set inventory to ${qty} at ${location.name}?`, false);
+    if (!ok) { console.log("Cancelled."); process.exit(0); }
+    runAdminMutation(`mutation { inventorySetOnHandQuantities(input: {
+  reason: "correction", setQuantities: [{ inventoryItemId: "${variant.inventoryItem.id}", locationId: "${location.id}", quantity: ${qty} }]
+}) { userErrors { field message } inventoryAdjustmentGroup { changes { delta quantityAfterChange } } } }`, cfg);
+  } else {
+    const delta = parseInt(deltaStr, 10);
+    if (isNaN(delta)) { console.error("Invalid. Use +5, -3, or =10."); process.exit(1); }
+    const ok = await confirm(`Adjust by ${delta > 0 ? "+" : ""}${delta} at ${location.name}?`, false);
+    if (!ok) { console.log("Cancelled."); process.exit(0); }
+    runAdminMutation(`mutation { inventoryAdjustQuantities(input: {
+  reason: "correction", name: "available",
+  changes: [{ inventoryItemId: "${variant.inventoryItem.id}", locationId: "${location.id}", delta: ${delta} }]
+}) { userErrors { field message } inventoryAdjustmentGroup { changes { delta quantityAfterChange } } } }`, cfg);
+  }
+}
+
+// ─── Orders ────────────────────────────────────────────────────────────────
+
+async function ordersList() {
+  const flags = parseCliFlags();
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const status = flags.status || "open";
+  const limit = parseInt(flags.limit, 10) || 20;
+  const data = captureAdminQuery(`query {
+  orders(first: ${limit}, query: "status:${status}", sortKey: CREATED_AT, reverse: true) {
+    edges { node {
+      id name createdAt displayFinancialStatus displayFulfillmentStatus
+      totalPriceSet { presentmentMoney { amount currencyCode } }
+      customer { displayName }
+      lineItems(first: 2) { edges { node { title quantity } } }
+    } }
+  }
+}`, cfg);
+  const orders = (data.data?.orders?.edges || []).map((e) => e.node);
+  if (!orders.length) { console.log(`No ${status} orders found.`); return; }
+  printTable(orders.map((o) => ({
+    Order: o.name, Date: o.createdAt.slice(0, 10), Customer: trunc(o.customer?.displayName || "Guest", 22),
+    Total: `${o.totalPriceSet.presentmentMoney.amount} ${o.totalPriceSet.presentmentMoney.currencyCode}`,
+    Payment: o.displayFinancialStatus, Fulfillment: o.displayFulfillmentStatus
+  })));
+  console.log(`\n${orders.length} orders  |  --status open|closed|cancelled|any  |  --limit N`);
+}
+
+async function ordersGet() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { orders(first: 30, query: "status:any", sortKey: CREATED_AT, reverse: true) {
+    edges { node { id name createdAt customer { displayName } totalPriceSet { presentmentMoney { amount currencyCode } } } }
+  } }`, cfg);
+  const orders = (data.data?.orders?.edges || []).map((e) => e.node);
+  if (!orders.length) { console.log("No orders found."); return; }
+  const o0 = await choose("Select order:", orders, (o) => `${o.name}  ${o.createdAt.slice(0, 10)}  ${o.customer?.displayName || "Guest"}  ${o.totalPriceSet.presentmentMoney.amount}`);
+  const d = captureAdminQuery(`query { order(id: "${o0.id}") {
+    id name createdAt displayFinancialStatus displayFulfillmentStatus
+    totalPriceSet { presentmentMoney { amount currencyCode } }
+    subtotalPriceSet { presentmentMoney { amount currencyCode } }
+    totalShippingPriceSet { presentmentMoney { amount currencyCode } }
+    totalTaxSet { presentmentMoney { amount currencyCode } }
+    customer {
+      displayName
+      defaultEmailAddress { emailAddress }
+      defaultPhoneNumber { phoneNumber }
+    }
+    shippingAddress { address1 city province country zip }
+    lineItems(first: 20) { edges { node { title quantity originalUnitPriceSet { presentmentMoney { amount currencyCode } } variant { sku } } } }
+    fulfillments { status trackingInfo { number url } }
+    note tags
+  } }`, cfg);
+  const o = d.data?.order; if (!o) { console.log("Not found."); return; }
+  console.log(`\n${"═".repeat(62)}\nOrder ${o.name}  —  ${o.createdAt.slice(0, 10)}\n${"═".repeat(62)}`);
+  console.log(`Customer: ${o.customer?.displayName || "Guest"} <${o.customer?.defaultEmailAddress?.emailAddress || "—"}>`);
+  if (o.shippingAddress) { const a = o.shippingAddress; console.log(`Ship to:  ${[a.address1, a.city, a.province, a.country].filter(Boolean).join(", ")}`); }
+  console.log(`Payment:  ${o.displayFinancialStatus}  |  Fulfillment: ${o.displayFulfillmentStatus}`);
+  if (o.fulfillments?.length) o.fulfillments.forEach((f) => f.trackingInfo?.forEach((t) => console.log(`Tracking: ${t.number}  ${t.url}`)));
+  console.log(`\nLine Items:`);
+  o.lineItems.edges.forEach(({ node: li }) =>
+    console.log(`  ${String(li.quantity).padStart(2)}×  ${li.title.padEnd(42)} ${li.originalUnitPriceSet.presentmentMoney.amount}`)
+  );
+  const m = o.totalPriceSet.presentmentMoney;
+  console.log(`\n  Subtotal: ${o.subtotalPriceSet.presentmentMoney.amount}  |  Shipping: ${o.totalShippingPriceSet.presentmentMoney.amount}  |  Tax: ${o.totalTaxSet.presentmentMoney.amount}  |  Total: ${m.amount} ${m.currencyCode}`);
+  if (o.note) console.log(`Note: ${o.note}`);
+}
+
+async function ordersCancel() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { orders(first: 30, query: "status:open") {
+    edges { node { id name customer { displayName } totalPriceSet { presentmentMoney { amount currencyCode } } } }
+  } }`, cfg);
+  const orders = (data.data?.orders?.edges || []).map((e) => e.node);
+  if (!orders.length) { console.log("No open orders to cancel."); return; }
+  const order = await choose("Select order to cancel:", orders, (o) => `${o.name}  ${o.customer?.displayName || "Guest"}  ${o.totalPriceSet.presentmentMoney.amount}`);
+  const reason = await choose("Reason:", ["CUSTOMER", "FRAUD", "INVENTORY", "DECLINED", "OTHER"], (r) => r.charAt(0) + r.slice(1).toLowerCase(), 4);
+  const refund = await confirm("Refund payment?", false);
+  const restock = await confirm("Restock inventory?", true);
+  console.log(`\n⚠️  Cancelling order ${order.name}. This cannot be undone.`);
+  const ok = await confirm("Confirm cancellation?", false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation {
+  orderCancel(orderId: "${order.id}", reason: ${reason}, refund: ${refund}, restock: ${restock}) {
+    job { id }
+    orderCancelUserErrors { field message }
+  }
+}`, cfg);
+}
+
+async function ordersClose() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { orders(first: 30, query: "status:open") {
+    edges { node { id name customer { displayName } } }
+  } }`, cfg);
+  const orders = (data.data?.orders?.edges || []).map((e) => e.node);
+  if (!orders.length) { console.log("No open orders."); return; }
+  const order = await choose("Select order to close:", orders, (o) => `${o.name}  ${o.customer?.displayName || "Guest"}`);
+  const ok = await confirm(`Close order ${order.name}?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation {
+  orderClose(input: { id: "${order.id}" }) {
+    order { id name displayFulfillmentStatus }
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+// ─── Customers ─────────────────────────────────────────────────────────────
+
+async function customersList() {
+  const flags = parseCliFlags();
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const limit = parseInt(flags.limit, 10) || 20;
+  const data = captureAdminQuery(`query {
+  customers(first: ${limit}) {
+    edges { node {
+      id displayName numberOfOrders
+      defaultEmailAddress { emailAddress }
+      defaultPhoneNumber { phoneNumber }
+      amountSpent { amount currencyCode }
+      defaultAddress { city country }
+      createdAt
+    } }
+  }
+}`, cfg);
+  const items = (data.data?.customers?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No customers found."); return; }
+  printTable(items.map((c) => ({
+    ID: extractId(c.id), Name: trunc(c.displayName || "—", 25), Email: trunc(c.defaultEmailAddress?.emailAddress || "—", 30),
+    Orders: c.numberOfOrders || 0, Spent: `${c.amountSpent?.amount || "0"} ${c.amountSpent?.currencyCode || ""}`,
+    Location: c.defaultAddress ? `${c.defaultAddress.city || "—"}, ${c.defaultAddress.country || ""}` : "—"
+  })));
+  console.log(`\n${items.length} customers  |  --limit N`);
+}
+
+async function customersSearch() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const query = await ask("Search (name, email, phone, tag)", "");
+  if (!query) { console.error("Search query required."); process.exit(1); }
+  const data = captureAdminQuery(`query {
+  customers(first: 20, query: "${esc(query)}") {
+    edges { node {
+      id displayName numberOfOrders
+      defaultEmailAddress { emailAddress }
+      defaultPhoneNumber { phoneNumber }
+      amountSpent { amount currencyCode }
+      defaultAddress { city country }
+    } }
+  }
+}`, cfg);
+  const items = (data.data?.customers?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log(`No customers matching "${query}".`); return; }
+  printTable(items.map((c) => ({
+    ID: extractId(c.id), Name: trunc(c.displayName || "—", 25), Email: trunc(c.defaultEmailAddress?.emailAddress || "—", 30),
+    Phone: c.defaultPhoneNumber?.phoneNumber || "—", Orders: c.numberOfOrders, Spent: `${c.amountSpent?.amount || "0"} ${c.amountSpent?.currencyCode || ""}`
+  })));
+}
+
+async function customersGet() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const q = await ask("Search to find customer (name or email)", "");
+  const data = captureAdminQuery(`query { customers(first: 20, query: "${esc(q)}") {
+    edges { node { id displayName defaultEmailAddress { emailAddress } } }
+  } }`, cfg);
+  const customers = (data.data?.customers?.edges || []).map((e) => e.node);
+  if (!customers.length) { console.log("No customers found."); return; }
+  const c0 = await choose("Select customer:", customers, (c) => `${c.displayName} <${c.defaultEmailAddress?.emailAddress || "no email"}>`);
+  const d = captureAdminQuery(`query { customer(id: "${c0.id}") {
+    id displayName firstName lastName numberOfOrders
+    defaultEmailAddress { emailAddress }
+    defaultPhoneNumber { phoneNumber }
+    amountSpent { amount currencyCode }
+    tags verifiedEmail taxExempt createdAt
+    defaultAddress { address1 city province country zip }
+    orders(first: 5, sortKey: CREATED_AT, reverse: true) {
+      edges { node { name createdAt totalPriceSet { presentmentMoney { amount currencyCode } } displayFinancialStatus } }
+    }
+  } }`, cfg);
+  const c = d.data?.customer; if (!c) { console.log("Not found."); return; }
+  console.log(`\n${"═".repeat(60)}\n${c.displayName}\n${"═".repeat(60)}`);
+  console.log(`Email: ${c.defaultEmailAddress?.emailAddress || "—"} ${c.verifiedEmail ? "(verified)" : "(unverified)"}  |  Phone: ${c.defaultPhoneNumber?.phoneNumber || "—"}`);
+  console.log(`Orders: ${c.numberOfOrders}  |  Spent: ${c.amountSpent?.amount} ${c.amountSpent?.currencyCode}  |  Tax Exempt: ${c.taxExempt ? "Yes" : "No"}`);
+  console.log(`Tags: ${(c.tags || []).join(", ") || "—"}`);
+  if (c.defaultAddress) { const a = c.defaultAddress; console.log(`Address: ${[a.address1, a.city, a.province, a.country].filter(Boolean).join(", ")}`); }
+  console.log(`\nRecent Orders:`);
+  c.orders.edges.forEach(({ node: o }) => console.log(`  ${o.name}  ${o.createdAt.slice(0, 10)}  ${o.totalPriceSet.presentmentMoney.amount} ${o.totalPriceSet.presentmentMoney.currencyCode}  ${o.displayFinancialStatus}`));
+}
+
+async function customersCreate() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  console.log("\nNew Customer Wizard\n");
+  const firstName = await ask("First name", "");
+  const lastName = await ask("Last name", "");
+  const email = await ask("Email", "");
+  if (!email && !firstName) { console.error("Name or email required."); process.exit(1); }
+  const phone = await ask("Phone (optional)", "");
+  const tags = await ask("Tags (comma-separated, optional)", "");
+  const sendEmail = await confirm("Subscribe to marketing emails?", false);
+  const ok = await confirm(`Create customer ${[firstName, lastName].filter(Boolean).join(" ")} <${email}>?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  const fields = [];
+  if (firstName) fields.push(`firstName: "${esc(firstName)}"`);
+  if (lastName) fields.push(`lastName: "${esc(lastName)}"`);
+  if (email) fields.push(`email: "${esc(email)}"`);
+  if (phone) fields.push(`phone: "${esc(phone)}"`);
+  if (tags) fields.push(`tags: [${tags.split(",").map((t) => `"${esc(t.trim())}"`).join(",")}]`);
+  if (sendEmail) fields.push(`emailMarketingConsent: { marketingState: SUBSCRIBED, marketingOptInLevel: SINGLE_OPT_IN }`);
+  runAdminMutation(`mutation {
+  customerCreate(input: { ${fields.join(", ")} }) {
+    customer { id displayName email }
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+async function customersTags() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const q = await ask("Search to find customer", "");
+  const data = captureAdminQuery(`query { customers(first: 20, query: "${esc(q)}") { edges { node { id displayName email tags } } } }`, cfg);
+  const customers = (data.data?.customers?.edges || []).map((e) => e.node);
+  if (!customers.length) { console.log("No customers found."); return; }
+  const c = await choose("Select customer:", customers, (c) => `${c.displayName} — tags: ${(c.tags || []).join(", ") || "none"}`);
+  const action = await choose("Action:", ["add", "remove"], (a) => `${a} tags`, 0);
+  const tagsInput = await ask(`Tags to ${action} (comma-separated)`, "");
+  if (!tagsInput) { console.log("No tags."); return; }
+  const tagsList = tagsInput.split(",").map((t) => `"${esc(t.trim())}"`).join(",");
+  const ok = await confirm(`${action === "add" ? "Add" : "Remove"} tags [${tagsInput}] for ${c.displayName}?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation { ${action === "add" ? "tagsAdd" : "tagsRemove"}(id: "${c.id}", tags: [${tagsList}]) {
+  node { id } userErrors { field message } } }`, cfg);
+}
+
+// ─── Discounts ─────────────────────────────────────────────────────────────
+
+async function discountsList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query {
+  codeDiscountNodes(first: 30) {
+    edges { node { id codeDiscount {
+      __typename
+      ... on DiscountCodeBasic {
+        title status appliesOncePerCustomer usageLimit asyncUsageCount startsAt endsAt
+        codes(first: 3) { edges { node { code } } }
+        customerGets { value {
+          ... on DiscountPercentage { percentage }
+          ... on DiscountAmount { amount { amount currencyCode } }
+        } }
+      }
+      ... on DiscountCodeBxgy {
+        title status appliesOncePerCustomer usageLimit asyncUsageCount startsAt endsAt
+        codes(first: 3) { edges { node { code } } }
+      }
+      ... on DiscountCodeFreeShipping {
+        title status appliesOncePerCustomer usageLimit asyncUsageCount startsAt endsAt
+        codes(first: 3) { edges { node { code } } }
+      }
+      ... on DiscountCodeApp {
+        title status appliesOncePerCustomer usageLimit asyncUsageCount startsAt endsAt
+        codes(first: 3) { edges { node { code } } }
+      }
+    } } }
+  }
+}`, cfg);
+  const items = (data.data?.codeDiscountNodes?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No discount codes found."); return; }
+  printTable(items.map((d) => {
+    const disc = d.codeDiscount;
+    const codes = (disc.codes?.edges || []).map((e) => e.node.code).join(", ");
+    const used = disc.asyncUsageCount || 0;
+    const val = disc.customerGets?.value?.percentage
+      ? `${(disc.customerGets.value.percentage * 100).toFixed(0)}% off`
+      : disc.customerGets?.value?.amount
+        ? `${disc.customerGets.value.amount.amount} ${disc.customerGets.value.amount.currencyCode} off`
+        : (disc.__typename || "—").replace(/^DiscountCode/, "");
+    return {
+      Title: trunc(disc.title || "—", 28), Code: trunc(codes, 20), Value: val,
+      Used: used, Limit: disc.usageLimit || "∞", "1×/customer": disc.appliesOncePerCustomer ? "Yes" : "No",
+      Status: disc.status, Expires: disc.endsAt ? disc.endsAt.slice(0, 10) : "Never"
+    };
+  }));
+}
+
+async function discountsDelete() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { codeDiscountNodes(first: 30) {
+    edges { node { id codeDiscount {
+      ... on DiscountCodeBasic { title status codes(first: 1) { edges { node { code } } } }
+      ... on DiscountCodeBxgy { title status codes(first: 1) { edges { node { code } } } }
+      ... on DiscountCodeFreeShipping { title status codes(first: 1) { edges { node { code } } } }
+      ... on DiscountCodeApp { title status codes(first: 1) { edges { node { code } } } }
+    } } }
+  } }`, cfg);
+  const items = (data.data?.codeDiscountNodes?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No discounts found."); return; }
+  const d = await choose("Select discount to delete:", items, (d) => {
+    const code = d.codeDiscount.codes?.edges?.[0]?.node?.code || "—";
+    return `${d.codeDiscount.title} (${code}) — ${d.codeDiscount.status}`;
+  });
+  console.log(`\n⚠️  Permanently deleting: ${d.codeDiscount.title}`);
+  const ok = await confirm("Delete this discount?", false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation {
+  discountCodeDelete(id: "${d.id}") { deletedCodeDiscountId userErrors { field message } }
+}`, cfg);
+}
+
+async function discountsDisable() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { codeDiscountNodes(first: 30) {
+    edges { node { id codeDiscount {
+      ... on DiscountCodeBasic { title status codes(first: 1) { edges { node { code } } } }
+      ... on DiscountCodeBxgy { title status codes(first: 1) { edges { node { code } } } }
+      ... on DiscountCodeFreeShipping { title status codes(first: 1) { edges { node { code } } } }
+      ... on DiscountCodeApp { title status codes(first: 1) { edges { node { code } } } }
+    } } }
+  } }`, cfg);
+  const items = (data.data?.codeDiscountNodes?.edges || []).map((e) => e.node).filter((d) => d.codeDiscount.status === "ACTIVE");
+  if (!items.length) { console.log("No active discounts."); return; }
+  const d = await choose("Select discount to disable:", items, (d) => `${d.codeDiscount.title} (${d.codeDiscount.codes?.edges?.[0]?.node?.code || "—"})`);
+  const ok = await confirm(`Disable "${d.codeDiscount.title}"?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation { discountCodeDeactivate(id: "${d.id}") { codeDiscountNode { id } userErrors { field message } } }`, cfg);
+}
+
+async function discountsEnable() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { codeDiscountNodes(first: 30) {
+    edges { node { id codeDiscount {
+      ... on DiscountCodeBasic { title status codes(first: 1) { edges { node { code } } } }
+      ... on DiscountCodeBxgy { title status codes(first: 1) { edges { node { code } } } }
+      ... on DiscountCodeFreeShipping { title status codes(first: 1) { edges { node { code } } } }
+      ... on DiscountCodeApp { title status codes(first: 1) { edges { node { code } } } }
+    } } }
+  } }`, cfg);
+  const items = (data.data?.codeDiscountNodes?.edges || []).map((e) => e.node).filter((d) => d.codeDiscount.status !== "ACTIVE");
+  if (!items.length) { console.log("No inactive discounts."); return; }
+  const d = await choose("Select discount to enable:", items, (d) => `${d.codeDiscount.title} (${d.codeDiscount.status})`);
+  const ok = await confirm(`Enable "${d.codeDiscount.title}"?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation { discountCodeActivate(id: "${d.id}") { codeDiscountNode { id } userErrors { field message } } }`, cfg);
+}
+
+// ─── Gift Cards ─────────────────────────────────────────────────────────────
+
+async function giftCardsList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query {
+  giftCards(first: 20) {
+    edges { node {
+      id lastCharacters maskedCode enabled expiresOn createdAt
+      initialValue { amount currencyCode } balance { amount currencyCode }
+      customer { displayName email }
+    } }
+  }
+}`, cfg);
+  const items = (data.data?.giftCards?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No gift cards found."); return; }
+  printTable(items.map((c) => ({
+    Code: `...${c.lastCharacters}`, Customer: trunc(c.customer?.displayName || "—", 20),
+    Initial: `${c.initialValue.amount} ${c.initialValue.currencyCode}`,
+    Balance: `${c.balance.amount} ${c.balance.currencyCode}`,
+    Expires: c.expiresOn || "Never", Status: c.enabled ? "Active" : "Disabled"
+  })));
+}
+
+async function giftCardsCreate() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  console.log("\nNew Gift Card Wizard\n");
+  const amount = await ask("Amount (e.g. 500.00)", "500.00");
+  const note = await ask("Note (optional)", "");
+  const expiresOn = await ask("Expiry date YYYY-MM-DD (blank = no expiry)", "");
+  const customerEmail = await ask("Assign to customer email (optional)", "");
+  const ok = await confirm(`Create gift card worth ${amount}?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  const fields = [`initialValue: ${parseFloat(amount)}`];
+  if (note) fields.push(`note: "${esc(note)}"`);
+  if (expiresOn) fields.push(`expiresOn: "${expiresOn}"`);
+  if (customerEmail) {
+    const cData = captureAdminQuery(`query { customers(first: 1, query: "email:${esc(customerEmail)}") { edges { node { id } } } }`, cfg);
+    const cId = cData.data?.customers?.edges?.[0]?.node?.id;
+    if (cId) fields.push(`customerId: "${cId}"`); else console.log("Customer not found — creating unassigned gift card.");
+  }
+  runAdminMutation(`mutation {
+  giftCardCreate(input: { ${fields.join(", ")} }) {
+    giftCard { id lastCharacters initialValue { amount currencyCode } balance { amount currencyCode } }
+    giftCardCode
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+// ─── Store Info & Dashboard ────────────────────────────────────────────────
+
+async function storeInfo() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { shop {
+    name myshopifyDomain primaryDomain { url }
+    plan { displayName } currencyCode weightUnit ianaTimezone
+    email shopAddress { address1 city country phone }
+    enabledPresentmentCurrencies
+    checkoutApiSupported
+  } }`, cfg);
+  const s = data.data?.shop; if (!s) { console.log("Could not get store info."); return; }
+  console.log(`\n${"═".repeat(50)}\n${s.name}\n${"═".repeat(50)}`);
+  console.log(`Domain:     ${s.primaryDomain?.url || s.myshopifyDomain}`);
+  console.log(`Plan:       ${s.plan?.displayName || "—"}`);
+  console.log(`Currency:   ${s.currencyCode}  |  Timezone: ${s.ianaTimezone}  |  Weight: ${s.weightUnit}`);
+  console.log(`Email:      ${s.email || "—"}  |  Phone: ${s.shopAddress?.phone || "—"}`);
+  if (s.shopAddress) console.log(`Location:   ${[s.shopAddress.address1, s.shopAddress.city, s.shopAddress.country].filter(Boolean).join(", ")}`);
+  if (s.enabledPresentmentCurrencies?.length > 1) console.log(`Multi-currency: ${s.enabledPresentmentCurrencies.join(", ")}`);
+}
+
+async function storeLocations() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { locations(first: 20) { edges { node {
+    id name isActive fulfillsOnlineOrders
+    address { address1 city province country zip phone }
+  } } } }`, cfg);
+  const items = (data.data?.locations?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No locations found."); return; }
+  printTable(items.map((l) => ({
+    ID: extractId(l.id), Name: l.name, Active: l.isActive ? "Yes" : "No",
+    Fulfills: l.fulfillsOnlineOrders ? "Yes" : "No",
+    City: l.address?.city || "—", Country: l.address?.country || "—"
+  })));
+}
+
+async function storeDashboard() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  console.log(`\nFetching dashboard for ${cfg.store}...\n`);
+  const data = captureAdminQuery(`query {
+  shop { name currencyCode }
+  orders(first: 5, query: "status:open", sortKey: CREATED_AT, reverse: true) {
+    edges { node {
+      name createdAt displayFinancialStatus displayFulfillmentStatus
+      totalPriceSet { presentmentMoney { amount currencyCode } }
+      customer { displayName }
+    } }
+  }
+  products(first: 5, query: "status:active") {
+    edges { node { id title totalInventory } }
+  }
+  codeDiscountNodes(first: 5) {
+    edges { node { codeDiscount {
+      __typename
+      ... on DiscountCodeBasic {
+        title status asyncUsageCount codes(first: 1) { edges { node { code } } }
+      }
+      ... on DiscountCodeBxgy {
+        title status asyncUsageCount codes(first: 1) { edges { node { code } } }
+      }
+      ... on DiscountCodeFreeShipping {
+        title status asyncUsageCount codes(first: 1) { edges { node { code } } }
+      }
+      ... on DiscountCodeApp {
+        title status asyncUsageCount codes(first: 1) { edges { node { code } } }
+      }
+    } } }
+  }
+  customers(first: 1) { edges { node { id } } }
+}`, cfg);
+  const shop = data.data?.shop;
+  const orders = (data.data?.orders?.edges || []).map((e) => e.node);
+  const products = (data.data?.products?.edges || []).map((e) => e.node);
+  const discounts = (data.data?.codeDiscountNodes?.edges || []).map((e) => e.node);
+  console.log(`${"═".repeat(60)}\n${shop?.name || cfg.store}  —  Dashboard\n${"═".repeat(60)}`);
+  console.log(`\n📦  OPEN ORDERS (${orders.length} shown)`);
+  if (orders.length) {
+    orders.forEach((o) => console.log(`  ${o.name.padEnd(8)} ${o.createdAt.slice(0, 10)}  ${trunc(o.customer?.displayName || "Guest", 22)}  ${o.totalPriceSet.presentmentMoney.amount} ${o.totalPriceSet.presentmentMoney.currencyCode}  ${o.displayFulfillmentStatus}`));
+  } else console.log("  No open orders.");
+  console.log(`\n🛍️  ACTIVE PRODUCTS (sample)`);
+  if (products.length) {
+    products.forEach((p) => {
+      const warn = p.totalInventory < 5 ? "  ⚠️  low stock" : "";
+      console.log(`  ${trunc(p.title, 48)}  Qty: ${p.totalInventory}${warn}`);
+    });
+  } else console.log("  No active products.");
+  console.log(`\n🏷️  DISCOUNT CODES`);
+  if (discounts.length) {
+    discounts.forEach((d) => {
+      const disc = d.codeDiscount;
+      const code = disc.codes?.edges?.[0]?.node?.code || "—";
+      const used = disc.asyncUsageCount || 0;
+      console.log(`  ${trunc(disc.title, 35)}  Code: ${code.padEnd(14)}  Used: ${used}  (${disc.status})`);
+    });
+  } else console.log("  No discount codes.");
+  console.log(`\nFor details: orders:list  products:list  customers:list  discounts:list`);
+}
+
+// ─── Content — Pages, Blogs, Articles, Redirects ──────────────────────────
+
+async function pagesList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { pages(first: 30) {
+    edges { node { id title handle isPublished updatedAt } }
+  } }`, cfg);
+  const items = (data.data?.pages?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No pages found."); return; }
+  printTable(items.map((p) => ({
+    ID: extractId(p.id), Title: trunc(p.title, 40), Handle: p.handle,
+    Published: p.isPublished ? "Yes" : "No", Updated: p.updatedAt.slice(0, 10)
+  })));
+}
+
+async function pagesCreate() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  console.log("\nNew Page Wizard\n");
+  const title = await ask("Page title", ""); if (!title) { console.error("Title required."); process.exit(1); }
+  const body = await ask("Body HTML (single-line, optional)", "");
+  const published = await confirm("Publish immediately?", false);
+  const ok = await confirm(`Create page "${title}"?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation {
+  pageCreate(page: {
+    title: "${esc(title)}" ${body ? `body: "${esc(body)}"` : ""} isPublished: ${published}
+  }) {
+    page { id title handle isPublished }
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+async function blogsList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { blogs(first: 10) { edges { node {
+    id title handle
+    articles(first: 5, reverse: true) { edges { node { title publishedAt } } }
+  } } } }`, cfg);
+  const blogs = (data.data?.blogs?.edges || []).map((e) => e.node);
+  if (!blogs.length) { console.log("No blogs found."); return; }
+  blogs.forEach((b) => {
+    console.log(`\n📝  ${b.title}  (/${b.handle})`);
+    const articles = b.articles.edges;
+    if (articles.length) articles.forEach(({ node: a }) => console.log(`   • ${trunc(a.title, 50)}  ${a.publishedAt?.slice(0, 10) || "draft"}`));
+    else console.log("   (no articles)");
+  });
+}
+
+async function articlesList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const bData = captureAdminQuery(`query { blogs(first: 10) { edges { node { id title } } } }`, cfg);
+  const blogs = (bData.data?.blogs?.edges || []).map((e) => e.node);
+  if (!blogs.length) { console.log("No blogs found."); return; }
+  const blog = await choose("Select blog:", blogs, (b) => b.title);
+  const data = captureAdminQuery(`query { blog(id: "${blog.id}") {
+    articles(first: 30, reverse: true) {
+      edges { node { id title handle author { name } publishedAt isPublished tags } }
+    }
+  } }`, cfg);
+  const items = (data.data?.blog?.articles?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No articles found."); return; }
+  printTable(items.map((a) => ({
+    ID: extractId(a.id), Title: trunc(a.title, 40), Author: trunc(a.author?.name || "—", 18),
+    Published: a.isPublished ? (a.publishedAt?.slice(0, 10) || "Yes") : "Draft",
+    Tags: trunc((a.tags || []).join(", "), 20)
+  })));
+}
+
+async function redirectsList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const data = captureAdminQuery(`query { urlRedirects(first: 50) {
+    edges { node { id path target } }
+  } }`, cfg);
+  const items = (data.data?.urlRedirects?.edges || []).map((e) => e.node);
+  if (!items.length) { console.log("No redirects found."); return; }
+  printTable(items.map((r) => ({ ID: extractId(r.id), From: r.path, To: trunc(r.target, 60) })));
+}
+
+async function redirectsCreate() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const from = await ask("Redirect from (e.g. /old-page)", "");
+  const to = await ask("Redirect to (e.g. /new-page)", "");
+  if (!from || !to) { console.error("Both from and to required."); process.exit(1); }
+  const ok = await confirm(`Create redirect: ${from} → ${to}?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation {
+  urlRedirectCreate(urlRedirect: { path: "${esc(from)}", target: "${esc(to)}" }) {
+    urlRedirect { id path target }
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+// ─── Metafields ────────────────────────────────────────────────────────────
+
+async function metafieldsList() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const ownerType = await choose("Resource type:", ["PRODUCT", "COLLECTION", "CUSTOMER", "ORDER", "SHOP"], (t) => t.charAt(0) + t.slice(1).toLowerCase(), 0);
+  let ownerId = null;
+  if (ownerType !== "SHOP") {
+    const resourceType = ownerType.toLowerCase() + "s";
+    const rData = captureAdminQuery(`query { ${resourceType}(first: 30${ownerType === "ORDER" ? ', query: "status:any"' : ""}) {
+      edges { node { id ${ownerType === "CUSTOMER" ? "displayName email" : ownerType === "ORDER" ? "name" : "title"} } }
+    } }`, cfg);
+    const resources = (rData.data?.[resourceType]?.edges || []).map((e) => e.node);
+    if (!resources.length) { console.log("No resources found."); return; }
+    const res = await choose(`Select ${ownerType.toLowerCase()}:`, resources, (r) => r.title || r.name || r.displayName);
+    ownerId = res.id;
+  }
+  const typeFragment = ownerType === "SHOP" ? "shop" : `node(id: "${ownerId}") { ... on ${ownerType.charAt(0) + ownerType.slice(1).toLowerCase()}`;
+  const queryStr = ownerType === "SHOP"
+    ? `query { shop { metafields(first: 30) { edges { node { id namespace key value type } } } } }`
+    : `query { node(id: "${ownerId}") { ... on ${ownerType.charAt(0) + ownerType.slice(1).toLowerCase()} { metafields(first: 30) { edges { node { id namespace key value type } } } } } }`;
+  const data = captureAdminQuery(queryStr, cfg);
+  const mf = ownerType === "SHOP"
+    ? (data.data?.shop?.metafields?.edges || []).map((e) => e.node)
+    : (data.data?.node?.metafields?.edges || []).map((e) => e.node);
+  if (!mf.length) { console.log("No metafields found."); return; }
+  printTable(mf.map((m) => ({ ID: extractId(m.id), Namespace: m.namespace, Key: m.key, Type: m.type, Value: trunc(m.value || "", 50) })));
+}
+
+async function metafieldsSet() {
+  const cfg = loadConfig(); requireStore(cfg); requireStoreExecute();
+  const ownerType = await choose("Resource type:", ["PRODUCT", "COLLECTION", "CUSTOMER", "ORDER", "SHOP"], (t) => t.charAt(0) + t.slice(1).toLowerCase(), 0);
+  let ownerId;
+  if (ownerType !== "SHOP") {
+    const resourceType = ownerType.toLowerCase() + "s";
+    const rData = captureAdminQuery(`query { ${resourceType}(first: 30${ownerType === "ORDER" ? ', query: "status:any"' : ""}) {
+      edges { node { id ${ownerType === "CUSTOMER" ? "displayName" : ownerType === "ORDER" ? "name" : "title"} } }
+    } }`, cfg);
+    const resources = (rData.data?.[resourceType]?.edges || []).map((e) => e.node);
+    const res = await choose(`Select ${ownerType.toLowerCase()}:`, resources, (r) => r.title || r.name || r.displayName);
+    ownerId = res.id;
+  } else {
+    const sData = captureAdminQuery(`query { shop { id } }`, cfg);
+    ownerId = sData.data?.shop?.id;
+  }
+  const namespace = await ask("Namespace (e.g. custom)", "custom");
+  const key = await ask("Key (e.g. launch_date)", "");
+  const type = await choose("Type:", ["single_line_text_field", "number_integer", "number_decimal", "boolean", "date", "json", "url"], (t) => t, 0);
+  const value = await ask("Value", "");
+  const ok = await confirm(`Set metafield ${namespace}.${key} = "${value}" on this ${ownerType.toLowerCase()}?`, false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+  runAdminMutation(`mutation {
+  metafieldsSet(metafields: [{
+    ownerId: "${ownerId}", namespace: "${esc(namespace)}", key: "${esc(key)}", type: "${type}", value: "${esc(value)}"
+  }]) {
+    metafields { id namespace key value type }
+    userErrors { field message }
+  }
+}`, cfg);
+}
+
+async function inventorySet(quantityArg) {
+  const qty = parseInt(quantityArg, 10);
+  if (isNaN(qty) || qty < 0) {
+    console.error("Usage: shopify-agent inventory:set <quantity>  (e.g., inventory:set 10)");
+    process.exit(1);
+  }
+
+  const cfg = loadConfig();
+  requireStore(cfg);
+  requireStoreExecute();
+
+  console.log("Fetching products, variants, and locations...");
+
+  const data = captureAdminQuery(`
+query InventoryAudit {
+  products(first: 250) {
+    edges {
+      node {
+        title
+        variants(first: 100) {
+          edges {
+            node {
+              title
+              inventoryItem { id }
+              inventoryQuantity
+            }
+          }
+        }
+      }
+    }
+  }
+  locations(first: 10) {
+    edges {
+      node { id name isActive }
+    }
+  }
+}`, cfg);
+
+  const locations = (data.data?.locations?.edges || []).map((e) => e.node).filter((l) => l.isActive);
+  if (!locations.length) {
+    console.error("No active locations found in your store.");
+    process.exit(1);
+  }
+  const location = locations[0];
+
+  const setQuantities = [];
+  for (const { node: product } of (data.data?.products?.edges || [])) {
+    for (const { node: variant } of product.variants.edges) {
+      setQuantities.push({
+        inventoryItemId: variant.inventoryItem.id,
+        locationId: location.id,
+        quantity: qty,
+        label: `${product.title}${variant.title !== "Default Title" ? ` / ${variant.title}` : ""}`,
+        current: variant.inventoryQuantity
+      });
+    }
+  }
+
+  if (!setQuantities.length) {
+    console.error("No inventory items found.");
+    process.exit(1);
+  }
+
+  console.log(`\nLocation: ${location.name}`);
+  console.log(`Variants to update: ${setQuantities.length}`);
+  console.log(`Setting all to: ${qty}`);
+  console.log("\nPreview (first 10):");
+  setQuantities.slice(0, 10).forEach((item) => {
+    console.log(`  ${item.label}: ${item.current ?? "?"} → ${qty}`);
+  });
+  if (setQuantities.length > 10) console.log(`  ... and ${setQuantities.length - 10} more`);
+
+  const ok = await confirm("\nProceed with inventory update?", false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+
+  const setQtyLines = setQuantities
+    .map((i) => `    { inventoryItemId: "${i.inventoryItemId}", locationId: "${i.locationId}", quantity: ${qty} }`)
+    .join(",\n");
+
+  const mutation = `mutation SetInventoryOnHand {
+  inventorySetOnHandQuantities(input: {
+    reason: "correction",
+    setQuantities: [
+${setQtyLines}
+    ]
+  }) {
+    userErrors { field message }
+    inventoryAdjustmentGroup {
+      reason
+      changes { name delta quantityAfterChange }
+    }
+  }
+}`;
+
+  console.log("\nRunning inventory mutation...");
+  runAdminMutation(mutation, cfg);
+}
+
+async function discountCreate() {
+
+  const cfg = loadConfig();
+  requireStore(cfg);
+  requireStoreExecute();
+
+  console.log("\nDiscount Code Wizard\n");
+
+  const title = await ask("Discount title (internal name)", "10% Off First Order");
+  const code = await ask("Discount code (customers enter this)", "WELCOME10");
+
+  const discountType = await choose(
+    "Discount type:",
+    ["percentage", "fixed_amount"],
+    (t) => t === "percentage" ? "Percentage off" : "Fixed amount off",
+    0
+  );
+
+  let valueInput;
+  if (discountType === "percentage") {
+    const pct = parseFloat(await ask("Percentage off (e.g. 10 for 10%)", "10"));
+    valueInput = `percentage: ${pct / 100}`;
+  } else {
+    const amount = parseFloat(await ask("Fixed amount off (e.g. 5.00)", "5.00"));
+    const currency = await ask("Currency code", "INR");
+    valueInput = `discountAmount: { amount: "${amount}", appliesOnEachItem: false }`;
+  }
+
+  const oncePerCustomer = await confirm("Limit to one use per customer? (recommended for welcome codes)", true);
+  const usageLimitRaw = await ask("Total usage limit (leave blank for unlimited)", "");
+  const usageLimit = usageLimitRaw ? `usageLimit: ${parseInt(usageLimitRaw, 10)}` : "";
+
+  const today = new Date().toISOString().split("T")[0];
+  const startDate = await ask("Start date (YYYY-MM-DD)", today);
+  const endDate = await ask("End date (YYYY-MM-DD, leave blank for no expiry)", "");
+
+  console.log("\nDiscount summary:");
+  console.log(`  Title: ${title}`);
+  console.log(`  Code: ${code}`);
+  console.log(`  Value: ${discountType === "percentage" ? valueInput.replace("percentage: ", "") * 100 + "%" : valueInput}`);
+  console.log(`  Once per customer: ${oncePerCustomer}`);
+  console.log(`  Usage limit: ${usageLimitRaw || "unlimited"}`);
+  console.log(`  Active: ${startDate}${endDate ? " → " + endDate : " (no expiry)"}`);
+
+  const ok = await confirm("\nCreate this discount?", false);
+  if (!ok) { console.log("Cancelled."); process.exit(0); }
+
+  const endsAtLine = endDate ? `\n    endsAt: "${endDate}T23:59:59Z"` : "";
+  const usageLimitLine = usageLimit ? `\n    ${usageLimit}` : "";
+
+  const mutation = `mutation CreateDiscountCode {
+  discountCodeBasicCreate(basicCodeDiscount: {
+    title: "${title}"
+    code: "${code}"
+    startsAt: "${startDate}T00:00:00Z"${endsAtLine}
+    customerGets: {
+      value: { ${valueInput} }
+      items: { all: true }
+    }
+    customerSelection: { all: true }
+    appliesOncePerCustomer: ${oncePerCustomer}${usageLimitLine}
+  }) {
+    codeDiscountNode {
+      id
+      codeDiscount {
+        ... on DiscountCodeBasic {
+          title
+          codes(first: 1) { edges { node { code } } }
+          startsAt
+          appliesOncePerCustomer
+        }
+      }
+    }
+    userErrors { field message }
+  }
+}`;
+
+  console.log("\nCreating discount...");
+  runAdminMutation(mutation, cfg);
+}
+
+async function adminOperation(fileArg, options = {}) {
+  const cfg = loadConfig();
+  requireStore(cfg);
+  const file = fileArg ? path.resolve(root, fileArg) : "";
+  if (!file || !fs.existsSync(file)) {
+    console.error("Provide a GraphQL file path, for example templates/graphql/shop-query.graphql");
+    process.exit(1);
+  }
+  const query = fs.readFileSync(file, "utf8");
+  const kind = operationKind(query);
+  const isMutation = kind === "mutation";
+
+  if (isMutation && !options.allowMutation) {
+    console.error("Refusing to run mutation. Use `shopify-agent admin:mutate <file>` to run mutations.");
+    process.exit(1);
+  }
+
+  if (isMutation) {
+    console.log(`\nMutation: ${path.basename(file)}`);
+    console.log(`Store:    ${cfg.store}`);
+    const ok = await confirm("Run this mutation against your live store?", false);
+    if (!ok) { console.log("Cancelled."); process.exit(0); }
+  }
+
+  const useStoreExecute = hasShopifyCommand("store execute");
+  const command = useStoreExecute ? ["store", "execute"] : ["app", "execute"];
+  const help = captureShopify([...command, "--help"]).output;
+  const args = [...command, "--store", cfg.store];
+  if (help.includes("--version")) args.push("--version", cfg.apiVersion);
+  if (help.includes("--query-file")) {
+    args.push("--query-file", file);
+  } else {
+    args.push("--query", query);
+  }
+  if (isMutation && useStoreExecute && help.includes("--allow-mutations")) args.push("--allow-mutations");
+  if (!useStoreExecute && cfg.appConfig) args.push("--config", cfg.appConfig);
+  if (!useStoreExecute && cfg.appClientId) args.push("--client-id", cfg.appClientId);
+  runShopify(args);
+}
+
+async function adminQuery(fileArg) {
+  return adminOperation(fileArg, { allowMutation: false });
+}
+
+async function adminMutate(fileArg) {
+  return adminOperation(fileArg, { allowMutation: true });
+}
+
+async function main() {
+  const positionals = process.argv.slice(2).filter((a) => !a.startsWith("-"));
+  const [command, fileArg] = positionals;
+  if (!command || command === "help" || command === "--help" || command === "-h") return printHelp();
+  if (command === "init") return init();
+  if (command === "auth") return auth();
+  if (command === "doctor") return doctor();
+  if (command === "capabilities") return capabilities();
+  if (command === "mcp:install") return mcpInstall();
+  if (command === "agents:install") return agentsInstall();
+  if (command === "profile:list") return profileList();
+  if (command === "profile:use") return profileUse(fileArg);
+  if (command === "store:list") return storeList();
+  if (command === "store:auth") return storeAuth();
+  if (command === "theme:list") return themeList();
+  if (command === "theme:select") return themeSelect();
+  if (command === "theme:check") return themeCommand("check");
+  if (command === "theme:pull") return themeCommand("pull");
+  if (command === "theme:dev") return themeCommand("dev");
+  if (command === "theme:push") return themeCommand("push");
+  if (command === "theme:publish") return themeCommand("publish");
+  if (command === "app:dev") return appCommand("dev");
+  if (command === "app:deploy") return appCommand("deploy");
+  if (command === "admin:query") return adminQuery(fileArg);
+  if (command === "admin:mutate") return adminMutate(fileArg);
+
+  // Products & Catalog
+  if (command === "products:list") return productsList();
+  if (command === "products:get") return productsGet();
+  if (command === "products:create") return productsCreate();
+  if (command === "products:publish") return productsSetStatus("ACTIVE");
+  if (command === "products:archive") return productsSetStatus("ARCHIVED");
+  if (command === "products:draft") return productsSetStatus("DRAFT");
+  if (command === "products:delete") return productsDelete();
+  if (command === "variants:list") return variantsList();
+  if (command === "variants:update") return variantsUpdate();
+  if (command === "collections:list") return collectionsList();
+  if (command === "collections:create") return collectionsCreate();
+
+  // Inventory
+  if (command === "inventory:list") return inventoryList();
+  if (command === "inventory:set") return inventorySet(fileArg);
+  if (command === "inventory:adjust") return inventoryAdjust();
+
+  // Orders
+  if (command === "orders:list") return ordersList();
+  if (command === "orders:get") return ordersGet();
+  if (command === "orders:cancel") return ordersCancel();
+  if (command === "orders:close") return ordersClose();
+
+  // Customers
+  if (command === "customers:list") return customersList();
+  if (command === "customers:search") return customersSearch();
+  if (command === "customers:get") return customersGet();
+  if (command === "customers:create") return customersCreate();
+  if (command === "customers:tags") return customersTags();
+
+  // Discounts & Gift Cards
+  if (command === "discounts:list") return discountsList();
+  if (command === "discounts:create") return discountCreate();
+  if (command === "discounts:delete") return discountsDelete();
+  if (command === "discounts:disable") return discountsDisable();
+  if (command === "discounts:enable") return discountsEnable();
+  if (command === "discount:create") return discountCreate();   // legacy alias
+  if (command === "gift-cards:list") return giftCardsList();
+  if (command === "gift-cards:create") return giftCardsCreate();
+
+  // Store
+  if (command === "store:info") return storeInfo();
+  if (command === "store:locations") return storeLocations();
+  if (command === "store:dashboard") return storeDashboard();
+  if (command === "dashboard") return storeDashboard();
+
+  // Content
+  if (command === "pages:list") return pagesList();
+  if (command === "pages:create") return pagesCreate();
+  if (command === "blogs:list") return blogsList();
+  if (command === "articles:list") return articlesList();
+  if (command === "redirects:list") return redirectsList();
+  if (command === "redirects:create") return redirectsCreate();
+
+  // Metafields
+  if (command === "metafields:list") return metafieldsList();
+  if (command === "metafields:set") return metafieldsSet();
+  console.error(`Unknown command: ${command}`);
+  printHelp();
+  process.exit(1);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});