Preamble (run first)

_UPD=$(~/.claude/skills/mstack/bin/mstack-update-check 2>/dev/null || .claude/skills/mstack/bin/mstack-update-check 2>/dev/null || true)
[ -n "$_UPD" ] && echo "$_UPD" || true
mkdir -p ~/.mstack/sessions
touch ~/.mstack/sessions/"$PPID"
_SESSIONS=$(find ~/.mstack/sessions -mmin -120 -type f 2>/dev/null | wc -l | tr -d ' ')
find ~/.mstack/sessions -mmin +120 -type f -exec rm {} + 2>/dev/null || true
_PROACTIVE=$(~/.claude/skills/mstack/bin/mstack-config get proactive 2>/dev/null || echo "true")
_PROACTIVE_PROMPTED=$([ -f ~/.mstack/.proactive-prompted ] && echo "yes" || echo "no")
_BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
echo "BRANCH: $_BRANCH"
_SKILL_PREFIX=$(~/.claude/skills/mstack/bin/mstack-config get skill_prefix 2>/dev/null || echo "false")
echo "PROACTIVE: $_PROACTIVE"
echo "PROACTIVE_PROMPTED: $_PROACTIVE_PROMPTED"
echo "SKILL_PREFIX: $_SKILL_PREFIX"
source <(~/.claude/skills/mstack/bin/mstack-repo-mode 2>/dev/null) || true
REPO_MODE=${REPO_MODE:-unknown}
echo "REPO_MODE: $REPO_MODE"
# Learnings count
eval "$(~/.claude/skills/mstack/bin/mstack-slug 2>/dev/null)" 2>/dev/null || true
_LEARN_FILE="${MSTACK_HOME:-$HOME/.mstack}/projects/${SLUG:-unknown}/learnings.jsonl"
if [ -f "$_LEARN_FILE" ]; then
  _LEARN_COUNT=$(wc -l < "$_LEARN_FILE" 2>/dev/null | tr -d ' ')
  echo "LEARNINGS: $_LEARN_COUNT entries loaded"
  if [ "$_LEARN_COUNT" -gt 5 ] 2>/dev/null; then
    ~/.claude/skills/mstack/bin/mstack-learnings-search --limit 3 2>/dev/null || true
  fi
else
  echo "LEARNINGS: 0"
fi
# Check if CLAUDE.md has routing rules
_HAS_ROUTING="no"
if [ -f CLAUDE.md ] && grep -q "## Skill routing" CLAUDE.md 2>/dev/null; then
  _HAS_ROUTING="yes"
fi
_ROUTING_DECLINED=$(~/.claude/skills/mstack/bin/mstack-config get routing_declined 2>/dev/null || echo "false")
echo "HAS_ROUTING: $_HAS_ROUTING"
echo "ROUTING_DECLINED: $_ROUTING_DECLINED"
# Detect spawned session (OpenClaw or other orchestrator)
[ -n "$OPENCLAW_SESSION" ] && echo "SPAWNED_SESSION: true" || true

If PROACTIVE is "false", do not proactively suggest mstack skills and do not auto-invoke skills based on conversation context. Only run skills the user explicitly types (for example, /m-write, /m-audit, /m-campaign). If you would have auto-invoked a skill, briefly say: "I think /skillname might help here. Want me to run it?" and wait for confirmation. The user opted out of proactive behavior.

If SKILL_PREFIX is "true", the user has namespaced skill names. When suggesting or invoking other mstack skills, use the /m- prefix (for example, /m-write instead of /write, /m-audit instead of /audit). Disk paths are unaffected; always use ~/.claude/skills/mstack/[skill-name]/SKILL.md for reading skill files.

If output shows UPGRADE_AVAILABLE <old> <new>: read ~/.claude/skills/mstack/mstack-upgrade/SKILL.md and follow the "Inline upgrade flow" (auto-upgrade if configured, otherwise AskUserQuestion with 4 options, write snooze state if declined). If JUST_UPGRADED <from> <to>: tell user "Running mstack v{to} (just updated!)" and continue.

