taketomarket 2.2.0 → 2.3.0

package/.claude-plugin/marketplace.json

@@ -1,19 +1,19 @@
 {
   "name": "taketomarket",
   "displayName": "takeToMarket",
-  "description": "Marketing OS for Claude Code and Codex. Spec-driven campaigns with positioning invariants and quality gates.",
-  "version": "2.2.0",
+  "description": "Marketing OS for developerneurs and solopreneurs. Built for engineers shipping products with zero marketing experience required. Spec-driven campaigns with positioning-as-invariant enforcement and quality gate walls.",
+  "version": "2.3.0-rc.1",
   "author": {
     "name": "Rishikesh Ranjan",
     "url": "https://github.com/ranjanrishikesh"
   },
   "homepage": "https://www.npmjs.com/package/taketomarket",
-  "repository": "https://github.com/ranjanrishikesh/takeToMarket",
+  "repository": "https://github.com/ranjanrishikesh/taketomarket",
   "license": "MIT",
   "keywords": ["marketing", "campaigns", "positioning", "quality-gates", "agent-skills"],
   "category": "productivity",
   "source": "git",
-  "sourceUrl": "https://github.com/ranjanrishikesh/takeToMarket.git",
+  "sourceUrl": "https://github.com/ranjanrishikesh/taketomarket.git",
   "skills": [
     "ttm-init", "ttm-new-campaign", "ttm-brief", "ttm-research",
     "ttm-produce", "ttm-review", "ttm-fix", "ttm-verify", "ttm-ship",

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "taketomarket",
-  "version": "2.2.0",
-  "description": "Marketing operating system for Claude Code. Spec-driven campaigns with positioning-as-invariant enforcement, quality gate walls, and compound learnings.",
+  "version": "2.3.0",
+  "description": "Marketing OS for developerneurs and solopreneurs. Built for engineers shipping products with zero marketing experience required. Spec-driven campaigns with positioning-as-invariant enforcement and quality gate walls.",
   "author": {
     "name": "takeToMarket"
   },

package/README.md

@@ -1,11 +1,28 @@
 # takeToMarket
 
 [![npm](https://img.shields.io/npm/v/taketomarket)](https://www.npmjs.com/package/taketomarket)
+[![GitHub stars](https://img.shields.io/github/stars/ranjanrishikesh/taketomarket?style=social)](https://github.com/ranjanrishikesh/taketomarket)
 
-A marketing operating system for Claude Code and Codex. Spec-driven campaigns with positioning-as-invariant enforcement, quality gate walls, and compound learnings.
+**Marketing OS for developerneurs and solopreneurs.** Built for engineers shipping products with zero marketing experience required.
+
+takeToMarket is a Claude Code / Codex skill set that brings spec-driven development to marketing. Every campaign, asset, and channel is a spec-driven unit with a verifiable outcome metric and a positioning-invariant quality gate wall.
 
 **Core invariant:** Every marketing asset ships with a verifiable outcome metric and passes through a positioning-invariant quality gate wall — no asset ships without both, ever.
 
+## Who this is for
+
+- **Developerneurs** — engineers building and shipping their own products.
+- **Solopreneurs with engineering backgrounds** — founders who code their MVP themselves.
+- **Indie hackers** — anyone shipping a product who has zero or near-zero marketing/growth experience.
+
+If you can write code but have never built a landing page, written a positioning statement, or thought about ICPs — takeToMarket gives you the operating system. The AI does the marketing work; you stay in control of the decisions.
+
+## Who this is NOT for
+
+- Full-time marketers who already have a stack — takeToMarket overlaps with what you already do.
+- Agencies serving multiple clients — built for one product per workspace.
+- Anyone wanting a one-click blog generator — takeToMarket is opinionated, slower, and quality-gated by design.
+
 ## What it is / What it isn't
 
 **IS:** A marketing OS that treats every campaign, asset, and channel as a spec-driven unit with a verifiable outcome, a positioning invariant, and a quality gate wall. Persistent state. Compound learnings. Nine-phase lifecycle enforcement.
@@ -39,12 +56,12 @@ Flags:
 /plugin install taketomarket@claude-plugins-official
 ```
 
-> Status: pending marketplace approval. Check https://github.com/ranjanrishikesh/takeToMarket for current status.
+> Status: pending marketplace approval. Check https://github.com/ranjanrishikesh/taketomarket for current status.
 
 ### Option 3 — Direct from GitHub (Claude Code)
 
 ```
-/plugin marketplace add ranjanrishikesh/takeToMarket
+/plugin marketplace add ranjanrishikesh/taketomarket
 /plugin install taketomarket
 ```
 
@@ -53,7 +70,7 @@ This uses the Claude Code plugin system to install directly from the GitHub repo
 ### Option 4 — Manual (advanced)
 
 ```bash
-git clone https://github.com/ranjanrishikesh/takeToMarket
+git clone https://github.com/ranjanrishikesh/taketomarket
 cd takeToMarket
 node install.js
 ```
@@ -98,34 +115,40 @@ All non-Claude runtimes also support `~/.agents/skills/` as a universal path. Se
 
 | Command | Description |
 |---------|-------------|
-| `/ttm-aeo-check` | Check citation status across AI engines for a query |
 | `/ttm-affiliate-kit` | Generate creative kit for affiliate partners |
 | `/ttm-archive` | Archive a completed campaign, finalize state, and update LEARNINGS.md |
 | `/ttm-brand-refresh` | Update BRAND.md with new proof points and deprecate expired ones |
 | `/ttm-brief` | Generate a campaign brief with mandatory outcome metrics, positioning anchor, and channel mix |
 | `/ttm-competitor-scan` | On-demand competitor analysis that updates COMPETITORS.md |
-| `/ttm-email-preflight` | Deliverability, dark-mode, and spam-trigger scan for email assets |
+| `/ttm-deploy` | Vercel deploy with auto-detected best path (git-push, Vercel CLI, API token) |
+| `/ttm-discover` | Discover phase: SERP analysis, competitor content audit, ambient narrative mapping (renamed from `/ttm-research`) |
+| `/ttm-email-check` | Deliverability, dark-mode, and spam-trigger check for email assets (renamed from `/ttm-email-preflight`) |
 | `/ttm-fix` | Fix phase: root cause analysis, fix brief, re-produce, re-verify (capped 3×) |
-| `/ttm-health` | Validate .marketing/ directory integrity, reference file completeness, and state consistency |
+| `/ttm-health` | Validate .taketomarket/ directory integrity, reference file completeness, and state consistency |
+| `/ttm-humanize` [MANDATORY] | Mandatory final-step humanizer for every audience-facing asset. Runnable ad-hoc. |
 | `/ttm-icp-refresh` | Update ICP.md from new customer data including calls, reviews, and feedback |
-| `/ttm-init` | Interview-driven onboarding that generates all .marketing/ reference files |
-| `/ttm-keyword-map` | Generate keyword cluster map with intent tags |
+| `/ttm-init` | Interview-driven onboarding that generates all .taketomarket/ reference files |
+| `/ttm-landing` | Next.js 15 + Tailwind v4 + React 19 marketing site scaffold with brand-token integration |
 | `/ttm-learn` | Extract lessons from campaign data, propose reference file edits, log to LEARNINGS.md |
+| `/ttm-linkedin-post` | Manual LinkedIn post generator. Author-mimic style + post-history tracking + last-7-day news WebSearch. Final draft passes through `/ttm-humanize` |
 | `/ttm-measure` | Analyze campaign analytics against outcome metrics using attribution models |
 | `/ttm-new-campaign` | Create a new campaign directory with initialized state and reference file links |
 | `/ttm-next` | Guide user to the right next command based on current campaign state |
+| `/ttm-playwright-setup` | Install walkthrough for Playwright MCP server + Chrome extension bridge. Run once per machine to unlock author scraping, competitor render, and Lighthouse/visual gates |
 | `/ttm-positioning-check` | Sample recent assets and report positioning drift percentage and analysis |
 | `/ttm-positioning-shift` | Controlled positioning change with reasoning, migration plan, and approval gate |
 | `/ttm-produce` | Generate content assets in fresh contexts loaded with brief, positioning, brand, ICP, and playbook |
+| `/ttm-pseo` | Programmatic SEO route generator for blog, use-case, comparison, alternative templates. JSON CMS input. AEO + SEO optimized |
 | `/ttm-repurpose` | Fan out a long-form asset into derivatives across channels with full brief-produce-verify per derivative |
-| `/ttm-research` | Market and audience research including SERP, competitor content, and narrative mapping |
 | `/ttm-resume` | Resume a paused campaign at its last completed phase |
 | `/ttm-review` | Present assets with structured review checklist for human evaluation |
-| `/ttm-seo-audit` | Technical and content SEO audit of a URL or sitemap |
+| `/ttm-seo audit\|keyword-map\|aeo` | Unified SEO + AEO toolkit with three subcommands (merged from `/ttm-aeo-check`, `/ttm-keyword-map`, `/ttm-seo-audit`) |
 | `/ttm-ship` | Generate launch checklist confirming tracking, UTMs, funnel testing, and asset finalization |
 | `/ttm-state` | Display current campaign states, decisions in flight, blockers, and experiments |
 | `/ttm-verify` | Run all applicable quality gates on every asset with pass/fail report and line-level feedback |
 
+**[MANDATORY]** `/ttm-humanize` runs automatically as the final step of every producing skill (`/ttm-produce`, `/ttm-repurpose`, `/ttm-affiliate-kit`). It can also be invoked ad-hoc to humanize existing copy.
+
 ## Verify Installation
 
 Inside Claude Code, run:

package/bin/lib/campaign.cjs

@@ -8,6 +8,10 @@
  * Exports: cmdCampaignInit, cmdCampaignState, cmdCampaignUpdate, cmdCampaignList, cmdCampaignArchive
  */
 
+// NOTE: `phase: researched` is a state-machine identifier kept for backward
+// compatibility with existing STATE.md files. User-facing command names use
+// /ttm-discover (the v2.3.0 rename). Full literal rename is scheduled for v2.4.0.
+
 'use strict';
 
 const fs = require('fs');
@@ -32,7 +36,7 @@ function resolveCampaignStatePath(slug) {
   // Re-sanitize slug (defense in depth -- caller may pass unsanitized input)
   const safe = slug.toLowerCase().replace(/[^a-z0-9-]/g, '');
   if (!safe) error('campaign slug must contain at least one alphanumeric character after sanitization');
-  const statePath = path.resolve(process.cwd(), '.marketing', 'CAMPAIGNS', safe, 'STATE.md');
+  const statePath = path.resolve(process.cwd(), '.taketomarket', 'CAMPAIGNS', safe, 'STATE.md');
   const projectRoot = path.resolve(process.cwd());
   if (!statePath.startsWith(projectRoot + path.sep)) {
     error('campaign STATE.md path escapes project directory');
@@ -55,7 +59,7 @@ function cmdCampaignInit(slug, name, raw) {
   const safe = slug.toLowerCase().replace(/[^a-z0-9-]/g, '');
   if (!safe) error('campaign slug must contain at least one alphanumeric character after sanitization');
 
-  const campaignDir = path.resolve(process.cwd(), '.marketing', 'CAMPAIGNS', safe);
+  const campaignDir = path.resolve(process.cwd(), '.taketomarket', 'CAMPAIGNS', safe);
   const assetsDir = path.resolve(campaignDir, 'ASSETS');
   const statePath = path.resolve(campaignDir, 'STATE.md');
 
@@ -112,7 +116,7 @@ function cmdCampaignInit(slug, name, raw) {
     'ship.shipped_at': 'null',
     'ship.checklist_result': 'null',
   };
-  const bodyContent = `\n# Campaign: ${name}\n\nPhase: created\nNext step: Run \`/ttm-research ${safe}\` to gather market intelligence.\n`;
+  const bodyContent = `\n# Campaign: ${name}\n\nPhase: created\nNext step: Run \`/ttm-discover ${safe}\` to gather market intelligence.\n`;
   const stateContent = serializeFrontmatter(frontmatterObj, bodyContent);
 
   // TOCTOU-safe creation: wx flag fails atomically if file already exists
@@ -268,7 +272,7 @@ function cmdCampaignList(filter, sinceArg, raw) {
     error('--active/--shipped-since-last-audit and --since are mutually exclusive');
   }
 
-  const campaignsDir = path.resolve(process.cwd(), '.marketing', 'CAMPAIGNS');
+  const campaignsDir = path.resolve(process.cwd(), '.taketomarket', 'CAMPAIGNS');
 
   // If no campaigns directory, return empty
   let entries;
@@ -303,7 +307,7 @@ function cmdCampaignList(filter, sinceArg, raw) {
     const shippedCampaigns = campaigns.filter(c => c['phase.shipped'] && c['phase.shipped'] !== 'null');
     let lastAuditTimestamp = null;
 
-    const driftLogPath = path.resolve(process.cwd(), '.marketing', 'DRIFT-LOG.md');
+    const driftLogPath = path.resolve(process.cwd(), '.taketomarket', 'DRIFT-LOG.md');
     const driftLogContent = safeReadFile(driftLogPath);
     if (driftLogContent) {
       // Find last audit event timestamp in the Audit Trail table
@@ -366,8 +370,8 @@ function cmdCampaignArchive(slug, raw) {
   const safe = slug.toLowerCase().replace(/[^a-z0-9-]/g, '');
   if (!safe) error('campaign slug must contain at least one alphanumeric character after sanitization');
   const projectRoot = path.resolve(process.cwd());
-  const srcDir = path.resolve(projectRoot, '.marketing', 'CAMPAIGNS', safe);
-  const destDir = path.resolve(projectRoot, '.marketing', 'CAMPAIGNS', 'ARCHIVE', safe);
+  const srcDir = path.resolve(projectRoot, '.taketomarket', 'CAMPAIGNS', safe);
+  const destDir = path.resolve(projectRoot, '.taketomarket', 'CAMPAIGNS', 'ARCHIVE', safe);
 
   // Security check: both paths must be inside project root
   if (!srcDir.startsWith(projectRoot + path.sep)) {
@@ -468,7 +472,7 @@ function cmdRepurposeManifest(slug, sourceAssetId, derivatives, raw) {
   const safeSlug = slug.toLowerCase().replace(/[^a-z0-9-]/g, '');
   if (!safeSlug) error('campaign slug must contain at least one alphanumeric character after sanitization');
   const projectRoot = path.resolve(process.cwd());
-  const manifestPath = path.resolve(projectRoot, '.marketing', 'CAMPAIGNS', safeSlug, 'MANIFEST.json');
+  const manifestPath = path.resolve(projectRoot, '.taketomarket', 'CAMPAIGNS', safeSlug, 'MANIFEST.json');
 
   // Security: path must stay within project root (T-10-12)
   if (!manifestPath.startsWith(projectRoot + path.sep)) {

package/bin/lib/codebase-scan.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function fileExists(p) {
+  try { fs.accessSync(p); return true; } catch { return false; }
+}
+
+function detectStack(cwd) {
+  const stack = new Set();
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fileExists(pkgPath)) {
+    stack.add('node');
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const deps = Object.assign({}, pkg.dependencies, pkg.devDependencies);
+      for (const name of Object.keys(deps)) {
+        if (['react', 'next', 'astro', 'svelte', 'vue', 'angular', 'remix', 'nuxt'].includes(name)) {
+          stack.add(name);
+        }
+        if (name === 'typescript') stack.add('typescript');
+        if (name === 'tailwindcss' || name === '@tailwindcss/postcss') stack.add('tailwind');
+        if (name === 'express' || name === 'fastify' || name === 'koa') stack.add(name);
+      }
+    } catch {}
+  }
+  if (fileExists(path.join(cwd, 'pyproject.toml')) || fileExists(path.join(cwd, 'requirements.txt'))) {
+    stack.add('python');
+  }
+  if (fileExists(path.join(cwd, 'go.mod'))) stack.add('go');
+  if (fileExists(path.join(cwd, 'Cargo.toml'))) stack.add('rust');
+  if (fileExists(path.join(cwd, 'Gemfile'))) stack.add('ruby');
+  if (fileExists(path.join(cwd, 'composer.json'))) stack.add('php');
+  return Array.from(stack);
+}
+
+function detectMonorepo(cwd) {
+  if (fileExists(path.join(cwd, 'pnpm-workspace.yaml'))) return true;
+  if (fileExists(path.join(cwd, 'turbo.json'))) return true;
+  if (fileExists(path.join(cwd, 'nx.json'))) return true;
+  if (fileExists(path.join(cwd, 'lerna.json'))) return true;
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fileExists(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      if (pkg.workspaces) return true;
+    } catch {}
+  }
+  const cargoPath = path.join(cwd, 'Cargo.toml');
+  if (fileExists(cargoPath)) {
+    try {
+      const cargo = fs.readFileSync(cargoPath, 'utf8');
+      if (/^\s*\[workspace\]/m.test(cargo)) return true;
+    } catch {}
+  }
+  return false;
+}
+
+function detectFeatureCandidates(cwd) {
+  const candidates = [];
+  for (const base of ['src', 'app', 'lib', 'packages', 'apps', 'modules']) {
+    const p = path.join(cwd, base);
+    if (!fileExists(p)) continue;
+    try {
+      const entries = fs.readdirSync(p, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.isDirectory() && !e.name.startsWith('.') && !e.name.startsWith('_')) {
+          candidates.push(e.name);
+        }
+      }
+    } catch {}
+  }
+  return Array.from(new Set(candidates));
+}
+
+function scanCodebase(cwd) {
+  return {
+    cwd,
+    stack: detectStack(cwd),
+    monorepo: detectMonorepo(cwd),
+    featureCandidates: detectFeatureCandidates(cwd),
+  };
+}
+
+module.exports = { scanCodebase, detectStack, detectMonorepo, detectFeatureCandidates };

package/bin/lib/config.cjs

@@ -0,0 +1,129 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Relative path fragment. Always prepended with `cwd` in readConfig/writeConfig.
+const CONFIG_RELATIVE_PATH = path.join('.taketomarket', 'CONFIG.md');
+
+const DEFAULTS = {
+  yolo: false,
+  inline_education: true,
+  landing_path: null,
+  brand_path: '.taketomarket/brand',
+};
+
+function parseYamlFrontmatter(text) {
+  if (!text.startsWith('---\n')) return {};
+  const end = text.indexOf('\n---', 4);
+  if (end < 0) return {};
+  const yaml = text.slice(4, end);
+  const out = {};
+  const lines = yaml.split('\n');
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    // Match scalar key: `key: value`
+    const scalar = line.match(/^([a-z_][a-z0-9_]*):\s*(.*)$/);
+    if (!scalar) { i++; continue; }
+    const key = scalar[1];
+    let val = scalar[2].trim();
+    if (val === '') {
+      // Possible nested object: gather indented `key.subkey: value` form on following lines
+      // We support a single-level nested object whose keys are listed as `  subkey: value`.
+      const obj = {};
+      let j = i + 1;
+      let foundChild = false;
+      while (j < lines.length) {
+        const child = lines[j].match(/^[ \t]+([a-zA-Z0-9_\-]+):\s*(.*)$/);
+        if (!child) break;
+        foundChild = true;
+        let cval = child[2].trim();
+        if (cval === 'true') cval = true;
+        else if (cval === 'false') cval = false;
+        else if (cval === 'null' || cval === '~' || cval === '') cval = null;
+        else if (/^-?\d+$/.test(cval)) cval = parseInt(cval, 10);
+        obj[child[1]] = cval;
+        j++;
+      }
+      if (foundChild) {
+        out[key] = obj;
+        i = j;
+        continue;
+      }
+      out[key] = null;
+      i++;
+      continue;
+    }
+    if (val === 'true') val = true;
+    else if (val === 'false') val = false;
+    else if (val === 'null' || val === '~') val = null;
+    else if (/^-?\d+$/.test(val)) val = parseInt(val, 10);
+    out[key] = val;
+    i++;
+  }
+  return out;
+}
+
+function serializeYamlFrontmatter(obj) {
+  const lines = ['---'];
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === null) lines.push(`${k}: null`);
+    else if (typeof v === 'boolean') lines.push(`${k}: ${v}`);
+    else if (v && typeof v === 'object' && !Array.isArray(v)) {
+      const keys = Object.keys(v);
+      if (keys.length === 0) {
+        lines.push(`${k}: {}`);
+      } else {
+        lines.push(`${k}:`);
+        for (const sk of keys) {
+          const sv = v[sk];
+          if (sv === null) lines.push(`  ${sk}: null`);
+          else if (typeof sv === 'boolean') lines.push(`  ${sk}: ${sv}`);
+          else lines.push(`  ${sk}: ${sv}`);
+        }
+      }
+    }
+    else lines.push(`${k}: ${v}`);
+  }
+  lines.push('---');
+  return lines.join('\n');
+}
+
+function readConfig(cwd) {
+  const p = path.join(cwd, CONFIG_RELATIVE_PATH);
+  if (!fs.existsSync(p)) return { ...DEFAULTS };
+  const body = fs.readFileSync(p, 'utf8');
+  return { ...DEFAULTS, ...parseYamlFrontmatter(body) };
+}
+
+function writeConfig(cwd, cfg) {
+  const dir = path.join(cwd, '.taketomarket');
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const merged = { ...DEFAULTS, ...cfg };
+  const text = serializeYamlFrontmatter(merged) + '\n\n# takeToMarket Config\n\nManaged by `/ttm-config`. Do not edit the frontmatter manually unless you know what you are doing.\n';
+  fs.writeFileSync(path.join(cwd, CONFIG_RELATIVE_PATH), text);
+}
+
+function setConfig(cwd, key, value) {
+  const cfg = readConfig(cwd);
+  cfg[key] = value;
+  writeConfig(cwd, cfg);
+}
+
+function markFirstRunSeen(cwd, skillName) {
+  const cfg = readConfig(cwd);
+  const seen = (cfg.first_run_seen && typeof cfg.first_run_seen === 'object')
+    ? { ...cfg.first_run_seen }
+    : {};
+  seen[skillName] = true;
+  cfg.first_run_seen = seen;
+  writeConfig(cwd, cfg);
+}
+
+function isFirstRunSeen(cwd, skillName) {
+  const cfg = readConfig(cwd);
+  return !!(cfg.first_run_seen && typeof cfg.first_run_seen === 'object' && cfg.first_run_seen[skillName] === true);
+}
+
+module.exports = { readConfig, writeConfig, setConfig, markFirstRunSeen, isFirstRunSeen, DEFAULTS };

package/bin/lib/deploy.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function commandExists(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function detectDeployPath(cwd, opts = {}) {
+  const env = opts.env !== undefined ? opts.env : process.env;
+  const hasCli = opts.hasCli !== undefined ? opts.hasCli : commandExists('vercel');
+  const available = [];
+
+  const vercelProjectJson = path.join(cwd, '.vercel', 'project.json');
+  const gitConnected = fs.existsSync(vercelProjectJson);
+
+  if (gitConnected) available.push('git-push');
+  if (hasCli) available.push('cli');
+  if (env.VERCEL_TOKEN) available.push('api-token');
+
+  let preferred = null;
+  if (available.includes('git-push')) preferred = 'git-push';
+  else if (available.includes('cli')) preferred = 'cli';
+  else if (available.includes('api-token')) preferred = 'api-token';
+
+  return { available, preferred, gitConnected, hasCli, hasToken: !!env.VERCEL_TOKEN };
+}
+
+module.exports = { detectDeployPath };

package/bin/lib/deviation.cjs

@@ -67,7 +67,7 @@ function cmdDeviationAppend(slug, gate, result, justification, asset, raw, extra
   // Validate slug via path.resolve to prevent traversal
   const safe = slug.toLowerCase().replace(/[^a-z0-9-]/g, '');
   const projectRoot = path.resolve(process.cwd());
-  const campaignDir = path.resolve(projectRoot, '.marketing', 'CAMPAIGNS', safe);
+  const campaignDir = path.resolve(projectRoot, '.taketomarket', 'CAMPAIGNS', safe);
   if (!campaignDir.startsWith(projectRoot)) {
     error('campaign path escapes project directory');
   }

package/bin/lib/drift-log.cjs

@@ -46,7 +46,7 @@ function sanitizeDetails(text) {
  */
 function resolveDriftLogPath() {
   const projectRoot = path.resolve(process.cwd());
-  const driftLogPath = path.resolve(process.cwd(), '.marketing', 'DRIFT-LOG.md');
+  const driftLogPath = path.resolve(process.cwd(), '.taketomarket', 'DRIFT-LOG.md');
   if (!driftLogPath.startsWith(projectRoot)) {
     error('DRIFT-LOG.md path escapes project directory');
   }
@@ -83,7 +83,7 @@ function ensureDriftLog(driftLogPath) {
         '<!-- DEPRECATION ENTRIES BELOW THIS LINE -->',
       ].join('\n');
 
-  // Ensure .marketing directory exists
+  // Ensure .taketomarket directory exists
   const dir = path.dirname(driftLogPath);
   fs.mkdirSync(dir, { recursive: true });
 
@@ -96,7 +96,7 @@ function ensureDriftLog(driftLogPath) {
 }
 
 /**
- * Append a drift event entry to .marketing/DRIFT-LOG.md.
+ * Append a drift event entry to .taketomarket/DRIFT-LOG.md.
  *
  * @param {string} eventType - Event type (shift, audit, deviation)
  * @param {string} source - Source command or campaign that triggered the event
@@ -157,7 +157,7 @@ function cmdDriftLogAppend(eventType, source, details, affectedCount, raw) {
 }
 
 /**
- * Append a deprecation entry to .marketing/DRIFT-LOG.md Deprecation Backlog.
+ * Append a deprecation entry to .taketomarket/DRIFT-LOG.md Deprecation Backlog.
  *
  * @param {string} asset - Asset identifier
  * @param {string} campaign - Campaign slug