Member 3 · Planning side of the loop

Ideas in.
Prioritized plans out.

AI 規劃大師 · MK PLAN MASTER

mk-plan-master reads ideas from Markdown / Linear / JIRA / Notion, runs idea triage, scores with RICE or Impact-Effort, and emits a spec draft shaped to drop straight into mk-spec-master.parse_spec. analyze_initiative is the core — it forces the AI through a senior-PM analysis SOP before scoring, so you don't get a confident-looking RICE built from a two-paragraph blurb. Decision history + signature + telemetry built in: mk-spec-master's v0.4 self-reinforcement pattern, applied one step upstream.

GitHub → PyPI Read the docs
Reads ideas from
Markdown Linear JIRA Notion
Why this MCP exists

Close the upstream gap in the Idea → Plan → Spec → Code → Test loop

mk-spec-master and mk-qa-master already cover the right half. The upstream piece — turning 30–200 raw ideas (chat snippets, customer calls, URLs, gut hunches) into a prioritized quarterly roadmap and emitting a spec draft — is the gap nobody built MCP-native. mk-plan-master closes it, and generate_spec_draft's output drops verbatim into mk-spec-master.parse_spec — no manual reformat, no copy-paste fragility.

Scope

What this is not

mk-plan-master sits between your idea source and your spec layer. It's not a web crawler, code writer, LLM, or SaaS UI.

A web crawler
→ Your AI client summarizes via WebFetch / chat; add_initiative just writes the markdown
A code writer
→ spec_draft → mk-spec-master → code lives in your IDE (Claude Code / Cursor / Copilot)
An LLM
→ Reasoning lives in your AI client (Claude / Cursor / Codex / Gemini). analyze_initiative only scaffolds the prompt — it doesn't call an LLM
A Productboard / Aha! replacement UI
→ MCP-native: lives where the AI lives. Reads your existing Linear / JIRA / Notion — no migration
A spec editor
→ mk-spec-master + your existing Linear / JIRA / Notion / Markdown
Tool surface

15 tools across 9 roles

Grouped by role. Each group is one layer in the idea → plan → spec → memory loop.

Meta — orientation
  • get_plan_source_info — Active adapter + all available + version. Call this first so the AI knows whether to expect markdown / Linear / JIRA / Notion semantics.
Discovery — find + load ideas
  • list_initiatives — Filter by status / label / limit. Linear: triage / backlog / unstarted; JIRA: To Do; Notion: Triage / Backlog / Idea.
  • fetch_initiative — Pull one initiative by id. raw_metadata carries RICE inputs (reach / impact / confidence / effort / okr).
Capture — chat / WebFetch handoff
  • add_initiative — Persist an idea your AI client already gathered via WebFetch / chat / call notes into initiatives/.md. **The family does NOT crawl** — you summarize, this tool writes. Auto-generates IDEA-NNN.
Analysis — the senior-PM SOP
  • analyze_initiative — **The core meta-tool**. Forces a senior-PM analysis SOP — target users / competition / market signal / risks / MVP scope / out-of-scope / RICE rationale. Three frameworks: default (7 sections) / lite (4) / lean_canvas (9 blocks). Doesn't call an LLM — scaffolds the prompt so the AI doesn't shortcut into a shallow read.
Scoring — prioritize the backlog
  • score_initiative — Score one initiative with RICE or Impact-Effort. Tier thresholds: P0 > 25, P1 10..25, P2 3..10, P3 < 3. Appends a scored decision to index.json.
  • rank_backlog — Score the whole backlog, return top-N descending. **Auto-archives a snapshot** (debounced 5 min) so get_planning_history / get_decision_signature can compute trend deltas.
Bridge — the family lock-in
  • generate_spec_draft — **The family-bridge tool**. Markdown spec draft shaped so mk-spec-master.parse_spec(raw_text=...) ingests it verbatim — no manual editing. Three templates: default / lite / detailed.
Roadmap — quarterly planning
  • generate_roadmap — Pack the ranked backlog into a quarterly markdown roadmap, respecting an engineering-capacity envelope (engineer-months × 4 person-weeks) minus a buffer (default 20%). Greedy score-per-effort packer.
  • analyze_roadmap_balance — Classify top-N into feature / tech_debt / strategic / unlabeled buckets, surface ratio + score-share + heuristic advisory. "Is the roadmap balanced?" / "Are we starving tech debt?"
Knowledge — methodology
  • init_plan_knowledge — Create plan-knowledge.md from a starter template — RICE / WSJF / Impact-Effort / OKR mapping / INVEST / personas + TODO sections for active OKRs / strategic bets / tech-debt / glossary. Idempotent.
  • get_plan_context — Read plan-knowledge.md (built-in fallback). Optional section filter. Call near session start so the same methodology + glossary colours every score that follows.