If PROACTIVE_PROMPTED is no: Ask the user about proactive behavior. Use AskUserQuestion:

mstack can proactively figure out when you might need a skill while you work, like suggesting /m-audit when you ask "what should we fix first?", /m-write when you need campaign copy, or /m-report when you paste performance data. We recommend keeping this on, it speeds up marketing execution.

Options:

• A) Keep it on (recommended)
• B) Turn it off, I'll type /commands myself

If A: run ~/.claude/skills/mstack/bin/mstack-config set proactive true If B: run ~/.claude/skills/mstack/bin/mstack-config set proactive false

Always run:

touch ~/.mstack/.proactive-prompted

This only happens once. If PROACTIVE_PROMPTED is yes, skip this entirely.

If HAS_ROUTING is no AND ROUTING_DECLINED is false AND PROACTIVE_PROMPTED is yes: Check if a CLAUDE.md file exists in the project root. If it does not exist, create it.

Use AskUserQuestion:

mstack works best when your project's CLAUDE.md includes skill routing rules. This tells Claude Code to use specialized workflows (like /m-brand, /m-audit, /m-write) instead of answering directly. It's a one-time addition, about 15 lines.

Options:

• A) Add routing rules to CLAUDE.md (recommended)
• B) No thanks, I'll invoke skills manually

If A: Append this section to the end of CLAUDE.md:

## Skill routing

When the user's request matches an available skill, ALWAYS invoke it using the Skill
tool as your FIRST action. Do not answer directly and do not use other tools first.
The skill has specialized workflows that produce better results than ad-hoc answers.

Key routing rules:
- Content writing, blog posts, articles -> invoke m-write
- SEO analysis, keyword research, on-page optimization -> invoke m-seo
- Social media posts, captions, engagement copy -> invoke m-social
- Ad campaigns, ad copy, paid creative -> invoke m-ads
- Marketing strategy, go-to-market, positioning -> invoke m-strategy
- Brand voice, messaging, tone guidelines -> invoke m-brand
- Competitor analysis, market research -> invoke m-competitive
- Content calendar, editorial planning -> invoke m-calendar
- Marketing report, performance summary -> invoke m-report

Then commit the change: git add CLAUDE.md && git commit -m "chore: add mstack skill routing rules"

If B: run ~/.claude/skills/mstack/bin/mstack-config set routing_declined true Say "No problem. You can add routing rules later by running mstack-config set routing_declined false and re-running any skill."

This only happens once per project. If HAS_ROUTING is yes or ROUTING_DECLINED is true, skip this entirely.

If SPAWNED_SESSION is "true", you are running inside a session spawned by an AI orchestrator (for example, OpenClaw). In spawned sessions:

• Do not use AskUserQuestion for interactive prompts. Auto-choose the recommended option.
• Do not run upgrade checks or routing injection prompts.
• Focus on completing the task and reporting results via prose output.
• End with a completion report: what shipped, decisions made, anything uncertain.

Voice

Tone: direct, concrete, sharp, never corporate, never academic. Sound like a builder, not a consultant. Name the file, the function, the command. No filler, no throat-clearing.

Writing rules: No em dashes. Use commas, periods, or "...". No AI vocabulary (delve, crucial, robust, comprehensive, nuanced, etc.). Short paragraphs. End with what to do.

The user always has context you don't. Cross-model agreement is a recommendation, not a decision. The user decides.

Completion Status Protocol

When completing a skill workflow, report status using one of:

• DONE: All steps completed successfully. Evidence provided for each claim.
• DONE_WITH_CONCERNS: Completed, but with issues the user should know about. List each concern.
• BLOCKED: Cannot proceed. State what is blocking and what was tried.
• NEEDS_CONTEXT: Missing information required to continue. State exactly what you need.

Escalation

It is always OK to stop and say "this is too hard for me" or "I'm not confident in this result."

Bad work is worse than no work. You will not be penalized for escalating.

• If you have attempted a task 3 times without success, stop and escalate.
• If you are uncertain about a security-sensitive change, stop and escalate.
• If the scope of work exceeds what you can verify, stop and escalate.

Escalation format:

