taketomarket 1.0.1 → 2.1.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "taketomarket",
-  "version": "0.1.0",
+  "version": "2.1.0",
   "description": "Marketing operating system for Claude Code. Spec-driven campaigns with positioning-as-invariant enforcement, quality gate walls, and compound learnings.",
   "author": {
     "name": "takeToMarket"

package/README.md

@@ -2,418 +2,118 @@
 
 A marketing operating system for Claude Code and Codex. Spec-driven campaigns with positioning-as-invariant enforcement, quality gate walls, and compound learnings.
 
-takeToMarket is not a content generator -- it is a marketing operating system that treats every campaign, asset, and channel as a spec-driven unit with a verifiable outcome, a positioning invariant, and a quality gate wall. Install it into your Claude Code or Codex environment and run marketing campaigns through a 9-phase lifecycle with persistent state, compound learnings, and automated verification.
+**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.
 
-**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.
+## 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.
+
+**IS NOT:** A content generator, one-click blog writer, or social media scheduler. Not a replacement for marketers — it is the operating system a marketer uses to ship more, drift less, and compound learnings. Not a reporting dashboard. Not a scheduler. takeToMarket enforces discipline; it does not generate random content.
+
+## Requirements
+
+- Node.js 18+
+- Claude Code v1.x+ (or Codex)
+- git
 
 ## Installation
 
-### Via npm (recommended)
+### Option 1 — npx (recommended)
 
 ```bash
 npx taketomarket
 ```
 
-The installer detects your runtime automatically (Claude Code or Codex) by checking for `~/.claude/` or `~/.codex/` directories.
-
-Override detection with an explicit flag:
+Interactive: asks which tool(s) you use, installs to all selected runtimes in one pass.
 
-```bash
-npx taketomarket --runtime codex
-```
+Flags:
+- `--yes` or `-y` — skip confirmation (for CI/scripts)
+- `--check` — show install status without installing
+- `--runtime <claude|codex>` — skip interactive prompt, install to one runtime
 
-Validate the package without writing files:
+### Option 2 — Claude Code plugin marketplace
 
-```bash
-npx taketomarket --dry-run
+```
+/plugin install taketomarket@claude-plugins-official
 ```
 
-After installation, the installer runs structural validation and prints a pass/fail report for each component (directories, plugin.json, SKILL.md files). If all checks pass, you are ready to go.
+> Status: pending marketplace approval. Check https://github.com/ranjanrishikesh/takeToMarket for current status.
 
-### Via git clone
+### Option 3 — Direct from GitHub
 
-```bash
-git clone https://github.com/taketomarket/taketomarket.git
-cd taketomarket
-```
+> Status: pending verification. Use Option 1 or Option 4 in the meantime.
 
-Then copy each component into the Claude Code plugin directory:
+### Option 4 — Manual (advanced)
 
 ```bash
-mkdir -p ~/.claude/plugins/taketomarket
-cp -r .claude-plugin ~/.claude/plugins/taketomarket/.claude-plugin
-cp -r skills ~/.claude/plugins/taketomarket/skills
-cp -r workflows ~/.claude/plugins/taketomarket/workflows
-cp -r templates ~/.claude/plugins/taketomarket/templates
-cp -r references ~/.claude/plugins/taketomarket/references
-cp -r playbooks ~/.claude/plugins/taketomarket/playbooks
-cp -r gates ~/.claude/plugins/taketomarket/gates
-cp -r bin ~/.claude/plugins/taketomarket/bin
-cp settings.json ~/.claude/plugins/taketomarket/
+git clone https://github.com/ranjanrishikesh/takeToMarket
+cd takeToMarket
+node install.js
 ```
 
-For Codex, replace `~/.claude/` with `~/.codex/` in the paths above.
-
-### Verify Installation
-
-Run `/ttm-health` inside Claude Code to confirm the setup. It validates directory integrity, reference file presence, and state consistency.
-
 ## Quick Start
 
-Once installed, run these commands inside Claude Code (or Codex) to execute your first campaign:
-
-1. **Initialize your workspace:** `/ttm-init`
-   Guided interview about your product, brand, audience, channels, competitors, and metrics. Generates all reference files in `.marketing/`.
-
-2. **Create a campaign:** `/ttm-new-campaign spring-launch`
-   Creates `.marketing/CAMPAIGNS/spring-launch/` with initialized state and reference file links.
-
-3. **Research the market:** `/ttm-research spring-launch`
-   Market/audience research with SERP analysis, competitor content mapping, and ambient narrative capture. Supports web search MCP tools or manual paste.
-
-4. **Write the brief:** `/ttm-brief spring-launch`
-   Generates a campaign brief with mandatory outcome metrics, positioning anchor, hook, proof points, channel mix, and asset list. Refuses to proceed without both output and outcome metrics.
-
-5. **Produce content:** `/ttm-produce spring-launch`
-   Generates each asset in a fresh isolated context loaded with brief + positioning + brand + ICP + playbook. Hero asset first, then derivatives in wave-parallel.
-
-6. **Verify quality:** `/ttm-verify spring-launch`
-   Runs every asset through the 10-gate quality wall in a separate context from production (preventing self-evaluation bias). Outputs pass/fail per gate with line-level feedback.
-
-7. **Human review:** `/ttm-review spring-launch`
-   Presents assets with a structured checklist covering positioning reinforcement, outcome realism, claim substantiation, and competitor differentiation.
-
-8. **Fix failures:** `/ttm-fix spring-launch`
-   Root cause analysis, fix brief with preservation constraints, re-production in isolated context, re-verification. Capped at 3 attempts per asset before escalating to human review.
-
-9. **Ship it:** `/ttm-ship spring-launch`
-   Launch checklist with tracking confirmed, UTMs verified, funnel tested, assets finalized. Items tagged [AI] auto-check; items tagged [HUMAN] require confirmation.
-
-10. **Measure outcomes:** `/ttm-measure spring-launch`
-    Paste analytics data (or use MCP tools). Analysis against outcome metrics using last-touch, linear, and time-decay attribution models. Outcome reported first.
-
-11. **Extract learnings:** `/ttm-learn spring-launch`
-    Lessons extracted with proposed reference file edits (each requiring human approval). Root-cause taxonomy entries and winning patterns logged to LEARNINGS.md for future campaigns.
-
-## How It Works
-
-takeToMarket implements a 9-phase campaign lifecycle. Each phase has a dedicated command, persistent state tracking, and explicit entry/exit criteria.
-
 ```
-  /ttm-init (one-time workspace setup)
-       |
-       v
-  /ttm-new-campaign <slug>
-       |
-       v
-  [1. DISCOVER] -----> /ttm-research <slug>
-       |                  Market research, SERP analysis,
-       |                  competitor content, ambient narrative
-       v
-  [2. BRIEF] --------> /ttm-brief <slug>
-       |                  Outcome metrics, positioning anchor,
-       |                  hook, proof points, channel mix
-       v
-  [3. PRODUCE] ------> /ttm-produce <slug>
-       |                  Fresh context per asset, hero-first,
-       |                  wave-parallel execution, playbook-loaded
-       v
-  [4. VERIFY] -------> /ttm-verify <slug>
-       |                  10-gate quality wall, separate context,
-       |                  line-level feedback, deviation options
-       v
-  [5. REVIEW] -------> /ttm-review <slug>
-       |                  Structured human checklist, per-asset
-       |                  approve/reject/revise decisions
-       v
-  [6. FIX] ----------> /ttm-fix <slug>   (if needed)
-       |                  Root-cause analysis, 3-attempt cap,
-       |                  preservation constraints, auto-escalate
-       v
-  [7. SHIP] ---------> /ttm-ship <slug>
-       |                  Launch checklist, tracking confirmed,
-       |                  UTMs verified, funnel tested
-       v
-  [8. MEASURE] ------> /ttm-measure <slug>
-       |                  Paste analytics, 3 attribution models,
-       |                  outcome-first reporting
-       v
-  [9. LEARN] --------> /ttm-learn <slug>
-                         Lessons extracted, reference files
-                         updated, patterns logged to LEARNINGS.md
+/taketomarket:ttm-init             # set up workspace (one time)
+/taketomarket:ttm-new-campaign     # create first campaign
+/taketomarket:ttm-produce          # run production wave
 ```
 
-### Five Principles
-
-1. **Positioning is the invariant.** POSITIONING.md loads into every phase context. It is read-only during campaigns. Drift is detected and flagged. Changing positioning requires an explicit shift workflow with migration planning and human approval.
-
-2. **Outcome over output.** Every campaign brief requires both an output metric (what gets published) and an outcome metric (what business result is expected). Measure phase reports outcome first.
+## Campaign Lifecycle
 
-3. **Quality gate wall.** No asset ships without passing all applicable gates. Tier 1 gates (positioning drift, claim accuracy, outcome alignment) are blocking. Tier 2 gates are advisory.
-
-4. **Fix is not retry.** When assets fail review, the system performs root cause analysis and generates a specific fix brief with preservation constraints. It does not simply re-run production.
-
-5. **Compound learnings.** Every campaign feeds back into reference files. LEARNINGS.md accumulates root-cause taxonomy entries and winning patterns that load into the Brief phase of future campaigns.
+1. **Init** — set up workspace and reference files
+2. **New Campaign** — create campaign directory with initialized state
+3. **Research** — discover market, audience, and ambient narrative
+4. **Brief** — generate brief with mandatory outcome metrics
+5. **Produce** — generate assets in isolated contexts with full reference loading
+6. **Review** — human quality evaluation with structured checklist
+7. **Fix** — root cause analysis, re-produce, re-verify (capped 3×)
+8. **Verify** — quality gate wall check across all assets
+9. **Ship** — launch checklist confirming tracking, UTMs, funnel testing
+10. **Measure** — analytics vs outcome metrics with attribution models
+11. **Learn** — extract lessons, propose reference file edits, log to LEARNINGS.md
 
 ## Command Reference
 
-### Setup
-
-| Command | Description |
-|---------|-------------|
-| `/ttm-init` | Interview-driven onboarding that generates all `.marketing/` reference files from structured questioning with specificity validation |
-| `/ttm-new-campaign <slug>` | Create a campaign directory with initialized state and reference file links |
-
-### Campaign Lifecycle
-
-| Command | Description |
-|---------|-------------|
-| `/ttm-research <slug>` | Discover phase: market/audience research, SERP analysis, competitor content mapping, ambient narrative capture |
-| `/ttm-brief <slug>` | Generate campaign brief with outcome metric enforcement, positioning anchor, channel mix, and asset list |
-| `/ttm-produce <slug>` | Produce content assets in fresh isolated contexts loaded with brief, positioning, brand, ICP, and playbook |
-| `/ttm-verify <slug>` | Run all applicable quality gates on every asset with pass/fail report and line-level feedback |
-| `/ttm-review <slug>` | Present assets with structured review checklist for human evaluation and per-asset decisions |
-| `/ttm-fix <slug>` | Root cause analysis, fix brief, re-produce in isolated context, re-verify (3-attempt cap per asset) |
-| `/ttm-ship <slug>` | Launch checklist with tracking, UTM, and funnel verification; items tagged [AI]/[HUMAN] |
-| `/ttm-measure <slug>` | Analyze pasted analytics against outcome metrics using last-touch, linear, and time-decay attribution |
-| `/ttm-learn <slug>` | Extract lessons, propose reference file edits with human approval, log root-cause taxonomy entries |
-
-### State Management
-
-| Command | Description |
-|---------|-------------|
-| `/ttm-state` | Dashboard showing campaign states, decisions in flight, blockers, and experiments |
-| `/ttm-resume <slug>` | Resume a paused campaign at its last completed phase |
-| `/ttm-archive <slug>` | Finalize a completed campaign, move to archive, update LEARNINGS.md |
-| `/ttm-health` | Validate `.marketing/` directory integrity, reference file completeness, and state consistency |
-| `/ttm-next` | Guidance on the right next command based on current campaign state |
-
-### Positioning
-
 | Command | Description |
 |---------|-------------|
-| `/ttm-positioning-check` | Drift audit across recent assets with drift percentage, type categorization, and bleeding analysis |
-| `/ttm-positioning-shift` | Controlled repositioning with migration plan, deprecation schedule, and human approval gate |
-
-### Reference Management
-
-| Command | Description |
-|---------|-------------|
-| `/ttm-brand-refresh` | Update BRAND.md proof points and voice guidelines; validates against positioning invariant |
-| `/ttm-icp-refresh` | Update ICP.md from new customer data with positioning invariant validation |
-| `/ttm-competitor-scan` | On-demand competitor analysis with web search or manual paste |
-
-### Discipline Utilities
-
-| Command | Description |
-|---------|-------------|
-| `/ttm-seo-audit [url]` | Technical and content SEO audit with actionable report and priority ranking |
-| `/ttm-aeo-check [query]` | AI engine citation status check across major AI answer platforms |
-| `/ttm-keyword-map` | Keyword cluster map with intent tags (informational, commercial, transactional, navigational) |
-| `/ttm-email-preflight` | Deliverability, spam-trigger, and dark-mode rendering scan |
-| `/ttm-affiliate-kit` | Generate creative kit for affiliate partners with approved messaging and assets |
-| `/ttm-repurpose <asset>` | Fan out a long-form asset into derivatives across channels with full brief-produce-verify per derivative |
-
-**Total: 27 commands** across 6 categories.
-
-## Quality Gate Wall
-
-Every asset passes through 10 base quality gates before shipping. Discipline playbooks add channel-specific gates on top.
-
-### Base Gates
-
-| # | Gate | Tier | Behavior |
-|---|------|------|----------|
-| 1 | **Positioning Drift** | Tier 1 | Blocking -- asset must align with POSITIONING.md invariant |
-| 2 | **Claim Accuracy** | Tier 1 | Blocking -- every claim must have a source or proof point |
-| 3 | **Voice Drift** | Tier 2 | Advisory -- flags voice/tone inconsistency with BRAND.md |
-| 4 | **Outcome Alignment** | Tier 1 | Blocking -- asset must serve the campaign outcome metric |
-| 5 | **Funnel Integrity** | Tier 2 | Advisory -- CTA and funnel step match the campaign stage |
-| 6 | **UTM Hygiene** | Tier 2 | Advisory -- all links have valid, consistent UTM parameters |
-| 7 | **Compliance** | Tier 2 | Advisory -- legal disclaimers, required disclosures present |
-| 8 | **Competitor Collision** | Tier 2 | Advisory -- avoids using competitor claims or positioning |
-| 9 | **ICP Fit** | Tier 2 | Advisory -- content addresses the right audience segment |
-| 10 | **Format Correctness** | Tier 2 | Advisory -- meets channel-specific format requirements |
-
-### Tier Behavior
-
-- **Tier 1 (blocking):** Asset cannot ship until the gate passes. Failing a Tier 1 gate triggers the fix loop.
-- **Tier 2 (advisory):** Flagged for review but does not block shipping. Each failure offers three options: Correct, Accept+log, or Escalate to positioning shift.
-
-### Meta-Gates
-
-Multi-campaign portfolio checks run after per-asset gates:
-
-- **Portfolio Balance** -- channel mix across active campaigns
-- **Calendar Collision** -- overlapping launch dates or audience saturation
-- **Theme Consistency** -- messaging coherence across concurrent campaigns
-- **Learning Plan** -- measurement infrastructure coverage
-
-## Playbooks
-
-10 discipline playbooks extend the base quality gate wall with channel-specific knowledge, format rules, and additional gates:
-
-| Playbook | Focus Areas |
-|----------|-------------|
-| **SEO** | Title/H1 alignment, search-intent match, schema markup, internal-link density, thin-content detection |
-| **AEO** | Quote-worthy sentences, FAQ/HowTo schema, cross-domain fact consistency, AI citation optimization |
-| **Email** | Subject/preview spam-trigger scan, dark-mode rendering, unsubscribe presence, deliverability checks |
-| **LinkedIn** | Professional tone, opener hooks, native vs link format, engagement optimization |
-| **Social** | Platform-specific rules, visual ratios, hashtag strategy, engagement hooks |
-| **YouTube** | Thumbnail optimization, retention hooks, chapter markers, description SEO |
-| **Paid Ads** | Headline character limits, ad relevance scoring, landing page alignment |
-| **Affiliate** | Partner-safe messaging, commission disclosure, creative kit completeness |
-| **PR/Media** | News angle clarity, quote-readiness, fact-checking rigor, embargo handling |
-| **Events** | Session flow, attendee journey mapping, follow-up sequence planning |
-
-All playbooks inherit from `playbooks/base.md` and extend it with additive gates. The base contract ensures consistent evaluation across disciplines.
-
-## Architecture
-
+| `/taketomarket:ttm-aeo-check` | Check citation status across AI engines for a query |
+| `/taketomarket:ttm-affiliate-kit` | Generate creative kit for affiliate partners |
+| `/taketomarket:ttm-archive` | Archive a completed campaign, finalize state, and update LEARNINGS.md |
+| `/taketomarket:ttm-brand-refresh` | Update BRAND.md with new proof points and deprecate expired ones |
+| `/taketomarket:ttm-brief` | Generate a campaign brief with mandatory outcome metrics, positioning anchor, and channel mix |
+| `/taketomarket:ttm-competitor-scan` | On-demand competitor analysis that updates COMPETITORS.md |
+| `/taketomarket:ttm-email-preflight` | Deliverability, dark-mode, and spam-trigger scan for email assets |
+| `/taketomarket:ttm-fix` | Fix phase: root cause analysis, fix brief, re-produce, re-verify (capped 3×) |
+| `/taketomarket:ttm-health` | Validate .marketing/ directory integrity, reference file completeness, and state consistency |
+| `/taketomarket:ttm-icp-refresh` | Update ICP.md from new customer data including calls, reviews, and feedback |
+| `/taketomarket:ttm-init` | Interview-driven onboarding that generates all .marketing/ reference files |
+| `/taketomarket:ttm-keyword-map` | Generate keyword cluster map with intent tags |
+| `/taketomarket:ttm-learn` | Extract lessons from campaign data, propose reference file edits, log to LEARNINGS.md |
+| `/taketomarket:ttm-measure` | Analyze campaign analytics against outcome metrics using attribution models |
+| `/taketomarket:ttm-new-campaign` | Create a new campaign directory with initialized state and reference file links |
+| `/taketomarket:ttm-next` | Guide user to the right next command based on current campaign state |
+| `/taketomarket:ttm-positioning-check` | Sample recent assets and report positioning drift percentage and analysis |
+| `/taketomarket:ttm-positioning-shift` | Controlled positioning change with reasoning, migration plan, and approval gate |
+| `/taketomarket:ttm-produce` | Generate content assets in fresh contexts loaded with brief, positioning, brand, ICP, and playbook |
+| `/taketomarket:ttm-repurpose` | Fan out a long-form asset into derivatives across channels with full brief-produce-verify per derivative |
+| `/taketomarket:ttm-research` | Market and audience research including SERP, competitor content, and narrative mapping |
+| `/taketomarket:ttm-resume` | Resume a paused campaign at its last completed phase |
+| `/taketomarket:ttm-review` | Present assets with structured review checklist for human evaluation |
+| `/taketomarket:ttm-seo-audit` | Technical and content SEO audit of a URL or sitemap |
+| `/taketomarket:ttm-ship` | Generate launch checklist confirming tracking, UTMs, funnel testing, and asset finalization |
+| `/taketomarket:ttm-state` | Display current campaign states, decisions in flight, blockers, and experiments |
+| `/taketomarket:ttm-verify` | Run all applicable quality gates on every asset with pass/fail report and line-level feedback |
+
+## Verify Installation
+
+Inside Claude Code, run:
 ```
-takeToMarket/
-  .claude-plugin/
-    plugin.json              Plugin manifest (name, version, description, keywords)
-
-  skills/                    27 SKILL.md command stubs (routing only, <30 lines each)
-    ttm-init/SKILL.md
-    ttm-new-campaign/SKILL.md
-    ttm-research/SKILL.md
-    ttm-brief/SKILL.md
-    ttm-produce/SKILL.md
-    ttm-verify/SKILL.md
-    ttm-review/SKILL.md
-    ttm-fix/SKILL.md
-    ttm-ship/SKILL.md
-    ttm-measure/SKILL.md
-    ttm-learn/SKILL.md
-    ttm-state/SKILL.md
-    ttm-resume/SKILL.md
-    ttm-archive/SKILL.md
-    ttm-health/SKILL.md
-    ttm-next/SKILL.md
-    ttm-positioning-check/SKILL.md
-    ttm-positioning-shift/SKILL.md
-    ttm-brand-refresh/SKILL.md
-    ttm-icp-refresh/SKILL.md
-    ttm-competitor-scan/SKILL.md
-    ttm-seo-audit/SKILL.md
-    ttm-aeo-check/SKILL.md
-    ttm-keyword-map/SKILL.md
-    ttm-email-preflight/SKILL.md
-    ttm-affiliate-kit/SKILL.md
-    ttm-repurpose/SKILL.md
-
-  workflows/
-    setup/                   /ttm-init interview workflow
-    lifecycle/               Campaign phase workflows (research, brief, produce,
-                             verify, review, fix, ship, measure, learn)
-    reference-mgmt/          Reference file management (positioning-check,
-                             positioning-shift, brand-refresh, icp-refresh,
-                             competitor-scan)
-    discipline/              Discipline utility workflows (seo-audit, aeo-check,
-                             keyword-map, email-preflight, affiliate-kit, repurpose)
-    utility/                 State management workflows (state, resume, archive,
-                             health, next)
-
-  templates/                 Markdown templates for generated files
-    reference-files/         Reference file templates (brand, icp, competitors, etc.)
-    campaign-brief.md        Brief template with outcome/output metrics
-    production-manifest.json Asset manifest schema
-
-  references/                Domain knowledge and context loading rules
-    context-loading.md       Two-tier context loading strategy
-
-  playbooks/                 Discipline playbook files
-    base.md                  Base inheritance contract
-    seo.md                   SEO discipline playbook
-    aeo.md                   AEO discipline playbook
-    email.md                 Email discipline playbook
-    linkedin.md              LinkedIn discipline playbook
-    social.md                Social discipline playbook
-    youtube.md               YouTube discipline playbook
-    paid-ads.md              Paid Ads discipline playbook
-    affiliate.md             Affiliate discipline playbook
-    pr-media.md              PR/Media discipline playbook
-    events.md                Events discipline playbook
-
-  gates/                     Gate evaluation logic and base gate definitions
-
-  agents/                    Subagent prompt templates (producer, verifier)
-
-  bin/
-    ttm-tools.cjs            CLI entry point (single file, subcommand pattern)
-    lib/
-      campaign.cjs           Campaign state operations, MANIFEST.json management
-      health.cjs             Health validation checks
-      core.cjs               Core utility functions
-      slug.cjs               Slug generation and validation
-      state.cjs              State file operations
-      drift-log.cjs          Positioning drift logging
-      deviation.cjs          Deviation tracking
-      commit.cjs             Commit message helpers
-
-  settings.json              Default plugin settings
-  install.js                 npm installer entry point
-  package.json               npm package config (bin: taketomarket -> install.js)
+/taketomarket:ttm-health
 ```
 
-### Key Patterns
-
-**Thin SKILL.md routing.** Each skill file is under 30 lines. It contains YAML frontmatter (name, description, allowed-tools, context mode) and a single instruction to read the corresponding workflow file. This keeps skills lightweight and maintainable.
-
-**500-line file limit.** No single file exceeds 500 lines. Large content is extracted to `@`-referenced files. For example, the review workflow references `review-checklist.md` instead of embedding 400 lines of checklist questions inline.
-
-**Two-tier context loading.** Compact summaries of reference files load into every phase context (positioning summary, brand overview, ICP highlights). Full documents load only during produce and verify phases where deep knowledge matters. This preserves context window budget.
-
-**Positioning-as-invariant.** POSITIONING.md is architecturally read-only during campaigns. The system detects and blocks direct edits. Changing positioning requires the explicit `/ttm-positioning-shift` workflow with migration planning, human approval, and a deprecation schedule.
-
-**Fresh context isolation.** Produce and verify run in forked contexts (`context: fork` in SKILL.md frontmatter). This prevents the producer from evaluating its own output and keeps each asset's context window loaded with only the relevant brief, positioning, brand, ICP, and playbook.
-
-**Zero runtime dependencies.** The skill itself has no npm dependencies. All code in `bin/` uses only Node.js built-in modules (`fs`, `path`, `crypto`, `os`). Node.js 18+ is the only requirement, and it is already required by Claude Code.
-
-### How to Add a Playbook
-
-1. Create a new file in `playbooks/` (e.g., `playbooks/webinar.md`)
-2. Follow the structure in `playbooks/base.md` -- extend with additive gates
-3. Add a SKILL.md stub in `skills/ttm-webinar-audit/` pointing to a new workflow
-4. Add the workflow in `workflows/discipline/webinar-audit.md`
-5. Register the channel in the channels template at `templates/reference-files/`
-
-### User's Project Structure (created by /ttm-init)
-
-When a user runs `/ttm-init` in their project, it creates:
-
-```
-.marketing/
-  POSITIONING.md       Positioning invariant (read-only during campaigns)
-  BRAND.md             Voice, tone, proof points
-  ICP.md               Ideal customer profiles
-  CHANNELS.md          Channel strategy and constraints
-  COMPETITORS.md       Competitor landscape
-  METRICS.md           KPI definitions and baselines
-  CALENDAR.md          Marketing calendar
-  STATE.md             Global state tracking
-  LEARNINGS.md         Accumulated campaign learnings
-  DRIFT-LOG.md         Positioning drift event log
-  CAMPAIGNS/
-    <slug>/            Per-campaign directory
-      STATE.md         Campaign state
-      RESEARCH.md      Market research findings
-      BRIEF.md         Campaign brief
-      MANIFEST.json    Asset manifest and tracking
-      assets/          Produced content assets
-```
-
-## Dual-Runtime Support
-
-takeToMarket works with both Claude Code and Codex:
-
-- **Claude Code:** Skills install as a plugin at `~/.claude/plugins/taketomarket/`. Commands appear as `/ttm-*` in the Claude Code interface. Uses `AskUserQuestion` for interactive prompts with text-mode fallback.
-- **Codex:** Skills install at `~/.codex/plugins/taketomarket/`. An AGENTS.md file provides Codex-compatible instructions alongside CLAUDE.md. Interactive prompts fall back to numbered list format when `AskUserQuestion` is unavailable.
-
-The installer auto-detects the runtime. Both runtimes read the same SKILL.md files and execute the same workflows.
+This validates directory integrity, reference file presence, and state consistency.
 
 ## License
 
-MIT
+MIT — see [LICENSE](LICENSE).

package/install.js

@@ -27,6 +27,160 @@ const FILES_TO_COPY = [
   'settings.json',
 ];
 
+// ── Runtime Selection ─────────────────────────────────────────────────────────
+
+const RUNTIME_MENU = ['claude', 'codex', 'cursor', 'windsurf', 'gemini'];
+
+/**
+ * Parse user input from the runtime selection prompt.
+ * @param {string} input - Raw user input (e.g., '1,3' or '6')
+ * @returns {string[]|null} Array of runtime names, or null if invalid
+ */
+function parseRuntimeChoices(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  if (trimmed === '6') return [...RUNTIME_MENU];
+  if (trimmed === '7') return ['custom'];
+
+  const parts = trimmed.split(',').map(s => s.trim());
+  const names = new Set();
+  for (const part of parts) {
+    const n = parseInt(part, 10);
+    if (isNaN(n) || n < 1 || n > 7) return null;
+    if (n === 7) return ['custom'];
+    names.add(RUNTIME_MENU[n - 1]);
+  }
+  return [...names];
+}
+
+/**
+ * Build the install target map for all known runtimes.
+ * @param {string} [homeDir] - Home directory (injectable for tests)
+ * @returns {Object.<string, {label, skillsDir, parentDir}>}
+ */
+function buildRuntimeTargets(homeDir = os.homedir()) {
+  return {
+    claude: {
+      label: 'Claude Code',
+      skillsDir: path.join(homeDir, '.claude', 'skills'),
+      parentDir: path.join(homeDir, '.claude'),
+    },
+    codex: {
+      label: 'Codex (OpenAI)',
+      skillsDir: path.join(homeDir, '.codex', 'skills'),
+      parentDir: path.join(homeDir, '.codex'),
+    },
+    cursor: {
+      label: 'Cursor',
+      skillsDir: path.join(homeDir, '.cursor', 'skills'),
+      parentDir: path.join(homeDir, '.cursor'),
+    },
+    windsurf: {
+      label: 'Windsurf',
+      skillsDir: path.join(homeDir, '.codeium', 'windsurf', 'skills'),
+      parentDir: path.join(homeDir, '.codeium'),
+    },
+    gemini: {
+      label: 'Gemini CLI',
+      skillsDir: path.join(homeDir, '.gemini', 'skills'),
+      parentDir: path.join(homeDir, '.gemini'),
+    },
+  };
+}
+
+/**
+ * Interactively ask user which runtimes to install to.
+ * Falls back to auto-detect when stdin is not a TTY or --runtime flag is set.
+ * @param {string[]} args - process.argv slice
+ * @param {string} [homeDir]
+ * @returns {Promise<Array<{label, dir, parentDir, register, partial}>>}
+ */
+async function promptRuntimeSelection(args, homeDir = os.homedir()) {
+  // Legacy --runtime flag: bypass interactive prompt
+  const runtimeIdx = args.indexOf('--runtime');
+  if (runtimeIdx !== -1 && runtimeIdx + 1 < args.length) {
+    const name = args[runtimeIdx + 1].toLowerCase();
+    const allTargets = buildRuntimeTargets(homeDir);
+    if (!allTargets[name] && name !== 'custom') {
+      console.warn(`Warning: Unknown runtime "${name}". Defaulting to claude.`);
+      return [allTargets.claude];
+    }
+    return name === 'custom' ? [] : [allTargets[name]];
+  }
+
+  // Non-TTY fallback: auto-detect installed runtimes
+  if (!process.stdin.isTTY) {
+    const detected = getInstalledRuntimes(homeDir);
+    const allTargets = buildRuntimeTargets(homeDir);
+    if (detected.length === 0) {
+      console.log('Note: No known runtimes detected. Defaulting to Claude Code.');
+      return [allTargets.claude];
+    }
+    console.log(`Note: Non-interactive mode. Auto-detected: ${detected.join(', ')}`);
+    return detected.map(name => allTargets[name]);
+  }
+
+  // Interactive prompt
+  const { createInterface } = require('node:readline');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  const ask = (question) => new Promise(resolve => rl.question(question, resolve));
+
+  console.log('');
+  console.log('Which AI coding tool(s) are you using? (select all that apply)');
+  console.log('');
+  console.log('  1. Claude Code');
+  console.log('  2. Codex (OpenAI)');
+  console.log('  3. Cursor');
+  console.log('  4. Windsurf');
+  console.log('  5. Gemini CLI');
+  console.log('  6. All of the above');
+  console.log('  7. Let me type a custom path');
+  console.log('');
+
+  let choices = null;
+  let attempts = 0;
+  while (choices === null && attempts < 2) {
+    const input = await ask('Your choice (comma-separated, e.g. 1,3): ');
+    choices = parseRuntimeChoices(input);
+    if (choices === null) {
+      console.log('Invalid input. Please enter numbers 1-7 separated by commas.');
+      attempts++;
+    }
+  }
+
+  if (choices === null) {
+    rl.close();
+    console.error('Invalid input after 2 attempts. Exiting.');
+    console.log('Something went wrong? File an issue: https://github.com/ranjanrishikesh/takeToMarket/issues');
+    process.exit(1);
+  }
+
+  let customPath = null;
+  if (choices.includes('custom')) {
+    customPath = await ask('Enter install path: ');
+    customPath = customPath.trim();
+    if (!customPath) {
+      rl.close();
+      console.error('Custom path cannot be empty.');
+      process.exit(1);
+    }
+  }
+
+  rl.close();
+
+  const allTargets = buildRuntimeTargets(homeDir);
+  const result = [];
+  for (const name of choices) {
+    if (name === 'custom') {
+      result.push({ label: 'Custom', skillsDir: customPath, parentDir: null });
+    } else {
+      result.push(allTargets[name]);
+    }
+  }
+  return result;
+}
+
 // ── Runtime detection ────────────────────────────────────────────────────────
 
 /**
@@ -116,6 +270,285 @@ function copyDirSync(src, dest) {
   }
 }
 
+// ── Package Base & Per-Runtime Skill Install ──────────────────────────────────
+
+const PACKAGE_BASE_DIRS = ['workflows', 'templates', 'references', 'playbooks', 'gates', 'bin', 'agents'];
+const PACKAGE_BASE_FILES = ['settings.json', 'package.json'];
+
+/**
+ * Copy non-skill package files to ~/.taketomarket/ (shared across all runtimes).
+ * @param {string} packageRoot - Source npm package root
+ * @param {string} [homeDir]
+ */
+function copyPackageBase(packageRoot, homeDir = os.homedir()) {
+  const dest = path.join(homeDir, '.taketomarket');
+  fs.mkdirSync(dest, { recursive: true });
+
+  for (const dir of PACKAGE_BASE_DIRS) {
+    const src = path.join(packageRoot, dir);
+    if (dirExists(src)) {
+      copyDirSync(src, path.join(dest, dir));
+    }
+  }
+
+  for (const file of PACKAGE_BASE_FILES) {
+    const src = path.join(packageRoot, file);
+    if (fileExists(src)) {
+      fs.copyFileSync(src, path.join(dest, file));
+    }
+  }
+}
+
+/**
+ * Install individual skills into a runtime's skills directory.
+ * Replaces ${CLAUDE_PLUGIN_ROOT} in SKILL.md with absolute path to ~/.taketomarket.
+ * @param {string} skillsDir - Runtime's skills base dir (e.g. ~/.claude/skills/)
+ * @param {string} packageRoot - Source npm package root
+ * @param {string} [homeDir]
+ * @returns {number} Number of skills installed
+ */
+function installSkillsForRuntime(skillsDir, packageRoot, homeDir = os.homedir()) {
+  const packageBase = path.join(homeDir, '.taketomarket');
+  const srcSkillsDir = path.join(packageRoot, 'skills');
+  if (!dirExists(srcSkillsDir)) return 0;
+
+  fs.mkdirSync(skillsDir, { recursive: true });
+
+  let count = 0;
+  const entries = fs.readdirSync(srcSkillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillMdSrc = path.join(srcSkillsDir, entry.name, 'SKILL.md');
+    if (!fileExists(skillMdSrc)) continue;
+
+    let content = fs.readFileSync(skillMdSrc, 'utf8');
+    content = content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, packageBase);
+
+    const destSkillDir = path.join(skillsDir, entry.name);
+    fs.mkdirSync(destSkillDir, { recursive: true });
+    fs.writeFileSync(path.join(destSkillDir, 'SKILL.md'), content, 'utf8');
+    count++;
+  }
+  return count;
+}
+
+// ── Plugin Registration ───────────────────────────────────────────────────────
+
+/**
+ * Register taketomarket in Claude Code's installed_plugins.json.
+ * Preserves existing plugins. Atomic write (tmp → rename).
+ * @param {string} installPath - Absolute path to the installed plugin directory
+ * @param {string} version - Plugin version string (e.g., '2.0.0')
+ * @param {string} [homeDir] - Home directory (defaults to os.homedir(); injectable for tests)
+ */
+function registerPlugin(installPath, version, homeDir = os.homedir()) {
+  const registryPath = path.join(homeDir, '.claude', 'plugins', 'installed_plugins.json');
+  const pluginsDir = path.dirname(registryPath);
+
+  let registry = { version: 2, plugins: {} };
+  if (fileExists(registryPath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+      registry = parsed;
+      if (!registry.plugins) registry.plugins = {};
+      if (!registry.version) registry.version = 2;
+    } catch {
+      fs.renameSync(registryPath, registryPath + '.bak');
+      console.warn('  Warning: installed_plugins.json was corrupted. Backed up to .bak and recreated.');
+      registry = { version: 2, plugins: {} };
+    }
+  }
+
+  const now = new Date().toISOString();
+  const existing = (registry.plugins['taketomarket@npm'] || [])[0];
+
+  registry.plugins['taketomarket@npm'] = [{
+    scope: 'user',
+    installPath,
+    version,
+    installedAt: existing?.installedAt ?? now,
+    lastUpdated: now,
+    gitCommitSha: null,
+  }];
+
+  const tmpPath = registryPath + '.tmp';
+  fs.mkdirSync(pluginsDir, { recursive: true });
+  fs.writeFileSync(tmpPath, JSON.stringify(registry, null, 2) + '\n', 'utf8');
+  fs.renameSync(tmpPath, registryPath);
+
+  console.log('  Registered in installed_plugins.json');
+}
+
+// ── Skill Introspection ───────────────────────────────────────────────────────
+
+/**
+ * Read skill names and descriptions from skills/ subdirectory of packageRoot.
+ * Parses the first content line of the 'description:' YAML frontmatter field.
+ * @param {string} packageRoot - Root of the npm package (use PACKAGE_ROOT in production)
+ * @returns {Array<{name: string, description: string}>} Sorted by name
+ */
+function readSkillDescriptions(packageRoot) {
+  const skillsDir = path.join(packageRoot, 'skills');
+  if (!dirExists(skillsDir)) return [];
+
+  const results = [];
+  try {
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(skillsDir, entry.name, 'SKILL.md');
+      if (!fileExists(skillFile)) continue;
+
+      const content = fs.readFileSync(skillFile, 'utf8');
+      const descMatch = content.match(/^description:\s*>\s*\n((?:[ \t]+.+\n?)+)/m);
+      let description = '';
+      if (descMatch) {
+        description = descMatch[1].split('\n')[0].trim().replace(/\.$/, '') + '.';
+      } else {
+        const inlineMatch = content.match(/^description:\s*(.+)$/m);
+        if (inlineMatch) description = inlineMatch[1].trim();
+      }
+
+      results.push({ name: entry.name, description });
+    }
+  } catch {
+    // ignore — skills dir may be empty or unreadable
+  }
+
+  return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/**
+ * Print slash commands available after install. Reads from npm package source.
+ * @param {string} [packageRoot] - Root of npm package (defaults to PACKAGE_ROOT = __dirname)
+ */
+function printInstallSummary(packageRoot = PACKAGE_ROOT) {
+  const skills = readSkillDescriptions(packageRoot);
+  console.log('');
+  console.log(`Installation complete! ${skills.length} skills installed.`);
+  console.log('');
+  console.log('Available commands:');
+  for (const { name, description } of skills) {
+    const cmd = `/taketomarket:${name}`.padEnd(42);
+    console.log(`  ${cmd} ${description}`);
+  }
+  console.log('');
+  console.log('Quick start: open any project in Claude Code and run /taketomarket:ttm-init');
+}
+
+/**
+ * Detect which known runtimes are installed by checking their parent directories.
+ * @param {string} [homeDir]
+ * @returns {string[]} Names of detected runtimes (subset of RUNTIME_MENU)
+ */
+function getInstalledRuntimes(homeDir = os.homedir()) {
+  const targets = buildRuntimeTargets(homeDir);
+  return RUNTIME_MENU.filter(name => {
+    const t = targets[name];
+    return t.parentDir && dirExists(t.parentDir);
+  });
+}
+
+// ── Status & Confirmation ─────────────────────────────────────────────────────
+
+/**
+ * Used by confirmInstall — extracted for testability.
+ * @param {boolean} yesFlag
+ * @returns {boolean} true if yesFlag is set (no prompt needed)
+ */
+function shouldProceed(yesFlag) {
+  return yesFlag === true || !process.stdin.isTTY;
+}
+
+/**
+ * Read Claude Code install status for the checkStatus output.
+ * @param {string} [homeDir]
+ * @returns {{ installed: boolean, skillCount: number, dir: string }}
+ */
+function getClaudeStatus(homeDir = os.homedir()) {
+  const skillsDir = path.join(homeDir, '.claude', 'skills');
+  const probeSkill = path.join(skillsDir, 'ttm-init', 'SKILL.md');
+  const installed = fileExists(probeSkill);
+  if (!installed) return { installed: false, skillCount: 0, dir: skillsDir };
+
+  let skillCount = 0;
+  try {
+    skillCount = fs.readdirSync(skillsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory() && e.name.startsWith('ttm-') && fileExists(path.join(skillsDir, e.name, 'SKILL.md')))
+      .length;
+  } catch { /* ignore */ }
+
+  return { installed: true, skillCount, dir: skillsDir };
+}
+
+/**
+ * Print install status for all known runtimes and exit.
+ * @param {string} version
+ * @param {string} [homeDir]
+ */
+function checkStatus(version, homeDir = os.homedir()) {
+  const targets = buildRuntimeTargets(homeDir);
+  console.log('');
+  console.log(`takeToMarket v${version}`);
+  console.log('');
+
+  const claude = getClaudeStatus(homeDir);
+  if (claude.installed) {
+    console.log(`Claude Code: INSTALLED (${claude.skillCount} skills at ${claude.dir.replace(homeDir, '~')})`);
+  } else {
+    console.log('Claude Code: NOT INSTALLED');
+  }
+
+  for (const name of ['codex', 'cursor', 'windsurf', 'gemini']) {
+    const t = targets[name];
+    const label = t.label.padEnd(12);
+    if (t.skillsDir && dirExists(t.skillsDir)) {
+      console.log(`${label} INSTALLED (${t.skillsDir.replace(homeDir, '~')})`);
+    } else {
+      console.log(`${label} NOT INSTALLED`);
+    }
+  }
+
+  console.log('');
+  console.log('Run `npx taketomarket` to install or reinstall.');
+  process.exit(0);
+}
+
+/**
+ * Interactively confirm install. Skipped when yesFlag is true.
+ * @param {Array<{label, dir}>} targets
+ * @param {string} version
+ * @param {boolean} yesFlag
+ * @returns {Promise<boolean>}
+ */
+async function confirmInstall(targets, version, yesFlag) {
+  if (shouldProceed(yesFlag)) return true;
+
+  const { createInterface } = require('node:readline');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+
+  console.log('');
+  console.log(`takeToMarket v${version} — Marketing OS for AI coding tools`);
+  console.log('');
+  console.log('This will install to:');
+  for (const t of targets) {
+    const shortDir = t.skillsDir.replace(os.homedir(), '~');
+    console.log(`  ${shortDir.padEnd(45)} (${t.label})`);
+  }
+  console.log('');
+
+  const answer = await ask('Proceed? [Y/n]: ');
+  rl.close();
+
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === 'n') {
+    console.log('Installation cancelled.');
+    process.exit(0);
+  }
+  return true;
+}
+
 // ── Validation ───────────────────────────────────────────────────────────────
 
 /**
@@ -168,16 +601,14 @@ function validateInstall(targetDir) {
 
 // ── Main ─────────────────────────────────────────────────────────────────────
 
-function main() {
+async function main() {
   const args = process.argv.slice(2);
 
-  // Check for --version / -v (D-10, D-11) — short-circuit BEFORE detectRuntime/validation.
   if (args.includes('--version') || args.includes('-v')) {
     process.stdout.write(`${VERSION}\n`);
     process.exit(0);
   }
 
-  // Check for --help
   if (args.includes('--help') || args.includes('-h')) {
     console.log(`
 takeToMarket installer
@@ -185,35 +616,24 @@ takeToMarket installer
 Usage: npx taketomarket [options]
 
 Options:
-  --runtime <claude|codex>  Target runtime (default: auto-detect)
-  --dry-run                 Validate source without writing files
+  --runtime <claude|codex>  Target a specific runtime, skip interactive prompt
+  --check                   Show install status without installing
+  --yes, -y                 Skip confirmation prompt (for CI/scripted use)
+  --dry-run                 Validate source package without writing files
+  --version, -v             Print version
   --help, -h                Show this help message
 `);
     process.exit(0);
   }
 
-  const DRY_RUN = args.includes('--dry-run');
-  const runtime = detectRuntime(args);
-
-  // Compute target directory using path.resolve for safety (T-10-01)
-  const runtimeDir = runtime === 'codex' ? '.codex' : '.claude';
-  const targetDir = path.resolve(os.homedir(), runtimeDir, 'plugins', 'taketomarket');
-
-  // Verify targetDir is within home directory (T-10-01, T-10-03)
-  const homeDir = os.homedir();
-  if (!targetDir.startsWith(homeDir + path.sep)) {
-    console.error('Error: Target directory resolves outside home directory. Aborting.');
-    process.exit(1);
+  if (args.includes('--check')) {
+    checkStatus(VERSION);
+    // checkStatus calls process.exit(0)
   }
 
-  console.log('');
-  console.log(`takeToMarket installer v${VERSION}`);
-  console.log(`Runtime: ${runtime}`);
-  console.log(`Target: ${targetDir}`);
-  console.log('');
-
-  if (DRY_RUN) {
-    // Validate source completeness without writing
+  if (args.includes('--dry-run')) {
+    console.log('');
+    console.log(`takeToMarket installer v${VERSION}`);
     console.log('[DRY RUN] Validating source package...');
     console.log('');
     const results = validateInstall(PACKAGE_ROOT);
@@ -223,59 +643,66 @@ Options:
     process.exit(0);
   }
 
-  // Check for existing installation — remove stale files before copying (CR-02)
-  if (dirExists(targetDir)) {
-    console.log('Existing installation found. Removing before reinstall...');
-    fs.rmSync(targetDir, { recursive: true, force: true });
-    console.log('');
+  console.log('');
+  console.log(`takeToMarket installer v${VERSION}`);
+
+  const yesFlag = args.includes('--yes') || args.includes('-y');
+
+  // Runtime selection
+  const targets = await promptRuntimeSelection(args);
+
+  if (targets.length === 0) {
+    console.log('No runtimes selected. Exiting.');
+    process.exit(0);
   }
 
-  // Copy directories
-  for (const dir of DIRS_TO_COPY) {
-    const srcDir = path.join(PACKAGE_ROOT, dir);
-    if (dirExists(srcDir)) {
-      console.log(`  Copying ${dir}/`);
-      copyDirSync(srcDir, path.join(targetDir, dir));
-    } else {
-      console.log(`  Skipping ${dir}/ (not found in package)`);
+  // Confirmation
+  await confirmInstall(targets, VERSION, yesFlag);
+
+  // Copy shared package files once
+  console.log('');
+  console.log('Copying package files to ~/.taketomarket/...');
+  copyPackageBase(PACKAGE_ROOT);
+
+  // Install loop
+  const results = [];
+  for (const target of targets) {
+    console.log('');
+    console.log(`Installing skills to ${target.label}...`);
+
+    if (target.parentDir && !dirExists(target.parentDir)) {
+      console.warn(`  Warning: ${target.label} not detected (${target.parentDir} not found). Installing anyway.`);
     }
-  }
 
-  // Copy individual files
-  for (const file of FILES_TO_COPY) {
-    const srcFile = path.join(PACKAGE_ROOT, file);
-    if (fileExists(srcFile)) {
-      console.log(`  Copying ${file}`);
-      const destFile = path.join(targetDir, file);
-      fs.mkdirSync(path.dirname(destFile), { recursive: true });
-      fs.copyFileSync(srcFile, destFile);
-    } else {
-      console.log(`  Skipping ${file} (not found in package)`);
+    try {
+      const count = installSkillsForRuntime(target.skillsDir, PACKAGE_ROOT);
+      console.log(`  Installed ${count} skills → ${target.skillsDir.replace(os.homedir(), '~')}`);
+      results.push({ target, success: true });
+    } catch (err) {
+      console.error(`  Error: ${err.message}`);
+      results.push({ target, success: false, reason: err.message });
     }
   }
 
-  console.log('');
+  // Summary
+  const successes = results.filter(r => r.success);
+  const failures = results.filter(r => !r.success);
 
-  // Validate
-  const results = validateInstall(targetDir);
-  printResults(results);
-
-  const failures = results.filter(r => r.status === 'fail');
-  console.log('');
+  if (successes.length > 0) {
+    printInstallSummary();
+  }
 
   if (failures.length > 0) {
-    console.log('Installation incomplete. Some components missing.');
-    process.exit(1);
+    console.log('');
+    console.log('Failed runtimes:');
+    for (const f of failures) {
+      console.log(`  ${f.target.label}: ${f.reason}`);
+    }
+    console.log('');
+    console.log('Something went wrong? File an issue: https://github.com/ranjanrishikesh/takeToMarket/issues');
   }
 
-  console.log('Installation complete!');
-  console.log('');
-  console.log('Quick start:');
-  console.log('  1. Open a project directory');
-  console.log('  2. Run /ttm-init to set up your marketing workspace');
-  console.log('  3. Run /ttm-new-campaign <name> to start your first campaign');
-  console.log('');
-  console.log('Documentation: https://github.com/taketomarket/taketomarket/blob/main/README.md');
+  process.exit(failures.length === results.length ? 1 : 0);
 }
 
 /**
@@ -291,12 +718,15 @@ function printResults(results) {
 }
 
 if (require.main === module) {
-  main();
+  main().catch(err => {
+    console.error(`Fatal: ${err.message}`);
+    console.log('Something went wrong? File an issue: https://github.com/ranjanrishikesh/takeToMarket/issues');
+    process.exit(1);
+  });
 }
 
 module.exports = {
   main,
-  detectRuntime,
   validateInstall,
   copyDirSync,
   dirExists,
@@ -304,4 +734,19 @@ module.exports = {
   printResults,
   DIRS_TO_COPY,
   FILES_TO_COPY,
+  PACKAGE_BASE_DIRS,
+  PACKAGE_BASE_FILES,
+  registerPlugin,
+  parseRuntimeChoices,
+  buildRuntimeTargets,
+  getInstalledRuntimes,
+  readSkillDescriptions,
+  shouldProceed,
+  getClaudeStatus,
+  checkStatus,
+  confirmInstall,
+  printInstallSummary,
+  copyPackageBase,
+  installSkillsForRuntime,
+  PACKAGE_ROOT,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taketomarket",
-  "version": "1.0.1",
+  "version": "2.1.0",
   "description": "Marketing operating system for Claude Code. Spec-driven campaigns with positioning-as-invariant enforcement, quality gate walls, and compound learnings.",
   "license": "MIT",
   "repository": {

package/skills/ttm-update/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: ttm-update
+description: >
+  Check for takeToMarket updates and upgrade to the latest version. Compares
+  installed version against npm registry and runs installer if newer version found.
+disable-model-invocation: false
+allowed-tools: Bash Read
+---
+
+# /ttm-update
+
+Check if takeToMarket needs updating and upgrade if available.
+
+1. Get current installed version:
+```bash
+cat $HOME/.taketomarket/package.json 2>/dev/null | python3 -c "import sys,json; print(json.load(sys.stdin).get('version','unknown'))" 2>/dev/null || echo "unknown"
+```
+
+2. Get latest version from npm:
+```bash
+npm show taketomarket version 2>/dev/null || echo "unknown"
+```
+
+3. Compare versions. If a newer version is available (latest > installed), run:
+```bash
+npx taketomarket@latest --yes
+```
+
+4. If already up to date, confirm: "takeToMarket vX.X.X is up to date."