Self-reinforcement — longitudinal view
  • get_planning_history — Trend deltas (current vs ~7d / ~30d) for top-10 snapshots. Surfaces churn + average score. "Are we improving?" / "Is the same idea always at the top?"
  • get_decision_signature — Chronic patterns: **ghost initiatives** (top-10 >50% but never spec_generated), **score whiplash** (RICE swings >50%), **orphan OKRs** (in index, zero top-10 initiatives).
  • get_telemetry — Aggregates telemetry.jsonl (name + duration + ok only — **argument values never logged**). Top tools, error rates, p50 / p95 / p99, dead surface.
Source adapters

4 sources, one tool surface

Switch via the PLAN_SOURCE env var. Same tools, four different backends.

markdown_local
auth: none
since 0.1.0
linear
auth: LINEAR_API_KEY (+ optional PLAN_PROJECT_KEY)
since 0.1.0
jira
auth: JIRA_BASE_URL + JIRA_EMAIL + JIRA_API_TOKEN (+ optional PLAN_PROJECT_KEY)
since 0.1.0
notion
auth: NOTION_TOKEN + database id as PLAN_PROJECT_KEY
since 0.1.0
Workflows

Four prompts cover ~90% of real use

One sentence to the AI client; the tools chain automatically.

1.

"I drafted a feature idea from a customer call — capture it as an initiative, run analyze_initiative on it, score it, and produce a detailed spec draft I can hand to mk-spec-master."

add_initiative → analyze_initiative → add_initiative(overwrite=true) → score_initiative → generate_spec_draft(template='detailed') → mk-spec-master.parse_spec
2.

"Every Monday, rank my Linear triage backlog with RICE and show me the trend vs last week and last month."

rank_backlog(method='rice', limit=10) → get_planning_history(window_days=30)
3.

"Apply the senior-PM analysis SOP to IDEA-014 — I want target users, competition, market signal, risks, MVP scope, out-of-scope, and RICE rationale before I score it."

get_plan_context → fetch_initiative('IDEA-014') → analyze_initiative('IDEA-014', framework='default') → add_initiative(overwrite=true) → score_initiative
4.

"Pull every Notion idea in the Triage view, rank them with RICE, then pack a Q3 2026 roadmap assuming 4 engineers and 20% buffer. Tell me if the feature/tech-debt/strategic mix looks healthy."

list_initiatives(status='triage') → rank_backlog → generate_roadmap(capacity_engineer_months=12, period='Q3 2026') → analyze_roadmap_balance
Sample output

Why analyze_initiative exists — a real case

Same idea, two passes. By default an AI client shortcuts into a shallow read and emits a confident-looking P0. analyze_initiative forces the senior-PM SOP first; the numbers become honest.

Pass 1 — without analyze_initiative (AI guesses)

IDEA-001  ·  Self-serve onboarding wizard
  reach        500
  impact         2
  confidence   0.5
  effort        12  person-weeks
  out_of_scope  []  (none)
  RICE         (500 × 2 × 0.5) / 12  =  41.7   →   P0

A confident P0. Looks like a no-brainer "ship next quarter."

Pass 2 — with analyze_initiative (senior-PM SOP)

IDEA-002  ·  Self-serve onboarding wizard (after deep analysis)
  reach        250                    ← scoped to "new paid SMB signups per
                                          quarter", not the raw monthly visitor
                                          count
  impact         2                    ← unchanged
  confidence   0.4                    ← dropped: activation lift assumed from
                                          competitor blog posts, not our own
                                          funnel cohort; no held-out test yet
  effort        18  person-weeks      ← raised: wizard UI 3w + AI step generator
                                          4w + analytics & variants 3w + i18n 2w
                                          + accessibility audit 2w + observability
                                          + feature-flag rollout 2w + legal review 2w
  out_of_scope  8 explicit items      ← enterprise SSO, custom branding, multi-
                                          tenant theming, native mobile onboarding,
                                          import from a competitor, video
                                          walkthroughs, role-based provisioning, SCIM
  RICE         (250 × 2 × 0.4) / 18  =  11.1   →   P1

Same idea, two passes — 3.8× score drop, P0 → P1. The difference between "ship next quarter" and "validate first." analyze_initiative is the SOP that gets you there without needing a senior PM in the room.

Add to your MCP client config

Restart your client, then talk to the AI like you always do.

{
  "mcpServers": {
    "mk-plan-master": {
      "command": "uvx",
      "args": ["mk-plan-master"],
      "env": {
        "PLAN_SOURCE": "markdown_local",
        "PLAN_PROJECT_ROOT": "/path/to/your/project"
      }
    }
  }
}
Read the docs → Sibling → mk-spec-master