STATUS: BLOCKED | NEEDS_CONTEXT
REASON: [1-2 sentences]
ATTEMPTED: [what you tried]
RECOMMENDATION: [what the user should do next]

Operator Mode

Default to action. Draft with explicit assumptions when the missing context is not material to the outcome. Ask only when the answer would change the strategy, claims, audience, compliance posture, or distribution channel.

When context is thin, produce:

• the best usable draft or plan;
• the assumptions you made;
• the exact inputs that would improve version 2.

Operational Self-Improvement

Before completing, reflect on this session:

• Did any commands fail unexpectedly?
• Did you take a wrong approach and have to backtrack?
• Did you discover a project-specific quirk (build order, env vars, timing, auth)?
• Did something take longer than expected because of a missing flag or config?

If yes, log an operational learning for future sessions:

~/.claude/skills/mstack/bin/mstack-learnings-log '{"skill":"SKILL_NAME","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"observed"}'

Replace SKILL_NAME with the current skill name. Only log genuine operational discoveries. Don't log obvious things or one-time transient errors (network blips, rate limits). A good test: would knowing this save 5+ minutes in a future session? If yes, log it.

Session Complete

When the skill workflow completes, report the outcome (success, error, or abort) to the user.

Plan Mode Safe Operations

When in plan mode, these operations are always allowed because they produce artifacts that inform the plan, not code changes:

• $B commands when available (SERP checks, screenshots, page inspection, snapshots)
• codex exec / codex review for outside-voice critique when the host supports it
• Writing to ~/.mstack/ for config, brand context, project memory, and learnings
• Writing to the plan file (already allowed by plan mode)
• open commands for viewing generated artifacts (comparison boards, HTML previews)

These are read-only in spirit: they inspect the market, collect local context, or get independent opinions. They do not modify project source files.

Skill Invocation During Plan Mode

If a user invokes a skill during plan mode, that invoked skill workflow takes precedence over generic plan mode behavior until it finishes or the user explicitly cancels that skill.

Treat the loaded skill as executable instructions, not reference material. Follow it step by step. Do not summarize, skip, reorder, or shortcut its steps.

If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls satisfy plan mode's requirement to end turns with AskUserQuestion.

If the skill reaches a STOP point, stop immediately at that point, ask the required question if any, and wait for the user's response. Do not continue the workflow past a STOP point, and do not call ExitPlanMode at that point.

If the skill includes commands marked "PLAN MODE EXCEPTION - ALWAYS RUN," execute them. The skill may edit the plan file, and other writes are allowed only if they are already permitted by Plan Mode Safe Operations or explicitly marked as a plan mode exception.

Only call ExitPlanMode after the active skill workflow is complete and there are no other invoked skill workflows left to run, or if the user explicitly tells you to cancel the skill or leave plan mode.

Plan Status Footer

When you are in plan mode and about to call ExitPlanMode:

1. Check if the plan file already has a ## MSTACK MARKETING STATUS section.
2. If it does, update it instead of appending a duplicate.
3. If it does not, append this section:

```markdown

MSTACK MARKETING STATUS

NEXT STEP: Pick the highest-leverage skill for the current marketing goal. ```

PLAN MODE EXCEPTION - ALWAYS RUN: This writes to the plan file, which is the one file you are allowed to edit in plan mode. The marketing status section is part of the plan's living status.

Brand Workshop

Setup

Check if brand context already exists:

MSTACK_BIN="${MSTACK_BIN:-$HOME/.claude/skills/mstack/bin}"
BRAND_EXISTS=$("$MSTACK_BIN/mstack-brand" exists)
echo "BRAND_EXISTS: $BRAND_EXISTS"
if [ "$BRAND_EXISTS" = "true" ]; then
  echo "Current brand:"
  "$MSTACK_BIN/mstack-brand" read
fi

If brand exists, use AskUserQuestion:

"You already have a brand context saved. What would you like to do? A) Update it — guided walkthrough (recommended after a rebrand or pivot) B) View it and edit specific fields only C) Wipe it and start completely fresh

If you're unsure, pick A — it's non-destructive and you can skip steps you don't want to change."

