arkaos 4.26.0 → 4.27.0

package/departments/marketing/skills/marketing-loops/references/loop-guardrails.md

@@ -0,0 +1,73 @@
+# Loop Guardrails & Compliance
+
+Loops act on a schedule, often on customer data, sometimes with money or a public voice. This reference consolidates the safety rules that keep autonomous loops from doing harm. Apply it to every loop that sends, spends, publishes, or touches personal data.
+
+## The two-tier action model
+
+Classify every action a loop can take:
+
+**Tier 1 — Autonomous-safe** (a loop may do these unattended):
+read data, analyze, diff, score, **draft**, and **stage** work for review.
+
+**Tier 2 — Gated** (require a human checkpoint by default):
+**spend** money, **shift budget**, **send** messages, **publish** anything public, **delete/suppress** records, **change** live account settings.
+
+A Tier-2 action may run without a per-action human check only if the user has **explicitly authorized** it *and* it's bounded by caps + an allowlist (below). Absent that, the loop stages a draft and a human approves.
+
+## Spend guardrails (ad-fatigue, paid-search, retargeting, expansion)
+
+- **Hard caps**: a daily/weekly spend ceiling the loop can never exceed; halt and alert if approached.
+- **Per-run change limit**: cap how much budget can move in one run (e.g., ≤20%), so a bad read can't reallocate everything.
+- **Allowlist**: only specified accounts/campaigns are eligible for autonomous changes; everything else is staged.
+- **Directional guardrails**: judge paid changes on revenue/ROAS, not just CTR/CPA — never optimize a proxy metric into a revenue loss.
+
+## Publish & send guardrails (email, social, PR, community, reviews)
+
+- **Default to a staging queue** + human approval for anything public or outbound. Auto-*drafting* is fine; auto-*publishing* is not, unless explicitly authorized.
+- **Volume caps**: per-run and per-recipient limits so a loop can't blast a list or over-post a channel.
+- **Suppression first**: always check suppression/unsubscribe/do-not-contact lists before sending.
+- **No auto-posting where detection/ToS bites**: owned social, press pitches, and community replies are staged for a human (bot detection + brand risk).
+
+## Compliance
+
+Match each rule to the loops it governs:
+
+- **CAN-SPAM / CASL (email/SMS loops — lifecycle, re-engagement, churn, trial, dunning, referral)**: honor unsubscribes immediately and permanently; include a working unsubscribe + physical address; identify the sender; don't email/text without a lawful basis or consent; scrub against suppression every send.
+- **GDPR / CCPA (any loop touching personal data)**: process on a lawful basis; get consent for EU marketing; honor deletion and opt-out requests; minimize data pulled and retained; don't repurpose data beyond its collected purpose.
+- **FTC (review-and-UGC-harvest, referral, social)**: disclose material connections and incentives (#ad, "I was compensated"); only use testimonials with permission; no fabricated or cherry-picked-to-mislead claims.
+- **Platform ToS (social-listening, community-engagement, review-site-management, scraping-based loops)**: respect rate limits and automation rules; follow review-platform response policies; don't scrape or auto-act where prohibited.
+
+When a loop can't confirm consent, permission, or ToS-compatibility, its stop condition is **don't act** — stage for a human instead.
+
+## PII handling
+
+- Don't log raw PII in loop **state** or **run logs** — use internal IDs or hashes.
+- Pull the minimum personal data needed to make the decision; don't hoard it in state.
+- Keep exports and drafts out of shared/synced locations unless intended.
+
+## Always-escalate list
+
+These never run fully autonomously — route to a human regardless of authorization:
+
+- Negative or crisis brand mentions; responses to complaints or legal/medical/financial-sensitive issues.
+- Newsjacking angles (see the veto list in the catalog) — human approval before any pitch/post.
+- High-value or strategic accounts (enterprise, at-risk logos).
+- Anomalies in **revenue** or **ad spend** — flag immediately, don't self-correct.
+- Anything that would delete data or contact a large audience at once.
+
+## Kill switch
+
+Every scheduled loop needs a manual off switch, and you should know how to stop **all** loops fast (disable the schedule / cron, or a global flag the loop bodies check). Document it where the loops are scheduled. A loop you can't stop quickly is a liability.
+
+## Pre-launch guardrail checklist
+
+Before scheduling any loop that sends, spends, publishes, or touches personal data:
+
+- [ ] Every action is classified Tier 1 (auto) or Tier 2 (gated).
+- [ ] Tier-2 actions are staged for approval — or bounded by explicit authorization + caps + allowlist.
+- [ ] Spend loops have a hard cap and a per-run change limit.
+- [ ] Send loops check suppression/unsubscribe and have volume caps.
+- [ ] Applicable compliance rules (CAN-SPAM/GDPR/FTC/ToS) are satisfied, with "don't act" as the fallback.
+- [ ] No raw PII in state or logs.
+- [ ] The always-escalate cases route to a human.
+- [ ] There's a documented kill switch.

package/departments/marketing/skills/marketing-loops/references/loop-orchestration.md

@@ -0,0 +1,69 @@
+# Loop Orchestration & Rollout
+
+Loops aren't independent scripts — they compose into a marketing operating system. This reference covers how they fit together and the order to adopt them so you never build 43 at once.
+
+## The system view
+
+Loops fall into four layers. Data flows down and learnings flow back up.
+
+```
+SENSING        analytics-anomaly · tracking-QA · weekly-marketing-review
+                  │  (detect what changed; trust the numbers first)
+                  ▼
+DIAGNOSTIC     per-stage watchers — onboarding drop-off, churn-signal,
+               ranking-drop, landing-page regression, ad-fatigue, …
+                  │  (figure out what to do about it)
+                  ▼
+ACTION         staged drafts, nudges, outreach, budget moves
+                  │  (mostly human-checkpointed)
+                  ▼
+LEARNING       experiment-backlog · campaign-postmortem · voice-of-customer
+                  │  (capture what worked)
+                  └──────────────► feeds back into SENSING & DIAGNOSTIC
+```
+
+Key connective tissue:
+- **weekly-marketing-review is the router.** It reads top-line metrics and dispatches each notable mover to the loop that owns it. It's the one loop that sees the whole board.
+- **tracking-QA + analytics-anomaly are the foundation.** Every other loop reads from analytics. If tracking is broken, every downstream loop acts on lies. These come first.
+- **experiment-backlog is the sink.** Hypotheses generated by many loops (signup-leak, pricing, onboarding, voice-of-customer) converge here, then hand off to `ab-testing`. Don't let each loop run its own tests.
+- **voice-of-customer is a source.** Customer language it mines feeds copy for ad-fatigue, lifecycle-email, landing-page, and pricing loops.
+- **campaign-postmortem closes the loop.** Its learnings become next quarter's hypotheses and plan inputs.
+
+Avoid duplicate ownership: when two loops could act on the same signal, one owns the action and the other just flags. (E.g., an at-risk account belongs to churn-signal, not expansion/upsell — never upsell an account that's churning.)
+
+## Rollout path (adopt in this order)
+
+Add a loop only when the loops before it are running and earning their keep. Each stage assumes the previous one is solid.
+
+**Stage 0 — Foundation (trust the data + see the board).**
+`tracking-QA`, `weekly-marketing-review`.
+You cannot run any loop responsibly on untrustworthy data or without a full-funnel pulse. This is non-negotiable and comes first.
+
+**Stage 1 — Plug the leaks (highest ROI, protects existing revenue).**
+`failed-payment/dunning`, `churn-signal`, `lifecycle-email-refresh`.
+Recovering customers you already have is cheaper than acquiring new ones. Dunning alone often pays for the whole system.
+
+**Stage 2 — Convert what you already get (fix the bucket before adding water).**
+`onboarding drop-off`, `signup-funnel-leak`, `trial-conversion`.
+More traffic into a leaky funnel is waste. Seal activation and conversion next.
+
+**Stage 3 — Grow the top (now scale acquisition).**
+`keyword-gap`, `content-repurposing`, `ad-fatigue`, `social-listening`, `analytics-anomaly`.
+With the bucket sealed, turn on demand generation and the safety-net anomaly watcher.
+
+**Stage 4 — Optimize monetization.**
+`pricing-page-experiment`, `paywall-optimization`, `PQL/upgrade-intent`, `expansion/upsell`.
+Once volume is healthy, tune revenue per user — judged on revenue quality, not conversion alone.
+
+**Stage 5 — Compounding & advocacy.**
+`referral-nudge`, `review-and-UGC-harvest`, `review-site-management`, `case-study-sourcing`, `partner-pipeline`, `brand-mention/reputation`, `experiment-backlog`, `campaign-postmortem`.
+The flywheel: happy customers and earned media that feed back into acquisition, plus the learning loops that make everything compound.
+
+The remaining catalog loops (content-decay, internal-linking, programmatic-SEO quality, content-calendar refill, paid-search query-mining, retargeting-hygiene, landing-page regression, community-engagement, competitor-watch, backlink-prospecting, directory-submission, feature-adoption, lead-capture-asset, email-deliverability, voice-of-customer) slot into the stage that matches their function as each channel becomes a priority.
+
+## Rollout rules
+
+- **One at a time.** Prove a loop earns its keep (someone acts on its output, it moves its metric) before adding the next.
+- **Foundation before growth.** Acquisition loops before solid tracking + retention = pouring water into a leaky bucket.
+- **Cap the total.** If you're running more loops than you can review the output of, you have vanity loops. Retire the ones nobody acts on.
+- **Re-audit quarterly.** Recalibrate thresholds, kill dead loops, promote the ones that consistently drive action.

package/departments/marketing/skills/marketing-loops/references/loop-state.md

@@ -0,0 +1,67 @@
+# Loop State & Run Logging
+
+Idempotency is only real if the loop can remember what it already did between runs. This reference defines where that state lives and how to log runs — so loops don't double-act, re-nag the same people, or re-alert the same issue.
+
+## Where state lives
+
+Persist each loop's state in a file under `.agents/loops/` — the same `.agents/` convention this repo uses for `product-marketing.md` and `listening-sources.md`. One state file per loop:
+
+```
+.agents/loops/<loop-name>.json     # the loop's memory
+.agents/loops/<loop-name>.log      # append-only run log
+```
+
+If your scheduler or platform provides its own dedupe/cursor storage, use that instead — the point is durable state, not the specific file. Never keep state only in memory; a loop that forgets on restart will repeat itself.
+
+## What to store
+
+A state file holds whatever the loop needs to not repeat itself:
+
+```json
+{
+  "loop": "churn-signal",
+  "last_run": "2026-07-01T09:00:00Z",
+  "cursor": "2026-06-30T23:59:59Z",        // watermark — only process items newer than this
+  "handled": ["acct_1042", "acct_1077"],    // dedupe keys already acted on
+  "cooldowns": {                             // entity -> next-eligible timestamp
+    "acct_1042": "2026-07-15T00:00:00Z"
+  },
+  "in_flight": ["exp_pricing_v3"],           // actions/tests currently open
+  "counters": { "acct_1042_attempts": 2 }    // e.g. dunning/win-back attempt counts
+}
+```
+
+- **cursor / watermark** — the high-water mark of what's been processed (a timestamp or last ID). The loop only looks at items past it.
+- **handled** — dedupe keys for items already acted on, so re-runs skip them.
+- **cooldowns** — per-entity suppression windows so you never re-contact someone inside the window.
+- **in_flight** — open items (running tests, active interventions) so the loop doesn't start a conflicting one.
+- **counters** — attempt counts that drive stop conditions (e.g., "after 2 win-back emails, stop").
+
+Keep state small and prune it: expire old `handled`/`cooldown` entries once they're past their window.
+
+## Idempotency patterns
+
+- **Watermark**: process only items newer than `cursor`; advance `cursor` at the end of a successful run. Safe to re-run — it won't reprocess.
+- **Dedupe set**: before acting on an item, check its key against `handled`; add it after acting.
+- **Cooldown map**: before contacting an entity, check `cooldowns[entity]`; set it after contact.
+- **In-flight guard**: before starting an action that shouldn't overlap (a test, an intervention), check `in_flight`.
+
+## Run logging
+
+Append one line per run, whether or not it acted. This is the audit trail and the vanity-loop detector.
+
+```
+2026-07-01T09:00Z  checked=312  acted=2   note="2 accounts newly at-risk, interventions staged"
+2026-07-02T09:00Z  checked=298  acted=0   note="no action"
+2026-07-03T09:00Z  checked=305  acted=0   note="no action"
+```
+
+Log at minimum: timestamp, how many items checked, how many acted on, and a short note. Use it to answer two questions:
+- **Is it a vanity loop?** If every run is `acted=0` for weeks and nobody misses it — or it acts every run (a sign it's chasing noise) — reconsider it.
+- **Did it double-act?** Two runs acting on the same entity means the dedupe/cooldown state isn't working.
+
+## Resetting & backfilling safely
+
+- To **reset** a loop, clear its `cursor`/`handled` — but keep `cooldowns` so a reset doesn't spam people who were recently contacted.
+- On **first run** (no state yet), set the watermark to "now" rather than processing all history, or you'll blast every historical item. If you genuinely want a backfill, do a dry run first (log what it *would* do, act on nothing) and respect cooldowns.
+- Never log raw PII in state or run logs — use IDs or hashes (see `loop-guardrails.md`).

package/departments/marketing/skills/marketing-loops/references/loop-template.md

@@ -0,0 +1,79 @@
+# Loop Template
+
+A copy-paste template for authoring your own marketing loop. Fill every one of the nine parts — a loop missing its **state/idempotency**, **self-check**, or **stop/bail-out** isn't a system, it's a way to do the wrong thing on a schedule.
+
+Before you start, sanity-check that this *should* be a loop at all (see "When NOT to loop" in `SKILL.md`): it's recurring, signal-driven, and doesn't require human judgment to set strategy or creative direction each run.
+
+---
+
+## Blank template (copy this)
+
+```markdown
+### The <name> loop
+- **Check cadence**: <how often it looks — match to how fast the signal changes, not how often you'd like an update>
+- **Acts when**: <the action condition — what must be true to actually DO something vs. just check and skip. Most runs should skip.>
+- **Purpose**: <the ONE outcome this loop exists to move>
+- **Skills used**: <which marketing skills the loop orchestrates each run>
+- **Loop body**:
+  1. <step — usually: pull data / diff vs. last run>
+  2. <step — identify what, if anything, crossed the action condition>
+  3. <step — draft or stage the response>
+- **Self-check**: <the verification done BEFORE acting — is the signal real vs. noise/seasonality/tracking bug? Is the sample big enough to be significant?>
+- **State / idempotency**: <what it remembers between runs — last-run marker, dedupe key, cooldown window, "already handled" set — so it doesn't double-act or re-nag the same people>
+- **Stop / bail-out**: <when it skips, halts, escalates to a human, or disables itself — plus what it does on error. Include a human checkpoint before anything that spends money or publishes.>
+- **Output**: <where results go — a file, a PR, a staged draft, a notification, a report>
+```
+
+---
+
+## Fill-in prompts (answer these, in order)
+
+1. **What outcome does this protect or grow?** (rankings, ad efficiency, activation, retention, revenue, referrals) → *Purpose*
+2. **How fast does that signal actually change?** (hours / days / weeks / months) → *Check cadence*
+3. **What has to be true before it's worth acting?** (a threshold crossed, a new item appeared, a regression vs. baseline) → *Acts when*
+4. **What data does it read and what does it produce each run?** → *Loop body* + *Output*
+5. **What would make it act on a false signal?** (noise, seasonality, a tracking break, too-small a sample) → *Self-check*
+6. **What must it remember so it doesn't repeat itself?** (dedupe key, cooldown, last-run marker) → *State / idempotency*
+7. **When should it stop, skip, or hand off to a human?** (no action needed, error, spend/publish decision, N failed attempts) → *Stop / bail-out*
+
+If you can't answer 5, 6, and 7 concretely, the loop isn't ready to run.
+
+---
+
+## Worked example (blank → filled)
+
+Say you sell a freemium API tool and want to stop losing signups who never make their first API call.
+
+```markdown
+### The first-call activation loop
+- **Check cadence**: Daily
+- **Acts when**: A user who signed up 48h ago still hasn't made a successful API call and isn't already in this nudge sequence.
+- **Purpose**: Increase the share of new signups that reach first value (first successful API call).
+- **Skills used**: `onboarding`, `emails`, `analytics`
+- **Loop body**:
+  1. Pull signups from ~48h ago and their first-call status.
+  2. Filter to those with zero successful calls and no active nudge.
+  3. Draft a targeted "get your first call working" email (docs link, common blocker, offer to help).
+- **Self-check**: Is "no call" a real activation gap, or a tracking gap (calls firing but not logged)? Confirm against server logs before emailing.
+- **State / idempotency**: Track which users have entered this sequence; suppress anyone who has made a call since; one nudge per user per stage.
+- **Stop / bail-out**: After 2 nudges with no call, stop and route to the broader re-engagement loop — don't keep emailing. Skip the run entirely if the events pipeline looks stale.
+- **Output**: A staged activation email per qualifying user + a daily count of new activations.
+```
+
+Notice what makes it safe: the **self-check** guards against a tracking bug emailing active users, the **state** stops it re-nagging, and the **stop** caps attempts and hands off instead of looping forever.
+
+---
+
+## Ship checklist
+
+Before you schedule a new loop, confirm:
+
+- [ ] All nine parts are filled — especially self-check, state, and stop.
+- [ ] Cadence matches signal speed (you're not checking daily for a weekly-moving signal).
+- [ ] It's designed so **most runs do nothing** — it acts only on a real condition.
+- [ ] Anything that **spends money or publishes** has a human checkpoint (unless caps + an allowlist are explicitly authorized).
+- [ ] State prevents double-acting and re-nagging the same people.
+- [ ] There's an error path (stale data → report "stale," don't fabricate movement) and a manual off switch.
+- [ ] For scheduling mechanics, see the "Scheduling a loop" section in `SKILL.md`.
+
+Once it runs, give it a few cycles and ask the "is this a vanity loop?" question: if nobody acts on the output, delete it.

package/departments/marketing/skills/marketing-plan/SKILL.md

@@ -0,0 +1,302 @@
+---
+name: mkt/marketing-plan
+description: >
+  fCMO-level 12-month marketing plan: an exhaustive 13-section plan
+  structured by AARRR, customized to the client's budget/team/stage,
+  mapped to funding milestones, cross-referenced with the 139-idea
+  library and a 17-section current-state audit rubric, with a full
+  marketing operations stack. TRIGGER: "marketing plan", "plano de
+  marketing", "growth plan", "GTM plan", "go-to-market plan", "AARRR
+  plan", "90-day marketing plan", "12-month roadmap", "fractional CMO
+  plan", "fCMO plan", "/mkt marketing-plan <client>". SKIP: positioning
+  and ICP context BEFORE planning -> mkt/product-marketing (run first);
+  a single channel's execution doc -> the channel skill (mkt/paid-campaign,
+  mkt/seo-audit, mkt/email-sequence, saas/onboarding-optimize); just a
+  list of tactics with no plan -> mkt/marketing-ideas; multi-agent HOW
+  planning of one build -> arka-forge.
+allowed-tools: [Read, Write, Edit, Bash, Grep, Glob, Agent, WebFetch, WebSearch]
+metadata:
+  origin: community
+  source: https://github.com/coreyhaines31/marketingskills
+  license: MIT
+---
+
+<!-- arka:kb-first-prefix begin -->
+> **KB-first:** query `mcp__obsidian__search_notes` (and
+> `mcp__graphify__query_graph` when configured) and cite `[[wikilinks]]`
+> or graph nodes — or declare the gap — BEFORE any external research.
+> Full doctrine: `arka/SKILL.md` (KB-First Research).
+<!-- arka:kb-first-prefix end -->
+
+# Marketing Plan — `/mkt marketing-plan <client>`
+
+> **Agent:** Luna (Marketing Director) | **Frameworks:** AARRR (McClure), Growth Loops, 3-3-2-2-2, S-curve layering
+
+**Context:** read the product marketing context first —
+`WizardingCode/Marketing/product-marketing.md` in Obsidian (KB-first),
+else the project-local `.agents/product-marketing.md`. If neither exists,
+offer to run `/mkt product-marketing`. Section 2 (Strategic frame) builds
+directly on it.
+
+You are an expert marketing strategist operating at fCMO (fractional CMO) level. Your job is to produce a comprehensive, executable 12-month marketing plan for a specific client or company, structured by AARRR (Acquisition, Activation, Retention, Referral, Revenue), customized to their actual budget, team, stage, and capabilities, and cross-referenced with the full marketing-ideas library and the embedded 17-section current-state audit rubric.
+
+The deliverable is a single Notion-paste-ready markdown document — the kind of strategy artifact a fractional CMO would present to founders. It must be specific to the client (not generic), exhaustive (covers every tactical surface area, not just what's prescribed), and operationally honest (reflects what their team can actually execute with their current stack and headcount).
+
+## When to use
+
+Invoke this skill when:
+
+- A user is starting a new client engagement as a fractional CMO or marketing consultant
+- A founder needs a 12-month marketing roadmap they can share with their team or investors
+- A team wants to consolidate scattered marketing work (SEO research, brand voice docs, audit findings, onboarding analyses) into a single coherent plan
+- The user explicitly asks for a "marketing plan," "growth plan," "GTM plan," "fCMO plan," "AARRR plan," or "90-day + 12-month marketing roadmap"
+- An existing scored audit (from any prior current-state assessment) needs to be sequenced into an action plan
+
+**Do not use** when the user wants a tactical execution document for a single channel (use the channel-specific skill instead — `emails`, `ads`, `seo-audit`, `onboarding`, etc.), or when the user just wants marketing ideas without commitment to a plan (use `marketing-ideas`).
+
+## How this skill is invoked
+
+```
+/marketing-plan {client-name-or-domain}
+```
+
+Examples:
+- `/marketing-plan quietude.app`
+- `/marketing-plan acme-saas`
+- `/marketing-plan` (will prompt for client name)
+
+On invocation, the skill reads `~/marketing-plans/{client-slug}/progress.md` and resumes based on the state machine documented in `references/methodology.md` Step 1.1.2 (fresh → INIT → REVIEW → FINALIZE → finalized). Finalized plans are never silently overwritten — the user is asked whether to revise as v{N+1}, start fresh, or re-open a section.
+
+## The three phases
+
+The full workflow lives in `references/methodology.md`. Quick summary:
+
+### Phase 1 — INIT (research + intake)
+
+Read all available materials about the client. Pull data from any wired tools (Ahrefs, GA4 MCP, Stripe MCP, etc.). Conduct structured intake covering: client overview, ICP, current funnel state, funding state, team composition, marketing budget, channels currently active, what's already been done, what's in-flight, what's stuck, tooling stack. Save to `research.md`.
+
+Use the embedded 17-section current-state rubric (`references/current-state-rubric.md`) as your scoring lens for Section 3 — score each section 0–5 against available materials.
+
+### Phase 2 — REVIEW (walk through each of 13 sections interactively)
+
+Present each section's draft in chat. For each section you can:
+- Approve as-is ("good," "next")
+- Adjust ("change X to Y")
+- Add observations ("also mention Z")
+- Expand ("go deeper on this")
+
+Save each confirmed section to the progress file as you go. The skill is resumable — if interrupted, run `/marketing-plan client-name` again to pick up at the next unfinished section.
+
+### Phase 3 — FINALIZE (compile + verify + publish)
+
+Compile all 13 sections into `final_plan.md`. Run a verification pass: confirm cross-references (marketing-ideas idea numbers, related skills, MCP integrations) are accurate; check for machine-specific paths that shouldn't ship; ensure the brand voice matches what was captured in the strategic frame.
+
+Optionally offer to publish to a shared GitHub repo (e.g., `{client-org}/{client-context}/marketing/plan.md`) if the user wants to share it with the team.
+
+## The 13-section plan structure
+
+Full template lives in `references/plan-template.md`. The structure:
+
+1. **Executive summary** — 3 big bets, 90-day priorities, 12-month outcome. Written so it can be lifted into an investor or board update.
+2. **Strategic frame** — Category claim, ICP distilled, business-model logic, brand voice non-negotiables.
+3. **Current state** — Team, budget, what's done, what's in-flight, what's stuck. Scored against the embedded 17-section current-state rubric (`references/current-state-rubric.md`).
+4. **Acquisition** — How strangers become aware. Channels current + planned + skipped, 90-day and 12-month moves, skills + tools.
+5. **Activation** — How a new user has an experience that converts. Onboarding, first session, App Store / signup, paywall, lifecycle setup.
+6. **Retention** — How a converted user stays and deepens. Lifecycle flows, churn prevention, win-back, support-as-marketing.
+7. **Referral** — How retained users bring more users. Ambassador / affiliate / Guides / WOM mechanics.
+8. **Revenue** — Pricing, packaging, upsells, bundles, hardware-to-software, B2B ACV.
+9. **90-day roadmap** — Weeks 1–2 (Unblock), 3–4 (Foundation), 5–8 (Velocity), 9–12 (Compound). AARRR-tagged, owner-assigned.
+10. **12-month outlook** — Quarterly milestones tied to funding-stage capability unlocks.
+11. **Marketing operations stack** — Marketing skills + MCP/API integrations mapped to each AARRR stage. Capability unlocks by funding stage.
+12. **Tactical idea bank** — All 139 ideas from `marketing-ideas` cross-referenced to AARRR + client-specific status (Now / Q2 / Q3+ / Q4+ / Skip).
+13. **Measurement, RACI, open decisions, appendix** — North-star metric, leading indicators by stage, RACI table, blocking decisions, links to deeper docs.
+
+## The AARRR framing
+
+AARRR replaces the older "channels and tactics" approach because it forces every recommendation to be funnel-stage-tagged, which makes the plan executable in priority order.
+
+Full primer in `references/aarrr-framework.md`. Quick rule:
+
+- **Acquisition** = strangers → aware (top of funnel)
+- **Activation** = aware → first valued experience (signup, onboarding, first session)
+- **Retention** = repeat users (lifecycle, churn prevention, deepening engagement)
+- **Referral** = retained users → bring more users (programs, viral mechanics)
+- **Revenue** = monetization (pricing, upsells, bundles, ACV expansion)
+
+Brand and content are **cross-cutting**, not their own AARRR stage — they serve every stage.
+
+## The current-state rubric
+
+The plan's "Current State" section scores the client against the embedded 17-section rubric. Full rubric in `references/current-state-rubric.md` — it's the source of truth, not a derivative of any external skill.
+
+If the user already has a separately scored audit, ingest those scores directly into Section 3. Otherwise, score from available materials using the rubric as your lens — mark "scored from materials" in the section header so the team can push back where they have better data.
+
+## Cross-references — skills this plan integrates with
+
+1. **`marketing-ideas`** — 139 proven marketing tactics. Section 12 of the plan cross-references every one to AARRR + client status. Detail in `references/idea-cross-reference.md`.
+2. **`mkt/product-marketing`** — Sets up the foundational product marketing context (positioning, ICP, voice) in the Obsidian note and its project-local mirror. Read this first; Section 2 (Strategic frame) builds on it.
+3. **AARRR-stage-specific skills** — `onboarding`, `signup`, `emails`, `referrals`, `pricing`, etc. The "Marketing operations stack" (Section 11) maps these to AARRR stages.
+
+The plan is **opinionated about which skills serve which stages.** Full mapping in `references/ops-stack-mapping.md`.
+
+## The marketing operations stack
+
+This is the differentiator of an fCMO-style plan vs. a generic marketing plan. The plan doesn't just say *what* to do — it says *what skills and tooling execute it.*
+
+A small team + an fCMO + the marketing-skills library + MCP integrations can output the work of a 15–20-person traditional marketing org. The plan must show this stack explicitly, AARRR-stage by AARRR-stage.
+
+Full mapping in `references/ops-stack-mapping.md`.
+
+## Funding-stage capability unlocks
+
+Every plan must include explicit "what changes when funding closes / when budget unlocks" reasoning. This makes the plan investor-friendly (founders mid-raise see what they're buying) and operationally honest (we're not pretending the team can spend $50K/mo on paid before the round closes).
+
+Standard tiers in `references/funding-stage-unlocks.md`:
+- **Pre-seed / bootstrapped** — $0–$2K/mo total marketing spend; organic only
+- **Seed close** — $5–$15K/mo paid test budget; first marketing hire
+- **Seed deployment** — $20–$50K/mo paid; second marketing hire
+- **Series A** — $50–$150K/mo paid; performance + content + designer; international consideration
+- **Series B+** — $150K+/mo paid; brand campaigns; PR firm; full-stack marketing org
+
+Use these as anchors. Adjust for category (consumer apps and ecommerce can spend more; deep-tech B2B may spend less).
+
+## Setting the budget scientifically
+
+The funding-stage anchors above tell you *what's in the ballpark*. To set the actual number defensibly, use one of two methods (full detail in `references/budget-planning.md`):
+
+1. **Revenue-Based (5–40% of ARR)** — start from comfortable spend, forecast resulting revenue. Best when historical CAC data exists.
+2. **Goal-Based** — reverse-engineer the budget from the revenue target. Formula: `[(New ARR / (ARPC × 12)) × CAC] / annual retention rate`. Best for fundraising or when the goal is fixed.
+
+Always add **10–20% experimental budget** on top — CAC is the main dependency, and the experimental layer is what funds the next-channel investment before the current one plateaus.
+
+For VC-backed Series A+ clients, anchor the 12-month outlook against the **3-3-2-2-2 rule** (3× in years 1–2, 2× in years 3–7 from $1M ARR).
+
+## Growth patterns — the real shape of SaaS growth
+
+Pitch decks show hockey sticks. Real growth is a series of S-curves with plateaus between them. Full framework in `references/growth-patterns.md`. Key implications for the plan:
+
+- **Phase identification** — $0–10K ARR (grueling), $10K–100K (treacherous middle), $100K–1M (acceleration). Section 3 names the current phase; Section 10 sequences the next.
+- **Linear vs step-function** — most healthy SaaS growth is linear (predictable additions per month) punctuated by step-functions (enterprise tier launch, new segment, channel breakthrough). The plan should describe both honestly — not promise exponential.
+- **S-curve layering** — Channel × Product × Market. Start the next S-curve while the current one is still growing. Riding any single S-curve to its ceiling before investing in the next produces multi-month plateaus.
+
+## Team and agency model
+
+Strategy lives in-house. Execution can — and often should — be outsourced. Full framework in `references/team-and-agency-model.md`. Three implications for every plan:
+
+1. **First hire is a strategist, not a tactician.** Look for a **π-shaped marketer** (two deep skill sets) — common high-leverage combos: Product Marketing + Growth Marketing, Product Marketing + Content Marketing, Growth Marketing + Content Marketing.
+2. **Title conservatively.** First marketing hire is almost always Manager or Lead, not VP or CMO. Inflated titles paint the org into a corner when you scale.
+3. **Use contractors and small niche agencies for execution.** Most pre-Series-A companies should rely on individual contractors for nearly all outsourced work; deepen agency relationships as the company moves into Growth Stage and Scale Stage.
+
+## What every plan must customize
+
+A generic plan is a failed plan. Every plan must explicitly customize for:
+
+1. **Current marketing budget** — exact $/mo, broken down by line (paid, tools, headcount, retainers). Plus blended CAC (must include salaries, content costs, tools, retainers — not just paid ad spend) and current %-of-ARR allocation.
+2. **Unit economics** — ARPC, annual retention rate, LTV. These feed the budget math in Section 8 and Section 10.
+3. **Team composition and surface area** — every person who touches marketing, with what they own. Identify whether the strategic owner (if there is one) is π-shaped, T-shaped, or tactical-only.
+4. **What the client is currently doing** — by channel, with status (working / not / TBD).
+5. **What they've already done that should be acknowledged** — past launches, PR moments, content, partnerships. Don't write a plan that ignores work they're proud of.
+6. **Phase of SaaS growth** — $0–10K ARR / $10K–100K / $100K–1M / $1M+. Each phase has its own binding constraint.
+7. **Future funding milestones** — when the next round closes, what budget tier that unlocks, and which capability comes online (first hire, paid channels, agency relationship).
+8. **The marketing skills mapped to specific moves** — every move in the AARRR sections names the skill that executes it.
+9. **The API/MCP/tool connections that enable execution** — every move names the tooling that makes it doable without hiring.
+
+If you can't confirm any of these in INIT, list them in Section 13's "Open decisions" — never gloss over them. **CAC unknown is the highest-impact open decision** — every revenue projection depends on it.
+
+## Common client-type variations
+
+Plan structure stays consistent. What changes:
+- **B2B SaaS** — Acquisition leans on SEO + content + outbound + LinkedIn. Activation = signup + product trial. Retention = product engagement + CSM motion. Referral = customer advocacy. Revenue = expansion / NRR.
+- **D2C consumer app** — Acquisition leans on App Store + paid social + influencer + PR. Activation = onboarding + first session + paywall. Retention = lifecycle email + push. Referral = sharing mechanics. Revenue = subscription + upsell.
+- **Hardware-led** — Acquisition leans on PR + retail + Amazon + Shopify SEO. Activation = unboxing + setup + first use. Retention = software companion + community. Referral = gifting + reviews. Revenue = blended LTV hardware + accessories + subscription.
+- **Marketplace** — Activation has two sides (supply + demand). Retention is repeat transaction frequency. Revenue is take-rate × GMV.
+- **Developer tool** — Acquisition leans on technical content + DevRel + documentation SEO. Activation = first build / first integration. Retention = depth of integration. Referral = team adoption.
+
+Detail in `references/client-types.md`.
+
+## Quality bar
+
+What separates a good plan from a generic one:
+
+**Good plan signals:**
+- Every move names the AARRR stage it serves
+- Every recommendation is anchored in real client data (their actual budget, their actual team, their actual current channels)
+- The 90-day roadmap has owners, not just actions
+- The funding-stage section explains what changes when the next round closes
+- The ops stack section names specific skills + MCPs per move
+- The idea bank shows what we're *not* doing and why (skipped ideas with rationale)
+- The exec summary can stand alone — could be lifted into an investor update
+- Open decisions are explicit, not glossed over
+
+**Failure modes to avoid:**
+- Listing tactics without sequencing
+- Recommending things the team can't execute at current size
+- Pretending paid budget exists before the round closes
+- Glossing over uncomfortable metrics (e.g., churn) instead of naming them as open decisions
+- Generic language ("build a community," "improve SEO") without specific moves
+- Ignoring brand voice — every plan section must respect the client's voice rules
+- Padding the plan with skills/ideas the client doesn't actually need
+- Not acknowledging work the team has already done
+
+## Output format
+
+The final deliverable is a single markdown file: `~/marketing-plans/{client-slug}/final_plan.md` (working copy for resumability). On FINALIZE, also publish the compiled plan to Obsidian at `WizardingCode/Marketing/Plans/{client-slug}.md` so the KB holds the canonical version.
+
+Headers (`## 1. Executive summary`, etc.) are H2 for clean Notion paste. Tables for any structured comparison (RACI, idea bank, ops stack). Status legend for the idea bank. Internal references to other sections use `§N` (e.g., "see §5 for Activation detail").
+
+Length expectation: ~8,000–12,000 words for a comprehensive plan. Shorter is fine if the client is early-stage with limited surface area; longer is fine if the client has years of history to acknowledge.
+
+## File layout per plan
+
+```
+~/marketing-plans/
+└── {client-slug}/
+    ├── materials/         # Client-provided files (decks, audit output, brand-voice doc, etc.)
+    ├── research.md        # Research record written during INIT
+    ├── progress.md        # State machine — phase, current_section, approved artifacts, plan_version
+    ├── sections/
+    │   ├── 01.md          # Each approved section saved as a canonical artifact
+    │   └── ...            # Zero-padded so they sort in order
+    └── final_plan.md      # Compiled deliverable (FINALIZE output)
+```
+
+The full schema for `progress.md` and the resumption decision tree live in `references/methodology.md` Steps 1.1.1 and 1.1.2.
+
+## Related ArkaOS skills
+
+- **`mkt/product-marketing`** — Run first. Captures positioning, ICP, voice so every section references the same foundation.
+- **`mkt/marketing-ideas`** — Source of the 139 tactics in Section 12.
+- **`saas/onboarding-optimize`** — Deep work on Section 5 (Activation).
+- **`mkt/email-sequence`** — Deep work on Section 6 (Retention) + onboarding emails in Section 5.
+- **`landing/affiliate-bridge`** — Deep work on Section 7 (Referral).
+- **`saas/pricing-strategy`** — Deep work on Section 8 (Revenue).
+- **`mkt/seo-audit`** / **`mkt/programmatic-seo`** — Deep work on the SEO portion of Section 4 (Acquisition).
+- **`mkt/paid-campaign`** — Deep work on the paid portion of Section 4 once budget unlocks.
+- **`saas/launch-execute`** — Deep work on launch moments inside Section 4 / Section 9.
+
+## Task-specific questions (used during INIT)
+
+The full intake questionnaire lives in `references/methodology.md`. The most important questions:
+
+1. **Funding state** — What round are you in? How much raised so far? Burn? Runway? Upcoming rounds and timing?
+2. **Team** — Who are all the people who touch marketing? What does each own? Where are the gaps?
+3. **Budget** — What's the current monthly marketing spend, broken down by paid acquisition, tools, retainers, headcount? What budget unlocks when the next round closes?
+4. **Current channels** — What's working today? What's not? What have you not tried yet?
+5. **Already done** — What past campaigns / launches / content / PR moments should this plan acknowledge?
+6. **In-flight** — What's drafted but not shipped? What's blocking each item?
+7. **Tooling stack** — What's wired? Customer.io / Mailchimp / Resend? Shopify / Stripe / App Store Connect? GA4 / Mixpanel / Amplitude? GitHub / Notion / Figma?
+8. **Beta or GA?** — If product is in beta, what's the GA timeline? Throttling? What gates exist?
+9. **The most important thing to fix this quarter** — founder's read.
+10. **The most important thing to ignore this quarter** — what looks important but isn't.
+
+## How exhaustive should the plan be?
+
+Default to comprehensive. Founders share a plan with their team and investors; brevity here is false economy. A 10,000-word plan with the right structure is more useful than a 3,000-word plan that misses the ops stack or the idea bank.
+
+That said: don't pad. Every section should be **dense, not bloated**. If a section has nothing to say, write that explicitly — "Q4+ — long-game / not in scope for this 12-month plan" is honest and useful.
+
+## A note on tone
+
+This plan is written for founders who are sharp, busy, and skeptical of marketing-speak. Write like a thoughtful colleague, not a deck-slide-writer. No jargon for jargon's sake. Direct claims, named tradeoffs, explicit assumptions. When unsure, name the open question rather than guessing.
+
+The exec summary should be short enough to read in 60 seconds. The rest should reward deep reading.