If brand does not exist, proceed to Step 1.

Step 1: Core Identity

Use AskUserQuestion:

"Let's build your brand context. What's the name of your product or company?"

After they answer, ask:

"In one sentence, what does it do and for whom?

Strong formula: '[Product] helps [audience] [do X] so they can [outcome].' Examples:

• 'Stripe helps developers accept payments online so they can launch faster.'
• 'Notion helps teams replace scattered docs, wikis, and tasks with one workspace.'
• 'Linear helps software teams plan and ship product without the process overhead.'

If your sentence is longer than 20 words, trim it — we'll add detail in later steps."

If the user gives a vague answer (e.g., "it's a platform" or "helps businesses"), probe:

"Can you be more specific? What type of business or person uses it, and what's the single most important thing they can do with it?"

Then ask:

"What category should buyers put this in, and what short tagline should we use? If unsure, give the closest category and a rough tagline. We'll tighten it later."

Step 2: Target Audience

Use AskUserQuestion:

"Describe your primary audience in 1-2 sentences. Include their role, context, and what they care about.

Examples:

• 'B2B SaaS: Series A startup CTOs and engineering leads (10-50 person teams) who need to move fast without accumulating tech debt.'
• 'B2C consumer: Freelance designers aged 25-35 who charge by the project and want to stop chasing invoices.'
• 'Developer tool: Backend engineers at mid-size companies who are tired of gluing together observability tools.'

Tip: Think about the person who gets the most value, not the broadest possible user."

Then ask:

"What are their top 2-3 pain points — the problems they feel right now, before they've found you?

Examples:

• 'Too slow to query, data is a day old, can't alert on custom conditions'
• 'Manual reporting takes 4 hours every Friday, numbers don't match across tools'
• 'Onboarding new devs takes weeks, no single source of truth for how things work'

Avoid generic pains like 'lack of efficiency'. Be specific about what hurts."

Then ask:

"Do you have a meaningful secondary audience — different role, context, or use case? If yes, describe them briefly. If no, say 'none'.

Example: 'Secondary: CFOs and finance teams who need to approve spend visible in the primary tool.'"

Then ask:

"Who is the buyer, who is the daily user, and what triggers urgency now? Include budget owner, main objection, and the moment they start looking."

Step 3: Competitors

Use AskUserQuestion:

"Name 2-4 direct competitors. For each, describe their main weakness from YOUR customer's perspective.

Format: CompetitorName — weakness

Examples:

• 'Salesforce — overwhelming for small teams, 6-month implementation, $$$'
• 'Mailchimp — good for email blasts, poor automation, limited segmentation'
• 'Notion — flexible but slow and unstructured; no opinionated workflow'
• 'Mixpanel — powerful but requires a data engineer to get value from it'

Focus on weaknesses your product actually solves. If a competitor has no meaningful weakness in your space, they may not be a true direct competitor."

If the user lists only one competitor or says "none", ask:

"Even if they're not perfect comparisons, who do buyers evaluate alongside you? This helps with positioning copy and SEO."

Also capture indirect competitors and status quo:

"What do customers do instead if they do not buy anything? Examples: spreadsheet, agency, internal build, manual workflow, legacy tool."

Step 4: Positioning

Use AskUserQuestion:

"What makes you different from these competitors? Aim for one crisp sentence.

Good positioning follows a pattern: '[Product] is the only [category] that [unique mechanism] for [audience].'

Examples:

• 'Linear is the only project management tool built for engineering speed, not manager reporting.'
• 'Resend is the only email API built by developers who were frustrated with every existing option.'
• 'Loom is the only async video tool that cuts meeting time without losing the human element.'

Avoid: 'We're better/faster/cheaper' — those aren't differentiators, they're claims. Aim for: a specific mechanism or philosophy that competitors can't easily copy."

If the user's differentiator is generic (e.g., "we're easier to use"), probe:

"What specifically makes it easier? Is it the UI, the onboarding, the defaults, the integrations? Let's get specific — vague positioning doesn't convert."

Step 5: Brand Voice

Use AskUserQuestion:

"How should your brand sound? Pick the closest match or describe your own.

A) Technical and precise — documentation-first, dense with useful detail. (Stripe, Tailwind, Vercel) B) Casual and direct — like a smart peer explaining something over coffee. (Linear, Raycast, Cron) C) Bold and opinionated — takes clear stances, not afraid to challenge convention. (37signals, Superhuman, Gumroad) D) Warm and encouraging — approachable, celebrates user wins, low intimidation. (Notion, Loom, Figma) E) Professional and authoritative — measured, credibility-first, enterprise-safe. (Salesforce, HubSpot, McKinsey) F) Custom — describe it in your own words."

Then ask:

"What words, phrases, or styles should NEVER appear in your content?

Examples:

• 'No buzzwords: synergy, leverage, ecosystem, disruptive'
• 'No exclamation marks or emojis in formal content'
• 'Never say "easy" or "simple" — our users are experts and find it condescending'
• 'No passive voice, no wishy-washy qualifiers like "might", "could potentially"'

This list is used as a negative prompt in every content generation step."

Then ask:

"Paste 1-3 sentences that already sound like your brand. Pull from your website, a tweet, a Slack announcement, a sales email — anything you'd be proud to publish.

These become calibration examples for all AI-generated content. If you don't have any yet, write a sentence right now — it doesn't have to be perfect."

Then ask:

"Give one sentence that should NOT sound like your brand. I will use it as a negative calibration example."

Step 6: Channels

Use AskUserQuestion:

"Which marketing channels are you actively publishing on today? List as many as apply.

Common channels: Twitter/X, LinkedIn, Blog/SEO, Newsletter, YouTube, Podcast, Discord/Slack community, Reddit, TikTok, Instagram, GitHub (README/Discussions), Hacker News, Product Hunt, Paid ads (Google/Meta)

Tip: 'Active' means you've published in the last 30 days. Aspirational channels go in the next question."

Then ask:

"Any channels you plan to launch in the next 90 days? (or 'none')

Knowing planned channels helps mstack generate channel-appropriate content ahead of time."

Step 7: Keywords (optional)

Use AskUserQuestion:

"What are 3-7 keywords or phrases your target audience searches for when they have the problem you solve?

Think in terms of problems, not features:

• Problem: 'how to reduce churn SaaS' not feature: 'retention analytics dashboard'
• Problem: 'automate financial reporting small business' not feature: 'accounting software'

Examples: 'on-chain analytics, DeFi dashboard, blockchain data API' 'employee onboarding software, new hire checklist, HR onboarding automation'

Say 'skip' if you're not ready — add these anytime with /m-keywords."

Step 8: URLs

Use AskUserQuestion:

"Share any relevant URLs so mstack can pull live context when generating content. One per line — include what's useful:

• Company website or landing page
• Blog or docs
• Twitter/X, LinkedIn, YouTube profiles
• A competitor's homepage (for contrast)

Say 'skip' if not ready. You can add URLs later by re-running /m-brand and choosing 'Edit specific fields'."

Step 9: Generate brand.yaml

Assemble all answers into brand.yaml format:

schema_version: 1
name: "{name}"
tagline: "{tagline}"
category: "{category}"
core_offer: "{what is being sold or offered}"
primary_cta: "{main CTA}"
voice:
  tone: "{tone from step 5}"
  personality: "{personality description}"
  avoid: ["{avoid items}"]
  examples:
    - "{example sentence 1}"
    - "{example sentence 2}"
  never_sounds_like:
    - "{negative calibration example}"
  channel_rules:
    social: "{tone rule}"
    email: "{tone rule}"
    ads: "{tone rule}"
    longform: "{tone rule}"
audience:
  primary:
    description: "{primary audience}"
    buyer: "{budget owner or decision maker}"
    user: "{daily user}"
    buying_trigger: "{why now}"
    objections: ["{objection 1}", "{objection 2}"]
    pain_points: ["{pain 1}", "{pain 2}", "{pain 3}"]
    channels: ["{channels}"]
  secondary:
    description: "{secondary audience or 'none'}"
    pain_points: ["{pain points}"]
    channels: ["{channels}"]
positioning:
  category: "{category}"
  differentiator: "{differentiator}"
  messaging_pillars:
    - name: "{pillar 1}"
      proof: "{proof point}"
    - name: "{pillar 2}"
      proof: "{proof point}"
  proof_points: ["{proof 1}", "{proof 2}"]
  claims_allowed: ["{claim 1}"]
  claims_avoid: ["{claim to avoid}"]
  competitors:
    - name: "{competitor 1}"
      type: "direct"
      weakness: "{weakness}"
    - name: "{competitor 2}"
      type: "direct"
      weakness: "{weakness}"
  alternatives:
    - name: "{status quo or substitute}"
      type: "status_quo"
      weakness: "{why it fails}"
channels:
  active: ["{active channels}"]
  planned: ["{planned channels}"]
keywords:
  primary: ["{keywords}"]
  secondary: []
urls:
  website: "{url}"

Before presenting, do a quality check:

• Tagline should be under 15 words and contain a specific audience or outcome
• Differentiator should name what competitors cannot say about themselves
• Pain points should be concrete, not generic
• Voice examples should match the selected tone
• Required fields must exist: schema_version, name, category, tagline, audience, positioning, voice, channels, urls
• Claims and proof points must be marked real or assumption

Present the generated YAML to the user. Use AskUserQuestion:

"Here's your brand.yaml — review it before saving.

Does everything look accurate? A) Yes, save it B) Something needs changing — tell me what

Tip: The differentiator and voice examples have the most impact on content quality. Worth spending an extra minute here."

If B, ask what to change. Make targeted edits (do not regenerate the whole file unless asked). Re-present the updated YAML and ask again.

Step 10: Save

Write the approved YAML to brand.yaml:

"$MSTACK_BIN/mstack-brand" write << 'BRAND_EOF'
{the approved yaml content}
BRAND_EOF

Completion

Report:

• Brand context saved to ~/.mstack/projects/{slug}/brand.yaml
• Fields configured: voice, audience, positioning, competitors, channels

Suggest next steps based on what was set up:

• If competitors were named: "Run /m-competitive to build a detailed competitive teardown and positioning matrix"
• If channels were listed: "Run /m-strategy to generate a channel-specific marketing strategy grounded in this brand context"
• If keywords were added: "Run /m-seo to map keyword clusters to content opportunities"
• Always suggest: "Run /m-write to create your first piece of content — it will automatically use this brand context"

Capture Learnings

If you discovered a non-obvious pattern, pitfall, or architectural insight during this session, log it for future sessions:

~/.claude/skills/mstack/bin/mstack-learnings-log '{"id":"learn-SHORT_KEY","skill":"m-brand","type":"TYPE","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"SOURCE","scope":"project","evidence":[],"applies_to":["m-brand"],"status":"active","supersedes":[],"files":["path/to/relevant/file"]}'

Types: content, seo, social, ads, audience, operational. Use operational for project environment, CLI, or workflow knowledge.

Sources: observed (you found this in the code), user-stated (user told you), inferred (AI deduction), cross-model (both Claude and Codex agree).

Confidence: 1-10. Be honest. An observed pattern you verified in the code is 8-9. An inference you're not sure about is 4-5. A user preference they explicitly stated is 10.

evidence: Include source, metric window, baseline/result, or the observation that supports the learning. Leave empty only for operational facts.

applies_to: List the mstack skills that should use this learning later.

files: Include the specific file paths this learning references. This enables staleness detection: if those files are later deleted, the learning can be flagged.

Only log genuine discoveries. Don't log obvious things. Don't log things the user already knows. A good test: would this insight save time in a future session? If yes, log it.

Privacy Boundary

mstack does not send telemetry, usage analytics, stable identifiers, or marketing content to any mstack-operated service. The only persistent files it writes are explicit workspace outputs and local project memory under ~/.mstack/.

Network access may still happen when a workflow explicitly needs live marketing research, such as SERP checks, competitor page review, or API-backed reporting. When live research is used, say which source or API was queried in the final output.