
monday-crm
Run your sales pipeline in monday CRM from plain language. Start the day with a ranked deal briefing, build a forecast, turn meeting notes into deal updates, set up a CRM workspace from scratch, keep your data clean, manage sequences end-to-end, log calls and meetings to timelines, analyze team activity and rep performance, review why closed deals were won or lost, and set up automations — every result written straight back into monday. Built on the official monday MCP connector.
- version
- 0.6.3
- GitHub stars
- 440
Install
/plugin install monday-crm@monday-mcpRun it inside Claude Code after adding the marketplace with /plugin marketplace add mondaycom/mcp.
Contents
Discovered from sourceSkills 10
Activity Insights
Flow: Trigger → Connector check → Resolve board → Build query → Fetch insights → Synthesize.
Input
- Optional: argument describing the analysis (e.g., "rep activity this week", "call breakdown for the team").
- Optional: rep name, date range, or grouping preference.
Output
A synthesized summary with specific numbers and rep-level breakdowns. Never raw JSON.
Knowledge
get-activity-insightsreturns aggregated counts — not individual activity records. For activity history with content, useget-timeline-items.- Default time range is 7 days — no need to pass a date if the user asks about "recent" or "this week".
- groupBy accepts 1–2 fields:
["type"]for activity breakdown;["userId", "type"]for per-rep breakdown;["userId"]for rep totals only. board_idis required — always resolve it before calling the tool.- Present results as natural language insights — never dump the raw results array.
Tools (MCP)
get-activity-insights— aggregated activity stats (counts, duration) grouped by rep, type, or item.get_user_context— user identity and account info.search/get_board_info/get_board_items_page— resolve boards and items.list_users_and_teams— resolve rep names to user IDs for filtering.get-timeline-items— fallback for item-level activity detail (content, not aggregates).
When to use each groupBy
| User says | groupBy | Notes |
|---|---|---|
| "How many calls did each rep make?" | ["userId", "type"] | Per-rep breakdown |
| "What's the activity breakdown this week?" | ["type"] | Team totals by type |
| "Who's the most active rep?" | ["userId"] | Rep totals only |
| "How many emails did John send?" | ["type"] | + userIds filter |
| "Activity on the Acme deal?" | ["type"] | + itemIds filter — or use get-timeline-items for content |
| "Compare rep performance last month" | ["userId", "type"] | Set fromDate/toDate |
Step 0: Connector check
- Call
mcp__plugin_monday-crm_monday__get_user_context. On error → print connector install prompt, stop.
Step 1: Resolve board
get-activity-insights requires a board_id.
- If a board name is clear from the argument →
mcp__plugin_monday-crm_monday__searchormcp__plugin_monday-crm_monday__get_board_infoto resolve the ID. - If multiple CRM boards exist → ask: "Which board should I analyze — Deals, Contacts, or Leads?"
- No board context →
mcp__plugin_monday-crm_monday__search({ searchType: "BOARD", searchTerm: "deals" })to find the most likely CRM board. Still ambiguous → ask.
Step 2: Build query parameters
Parse the argument:
groupBy:
- Reps, "who", "by rep", "each rep" →
["userId", "type"] - "breakdown", "by type", "what kind" →
["type"] - Default →
["userId", "type"]
Date range:
- "this week" → 7-day default (no params needed)
- "last month" →
fromDate: 30 days ago - "today" →
fromDate: start of today - Explicit dates → parse and pass
fromDate/toDate
Filters:
- Rep name mentioned → resolve via
mcp__plugin_monday-crm_monday__list_users_and_teams, passuserIds - Item/deal name mentioned → resolve item ID, pass
itemIds(or redirect toget-timeline-itemsfor content)
aggregationType: default count. Use sum / avg for duration questions ("how long were the calls").
Step 3: Fetch and synthesize
- Call
mcp__plugin_monday-crm_monday__get-activity-insightswith resolved parameters. - If
total_results === 0: "No activities found on <board> in the last <window>. The team may not have logged activities yet, or try a wider date range." - Synthesize results:
- Lead with the headline: "Your team logged 92 activities this week."
- Break down by type: "42 emails, 28 calls, 15 meetings, and 7 notes."
- Call out top performers if grouped by rep: "Alex led with 34 activities, followed by Sam (28) and Jordan (19)."
- Flag low activity if relevant: "4 reps logged fewer than 5 activities this week."
Cross-skill handoffs
- To log-activity: insights show a rep with zero activity → "Want to log a recent call or meeting for them?"
- To run-sequence: low outreach volume → suggest enrolling contacts in a sequence.
- From daily-briefing: briefing surfaces activity gaps → this skill provides the full breakdown.
- To get-timeline-items: user asks for actual content (what was said, meeting notes) rather than counts.
Error handling reference
| Failure | Behavior |
|---|---|
| Connector missing | Stop; print install prompt. |
| Board not resolved | Ask user to specify the board. |
| Tool unavailable | "Activity insights aren't available on the connector for your account yet." |
| No results | Confirm date range; suggest widening. |
| Rep name not found | Ask for clarification or list available reps via list_users_and_teams. |
| Item-level content request | Redirect to get-timeline-items; get-activity-insights operates at board level. |
Completion criteria
- Connector check passed.
-
board_idresolved before calling the tool. - Query parameters derived from context — not hardcoded defaults.
- Results synthesized into natural language — no raw JSON.
- Zero-result case handled gracefully.
- Item-level content requests redirected to
get-timeline-items.
Automate CRM
Flow: Detect intent → Resolve board → Describe automation → Create / List / Manage → Confirm
Input
- Optional: automation description via argument (e.g., "notify owner when Stage = Won").
- Optional: board name or type (Deals, Contacts, Leads).
Output
- Create: active automation on the target board, confirmed with a summary of what it does.
- List: formatted table of automations currently active on the board.
- Manage: automation activated, deactivated, or deleted, with confirmation.
Knowledge
Most common CRM automations (by account usage)
| Trigger | Action | Accounts |
|---|---|---|
| Status changes to something | Move item to group | 9,821 |
| Status changes to something | Notify someone | 6,482 |
| Status changes to something | Set date | 6,341 |
| Item created | Notify someone / assign / set date | 10,019 |
| Date arrives | Notify / change status | 4,972 |
| Button clicked | Any action | 3,015 |
| Status changes from X to Y | Move / notify | 1,721 |
The dominant CRM pattern: status change → move to group. When in doubt, this is what most users want.
Automations vs. Workflows
- Automations (
create_automation) — board-scoped trigger/action rules. Active immediately on creation. Use for CRM daily operations. - Workflows (
create_workflow) — workspace-level, cross-board objects. Start as drafts; must be published. Use only when explicitly asked.
Known limitations
- No date arithmetic. Engine only accepts static dates — cannot compute "7 days from today". Offer
todayas fallback or a periodic trigger. - Column resolution. Tool matches columns by semantic similarity. If a column doesn't exist, the tool returns
needs_clarification. - One trigger per automation.
- Legacy automations are read-only —
list_automationsreturns them but they cannot be modified via MCP.
needs_clarification response
When create_automation returns needs_clarification, present each unresolvedField with available options, collect the answer, then retry.
Step 0: Connector check
mcp__plugin_monday-crm_monday__get_user_context. On error → print install prompt, stop.
Step 1: Detect intent
| Intent | Trigger signals |
|---|---|
| create | "set up", "create", "automate", "when X then Y", default |
| list | "what automations", "show automations", "which rules" |
| manage | "turn off", "disable", "delete", "activate", "remove automation" |
Step 2: Resolve board
- Extract board reference from argument (Deals, Contacts, Leads, or specific name).
- If mentioned →
mcp__plugin_monday-crm_monday__searchorget_user_contextfavorites. - If not mentioned → ask: "Which board? (e.g. Deals, Contacts, Leads)"
Step 3: Create automation
3a: Clarify if vague
If the user says something generic, present top 3 patterns:
"What should trigger it? Common CRM automations: 1. Stage = Won → notify owner + move to Closed Won group 2. New deal created → assign + set close date 3. Close date arrives → notify owner Or describe what you want."
3b: HITL gate before creating
"Create this automation on [board name]?"
When: Stage → Won Action 1: Notify [deal owner] Action 2: Move item to Closed Won group(yes / edit / cancel)
On "yes" → mcp__plugin_monday-crm_monday__create_automation({ boardId, userPrompt }).
3c: Handle needs_clarification
If returned: parse unresolvedFields, present options to user, incorporate answer, retry once.
3d: Confirm
On status: "activated":
"Done. Automation is live on [board name]. From now on: when Stage = Won → [owner] is notified + item moves to Closed Won."
Step 4: List automations
mcp__plugin_monday-crm_monday__list_automations({ boardId }).- Format as table: Name, Trigger, Status.
- Note legacy automations as read-only.
- Offer next action: "Want to turn any off, or set up a new one?"
Step 5: Manage (activate / deactivate / delete)
- Resolve ID via
list_automationsif needed. - For delete: explicit irreversibility warning: "Delete '[name]'? This can't be undone. (yes / cancel)"
mcp__plugin_monday-crm_monday__manage_automations({ workflowId, action }).- Confirm: "Done. '[name]' is now [state]."
Cross-skill handoffs
- From workspace-builder: after building a workspace, suggest top-3 automations.
- From log-activity: if a user mentions repeating a notification manually, suggest automating it.
Error handling reference
| Failure | Behavior |
|---|---|
| Connector missing | Step 0 stops; print install prompt. |
| Board not found | Broaden search; ask user. |
needs_clarification | Present unresolved fields; gather answers; retry once. |
| Date arithmetic requested | Explain limitation; offer today or periodic trigger. |
| Legacy automation on manage | "This automation was set up in an older way and can't be modified here." |
| Delete on legacy | Same as above. |
| Create fails after retry | Surface error; suggest monday.com UI as fallback. |
Completion criteria
- Connector check passed.
- Intent classified (create / list / manage).
- Board resolved before any tool call.
- User confirmed automation via HITL before
create_automation. -
needs_clarificationhandled: fields presented, user answered, retried. - Date arithmetic limitation surfaced if relevant.
- Delete: explicit irreversibility warning shown.
- Legacy automations flagged as read-only.
Daily Briefing
Builds a prioritized brief over the user's monday CRM data. By default the brief is shown in chat only; it is posted to monday only when the user asks.
Board type drives the content: pipeline boards get deal buckets and totals, contacts/accounts boards get follow-up queues and relationship health, leads boards get inbound status. With no CRM board, the skill asks a couple of questions and builds a brief from the answers.
Reference files (read when the step says so):
references/output-config.md— destination, verbosity, sections, style, saved preferences.references/templates.md— brief templates per board type.- Worked runs:
examples/01-default-mode-admin.md,examples/02-non-admin-fallback.md.
Flow: Connector check → Mode + config → Boards → Board type → Schema → Pull → Synthesize → Render → Publish (opt-in) → Share (opt-in) → Proactive (opt-in) → Close.
Input
- Optional: board name or ID.
- Optional: mode (Default / Silent / Proactive) and output config in the prompt or saved preferences.
Output
- Chat brief (default): rendered from
references/templates.md. - monday artifact (opt-in): an update on the user's "My Morning" item, or a private doc
Morning Briefing — <weekday>, <Mon DD>, <YYYY>. - Share (opt-in): notification to a teammate pointing at the posted brief.
- Proactive (opt-in): nudge updates on going-cold records and notifications for items due today.
Where activity lives (what this skill reads)
- Timeline (
get-timeline-items) — calls, meetings, emails and notes logged on the CRM item, including everything log-activity writes and synced emails. - Updates feed (
get_updates) — team comments and the meeting recaps meeting-to-deal posts. - Board activity (
get_board_activity) — column changes such as stage moves. The brief reads all three; none of them alone gives the full picture.
Cross-skill handoffs
- To forecast: for period views (this quarter, by close month, commit vs best case), suggest
/monday-crm:forecast. - To data-cleanup: if more than 30% of records are unowned or core fields are missing on most items, suggest
/monday-crm:data-cleanup. - To log-activity: for a record in Going cold, offer
/monday-crm:log-activityto log the latest touch. - To meeting-to-deal: if recent Notetaker meetings are not linked to any deal, suggest
/monday-crm:meeting-to-deal.
Step 0: Connector check
get_user_context. If the tool is missing, errors with an auth error, or the user has no workspace: print "I don't see the monday connector active on this session. Install it from https://monday.com/mcp, then run this skill again." and stop. Otherwise cache the user id and name.
No write happens before Step 8. With the default chat destination nothing is written to monday except Share (Step 9) or Proactive (Step 10) actions the user explicitly approved.
Step 1: Mode and output config
Output config: read references/output-config.md and resolve destination (default chat), verbosity, sections and style.
Write mode (only matters when something will be written):
- Default — one confirmation before each publish, share or proactive batch.
- Silent — no confirmations; only the brief itself is posted (when the destination asks for it). No shares, no proactive writes.
- Proactive — ask once: "Proactive mode will post a nudge update on going-cold records and notify owners about items due today. Approve all / review each / deny?" Cache the answer. Triggers: "morning briefing proactive", "mode: proactive".
Hard rail in every mode: no deletes, no column-value edits of any kind (this skill only posts briefs, updates and notifications), no cross-workspace moves.
Step 2: Resolve board(s)
- Argument given: numeric → board id; text →
search({ searchType: "BOARD", searchTerm: <arg>, strategy: "SPEED" }). One match → use it; several →AskUserQuestion. - No argument: scan
get_user_contextfavorites and relevant boards for names matching- pipeline:
deal|opportunit|pipeline|sales - contacts/accounts:
contact|account|client|customer - leads:
lead|prospect|inbound - relationships:
partner|renewal|relationship - tasks (kept for Step 5f):
task|to-do|action|follow-up
- pipeline:
- Nothing found →
searchfor"crm", then"deals", then"contacts". - Still nothing → standalone (Step 2c).
- Several boards of the same type →
AskUserQuestionwith the board names plus "all of them". Remember the choice for the session. - Boards of different types (e.g. a pipeline and a contacts board) → brief both in one output, one section group per board.
Step 2b: Classify board type
get_board_info({ boardId, filters: { columns: { only: true } } }), then:
| Type | Signals |
|---|---|
pipeline | a status column with stage-like labels (an is_done: true or Won/Lost label) + a numbers column with a currency unit |
leads | a status column without is_done and lead-like labels (New, Contacted, Qualified, Disqualified) |
contacts | mostly text / email / phone columns, no Won/Lost pattern |
accounts | company-named items with numbers (revenue/ARR) and status columns |
general | anything else — treat as accounts |
Step 2c: Standalone (no board)
Ask in one AskUserQuestion call: "What meetings or calls do you have today?" and "Which deals, accounts or relationships need your attention this week?". Build the Standalone template from the answers (Step 6d), print it in chat, and skip Steps 3–10 except the Step 10 chat line.
Step 3: Resolve columns by type
Columns are resolved by type, with titles only as hints (boards are often not in English). Use get_column_type_info when a column is ambiguous; a missing concept is skipped and noted under Data hygiene.
| Concept | Type | Title hints | Board types |
|---|---|---|---|
| Stage / status | status | stage, status | all |
| Owner | people | owner, rep, assigned | all |
| Value | numbers (currency) | value, amount, revenue | pipeline, accounts |
| Probability | numbers (%) | probability, % | pipeline |
| Close date | date | close, expected, target | pipeline |
| Last touch | date | touch, interaction, contacted | all |
| Next follow-up | date | follow-up, next step | contacts, accounts |
| Company | text | company, account, organization | contacts, leads |
Step 4: Terminal labels (pipeline and leads)
From the stage column's labels: Won = is_done: true; Lost = text containing lost / perdido / verloren / perdu; for leads also Disqualified / Converted. No is_done label on a pipeline board → ask which label means Won. Cache the label ids. Status filters compare against each label's id from get_board_info, not its index (the index is display order; filtering on it silently returns the wrong items).
Step 5: Pull data
Window for "recent" = the last 24h (72h on Mondays, so the weekend is covered).
5a — Items
- Pipeline:
get_board_items_page({ boardId, includeColumns: true, filters: [{ columnId: <stage>, operator: "not_any_of", compareValue: [<terminal label ids>] }], limit: 500 }); follownextCursorwhilehas_more, up to 2,000 items (above that, add a sampling note). Useboard_insightsfor totals when the board has more active items than you pulled. - Contacts / accounts: same call without the stage filter.
- Leads: same as pipeline with the leads terminal labels; order by
__creation_log__desc for recent additions.
5b — Board activity
get_board_activity({ boardId, fromDate: <window start ISO>, toDate: <now ISO>, includeData: true }) — stage moves and other column changes. Without includeData the entries carry no item, column or value, so they can't be read; on busy boards pass itemIds for the active items to keep the payload small. Yesterday's movements = stage changes into a Won or Lost label inside the window (not "updated in the last 24h", which also catches edits to old deals). For leads boards use a 7-day fromDate instead, so Going stale (no status change in 7 days) can be computed; movements still use only the recent window.
5c — Updates feed
get_updates({ objectType: "Board", objectIds: ["<boardId>"], includeItemUpdates: true, fromDate: <window start>, toDate: <now>, limit: 100 }) — team comments and meeting recaps (recognize meeting-to-deal recaps by their ref meeting-to-deal/ line).
5d — Timeline for the items that matter
After a first synthesis pass (Step 6) has picked the items in Needs you today, call get-timeline-items({ item_id: <id>, limit: 10 }) for up to 10 of them, Going cold, Follow-up and Slipping candidates first (those are the buckets a newer touch can change). Entries come newest first, so one page is enough. A deal's timeline also shows activity from its linked contact on other deals: count it as a relationship touch, and say "last contact touch" when the newest entry isn't about this deal. Emails, meetings and calls often come back with type custom and a custom_activity_id: call get-custom-activities once and map ids to names (Email, Meeting, Call, …) to classify them. Use the entries to:
- correct "last touch" when the timeline is newer than the date column (a call logged yesterday means the deal is not going cold), and
- count calls, emails, meetings and notes in the window for the activity line, labelled "among the items checked".
A meeting-to-deal recap from 5c (an update with
ref meeting-to-deal/) also counts as a touch on its deal, dated by the meeting date in its second line. Items not checked keep their date-column value and get(timeline not checked)when they land in Going cold. Skip this step intldrverbosity.
5e — Notetaker meetings
Only if recent_meetings or activity_summary is on: explore_meetings({ start_time_from: <window start>, start_time_to: <now>, limit: 20 }), then get_meetings_content({ ids: [...], include_summary: true, include_action_items: true }). Match each meeting first by an existing recap in 5c whose ref line carries the meeting id (reuse its first key point as the takeaway), then by attendee domain or item name; keep unmatched meetings for the "not linked to a deal" line. Any error → leave the section out.
5f — Tasks due today
If a tasks board was found in Step 2: its items whose due date is today (filter on its date column). Otherwise: pulled items with a date column other than the close date equal to today.
Permissions and rate limits
- A 403 on 5b or 5c → add to Data hygiene: "Activity log unavailable — your monday account can't read this board's activity. A board owner can check your access." and continue.
- 429 → back off 3 times (1s, 2s, 4s); then "monday is rate-limiting right now. Retry in a minute, or narrow to one board." and stop.
Step 6: Synthesize
Each bucket below maps to the section of the same name in references/templates.md. Apply verbosity and section filters first, then de-duplicate: a record shows in its highest-priority printed bucket only; other signals are added as text (— also going cold (19 days)). Header counts are the counts actually printed.
6a — Pipeline
Priority: Tasks due today > Closing today > Slipping > Going cold > Follow-up > On track > New this week.
| Section | Rule |
|---|---|
| Tasks due today | in the Step 5f list |
| Closing today | close date = today, not terminal |
| Slipping | close date in the past, not terminal |
| Going cold | last touch (after the 5d correction) more than 14 days ago |
| Follow-up | last touch more than 7 days ago and probability ≥ 50% |
| On track | probability ≥ 70%, last touch within 7 days, close date within 30 days |
| New this week | created in the last 7 days |
| Recent meetings | Step 5e meetings, matched first |
| Yesterday's movements | Step 5b stage changes into Won / Lost |
Totals: active pipeline Σ value; weighted Σ value × probability; closing this week count and Σ value. Activity line: counts from 5d (and 5c recaps) in the window.
6b — Contacts / accounts
Priority: Tasks due today > Overdue follow-ups > Follow up today > Going cold > Recently active > New this week. Overdue = next follow-up in the past; Follow up today = next follow-up today; Going cold = last touch more than 21 days ago and no follow-up date; Recently active = updated in the window. No money totals; show counts, unowned share and records without a follow-up date.
6c — Leads
Unassigned (owner empty), Hot leads (early or qualified status, created in the last 7 days), Going stale (created more than 14 days ago and no status change in 7 days), Recent additions (created in the window). Totals: open, unassigned, conversion rate if terminal labels exist.
6d — Standalone
- Meetings today with something at stake. 2. Items the user called urgent. 3. Other deals or relationships the user mentioned.
Step 7: Render
Apply verbosity, sections and style from Step 1, then fill the matching template in references/templates.md. Always print the brief in chat.
Step 8: Publish (when the destination is monday or doc, or Step 9 needs a posted brief)
- Target:
monday(or a Share request):search({ searchType: "ITEMS", searchTerm: "My Morning", strategy: "SPEED" }), keeping items whose board (get_board_info) lists the user as owner or subscriber. One → post there. None or several → fall back to a doc.doc, or the fallback: a private doc in the CRM board's workspace.
- Idempotency (one brief per day per target):
- Item:
get_updates({ objectType: "Item", objectIds: ["<item id>"], limit: 25 }); if an update containsdaily-briefing · <today YYYY-MM-DD>, post the new brief as a reply (create_updatewithparentIdof that update) instead of a new top-level update. - Doc:
read_docs({ type: "workspace_ids", ids: ["<workspace id>"], order_by: "created_at", limit: 5 })and look for the exact title — results are newest first and carry each doc's full body, so keep the page small; DOCUMENTS search can miss a doc created minutes ago; if today's exact title exists, append withupdate_doc(add_markdown_content, starting with## Refreshed at <HH:MM>).
- Item:
- Confirm (Default mode): "I'll post this brief as <an update on 'My Morning' | a private doc 'Morning Briefing — …'>. OK? (yes / no)". Silent and Proactive skip it.
- Write:
- Item:
create_update({ itemId, body: <brief as HTML> }). - Doc:
create_doc({ location: "workspace", workspace_id: <board's workspace id>, doc_kind: "private", doc_name: "Morning Briefing — <weekday>, <Mon DD>, <YYYY>", markdown: <brief> }).
- Item:
- Permission error → try the doc; if that fails too, say "Couldn't post to monday (permission error). The brief above is complete."
Step 9: Share (opt-in)
Only when the user asked ("share with my manager", "post to the team") and a brief was posted in Step 8 (post it first if needed, with its confirmation).
- Resolve the recipient:
list_users_and_teams({ name: "<name>" }); if no name was given, ask. - Confirm in Default mode, then
create_notification({ user_id: "<recipient>", target_id: "<item id of the 'My Morning' item, or the update id>", target_type: <"Project" for the item | "Post" for the update>, text: "Morning briefing for <Mon DD>" }). A doc has no notification target: share the doc link in chat instead.
Step 10: Proactive (opt-in) and close
Proactive (approved in Step 1): first get_updates({ objectType: "Item", objectIds: [<candidate ids, up to 25>], limit: 25 }) and skip any record that already has a Claude nudge: update from the last 7 days. Then, for Going cold records, create_update({ itemId, body: "<b>Claude nudge:</b> No activity in <X> days. What's the next step?" }); for Closing today and Overdue follow-ups, create_notification({ user_id: "<owner>", target_id: "<item id>", target_type: "Project", text: "Action due today on <name>" }).
- "Review each" → one line per action; yes / no / stop.
- More than 20 actions → list them in chat and ask once whether to run all.
- Only items the user owns, unless they are a board owner and approved Proactive this session.
Close — print one line that matches what happened:
- chat only:
Brief for <date>: <N> items scanned, <M> need attention. - posted:
Posted Morning Briefing — <date>: <url>. <K> proactive actions, <P> pending.If any write failed, list what was written. Never attempt compensating deletes.
Error handling
| Failure | Behavior |
|---|---|
| Connector missing | Step 0 stops with the install message |
| No CRM board | Standalone brief (Step 2c) |
| Board over 2,000 active items | Cap, note the sampling, totals from board_insights |
| Activity / updates 403 | Note in Data hygiene; continue |
| Timeline call fails for an item | Use the date column for that item |
| Notetaker unavailable | Leave out Recent meetings |
| 429 | Back off 3 times, then stop with a retry message |
| Publish permission error | Doc, then chat only |
| Same-day brief already posted | Reply (item) or append (doc); never a second copy |
Completion criteria
- Step 0 passed; board type detected (or standalone).
- Brief printed in chat; nothing written to monday unless the destination was
monday/docor the user asked. - Every section in the output exists in the template, and every header count equals its line count.
- Up to 10 Needs-you-today items (Going cold / Follow-up / Slipping first) had their last touch checked against the timeline (except
tldr); unchecked ones are marked. - No record got a second Claude nudge within 7 days.
- At most one brief per target per day (reply or append on re-runs).
- Notifications used
user_id,target_id,target_type; no column values were changed. - Failed writes listed in the closing message.
Data Cleanup
Two jobs in one skill for the recurring "my CRM is messy" pain:
- Health check (report-only): a scored structural audit of a CRM board — missing-data patterns, stalled groups, abandoned columns, automation gaps, and a 0–100 data-quality score — published as a diagnosis doc. No writes.
- Cleanup (fix): audit the board for data gaps, let the user pick which to fix, then run a bounded, idempotent write loop.
Flow (report): Trigger → Gather → Score (5 strands) → Publish diagnosis doc → offer to fix. Flow (fix): Trigger → Audit → User picks gaps → Plan writes → Execute (bounded, idempotent) → Summary.
Input
- Optional: board name/ID via argument.
- Optional: pre-declared mode (Default / Silent / Proactive).
Output
- α (default): Bounded write loop on the chosen board. Normalizes phone/country/email; can also batch-set owner / source / last-touch / stage when the user explicitly picks those gap types and signals are clean. A
Hygiene fix — <Mon DD>doc lists every change withGenerated by Claude · data-cleanupfooter. - β (opt-in): A "before/after" snapshot doc (preserves the prior state for ~30 days, in case a pass over-corrected). User is asked at Step 4.
- Proactive extension: Out of scope — data-cleanup is already a write skill; proactive doesn't change its behavior. Default mode + batched confirm is the only write surface.
Knowledge
- Worked runs (read for the expected tone and output shape):
examples/01-phone-email-normalization.md. - Gap taxonomy + audit rules (§ Step 3).
- Normalization recipes (§ Step 5).
- Shared artifact conventions (§ Shared patterns).
Tools (MCP)
get_user_context,list_workspaces,search,get_board_info,get_column_type_info,get_board_items_page,board_insights— Gather.list_users_and_teams— enumerate users for bulk-assign owner step.change_item_column_values— the core write. Loop with bounded concurrency.create_doc/create_update— publish summary + before/after snapshot.all_monday_api— escape hatch for column types not exposed bychange_item_column_values. Forcountrycolumns, use:change_multiple_column_valueswithcolumn_values: {"<country_col_id>": {"countryCode": "<ISO2>", "countryName": "<name>"}}. Do not freeform the mutation type — only this shape is supported for country columns.
Cross-skill handoffs
- From daily-briefing: if the daily brief flags >N hygiene issues or >30% unowned deals, suggest this skill (health check first, then fix).
- From forecast / workspace-builder: if forecast-critical fields are missing or a freshly built board needs a fill-rate audit, route here.
- To daily-briefing / forecast: clean data feeds them — point the user there once cleanup is done.
Step 0: Connector check
Goal: Fail fast if the user has no monday MCP connection — no partial writes, no guessing.
- Try
mcp__plugin_monday-crm_monday__get_user_context. - If the tool is missing, returns an auth-style error, or the user has no accessible workspace: print "I don't see the monday connector active on this session. Install it from https://monday.com/mcp, then run this skill again." and stop.
- If it works, cache
user.id+user.namefor artifact metadata.
Step 1: Detect mode
- Default — confirm before each batch (not each item) of writes.
- Silent — skip batch confirms; still publishes the summary doc.
- Proactive — same as Default for this skill (proactive doesn't make sense — every write is intentional). If user pre-declared Proactive, treat it as Default and note in chat.
Hard safety rail regardless of mode: no deletes, no amount-column writes, no cross-workspace moves, no normalization on columns the user didn't pick. Stage / owner / source / last-touch edits ARE allowed when the user explicitly selected that gap type at Step 4 — data-cleanup is the canonical place for board-wide column rewrites that other skills point users at.
Also detect report vs. fix intent:
- Report ("health check", "audit", "what's broken", "what are the data gaps", "board is messy") → run Step 2.5: Health-check report (report-only), publish the scored diagnosis doc, then offer to proceed to fixes.
- Fix ("clean", "fix", "normalize", "fill in") → skip to Step 3.
- Ambiguous → ask once: "Want a read-only health check (scored report, no changes) or to clean up the data now?"
Step 2: Resolve board
Goal: Land on a single boardId before reading any data.
- If the user passed a board via argument: numeric → use as
boardIddirectly; string →mcp__plugin_monday-crm_monday__searchwithsearchType: "BOARD". One match → use it; multiple →AskUserQuestion. - If no argument:
get_user_context→ scanrelevantBoards+favoritesfor names matchingdeals|opportunities|pipeline|leads|sales|contacts|accounts. One candidate → use it; multiple →AskUserQuestion; zero →list_workspaces→search. Still zero → stop with "I don't see a CRM-shaped board in your workspaces. Tell me the board name or ID, or run/monday-crm:workspace-builderto create one."
Step 2.5: Health-check report (report-only path)
Goal: Produce a scored structural audit as a doc — no writes. Run only when the user asked for a report/health check (see Step 1 intent). Otherwise skip to Step 3.
Pull board schema (get_board_info, get_column_type_info), items (get_board_items_page, up to 2K most-recent), aggregate stats (board_insights — known ~9% baseline error rate; on failure skip that strand and note it), and activity (get_board_activity, or derive staleness from item updated_at). Then score five strands:
- Missing data — required fields (stage, owner, value, close_date) blank on >25% of items; compute fill-rate per column.
- Stalled groups — groups with no item updates in >30 days.
- Column drift — columns populated on <5% of items over 90 days (likely abandoned → suggest archive).
- Automation gaps — stage-based automations absent on deal boards (probe via
all_monday_api; if scope unavailable, skip with note). - Structure — duplicate columns, no groups, missing required column type.
Scoring (each strand 0–100, floor 0): Missing data 100 − (15·P0 + 8·P1 + 3·P2) · Stalled 100 − 15/group · Drift 100 − 8/column · Automations 100 − 20/missing stage automation · Structure 100 − 10/issue.
Overall = weighted avg: Missing 40% + Stalled 20% + Drift 15% + Automations 15% + Structure 10%.
Severity: P0 = fill-rate <50% on required fields, stall >90d, or no stage automation (blocks forecast/reporting). P1 = fill-rate 50–75%, stall 30–90d, column <5% populated. P2 = structural/minor.
Publish: create_doc titled Board Health Check — <board> — <Mon DD>, body ends with the visible footer Generated by Claude · data-cleanup · <ISO>. Sections: overall score + 5-strand breakdown, P0 fixes ([P0] <issue> → <fix>), P1/P2 batched, automation recommendations, column-archive list. Healthy-board shortcut: score ≥90 and zero P0/P1 → skip the doc, print the score + inline P2 notes.
Then offer to fix: "Want me to fix the fixable gaps now? I can normalize phone/email/country and bulk-set owner/source/stage within a scope you pick." → yes routes to Step 3; no stops here. Report path writes nothing.
Step 3: Audit — surface the gaps (Gather + Synthesize)
Goal: Compute a gap report grouped by fix-type, with a concrete count per type.
Pull all items via get_board_items_page (paginated up to 5000, then sample with disclosure). For each item, check:
| Gap type | Audit rule | Fixable here? |
|---|---|---|
| Missing email | email column empty AND contact name present AND company resolvable (see note below) | ✅ (heuristic guess from company domain — flagged with Source = guessed) |
| Missing phone | phone column empty | ❌ (no source — flag only) |
| Phone format | Phone present but no country code, or contains letters / >2 separators | ✅ (E.164 normalization) |
| Country code missing | country column empty AND phone has parseable country code OR email domain has CCTLD | ✅ |
| Email case | Mixed-case (John.Doe@Acme.COM) | ✅ (lowercase) |
| Stale last-touch | date last-touch >90d AND stage active | ✅ (set to "today" only if user picks; never overwrites a more-recent date) |
| Owner missing | people owner empty AND stage active | ✅ (bulk-assign within a user-picked group/scope) |
| Stage drift | items in non-canonical groups; user explicitly wants normalization | ✅ (bulk-set within user-picked scope) |
| Amount missing | numbers value empty AND stage past "qualifying" | ❌ (flag only — forecast integrity rail) |
| Source missing | status source column empty | ✅ (bulk-set within user-picked scope) |
"Company resolvable" definition for email guessing: look for (a) a text or email column containing a domain (@ or .), (b) a board_relation column linking to an accounts board, or (c) an item name matching First Last @ CompanyName. If none found, mark the item as not guessable.
Resolve columns by type, not English name (same rule as daily-briefing). Skip gap types where the matching column doesn't exist.
Produce the audit summary in chat:
## Audit — <board name>
**Items scanned:** N
**Gaps found:**
- ✅ Fixable (column normalization): <N> phone formats · <N> mixed-case emails · <N> missing country codes · <N> guessable missing emails
- ✅ Fixable (bulk-set within picked scope): <N> missing owners · <N> stale last-touch · <N> missing sources · <N> stage drift
- ⚠️ Flag-only: <N> missing phones (no source) · <N> missing amounts (forecast integrity rail)
Pick which fixable gaps to run, or "all". Flag-only items list in the summary doc — no writes.
Step 4: User picks (Synthesize)
First, ask whether to create a before/after snapshot: "Want a snapshot doc so you can see exactly what changed and roll back individual cells if something looks off? (yes / no)"
Then AskUserQuestion, multiSelect:
- "Phone formats (N items)"
- "Mixed-case emails (N items)"
- "Country codes from phone/email (N items)"
- "Guess missing emails from company domain (N items) — heuristic, may miss"
- "Bulk-assign owner (N items) — requires picking a scope and a target owner"
- "Backfill stale last-touch (N items) — will only fill empty or older-than-90d cells"
- "Bulk-set source (N items) — requires picking a scope and a source value"
- "Normalize stage drift (N items) — requires picking a scope and target stage"
- "All column-normalization fixes" (the first four — bulk-set ones still need scope)
Scope picker for bulk-set options: if the user picked multiple bulk-set options (owner / source / stage / last-touch), ask once: "Should the same scope (group / filter) apply to all of them, or do you want to set each separately?" One question beats four. If "same for all" → ask scope once and apply it across all bulk-set options. If "separately" → run a scope sub-prompt per option.
For bulk-set options, use list_users_and_teams to present available owners/teams when the target owner needs to be selected.
If user picks "Guess missing emails", surface a strong warning: "Email guessing uses a <first>.<last>@<companydomain> pattern. Accuracy varies widely — works best for B2B companies with standard email formats, unreliable for personal domains or non-Western name conventions. Only recommended for Leads boards where invalid sends are tolerable. Continue?"
Hard rule: no fix runs without an explicit Step 4 selection (and a scope-picker confirm for bulk-set options). Empty selection → stop with summary-only.
Step 5: Plan + execute (Publish)
Goal: Bounded, idempotent loop. Every write is reversible.
For each picked gap type, build a write plan: list of (itemId, columnId, oldValue, newValue, reason).
Normalization recipes
- Phone format → E.164:
- Strip non-digit/
+characters. - If no leading
+AND country column is populated → prepend dial code per country. - If no leading
+AND country empty AND phone starts with a known country prefix (e.g.,1for US,44for UK) → prepend+. - Edge case: phone is too short (<7 digits) or too long (>15 digits) → skip with reason "unparseable".
- Strip non-digit/
- Email lowercase:
value.toLowerCase(). Only write if changed. - Country code from phone: parse leading dial code → ISO-2 country code → write to country column using
all_monday_apiwith{"countryCode": "<ISO2>", "countryName": "<name>"}shape. - Country code from email CCTLD: if email ends in
.uk/.de/.fretc. and country empty → infer. - Email guess: for items with name + resolvable company domain, try
<firstname>.<lastname>@<domain>lowercase. Add aSource = guessedstatus flag on the item so the user can filter and verify later. If a source/status column is missing, prompt the user once to add one — never write the email without a verifiability flag. - Bulk-set owner / source / stage: within the user-confirmed scope (group / status filter from Step 4), apply the chosen target value via
change_item_column_values. Never extend beyond the picked scope. - Backfill stale last-touch: set to today's date only on items where last-touch is (a) empty, or (b) older than 90 days AND user explicitly picked the "stale last-touch" gap type. Never overwrite a more-recent date.
Bounded execution
- Cap total writes at 500 per run. Above that, prompt: " writes planned, capped at 500 per run. Run first 500 now and re-trigger for the rest, or narrow your selection?"
- Execute via
change_item_column_values, batched by item (one call per item updates multiple columns at once). Concurrency: 5 in flight max to avoid rate limits. - Confirm before write (Default mode) — single batched plan:
- "Plan: phone normalizations · email lowercase · country fills · owner assignments (scope: ) ·
source backfills (scope: ) · stale-last-touch fills · stage drift fixes (scope: → ). Proceed? (yes / show 3 examples per fix-type / no)."
- "Plan: phone normalizations · email lowercase · country fills · owner assignments (scope: ) ·
- After each batch of 50 writes, print progress:
Updated 50/500 cells. Continuing...
Idempotency
Compute oldValue == newValue per cell — never write a no-op (avoids audit-log noise).
Failure handling
- 429 rate limit: backoff 3x (1s, 2s, 4s). On third fail, halt the loop and emit a partial summary with "/ done; failed; re-run to continue."
- Per-item permission error: skip that item, log to summary, continue.
- Per-column write error (e.g., column type changed mid-run): skip that column on that item, log, continue.
- User halts mid-run: keep writes done so far, emit partial summary doc. Print the last item ID written so the user can pick up from there.
Step 6: Publish summary doc (Publish)
create_doc (idempotent — first read_docs({ type: "workspace_ids", ids: ["<workspace id>"], order_by: "created_at", limit: 5 }) and look for the exact title — results are newest first and carry each doc's full body, so keep the page small; DOCUMENTS search can miss a doc created minutes ago; if the same-day doc exists, append to it instead of creating a second one), title Hygiene fix — <Mon DD>. Body:
# Hygiene fix — <board name> · <Mon DD>
## Writes executed (<N>)
| Item | Column | Old → New | Scope / reason |
|---|---|---|---|
| ... | ... | ... | ... |
## Skipped (<N>)
| Item | Column | Reason |
|---|---|---|
## Flag-only (no writes)
- N items missing phone (no source — manual entry required)
- N items missing amount (forecast integrity rail — review manually)
## Undo
Every write here is reversible. The "Old" column above shows the prior value. To revert: find the row in monday and copy the Old value back in manually.
---
Generated by Claude · data-cleanup · <ISO timestamp>
Optional β: create_update on a "snapshot" item with the pre-fix state of every touched item, for 30-day rollback window. Only runs if user opted in at Step 4.
Step 7: Close the loop
One-line chat summary: Cleaned <N> cells across <M> items on <board>. <K> skipped. Doc: <url>.
If any failures: <N> failed (rate limits / permissions). Re-run to retry — already-fixed cells are idempotent.
Shared patterns
- No prefix on titles. Findability via the visible
Generated by Claude · data-cleanup · <ISO timestamp>footer in summary/snapshot doc bodies (no HTML comments — monday strips them). - Idempotency at the cell level — never write
oldValue == newValue. - Safety rail. No deletes, no amount-column writes, no cross-workspace moves, no normalization on columns the user didn't pick. Owner / source / stage / last-touch edits require an explicit Step 4 selection AND a scope-picker confirm.
- Bounded run — 500 writes max per execution. Anything bigger gets split.
- Concurrency cap — 5 in flight max.
- Type-based column resolution for non-English boards.
- Confirm in batches, not per-item.
- Skill marker is the visible footer
Generated by Claude · data-cleanup. Versions before 0.6.1 wrote an HTML-comment marker, which monday strips from saved content, so older artifacts are matched by title only.
Output template
Health check output (diagnosis doc)
Board Diagnosis — Sales Pipeline — Jun 15
**Score: 62 / 100**
| Strand | Score | Detail |
|---|---|---|
| Missing data | 55 | 12 deals missing Owner (fill-rate 78%) |
| Stalled groups | 40 | 8 deals stalled >30d in "Discovery" |
| Column drift | 85 | "Legacy Status" column — 0% fill, candidate for archive |
| Automations | 60 | No stage-move automations on this board |
| Structure | 90 | Board structure looks sound |
**P0 fixes (2)**
- [P0] Owner blank on 12 active deals → batch-assign in fix mode
- [P0] 8 deals stalled in "Discovery" >30d → review + advance or lose
**P1 fixes (1)**
- [P1] "Legacy Status" column — 0% fill over 90d → archive via Board Settings
**Automation recommendations**
- Add status-change → email-owner automation for stage moves
---
Generated by Claude · data-cleanup · 2026-06-15T09:00:00Z
Cleanup output (hygiene fix doc)
# Hygiene fix — Sales Pipeline · Jun 15
## Writes executed (3)
| Item | Column | Old → New | Scope / reason |
|---|---|---|---|
| Acme Corp — Q3 expansion | Phone | +1-555-123-4567 | +15551234567 | E.164 normalize |
| Beta Industries — pilot | Email | Mike.Jones@Beta.COM | mike.jones@beta.com | lowercase |
| Gamma Ltd — renewal | Country | (empty) | GB (United Kingdom) | from email CCTLD .co.uk |
## Skipped (0)
## Flag-only (no writes)
- 12 items missing Owner (no source — select scope then re-run to bulk-assign)
- 2 items missing Amount (forecast integrity rail — review manually)
## Undo
Every write here is reversible. The "Old" column above shows the prior value.
---
Generated by Claude · data-cleanup · 2026-06-15T09:00:00Z
Chat one-liner:
Cleaned 3 cells across 3 items on Sales Pipeline. 0 skipped. Doc: [url].
Error handling reference
| Failure | Behavior |
|---|---|
| Connector missing | Step 0 stops; print install link. |
| No board found | Step 2 stops; suggest workspace-builder. |
| Empty selection at Step 4 | Skip writes; publish summary doc with audit only. |
| 0 fixable gaps | Print "Board's already clean — N flag-only items in summary doc." |
| 429 rate limit | Backoff 3x; halt on third with partial summary. |
| Per-item permission error | Skip, log, continue. |
| Column type changed mid-run | Skip that column on that item, continue. |
| User halt | Keep writes done; emit partial summary with last-written item ID. |
| Email-guess accuracy concern | Strong warning at Step 4; Source = guessed flag on every guessed write. |
Completion criteria
- Step 0 (connector check) passed.
- User explicitly selected at least one gap type at Step 4 before any write.
- For bulk-set gap types (owner / source / stage / last-touch), a scope-picker confirm ran before write.
- Every write was non-no-op (idempotency).
- Total writes ≤ 500 (or user explicitly approved a multi-run plan).
- Summary doc lists every write (item, column, old→new, scope/reason) and every skip (with reason).
- Summary doc body carries
Generated by Claude · data-cleanupfooter. - Safety rail held: no deletes, no amount-column writes, no cross-workspace moves, no writes outside the user-selected gap types or picked scope.
- Guessed emails carry a
Source = guessedflag (or were withheld if no flag column existed).
Forecast Dashboard
Builds a native monday dashboard that renders the pipeline as a forecast — committed / best-case / pipeline / closed-won, grouped by stage × close month. Replaces the "export to CSV and pivot it" pattern that sales ops leaders do manually every Monday.
Flow: Trigger → Gather → Synthesize → Publish (α, default) → Share (β, opt-in) → Proactive extension (opt-in, hygiene fix).
Input
- Optional: board name / ID + forecast period (e.g., "Q2 2026", "next 90 days").
- Optional: pre-declared mode (Default / Silent / Proactive).
Output
- α (default): A native monday
create_dashboardwith widgets per bucket + URL. - β (Share): Viewer-permission grant to sales leader via
all_monday_api+create_notification. - Proactive extension: Hygiene fix — if a non-closed deal is missing close date,
change_item_column_values(with batched user confirm) to set a placeholder OR post a prompt update asking the owner to fill it. Missing-amount items are flagged in the dashboard description and a hygiene update is posted on the item, but the amount column itself is never written (forecast integrity rail).
Knowledge
- Worked runs (read for the expected tone and output shape):
examples/01-default-mode-admin.md,examples/02-non-admin-doc-fallback.md. - Bucket definitions: closed-won / committed / best-case / pipeline (§ Step 5).
- Shared artifact conventions (see Shared patterns section below).
Tools (MCP)
get_user_context,list_workspaces,search— board resolution.get_board_info,get_column_type_info— schema + column types (stage/amount/close-date/forecast-category).get_board_items_page— paginated pull.board_insights— aggregate fallback.create_dashboard,create_widget— α publish.create_doc— fallback for non-admins (see Error handling).create_notification,list_users_and_teams— β share.create_column— add a forecast-category column only if required to render the dashboard.change_item_column_values— proactive hygiene fix.all_monday_api— escape hatch for dashboard permissions and doc updates.
Cross-skill handoffs
- From daily-briefing: If the briefing surfaces forecast-hygiene issues (missing close date or amount on >10% of deals), the user may jump here to build the structured view.
- To data-cleanup: If >25% of deals are missing core forecast fields, suggest
/monday-crm:data-cleanupbefore publishing.
Step 0: Connector check
Goal: Fail fast if the user has no monday MCP connection.
- Try
mcp__plugin_monday-crm_monday__get_user_context. - If the tool is missing, returns auth-style error, or the user has no accessible workspace:
- Print exactly: "I don't see the monday connector active on this session. Install it from https://monday.com/mcp, then run this skill again."
- Stop. Do not proceed.
- If connector works, cache
user.idanduser.namefor artifact metadata.
PAUSE: Do not call create_dashboard, create_widget, create_column, or change_item_column_values before Step 0 passes and the user has confirmed the publish step in Step 6.
Step 1: Detect mode + confirm forecast period
Goal: Know write-confirmation policy AND lock the forecast window.
- Detect Default / Silent / Proactive per shared pattern.
- If no period declared,
AskUserQuestion: "Which period? (a) this quarter, (b) next 90 days, (c) custom." Storeperiod_start,period_end.
Step 2: Resolve the deals board (Gather)
Goal: Land on one (or user-confirmed multi) board. Same resolution path as daily-briefing Step 2. Use mcp__plugin_monday-crm_monday__get_user_context → list_workspaces → search(searchType: "BOARD", searchTerm: "deal").
Step 3: Read board schema (Gather)
Goal: Resolve columns by type — stage (status), amount (numbers with $), close date (date with "close"/"expected"), forecast category (status with commit/best-case/pipeline labels, if present).
get_board_info(boardId).get_column_type_infofor any ambiguous column.- If no forecast-category column exists AND the user wants commit vs best-case split: prompt the user — "I can add a
Forecast Categorycolumn (Commit / Best-case / Pipeline / Omit). OK?" Only create viacreate_columnin Proactive mode or after explicit user approval.
Step 4: Pull deal data (Gather)
Goal: Paginated pull over the forecast window.
get_board_items_page with filters = close_date in [period_start, period_end]. Paginate via cursor up to 2K items (same cap as daily-briefing). Same 429 / rate-limit handling.
Step 5: Synthesize (Synthesize)
Goal: Group deals into forecast buckets × close month.
Buckets:
- Closed-won — stage
is_done: true(won label). - Committed — forecast category = Commit OR (probability ≥ 80% AND stage in late-funnel).
- Best-case — forecast category = Best-case OR (probability in 50-79% AND stage in mid-funnel).
- Pipeline — everything else active.
Empty-category guard: If a forecast-category column exists but fewer than 20% of active deals have a non-empty value, surface this warning before synthesizing:
The Forecast Category column exists but 80%+ of deals haven't been categorized. I'll derive all buckets from probability + stage for now. Want to: (a) continue anyway, (b) run hygiene to prompt owners to fill it, or (c) remove the column from the forecast logic?
Wait for user choice before proceeding.
Group by close month within the period. Compute Σ amount per (bucket × month).
Step 6: Publish α — build the dashboard (Publish)
Goal: Produce a native monday dashboard with widgets per bucket, not a markdown brief.
Core call pattern:
- Idempotency:
search({ searchType: "DASHBOARDS", searchTerm: "Forecast <period>", creatorIds: [<user id>], strategy: "SPEED" }). A result titled exactlyForecast — <period>is this skill's earlier dashboard: add or refresh widgets on it instead of creating a second one. Dashboards carry no marker —create_dashboardhas no description field — so the exact name plus the creator is the key. create_dashboard({ name: "Forecast — <period>", workspace_id: "<board's workspace id>", board_ids: ["<board id>"] }).- For each bucket × month:
create_widget(dashboardId, ...)— see Widget call shapes below. - Return dashboard URL. Print it as the last line in chat.
Widget call shapes
Required fields for each widget type:
Number widget (per-bucket total):
{
"type": "numbers",
"board_ids": ["<boardId>"],
"column_ids": ["<amountColumnId>"],
"filter": { "rules": [{ "column_id": "<bucketFilterColumnId>", "compare_value": ["<label>"] }] }
}
Chart widget (buckets × close month stacked bar):
{
"type": "chart",
"board_ids": ["<boardId>"],
"column_ids": ["<amountColumnId>"],
"grouping_column_id": "<closeDateColumnId>"
}
Table widget (deal detail for committed + best-case):
{
"type": "table",
"board_ids": ["<boardId>"],
"column_ids": ["<nameCol>", "<amountColumnId>", "<stageColuumnId>", "<closeDateColumnId>"],
"filter": { "rules": [{ "column_id": "<bucketFilterColumnId>", "compare_value": ["Commit", "Best-case"] }] }
}
Non-admin fallback (§7 spec)
Non-admin users can't call create_dashboard. On permission error, ask:
I can't create dashboards on this workspace (your account lacks admin rights). Want me to: (a) publish a doc-version with the same forecast (summary tables), (b) stop so you can ask your admin to install the dashboard, or (c) try a different board?
Route to create_doc on option (a).
Step 7: Share β — viewer access for sales leader (opt-in)
Goal: Grant dashboard viewer permission + notify.
list_users_and_teams→ resolve sales leader.- Before granting access, ask: "Share this dashboard with [name]? They'll get a notification and viewer access. (yes / no)"
- On confirmation:
all_monday_apiGraphQL mutation to grant viewer permission on the dashboard. create_notification({ user_id: <recipient>, target_id: <dashboard board id>, target_type: "Project", text: "Forecast dashboard for <period>" }).
Step 8: Proactive extension — forecast hygiene fix (opt-in)
Goal: Fix hygiene gaps on deals blocking forecast accuracy — WITHOUT editing stage or amount.
Hygiene gap = deal in a non-closed stage that's missing either close date or amount.
Core pattern:
- For each gap deal with missing close-date:
change_item_column_values— set a placeholder (e.g., end-of-current-quarter) OR post a prompt update asking the owner to fill it. Stage edits are only permitted if the user typed an explicit instruction to move deals to a specific stage in this session. Do not infer stage-edit intent from context or from the hygiene gap summary. All writes happen inside the batched-confirm plan. - For each gap deal with missing amount: post a prompt update only — never write to the amount column (forecast integrity rail).
- If >20 gap deals: batch into one
Forecast hygiene — <period>review doc (withGenerated by Claude · forecastin body) rather than 20 individual writes.
Step 9: Close the loop
Goal: Summary line with dashboard URL + counts.
Print: Published Forecast — <period>. <N> deals, <N> widgets, <N> hygiene gaps flagged.
Shared patterns
- No title prefix. Dashboards are found by exact name + creator; docs carry the visible
Generated by Claude · forecast · <ISO timestamp>footer (no HTML comments — monday strips them). - Idempotency before create. Find an existing
Forecast — <period>dashboard by exact name and creator (searchDASHBOARDS) and update it instead of duplicating. - Safety rail. No deletes, no amount-column writes, no cross-workspace moves. Close-date placeholder writes OK in a batched-confirm plan. Stage edits only on explicit user instruction.
- Ask once per session, not per deal, when entering Proactive mode.
- Type-based column resolution, not name-based — global teams have non-English columns.
- Skill marker is the visible footer
Generated by Claude · forecast. Versions before 0.6.1 wrote an HTML-comment marker, which monday strips from saved content, so older artifacts are matched by title only.
Output template
Dashboard publish (α output)
Chat one-liner printed at end of run:
Published Forecast — Q3 2026. 5 deals, 6 widgets, 2 hygiene gaps flagged.
Dashboard: https://monday.com/boards/dashboard/123456789
Dashboard created in workspace "CRM":
- Name: Forecast — Q3 2026
Widgets:
| Widget | Type | Value |
|---|---|---|
| Closed-won | Number | $120K (1 deal) |
| Committed | Number | $85K (1 deal) |
| Best-case | Number | $32K (1 deal) |
| Pipeline | Number | $48K (2 deals) |
| Buckets × close month | Stacked bar | Jun / Jul / Aug |
| Committed + best-case detail | Table | Acme Corp, Beta Industries |
Hygiene gaps listed in chat (and in the hygiene doc when one is written):
- 2 deals missing close date — placeholder set to Sep 30, 2026
Non-admin fallback (doc version)
# Forecast — Q3 2026
| Bucket | Amount | Count |
|---|---|---|
| Closed-won | $120K | 1 |
| Committed | $85K | 1 |
| Best-case | $32K | 1 |
| Pipeline | $48K | 2 |
Generated by Claude · forecast · 2026-06-15T09:00:00Z
Error handling
| Error | Behaviour |
|---|---|
| Connector missing / auth error | Print install URL, stop immediately. |
| No board found matching query | Ask user to specify board name or ID directly. |
No admin perms (create_dashboard fails) | Ask: (a) doc version, (b) stop, (c) different board. |
| No deals found in period | Surface count = 0, ask if period or board is correct before stopping. |
| 429 rate limit | Pause 2 s, retry up to 3× with exponential backoff; surface if still failing. |
create_widget partially fails | Keep the dashboard, list failed widgets, offer retry. |
| Same-day artifact already exists | Idempotency check should have caught this; surface dashboard URL and ask if user wants to rebuild or update. |
Completion criteria
- Step 0 (connector check) ran and passed.
- PAUSE gate respected — no write tools called before Step 0 passes and user confirmed publish in Step 6.
- Exactly one α dashboard was created or updated (no duplicate — verified by exact name + creator via
searchDASHBOARDS). - No second
Forecast — <period>dashboard was created when one by the same user already existed. - Chat output ends with dashboard URL.
- Safety rail held: no deletes, no amount-column writes, no cross-workspace moves, no uninstructed stage edits.
- Non-admin fallback correctly routed to doc version if dashboard failed on perms.
- Empty-category guard evaluated if forecast-category column present.
- Step 7 share confirmation prompt shown before any permission grant.
Log Activity
Flow: Trigger → Detect intent (log / read / correct) → Resolve CRM item → Gather activity details → Execute → Confirm.
Input
- Optional: activity description via argument (e.g., "call with Acme about renewal").
- Optional: CRM item name or identifier if mentioned.
Output
- Log (create): structured activity record (call, meeting, note) on the target item's timeline, with confirmation.
- Read: formatted activity history for the specified item and time range.
- Correct: a correction note appended to the item's timeline that references the original entry by type and date. Existing entries are not edited.
Knowledge
- Timeline = the activity feed on any CRM item (deal, contact, lead, account).
- Activity types: calls, meetings, notes, emails (read-only from timeline), custom types per account.
- For aggregated stats (team totals, rep comparisons), use the activity-insights skill —
get-activity-insightsis more efficient than counting raw timeline items. - Where this skill writes: the item's timeline only. Meeting recaps built from Notetaker recordings or transcripts are meeting-to-deal's job and go to the deal's updates feed; daily-briefing and win-loss-review read both, so nothing logged here is lost to them.
- Timeline items are append-only through the connector: there is no tool to edit an existing entry. To change one, add a correction note; the user can edit the original in the monday CRM UI.
Tools (MCP)
get-custom-activities— list activity types configured on the account (call, meeting, note, custom).get-timeline-items— read an item's timeline (activities, emails, notes).create-timeline-item— log a structured activity (call, meeting) with type, date, attendees, notes.create-timeline-note— add a free-text note to an item's timeline.get_user_context— user identity for attribution.search/get_board_info/get_board_items_page— resolve CRM items by name or company.
Cross-skill handoffs
- From run-sequence: when a sequence triggers a manual call step, suggest logging the call outcome.
- From daily-briefing: records in the brief's Going cold section → offer to log the latest touch.
- To meeting-to-deal: if the user pastes a full transcript or asks to sync recorded meetings, hand off to
/monday-crm:meeting-to-dealinstead of logging it here. - To activity-insights: when the user asks about team totals or rep comparisons rather than a specific item's history.
Step 0: Connector check + activity types
Goal: Confirm connector works and cache available activity types.
- Try
mcp__plugin_monday-crm_monday__get_user_context. On error → print install prompt, stop. - Try
mcp__plugin_monday-crm_monday__get-custom-activities. - If successful → cache the list of activity types (id, name, icon) for use in Step 3. Set
activities_available: true. - If permission error or tool unavailable → set
activities_available: false. The skill can still operate withcreate-timeline-note(free-text notes don't require activity-type resolution), but structured activities (calls, meetings) will degrade to notes. Print: "Activity types couldn't be loaded — I can still add notes to timelines. Structured call/meeting logging may be limited."
Step 1: Detect intent
Parse the user's argument to classify:
| Intent | Trigger signals |
|---|---|
| log | "log", "record", "add", "note on", "track", "I just spoke with", default |
| read | "what activities", "activity history", "what happened on", "show timeline" |
| correct | "update the note", "edit the activity", "change the meeting note", "correct" |
If ambiguous and no CRM item mentioned, ask:
"Would you like to (a) log a new activity, (b) view activity history, or (c) correct an existing entry?"
Step 2: Resolve CRM item
Goal: Find the specific deal, contact, lead, or account the activity relates to.
-
Extract item identifier from the argument:
- Company name ("Acme", "Globex", "TechCorp")
- Contact name ("Johnson", "Sarah at Acme")
- Deal name ("Q2 renewal", "enterprise upgrade")
- Item ID (if explicitly given)
-
If name extracted →
mcp__plugin_monday-crm_monday__search({ searchType: "ITEMS", searchTerm: "<name>", strategy: "SPEED" })(retry withstrategy: "BALANCED"if nothing comes back).- Single result → use it.
searchreturnsboardIdbut no board name: resolve names fromget_user_contextrelevant boards, orget_board_infofor unknown ids. Drop results from activity-log boards (boards whose items are named like " - Email" or " - Meeting"); keep deals, contacts, accounts and leads.- Multiple results → present top 5 with board context: "Found multiple matches: (1) Acme Corp [Deals board] (2) Acme Inc [Leads board] (3) Acme - renewal [Deals board]. Which one?"
- Zero results → broaden: try partial name, try
get_board_items_pageon likely boards (Deals, Contacts, Leads). Still zero → ask user.
-
If no name in argument → ask: "Which CRM item should I log this activity on? (company name, deal name, or contact name)"
-
Once resolved, note the item id and board id for subsequent calls (CRM timeline tools take
item_id).
Step 3: Execute — Log (Create)
3a: Determine activity type
If activities_available: true:
- Parse the user's description for type signals:
- "call", "spoke with", "phoned", "rang" → call
- "meeting", "met with", "demo", "presentation" → meeting
- "note", "add a note", "reminder", "FYI" → note (free-text)
- Map the type to the closest entry returned by
get-custom-activitiesby name (e.g. "Call", "Phone call", "Meeting"). If unclear, present the returned types: "What type of activity? ( / note)" - If no returned type fits (many accounts have no "Call" type — e.g. only Email, Meeting, Task), log it as a note prefixed
Call:orMeeting:and say so in the confirmation preview, before the write.
If activities_available: false:
- Default to free-text note via
create-timeline-note.
3b: Gather details
Based on type, collect (ask only what's missing from the argument):
Call:
- Date/time (default: now)
- Duration (optional)
- Attendees/contacts (optional)
- Outcome/summary (required — at least one line)
- Follow-up action (optional)
Meeting:
- Date/time (default: now)
- Duration (optional)
- Attendees (optional)
- Summary/key points (required)
- Next steps (optional)
Note:
- Content (required)
- That's it — notes are lightweight.
Parsing heuristic: extract as much as possible from the original argument before asking.
3c: Confirm and write
HITL GATE: Present the structured activity: "Log this to ?"
Type: Call Title: Call with Acme — renewal Date: 2026-06-23 10:00 (Europe/London) Summary: They want to renew but need pricing by Friday Follow-up: Send pricing by Friday(yes / edit / cancel)
On "yes":
- For structured activities:
mcp__plugin_monday-crm_monday__create-timeline-item({ item_id, custom_activity_id, title, summary, content, timestamp })—item_idis numeric;custom_activity_idis theidfromget-custom-activities(not the name);timestampis ISO 8601; put attendees and follow-up incontentas text. For meetings with a duration, addstart_timestamp+end_timestamp. - For notes:
mcp__plugin_monday-crm_monday__create-timeline-note({ item_id, content: "<note text>" }).
Report: "Logged on . Timeline updated."
If the tool call fails, fall back to create-timeline-note with the same content formatted as text. Inform: "Couldn't log as a structured — added as a timeline note instead."
Step 4: Execute — Read
mcp__plugin_monday-crm_monday__get-timeline-items({ item_id, limit: 25 }); entries come newest first, so followcursoronly until entries predate the requested window.- Parse time filter from argument (this week / last 7 days / today / default last 10).
- Format output as a table with Date, Type, Summary columns.
- If zero activities: "No activities on in . Want to log one now?"
- For team-wide aggregated stats (totals by rep or type), use the activity-insights skill instead.
Step 5: Execute — Correct
Editing an existing timeline entry is not available through the connector. Append a correction instead.
- Retrieve timeline:
mcp__plugin_monday-crm_monday__get-timeline-items({ item_id, limit: 25 }). - Present recent entries; resolve which one is being corrected from context or by asking.
- Collect the correction.
HITL GATE: "Add this correction to 's timeline?"
Correcting: "Demo scheduled for next week" (<date>) Correction: "Decision moved to July."(yes / edit / cancel)
mcp__plugin_monday-crm_monday__create-timeline-note({ item_id, content: "Correction to <type> from <date>: <correction>" }).- Tell the user the original entry is unchanged and can be edited directly in monday CRM.
Shared patterns
- HITL gates on all writes and corrections.
- Parse-first, ask-second.
- Graceful type degradation — if structured activity creation fails, fall back to
create-timeline-note. - No deletes — timeline entries cannot be removed via MCP.
- Attribution — entries carry the user's identity from
get_user_context.
Error handling reference
| Failure | Behavior |
|---|---|
| Connector missing | Step 0 stops; print install link. |
| Activity types unavailable | Degrade to notes; inform user. |
| CRM item not found | Broaden search; ask user. |
| Create fails (invalid type) | Fall back to create-timeline-note; inform user. |
| Correction note fails | Surface error; suggest editing in monday CRM UI. |
| Timeline empty on read | Offer to log a new activity. |
| Tool unavailable (Gateway) | "Activity logging tools aren't available on the connector yet — use the monday CRM UI for now." |
Completion criteria
- Step 0 connector check passed; activity types cached or degraded gracefully.
- Intent correctly classified (log / read / correct).
- CRM item resolved before any write.
- Every write and correction went through HITL confirmation.
- Structured activities used when available; notes as fallback.
- No timeline entries deleted (hard rail).
- Errors surfaced with actionable guidance.
Meeting to Deal
Flow: Connector check → Mode → Window → Pull meetings → Resolve boards → Match → Synthesize → Confirm → Write recaps → Column edits → Contacts (opt-in) → Nudges (opt-in) → Sync doc.
Recap and sync-doc templates live in references/templates.md. Worked runs: examples/01-daily-meeting-sync.md, examples/02-notetaker-missing.md, examples/03-ambiguous-match.md, examples/04-proactive-with-contacts.md.
Input
- Optional: time window via argument (default = last 24h).
- Optional: mode (Default / Silent / Proactive) in the prompt.
- Optional: a pasted transcript or notes for one meeting (goes straight to Step 3b).
Output
- Recaps: one
Meeting recapupdate per matched deal (key points, commitments, open questions, stage signal), each carrying aref meeting-to-deal/<meeting-ref>line for idempotency. - Column edits (Default and Proactive only): high-confidence stage changes and last-touch dates, applied only after the batched confirmation.
- Contacts (opt-in): new Contacts items for unknown external attendees, linked to the deal.
- Nudges (Proactive only): notifications to deal owners for commitments due within 7 days.
- Sync doc: a private
Meeting sync — <date>doc listing matched, ambiguous, unmatched and skipped meetings. - Read-only branch: questions like "what did I commit to" get a chat answer and no writes.
Where this skill writes (activity data model)
- Meeting recaps go to the deal's updates feed (
create_update), where the team discusses the deal and where nudges can point to them. - Single dictated calls, meetings and notes go to the item timeline — that is log-activity's job, not this skill's. Do not also write a timeline entry for a recap.
- daily-briefing reads both stores, so recaps written here appear in the next brief.
Cross-skill handoffs
- To log-activity: if the user asks to log a call, meeting or note on an item ("log my call with Acme") rather than to sync or recap meetings, hand off to
/monday-crm:log-activity. Free-text descriptions in Step 3b are accepted only when this skill was invoked to sync meetings and Notetaker had none. - To data-cleanup: if more than 30% of external attendees match no deal or contact, suggest
/monday-crm:data-cleanup. - To workspace-builder: if there is no Deals board, suggest
/monday-crm:workspace-builder.
Step 0: Connector check, Notetaker, internal domain
get_user_context. On error print "I don't see the monday connector active on this session. Install it from https://monday.com/mcp, then run this skill again." and stop.- Internal domain:
get_user_contextdoes not return the user's email. Take it fromget_board_infoon the Deals board (Step 4) whencreator.idequals the user's id (creator.email); otherwise ask once: "Which email domain does your company use?". If the domain is a public mail provider (gmail.com, googlemail.com, outlook.com, hotmail.com, live.com, yahoo.com, icloud.com, me.com, aol.com, proton.me, protonmail.com, gmx.com and similar), or the user can't say, setinternal_domain = none. Never fall back to a vendor domain. Withinternal_domain = none, only addresses the user confirms as theirs count as internal. explore_meetings({ limit: 1 }). Results →notetaker_available: true. Auth, permission or not-enabled error →notetaker_available: falseand continue (Step 3b collects notes from the user). Do not stop.
No write happens before Step 7.
Step 1: Detect intent and mode
Read-only questions ("what did I commit to", "what did I promise"): run Steps 2–3, extract commitments from every pulled meeting (no matching needed), print them grouped by meeting, then offer "Want me to log these recaps to the matching deals?". No writes unless the user says yes; on yes continue from Step 4 in Default mode.
Modes for logging:
| Mode | Writes | Confirmation |
|---|---|---|
| Default (if undeclared) | recaps, sync doc, plus confirmed stage edits, last-touch dates and opt-in contacts | one batched confirmation (Step 7) |
| Silent | recaps and sync doc only. Stage edits, last-touch, contacts and nudges are never written; they are listed under "Pending your review" in the sync doc | none |
| Proactive | everything in Default plus nudges | asked once up front (below), then no confirmation prompts (questions about boards, windows or ambiguous matches still apply) |
Proactive prompt, asked once with AskUserQuestion: "Proactive mode will (a) write recaps to matched deals, (b) create missing contacts, (c) apply high-confidence stage and last-touch edits, (d) notify deal owners about commitments due this week. Amount columns stay untouched. Approve all / approve all except stage edits (last-touch dates still apply) / switch to Default?"
Hard rail in every mode: no deletes, no amount-column writes, no cross-workspace moves, never create a status label. Ambiguous matches are never written without the user's pick.
Step 2: Resolve time window
- Parse the argument: "today", "yesterday", "last N days", "since YYYY-MM-DD". Default: last 24h.
- If no window was given, say once: "Using last 24h. Add 'yesterday', 'last 7 days' or 'since YYYY-MM-DD' to change the range."
- Window over 14 days → confirm with
AskUserQuestionand state the cost: it may pull up to 200 meetings and take several minutes.
Step 3: Pull meetings
3a — Notetaker (notetaker_available: true)
explore_meetings({ start_time_from: <ISO>, start_time_to: <ISO>, limit: 20 })— newest first. If exactly 20 come back, split the window into smaller ranges and repeat, up to 200 meetings; above that, cap and add a sampling note to the sync doc.get_meetings_content({ ids: [...], include_summary: true, include_action_items: true }). Do not request transcripts here. Ids reported as not returned are logged as "not accessible". Content dropped for size → request that meeting alone.- Transcripts are fetched only in Step 6, one meeting at a time.
0 meetings in the window → print "No Notetaker meetings found in . You can paste meeting notes or describe what happened instead." and go to 3b. 429 → back off 3 times, then go to 3b.
3b — Manual input (Notetaker unavailable, empty, or the user pasted notes)
If the user already pasted a transcript or notes, use them. Otherwise ask once with AskUserQuestion: "No Notetaker recordings available. How do you want to provide the meeting?" — (a) paste notes here, (b) give a file path (read with Read), (c) describe it in free text, (d) skip. (d) → stop with "No meetings logged."
Build one meeting entry: title (first line, or ask), date (today unless stated), attendees (from the notes, or ask once for emails), content (the full text), source: manual, meeting-ref: manual-<YYYYMMDD>-<title slug>.
Step 4: Resolve boards and active deals
- Deals board: scan
get_user_contextfavorites and relevant boards fordeal|deals|opportunit|pipeline|sales. One → use it; several →AskUserQuestion; none →search({ searchType: "BOARD", searchTerm: "deals", strategy: "SPEED" }), then"pipeline". Still none → skip recaps, write only the sync doc with a "no Deals board found" header, and hand off to workspace-builder. - Contacts board (only if contacts may be created): same scan for
contact|contacts|people. Missing while contacts were approved → tell the user in chat "Contacts were approved but I couldn't find a Contacts board, so none were created." and continue. get_board_info({ boardId, filters: { columns: { only: true } } })on each. Resolve columns by type, not title:- Deals: keep the board's workspace id (for the Step 10 doc),
email(optional), company — atextcolumn, or amirrorcolumn showing the linked account or company (use its displayed text); many boards have neither, so the deal name is also used for company matching — ownerpeople, stagestatus, last-touchdate(title hint touch / contact / interaction; skip if none), valuenumbers(read only), and anyboard_relationcolumn pointing at Contacts. - Contacts:
email, companytext,phone, ownerpeople, aboard_relationcolumn pointing at the Deals board (optional), a sourcestatuscolumn (optional).
- Deals: keep the board's workspace id (for the Step 10 doc),
- Stage labels: from the stage column's labels, Won = labels with
is_done: true; Lost = label text containing lost / perdido / verloren / perdu. Nois_donelabel → ask which label means Won. Keep every label'sidand text — Step 6 may only propose, and Step 7c only write, labels from this list. Status filters compare against each label'sidfromget_board_info, not itsindex(theindexis display order; filtering on it silently returns the wrong items). - Active deals:
get_board_items_page({ boardId, includeColumns: true, filters: [{ columnId: <stage>, operator: "not_any_of", compareValue: [<Won label id>, <Lost label id>] }], limit: 500 }); follownextCursorwhilehas_more, up to 2,000 deals (above that, add a sampling note). Check the filter shape withget_column_type_info({ columnType: "status", fetchMode: "guidelines" })if the call is rejected.
Step 5: Match meetings to deals
For each meeting:
- External attendees = attendees whose domain is not
internal_domainand who are not the user. No external attendees → skipped: internal-only. Classify by attendees only: a 1:1 with one external person is a normal sales call and is in scope.- Manual meetings (Step 3b): if the user named a deal, or there are no attendee emails, find candidate deals by name and confirm the deal with
AskUserQuestion("Log this to ? / pick another / skip"); a confirmed deal counts as matched.
- Manual meetings (Step 3b): if the user named a deal, or there are no attendee emails, find candidate deals by name and confirm the deal with
- Score every active deal:
- +5 per external attendee email equal (case-insensitive) to the deal's email column, or to the email of a contact linked to the deal (when the Deals board links to Contacts, read those contacts' email column once for all active deals).
- +5 once if an external attendee's domain matches the deal's company (company column, mirrored account name, or — if neither exists — the deal name). Normalize both sides first: lowercase, drop
www.and the public suffix (.com,.io,.co.uk,.com.au…), remove spaces and punctuation (helixbio.com→helixbio, "Helix Bio" →helixbio). Match when they are equal (helixbio=helixbio), when the domain equals the company's first word and that word has 4+ characters (spindrift↔ "Spindrift Labs"), when the domain has 6+ characters and the company (or deal name) starts with it (vertexcap↔ "Vertex Capital",helixbio↔ "Helix Bio — renewal"), or when the domain is the company plus a trailingcorp,inc,hq,group,labs,apporteam(acmecorp↔ "Acme"). Anything looser does not count (applebeesis not "Apple"). Public mail domains never score. - +2 if the normalized meeting title contains the normalized deal name (or its company part), 4+ characters.
- Expect misses on small-business accounts: contacts often use free-mail addresses that differ from the address stored in CRM, and public mail domains never score. Do not loosen the rules to force a match; unmatched meetings are listed in the sync doc so the user can link them.
- Decide:
- Best score < 5 → unmatched.
- Best ≥ 5 and at least 3 ahead of the runner-up → matched.
- Two or more deals ≥ 5 within 2 points → ambiguous. In Default and Proactive ask with
AskUserQuestion(candidates with owner and stage, plus "skip this meeting"); batch all ambiguous meetings into one question. In Silent, do not write; list under "Ambiguous, not logged".
- Multi-deal meeting: when the summary or title names another active deal that also scores ≥ 5 for this meeting, write the recap to each such deal with an "also discussed" line. A deal named but scoring below 5 is not written; mention it in the recap text only. A score tie alone is not a multi-deal meeting.
- Same deal, several meetings in one run: write one recap per meeting, but merge the column edits per deal — latest meeting date for last touch; if stage signals disagree, treat both as
low.
Step 6: Synthesize
For each matched meeting, work from the summary and action items. If the summary suggests a stage change but gives no verbatim phrase, fetch that one meeting's transcript: get_meetings_content({ ids: [<id>], include_transcript: true }).
- Key points — 3 to 5 factual bullets.
- Commitments — who → what → by when ("I'll send…", "we'll follow up by…").
- Open questions — open items, "TBD", "we need to figure out".
- Stage signal — map to an existing stage label only.
high= an explicit, unambiguous phrase that names the outcome ("they signed today", "we agreed to open the redline") and maps to exactly one label; anything inferred islow. Moving to procurement or legal review is not a win. Onlyhighsignals enter the plan;lowones appear in the recap as "Suggested (not applied)". - Last touch — the meeting date, proposed only if later than the deal's current last-touch value.
Step 7: Confirm, then write recaps
7a — Idempotency scan (before the confirmation)
get_updates({ objectType: "Item", objectIds: [<matched deal ids, up to 25 per call>], limit: 100 }) (the limit applies per item; if a deal returns 100 updates, call again for that deal with page: 2 until updates predate the earliest meeting in the run). An existing recap is a hit when its text contains ref meeting-to-deal/<meeting-ref> followed by a non-alphanumeric character or the end of the line, or — for recaps posted by older versions, whose markers were HTML comments — its text starts with Meeting recap — <same meeting title> and it was created on or after the meeting date. Hits are not rewritten (the connector cannot edit an update); they go under "Already logged" and their stage and last-touch edits are dropped.
Contacts lookup (only if contacts may be created and a Contacts board exists): for each external attendee email of a matched meeting, get_board_items_page({ boardId: <contacts>, searchTerm: <email> }). Emails with no hit are the missing contacts <C>; Step 8 creates them.
7b — Batched confirmation (Default mode)
One message, then one answer:
"I'll write recaps · stage edits (high confidence) · last-touch dates. suggested stage changes stay as text. unmatched, already logged. Proceed? (yes / show details / skip column edits / no)"
- If
<C>> 0, ask the contact opt-in as a separate question in the sameAskUserQuestioncall: "Also create missing contacts on ?" Above 25, say: " new contacts found; I'll create 25 and list the rest in the sync doc." - "show details" → list every stage edit as
<deal> · <old> → <new> ("<evidence phrase>")and one sample recap, then ask again.
Proactive skips this prompt (approval came in Step 1). Silent skips it and writes recaps only.
7c — Write
For each matched meeting–deal pair that is not a hit:
- Column edits first (only if approved — not in Silent, not after "skip column edits"): one
change_item_column_valuescall per deal carrying both edits:{ boardId, itemId, columnValues: "{\"<stage col>\": {\"label\": \"<existing label>\"}, \"<last-touch col>\": {\"date\": \"YYYY-MM-DD\"}}" }. Never passcreateLabelsIfMissing. Never write the value column. If the call fails, list the edit under "Pending your review". - Then the recap:
create_update({ itemId: <deal id>, body: <recap HTML from references/templates.md, one line, no newlines between tags> }). The Stage signal line says "Applied" only for an edit that succeeded in step 1; every other proposed edit is written as "Suggested (not applied)". Updates cannot be edited afterwards, so never write the recap before its edit has settled. Keep the returned update id for Step 9.
Step 8: Create missing contacts (opt-in)
Runs only when contacts were approved (Step 1 Proactive or the 7b opt-in). For each missing contact found in 7a, up to 25 (name from the Notetaker participant name; if only an email is known, use the part before @, capitalized):
create_item({ boardId: <contacts>, name: "<First Last>", columnValues: "{\"<email col>\": {\"email\": \"<email>\", \"text\": \"<email>\"}, \"<company col>\": \"<company>\", \"<relation col>\": {\"item_ids\": [<deal id>]}, \"<source col>\": {\"label\": \"Claude\"}}" })
- Leave
groupIdout — the board's default group is used. - Include the relation key only if a
board_relationcolumn to the Deals board exists, and the source key only if a source status column already has aClaudelabel. If a source column is missing, create the contact without it and note "source not tracked" in the sync doc; do not create columns. - If the call fails because of the relation value, retry once without it and list the contact under "Contacts pending manual link".
Step 9: Commitment nudges (Proactive only)
For commitments due within 7 days on deals that got a recap in this run:
create_notification({ user_id: "<deal owner id>", target_id: "<recap update id from 7c>", target_type: "Post", text: "Commitment due <date> on <deal>: <commitment>" })
More than 20 nudges → send none; list them under "Commitments due this week" in the sync doc and tell the user in chat.
Step 10: Sync doc and chat summary
read_docs({ type: "workspace_ids", ids: ["<workspace id>"], order_by: "created_at", limit: 5 })and look for the exact title — results are newest first and carry each doc's full body, so keep the page small; DOCUMENTS search can miss a doc created minutes ago. If a doc titled exactlyMeeting sync — <Mon DD, YYYY>exists, append to it withupdate_doc(seereferences/templates.md).- Otherwise
create_doc({ location: "workspace", workspace_id: <workspace id from the Deals board's get_board_info>, doc_kind: "private", doc_name: "Meeting sync — <Mon DD, YYYY>", markdown: <sync doc> }). - No Deals board (Step 4), or both calls fail → print the sync doc in chat instead.
- Last line: the chat summary from
references/templates.md. If more than 30% of external attendees matched no deal and no contact, add the data-cleanup suggestion.
Error handling
The failure → behavior table is in references/templates.md (Error handling). Rule of thumb: skip the one meeting, deal or contact that failed, keep going, and list it in the sync doc; stop only when the connector is missing or monday keeps rate-limiting.
Completion criteria
- Step 0 passed;
internal_domainset from the user's email, ornonefor public mail providers — never a guessed vendor domain. - No write before the Step 7b confirmation (Default) or the Step 1 approval (Proactive); Silent wrote recaps and the sync doc only.
- Every recap is HTML and carries
ref meeting-to-deal/<meeting-ref>; no meeting got a second recap on the same deal. - Ambiguous meetings were asked about or left unwritten — never written to two deals on a tie.
- Stage edits used existing labels only and were high confidence; no amount column was written.
- Contacts (if any) capped at 25; failed links listed in the sync doc.
- Nudges (if any) pinned to the recap update with
target_type: "Post". - Sync doc created or appended once, or printed in chat on failure.
Run Sequence
Flow: Trigger → Detect intent → Resolve board/sequence/contact → Execute → Confirm + report.
Input
- Optional: action + target via argument (e.g., "enroll Acme in welcome sequence").
- If no argument: ask what they want to do.
Output
- List: sequences on a board with status, step count, enrollment counts, analytics.
- Create: new sequence scaffolded via the tool's built-in gate flow (board → steps → email sender if needed), starts INACTIVE.
- Enroll: one or more CRM items enrolled in a sequence; returns succeeded/failed counts.
- Activate/Deactivate: sequence state toggled with confirmation. Deactivate does NOT stop existing enrollments — only blocks new ones.
- Duplicate: copy of a sequence created in INACTIVE state.
- Analyze: per-run + level + step funnel (reply rate, open rate, click-through).
- Contact journey: all sequences a contact is enrolled in, sorted by most recent.
Knowledge
- Sequence states: ACTIVE (enrolling + running), INACTIVE (not enrolling; existing runs continue),
missing_config(setup incomplete, usually no sender mailbox or step content; it can't be activated or enrolled until finished in Tools → Sequences). Status may come back in lowercase; show it to the user as written above. deactivate-sequence≠ pause — enrolled contacts keep progressing; only new enrollments are blocked.- No sequence editing tool exists — steps cannot be added/modified via MCP. Direct users to Tools → Sequences in the UI.
get-board-sequencestakes an optionalboard_id. Without it, it returns only your sequences (ones you created), across boards — not every sequence on a board. Withboard_idit returns all sequences on that board, including teammates'. To find a sequence by name, try withoutboard_idfirst; if it isn't there, resolve the board (ask if needed) and retry withboard_id.create-sequencedocuments no personalization placeholders: a{{name}}in anautomatic_emailbody was sent literally in a live test. Never add{{...}}variables to step bodies yourself.create-sequencehas a built-in gate system: call it with what you have; if anything's missing the tool returnsCONFIRMATION_REQUIREDwith exact instructions — follow them verbatim, never pre-empt the gates.enroll-item-in-sequencetakesboard_id,sequenceId, anditemIds(array of string IDs).
Tools (MCP)
get-board-sequences— list all sequences on a board, or only the user's own sequences whenboard_idis omitted.get-sequence-analytics— per-run, level, and step analytics for one sequence.get-contact-journey— all sequences a contact/item is enrolled in (needsboard_id+item_id).enroll-item-in-sequence— enroll one or more items in a sequence.activate-sequence— INACTIVE → ACTIVE.deactivate-sequence— ACTIVE → INACTIVE (existing enrollments continue).duplicate-sequence— copy a sequence; new copy starts INACTIVE.create-sequence— create a new sequence; call directly with whatever args you have.show_connect_integration— renders a connect button for Gmail/Outlook when the user has no mailbox to send from.check-integration-connection-status— confirms the mailbox connected before retryingcreate-sequence.get_user_context— user identity + account.search/get_board_info/get_board_items_page— resolve boards and items by name.
Cross-skill handoffs
- To log-activity: after enrolling a contact in a sequence whose first step is a manual call, suggest logging the call outcome.
Step 0: Connector check
- Try
mcp__plugin_monday-crm_monday__get_user_context. On error → print install prompt, stop. - This skill does not pre-check sequence tools — if a sequence tool fails with a permission error in later steps, print: "Sequences may not be enabled on your account. Check Tools → Sequences in monday CRM."
Step 1: Detect intent
Parse the argument/prompt to classify:
| Intent | Trigger signals |
|---|---|
| list | "what sequences", "show sequences", "list", no argument |
| create | "create", "set up", "build", "new sequence", "drip campaign" |
| enroll | "enroll", "add to sequence", "put in sequence", "start on sequence" |
| activate | "activate", "turn on", "enable sequence" |
| deactivate | "deactivate", "turn off", "disable sequence", "stop new enrollments" |
| duplicate | "duplicate", "copy sequence", "clone" |
| analyze | "analytics", "how is", "performance", "open rate", "funnel", "reply rate" |
| contact-journey | "what sequences is", "sequence history for", "enrolled in", "contact journey" |
If ambiguous, ask once:
"What would you like to do with sequences? (list / create / enroll / activate or deactivate / duplicate / analyze / check a contact's history)"
Step 2: Resolve board
Required for: enroll, contact-journey. Optional for listing your own sequences and for a first try at finding one by name (omit board_id); needed to see teammates' sequences. Optional for create (let the gate handle it).
- If user named a board →
mcp__plugin_monday-crm_monday__searchorget_board_infoto resolve it. On ambiguity, present top results and ask. - If no board named:
- For list: call
get-board-sequenceswithoutboard_id, show the result with the board name for each, and say "These are the sequences you created. Name a board to see every sequence on it, including your teammates'." - For create: proceed to Step 4 and let the tool's gate request it.
- For enroll: ask "Which board is this contact/lead on?"
- For contact-journey: ask "Which board is this contact on?"
- For list: call
Step 3: Execute — List
mcp__plugin_monday-crm_monday__get-board-sequences({ board_id }) — or get-board-sequences({}) when no board was named.
Format as table:
Sequences on Leads board:
| # | Name | Status | Steps | Enrolled | Reply Rate |
|---|------|--------|-------|----------|------------|
| 1 | Cold outreach Q2 | ACTIVE | 5 | 120 | 12.4% |
| 2 | Welcome — new leads | INACTIVE | 3 | 0 | — |
If empty: "No sequences on this board yet."
Step 4: Execute — Create
Call mcp__plugin_monday-crm_monday__create-sequence directly with whatever you have from the user's message. The tool's built-in gates handle missing fields:
board_not_specifiedgate → follow the returned instructions verbatim: usesearchto list boards, present as-is, ask user to pick, retry.steps_not_specifiedgate → follow the returned instructions verbatim: ask user to build steps one at a time or create empty. Never invent steps.connections_not_specifiedgate (triggered whenautomatic_emailsteps needsender/emailColumnId) → the gate returns the user'smailboxes. Ask which one to send from and pass itsconnectionId+providerassender; resolveemailColumnIdviaget_board_info; retry. If the gate says there is no connected mailbox, callshow_connect_integration, wait for the user to connect, confirm withcheck-integration-connection-status, then retry.sender_not_found/sender_not_ready→ follow the returned instructions verbatim (pick another mailbox, or ask the user to reconnect).
If the user's email copy contains {{...}} placeholders, say before creating: "Personalization placeholders like {{name}} may be sent exactly as typed — the sequence tool doesn't document any. Keep them, or rewrite without?"
On success: "Sequence '' created (INACTIVE). Activate it? (yes / later)". If yes → activate-sequence.
Important: Never pre-empt the gates by asking all questions upfront. Call the tool first.
Step 5: Execute — Enroll
- Resolve the sequence:
mcp__plugin_monday-crm_monday__get-board-sequences({ board_id }), or withoutboard_idto find it by name — if the name isn't among your own sequences, retry with the board'sboard_id→ present list, ask which sequence if not named. - Resolve the items: extract from the argument (company/contact names) or ask "Which contacts or leads do you want to enroll?". Use
searchorget_board_items_pageto getitem_ids. - Confirm sequence is ACTIVE. If INACTIVE: "'' is currently inactive — new enrollments are blocked. Activate it first? (yes / cancel)"
HITL GATE: "Enroll item(s) in ''? The sequence is active, so its first email goes out from <timing of step 1>." List the items by name. For more than 25 items, say the count first and confirm the user really means all of them. (yes / cancel)
mcp__plugin_monday-crm_monday__enroll-item-in-sequence({ board_id, sequenceId, itemIds: ["<id>", ...] }).- Report: "Enrolled items. Succeeded: . Failed: ." Items already enrolled may be rejected — list them under Failed with the reason the tool gives.
Step 6: Execute — Activate / Deactivate
- Resolve the sequence (board →
get-board-sequences→ pick by name). - Check current state. Warn on no-ops:
- Activating an ACTIVE sequence → "'' is already active."
- Deactivating an INACTIVE sequence → "'' is already inactive."
HITL GATE:
- Activate: "Activate ''? This enables new enrollments. (yes / cancel)"
- Deactivate: "Deactivate ''? New enrollments will be blocked — contacts already enrolled will keep progressing. (yes / cancel)"
mcp__plugin_monday-crm_monday__activate-sequence({ sequenceId })ormcp__plugin_monday-crm_monday__deactivate-sequence({ sequenceId }).- Report the new state.
Step 7: Execute — Duplicate
- Resolve the sequence (board → list → pick).
HITL GATE: "Duplicate ''? The copy will start as INACTIVE. (yes / cancel)"
mcp__plugin_monday-crm_monday__duplicate-sequence({ sequenceId }).- Report: "Created '' (INACTIVE). Activate it? (yes / later)"
Step 8: Execute — Analyze
- Resolve the sequence (board → list → pick).
mcp__plugin_monday-crm_monday__get-sequence-analytics({ sequenceId }).- Format:
Sequence: "Cold outreach Q2" (ACTIVE)
Level: 450 events · 69% open rate · 23% reply rate · 5.6% click-through
Per-step:
| Step | Sent | Open % | Reply % | CTR % |
|------|------|--------|---------|-------|
| 1 — Email | 450 | 69% | 10% | 2.7% |
| 2 — Email | 405 | 66% | 9.4% | 2.0% |
| 3 — Email | 360 | 55% | 6.1% | 1.4% |
Runs: 12 active · 380 completed · 58 terminated
- Flag drop-offs: if open rate drops >15pp between consecutive email steps, surface it.
- If analytics are empty: "No analytics yet — this sequence hasn't sent any messages."
Step 9: Execute — Contact journey
- Resolve the contact item (search by name →
item_id; ask for board if unclear). mcp__plugin_monday-crm_monday__get-contact-journey({ board_id, item_id }).- Format:
Sequence history for Acme Corp:
| Sequence | Status | Steps done | Enrolled | Termination |
|----------|--------|-----------|----------|-------------|
| Welcome Q2 | Completed | 5/5 | Jun 10 | Replied |
| Cold outreach | Active | 2/5 | Jun 20 | — |
- If empty: " isn't enrolled in any sequences."
- If the call errors (the connector currently fails its own output validation for some journeys, e.g.
startStepId must be string), say "I couldn't read the sequence history for right now. You can see it on the item in monday." Don't retry in a loop.
Shared patterns
- HITL gates on all writes (enroll, activate, deactivate, duplicate).
create-sequencealways creates the sequence INACTIVE, so nothing is sent until the user confirms activation. - No sequence editing via MCP. If asked to add/edit/remove steps, say: "Step editing isn't available through MCP yet — go to Tools → Sequences in the monday CRM UI."
- Board-first for enroll/journey. Resolve the board before calling tools that need
board_id. Listing and finding a sequence by name don't need one. - Follow create-sequence gates verbatim. Call first, handle gates as they come.
Error handling reference
| Failure | Behavior |
|---|---|
| Connector missing | Step 0 stops; print install link. |
| Permission error on sequence tools | Suggest checking CRM Sequences is enabled in account settings. |
| Board not found | Broaden search; ask user to confirm board name. |
| Sequence not found | List all on board; ask user to pick. |
| Enroll — sequence INACTIVE | Offer to activate first. |
| Enroll — partial failure | Report succeeded and failed item IDs. |
| Named sequence not in your own list | Retry get-board-sequences with the board's board_id (it may belong to a teammate). |
get-contact-journey errors | Say the history couldn't be read and point to the item in monday; no retry loop. |
| Analytics empty | Inform no sends yet. |
| Tool unavailable on connector | "Sequence tools aren't on the connector yet — check back or use the monday UI." |
| Edit/add-step request | Redirect to UI; no MCP tool exists for this. |
Completion criteria
- Step 0 connector check passed.
- Intent correctly classified and executed.
- Board resolved before enroll and contact-journey calls.
- Enroll, activate, deactivate and duplicate went through HITL confirmation; new sequences were left INACTIVE until the user confirmed activation.
-
create-sequencegates followed verbatim; no pre-emption. - No sequence editing attempted (hard rail — redirect to UI).
- Analytics formatted with level + per-step breakdown and drop-off flags.
- Errors surfaced with actionable guidance.
Win / loss review
Produce an evidence-based explanation of why one closed deal was won or lost. Every claim must point to something you read. If the evidence is thin, say so instead of guessing.
0. Rules
- Connector check first: call
get_user_context. On error, tell the user to install and connect the monday MCP connector, and stop. - Reading is free. Writing (board columns, new columns, files, docs) happens only after the user confirms the exact values (step 7c). The recommended path is to save the result on the deal item, so offer it once, clearly, and do not nag.
- Never assume board, column or label names. Discover them (step 2).
- Never invent a reason. People act on these reviews, so a finding needs at least one cited data point (a stage change, an email, a note, a number).
- Mark the deal outcome from the data, not from the user's wording, and tell the user if they differ.
- One deal per run. If the user asks for several, run them one after another and keep each result separate. Do not write one deal's data into another item.
1. Ask the first-run questions (once per conversation, after the deal is confirmed closed)
First run step 2 (find the deal and confirm it is Won or Lost). Then ask both questions in one message with AskUserQuestion, skipping any the user already answered or said "always" or "never" about, and remember the answers.
- Depth: "Short analysis or deep analysis?"
- Short (default): bottom line, key facts, do-next-time.
- Deep: adds the full stage timeline, week-by-week activity, ranked drivers with dated evidence and a full comparison with other closed deals.
- Board update (recommended): "Should I save the result on the deal item in monday, so the review stays with the deal and your team can see and report on it?" Options: yes (recommended), or no (chat and artifact only).
If the user is unsure, recommend yes and short. Do not start the heavy reads (steps 3 to 5) until depth is answered.
2. Find the deal and the board structure
- Resolve the deal: item link, or search by name. If several match, list them (name, owner, value, stage) and ask which one.
- Call
get_board_info(columns only) for the deal's board. Identify by column type, not by title:- Stage: the status column used for the pipeline (labels like New, Discovery, Proposal, Negotiation, Won, Lost).
- Owner: people column. Value: numbers column. Expected close date: date column. Close probability, last interaction date, loss reason (dropdown or status) if present.
- Contacts and accounts: board-relation column.
- Activities timeline: a column of type
unsupported. It cannot be read as a column value. Use the timeline tool. - A long text column, if the user wants to write there (step 7c).
- Confirm the outcome: current stage label (Won or Lost) and group (for example "Closed Won"). Classify unusual endings explicitly: "no decision" or "went dark" is a loss, a deal that was reopened is judged by its latest close, and a deal won and later churned is judged on the win only (mention the churn).
- If the deal is not closed, stop and tell the user a post-mortem needs a closed deal. Offer to review it once it closes, or to run
daily-briefingon the board instead.
3. Read the stage history
Call get_board_activity with the board id, itemIds set to the deal, includeData: true and a fromDate early enough to cover the deal's creation (use the item's created_at, or one year back). get_board_activity has no paging: if the response looks cut off, split the range into smaller fromDate / toDate windows. Stop at about 300 events; if there are more, say the history is truncated.
From the events, build an ordered list of stage changes:
update_column_valueevents on the stage column.previous_value.label.textis the old label,value.label.textthe new one.move_pulse_from_groupevents for group moves (for example Active Deals to Closed Won).create_pulsefor creation and its source (form, import, manual).- Owner changes (
update_column_valueon the people column). - Changes to value, expected close date and close probability.
The created_at field on events is a 17-digit monday timestamp. Divide by 10,000,000 to get Unix seconds. If the response says no activity was found, say that stage history is unavailable and continue with step 4.
Compute:
| Signal | How |
|---|---|
| Stage changes | Count of stage changes, and how many were backward moves (for example Negotiation back to Proposal) |
| Time per stage | Days between consecutive stage changes. Flag the longest stage |
| Total cycle | First entry into the pipeline to close, in days. For imported or bulk-created items the creation date can be misleading, so prefer the first stage change and say which you used |
| Close-date slips | Number of times expected close date moved later, and total days pushed |
| Value changes | Start value, final value, direction and size of each change |
| Probability drift | Close probability at each stage change, if tracked |
| Owner changes | Count and timing. A handover close to the close date is a risk signal |
| Skipped stages | Pipeline stages never visited |
| Who changed it | If automations or other users changed the stage, note it |
4. Read the Emails & Activities timeline
Call get-timeline-items for the deal id and page through the results with the cursor, up to about 200 items. If there are more, work from the most recent 200 plus the first 20 and say the timeline is truncated. Do not use the "count timeline events" column.
Classify each item by type: email, meeting, phoneCall, note, aiSummary, sequencesEmail, custom and others. Many accounts log emails, meetings and calls as custom activity types, so items come back as type: "custom": call get-custom-activities once and classify those by the name of their custom_activity_id (for example "Email", "Meeting"). Results come newest first. Content may be HTML; strip tags before reading.
Compute:
| Signal | How |
|---|---|
| Activity volume | Count by type, and per stage if you can map dates to the stage history |
| Cadence | Average days between touches. Longest silent gap and when it happened |
| Last touch before close | Days between the last activity and the close |
| Responsiveness | For emails, inbound versus outbound counts and the typical reply lag in each direction |
| Multi-threading | Distinct contacts involved. A single-threaded deal is a risk signal |
| Meetings | Number held, and whether a meeting happened in each late stage |
| Customer voice | Objections, budget, timing, competitors, champions, blockers (see the privacy note below) |
| Rep voice | Commitments, promised follow-ups, whether they were done |
For customer and rep voice, also call extract_signals with itemId set to the deal, resourceTypes: ["email_thread", "video_meeting", "phone_call", "activity"], signalTypes: ["blocker", "objection", "buying_signal", "commitment", "stakeholder", "decision"] timeWindowDays set to the days from the first stage change (or item creation) to today, plus 7 — the window counts back from today, not from the close date — and maxCommunicationEvents: 200. Signals cover only the most recent events in that window, so say so if the cycle was long. Each signal cites its communicationEventsIds, so it counts as evidence. Use it to find objections, competitors, champions and promised follow-ups faster, and check the strongest ones against the timeline items. If it errors or returns nothing, carry on from the timeline alone.
If the item has meeting recordings or summaries, read them with search_meetings_content / get_meetings_content. Prefer these over guessing from titles.
Also read item updates with get_updates (item) and the loss-reason column if one exists. Treat free-text reasons as a claim to test against the evidence, not as the answer.
Privacy note: the result may be saved where the whole board can read it. Quote customers sparingly (a short phrase, not a full email), and leave out personal details such as private phone numbers or unrelated personal remarks.
5. Compare with other closed deals
On the same board, read closed deals with the same outcome and the opposite outcome from the last 6 to 12 months (get_board_items_page with a stage or group filter; get filter rules from get_column_type_info first). Use only stage history and activity counts, never full text.
Keep the cost in check, because each deal needs its own history and timeline calls:
- Read stage history for all comparison deals in one
get_board_activitycall with their ids initemIds(split by date window if it comes back cut off), not one call per deal. - Short mode: about 8 deals per side. Prefer what the board already gives you (created and close dates, value) and only pull the timeline for the counts you actually quote.
- Deep mode: about 20 deals per side.
Report medians for: cycle length, days in the stage where this deal spent the most time, activity count, contacts involved. State how far this deal sits from the median of won deals and of lost deals. If fewer than 5 comparison deals exist on a side, say the benchmark is weak.
6. Reason about the outcome
Group evidence into drivers. Use this checklist and report only the drivers that have evidence:
- Momentum: stalls, long stages, backward moves, close-date slips.
- Engagement: silence gaps, falling cadence, unanswered customer emails.
- Stakeholders: single contact, no economic buyer or champion visible, owner handover.
- Value and fit: discounting, scope changes, budget or pricing objections.
- Competition: competitor names in emails, notes or meetings.
- Timing and process: missing stages, late legal or security steps, customer-side delays.
- Execution: missed follow-ups, slow replies, no next step set.
- Won deals: what worked, in the same categories, so others can repeat it.
Rank drivers by strength of evidence. Label each as strong (two or more independent sources), moderate (one clear source) or weak (inferred). Give one top driver and up to three supporting drivers. Add an "unknowns" line for what the data could not show (for example calls that were never logged).
Overall confidence:
- High: the top driver is strong, and the comparison has at least 5 deals per side.
- Medium: the top driver is moderate, or the benchmark is weak.
- Low: the top driver is weak, or stage history or the timeline is missing or truncated.
7. Output
The goal is that the answer lives on the board, where the team works. Chat is the quick view.
7a. Short answer in chat (always, first)
Bullets only, at most 10 bullets, no paragraphs. For deep mode, keep this same chat summary and put the extra detail in the artifact.
WIN/LOSS: <deal> | <Won|Lost> | <value> | <owner>
BOTTOM LINE
- <One sentence: why it was won or lost. Name the top driver.>
KEY FACTS
- Cycle: <N> days (median for <won|lost> deals: <N>)
- Stages: <N> changes, longest in <stage> (<N> days)
- Engagement: <N> touches, longest silence <N> days, <N> contacts
- <One more fact that supports the bottom line>
DO NEXT TIME
- <Specific action 1>
- <Specific action 2>
Confidence: <High|Medium|Low>. Gaps: <short, or "none">
The bottom line comes first and fits in one sentence. Every number comes from the data. If evidence is thin, lower the confidence and say what is missing. Use a neutral tone: describe behaviors and timing, not people.
7b. Artifact
Create a single-deal page with the bottom line, metric tiles (cycle vs median, stage changes, longest silence, contacts, close-date slips), the stage-path bar, touches per week, ranked drivers with strength and dated evidence, what to repeat, what to do differently, data gaps and sources. In short mode, build the compact version: bottom line, key facts and do-next-time.
Use the artifact tool if this environment has one. If not, write the same content as a self-contained HTML file and tell the user where it is. If neither is possible, offer to put the deep analysis in a monday doc on the deal (create_doc, after confirmation in 7c), or say the chat summary is the only output. Never show invented numbers. Label missing data clearly.
7c. Update the board (only if the user chose yes in step 1)
If the user chose no, skip to 7e. Ask for confirmation once: a single plan with the columns to create, the exact value for each column and how the artifact is attached. Do not ask again per column or per file.
7c-i: find the columns. Use the column list from step 2. Match by column type and by meaning of the title, not exact names:
| Field | Best column type | Notes |
|---|---|---|
| Full analysis text | Long text | Short mode: the 7a text. Deep mode: the 7a text plus top drivers, under 3,000 characters |
| Win or loss reason | Status or dropdown | Suggest the closest existing label. Never create new labels without asking |
| Top driver | Dropdown, status or text | Optional |
| Cycle length (days) | Numbers | Optional |
| Longest silence (days) | Numbers | Optional |
| Artifact | Link, files, or monday doc column | See "Saving the artifact" below |
Do not overwrite a column that already has content without showing the old value and asking.
7c-ii: if columns are missing, include them in the plan. Adding columns changes a shared board, so list what is missing with the column type and a name, for example: "I couldn't find a place for the analysis. I suggest adding: Win/Loss Analysis (long text), Win/Loss Reason (dropdown), Cycle Days (numbers), Review Artifact (link). Want me to create these?" On a yes, create them with create_column (check get_column_type_info for the right settings). If the user declines, write only to the columns that exist and say what was left out.
7c-iii: show and confirm. Show the whole plan — new columns, the exact value per column, and the artifact attachment choice — and wait for one yes. Then write with change_item_column_values (or update_items). After writing, confirm in one line per column.
Saving the artifact on the deal
After the artifact is created, suggest keeping it on the deal:
- Link column (simplest): put the artifact URL in a link column. Suggest creating one named "Win/Loss Review" if missing.
- Files column: attach the artifact as a file so it travels with the deal. Suggest creating a files column if missing. Use the asset upload tools (
get_asset_upload_url, thenfinalize_asset_upload). If the artifact cannot be exported as a file here, fall back to the link. - monday doc column: create a monday doc on the item with the review text and the artifact link at the top, and place it in a doc column. Use
create_docand attach it to the item.
Put the choice in the 7c-iii plan with your recommendation (link plus doc), so the user confirms it together with the column values.
7d. Optional document
If the user asks for a separate document, create a monday doc with create_doc. Use another format (Google Doc, Word) only if this environment has a connector for it. Include the deep analysis if it was run. Show what will be created and wait for a yes.
7e. Closing
State in one line each where the result now lives: chat, artifact, board columns updated, doc or file attached. If nothing was saved to the board and the user had not already said no, mention once that it can be saved later. Do not ask again.
8. After the run
In one line, tell the user what was read (stage events, timeline items, comparison deals, and anything truncated) and what was saved where. Offer one follow-up: run the same review on another closed deal.
Cross-skill handoffs
- To log-activity: the review finds calls or meetings that were never logged → offer to log them on the deal.
- To activity-insights: the review points to a rep-level pattern (for example, slow replies) → offer team activity numbers.
- To data-cleanup: the loss-reason column is empty on most closed deals → offer a board health check.
- To daily-briefing: the user asks about an open deal → offer the daily briefing for the board instead.
Workspace Builder
Sets up a CRM workspace conversationally — turning "I don't know how to start" into a working board on day 1. Replaces the manual template-pick → column-rename → column-add → group-rename loop that gates 442 median days between CRM install and first MCP execution. This is the single highest-leverage retention skill in the catalog.
Flow: Trigger → Discover → Propose → Confirm → Build (α) → Seed (β, opt-in) → Handoff.
Input
- Optional: business description via argument.
- Optional: user pre-declared mode (Default / Silent / Proactive). Add "silently" or "skip confirmations" to your request to run in Silent mode. Silent mode builds without per-step confirmations.
Output
- α (default): One board (or set of boards) created in the user's chosen workspace. Boards carry the user's chosen names (no plugin prefix). Groups + columns scaffolded per the proposed structure. A
CRM Setup — <Mon DD>doc summarizes what was created and what's next, withGenerated by Claude · workspace-builder · <ISO timestamp>+Generated by Claude · workspace-builderin the body. - β (Seed mode, opt-in): 5–10 example items per board so the user can see the shape with data, not just empty columns. Each example item carries
Source = Claudeon a status column (auto-create the column with user confirm if missing) — no[Example]prefix on names. - Proactive extension: Automations are out of scope for this skill. After the build, hand off to
/monday-crm:automate-crmto add automations in plain language; the setup doc also links the in-product Automation Recipes UI.
Knowledge
- Worked runs (read for the expected tone and output shape):
examples/01-b2b-sales-setup.md,examples/02-custom-archetype-law-firm.md. - monday CRM entity board catalog + relationships (§ monday CRM Entity Boards).
- Industry → board-shape map (§ Step 3).
- Column-type repertoire (§ Step 4).
- Shared artifact conventions (§ Shared patterns).
- GraphQL mutations for group operations:
references/monday-graphql-mutations.md.
Tools (MCP)
get_user_context— resolve user + existing workspaces.list_workspaces/workspace_info— find a target workspace.search— confirm we aren't duplicating an existing CRM board.create_workspace— only if the user explicitly wants a new workspace.create_board— the core write.create_group— pipeline stages as groups (or as status labels — see Step 4).create_column— typed columns per the proposed schema.create_item— β seed items.create_doc— publish the setup summary doc.all_monday_api— group rename/delete mutations + column settings (status labels, number units) not exposed by wrapped tools. Seereferences/monday-graphql-mutations.mdfor exact payloads.
Cross-skill handoffs
- From none (entry point): First-run user, in-product CTA route, or explicit ask.
- To daily-briefing: Once the board has at least 5 items with a stage column populated, suggest
/monday-crm:daily-briefingto start the daily-ops loop. - To data-cleanup: After 30 days of use, suggest
/monday-crm:data-cleanupfor a fill-rate audit.
monday CRM Entity Boards
monday CRM is built around five canonical entity board types. When proposing a workspace structure, use these as building blocks — don't invent custom schemas. Use the user's own terminology for board and column names, but match the underlying column types and group structure.
Always propose Deals. Add other boards only when the user's description clearly signals the need.
Deals — the pipeline board (always included)
Every monday CRM user starts here.
- Groups (pipeline stages): New · Discovery · Proposal · Negotiation · Won · Lost
- Columns: Stage (status,
is_done: trueon Won), Owner (people), Deal Value (numbers $), Probability (numbers %), Expected Close (date), Last Touch (date), Source (status), Notes (long_text)
Contacts — individual people records
Add when the user mentions tracking people, contacts, or has account managers / a team managing relationships.
- Groups: Active · Inactive
- Columns: Email (email), Phone (phone), Company (text), Owner (people), Source (status), Last Activity (date), Notes (long_text)
- Relates to: Deals (link contact to their deal via board_relation)
Leads — inbound / unqualified prospects
Add when the user mentions SDR, outbound, lead gen, or has a qualification step before deals.
- Groups: New · Contacted · Qualified · Disqualified
- Columns: Stage (status), Owner (people), Source (status), Email (email), Phone (phone), Company (text), Last Touch (date), Notes (long_text)
- Relates to: Deals (qualified leads become deals — link via board_relation)
Accounts — companies / organizations
Add when the user mentions account management, renewals, B2B with multiple contacts per company, or CSM workflows.
- Groups: Active Customers · Prospects · Churned
- Columns: Owner (people), Industry (status), Size (numbers), ARR (numbers $), Health (status), Last Activity (date), Notes (long_text)
- Relates to: Contacts (people at this account), Deals (deals linked to this account)
Activities — calls, emails, meetings log
Add when the user explicitly mentions logging activity, tracking touchpoints, or managing a high-touch sales motion with multiple interactions per deal.
- Groups: This Week · This Month · Archive
- Columns: Type (status: Call / Email / Meeting / Demo), Owner (people), Date (date), Notes (long_text)
- Relates to: Deals (the deal this activity belongs to), Contacts (the person involved)
Board relationships
Leads ──qualified──▶ Deals ◀──linked──── Accounts
│ │
└──── Contacts ────────┘
│
Activities
- Leads → Deals: when a lead qualifies, create (or link to) a deal. board_relation on Leads pointing to Deals.
- Contacts ↔ Deals: contacts are participants on deals. board_relation on both sides.
- Accounts → Contacts + Deals: an account owns many contacts and many deals. board_relation on Contacts and Deals pointing to Accounts.
- Activities → Deals + Contacts: each activity is scoped to one deal and one contact. board_relation columns on Activities.
v0.1 constraint: create_column with board_relation type requires the target board to already exist. Build all boards first (Step 5), then add relation columns in a second pass via all_monday_api. Only wire relations the user explicitly asked for — don't create them by default.
Persona → board set
| Signal in user's description | Boards to propose |
|---|---|
| Sales rep / AE / closing deals | Deals + Contacts |
| SDR / BDR / outbound / lead gen | Leads + Deals |
| Sales manager / team lead | Deals — suggest dashboards manually |
| Account manager / renewals / CSM | Accounts + Contacts + Deals |
| Full team / full CRM setup | Deals + Contacts + Leads + Accounts |
| Solo founder / small team | Deals only — keep it simple |
Never create all 5 boards by default. Blank boards are intimidating and reduce activation.
Step 0: Connector check
Goal: Fail fast if the monday MCP connection is missing. Detect the CRM product and cache its numeric ID for workspace creation.
- Try
mcp__plugin_monday-crm_monday__get_user_context. - If missing/auth error/no workspace:
- Print exactly: "I don't see the monday connector active on this session. Install the monday connector at monday.com/mcp, then run
/monday-crm:workspace-builderagain." - Stop.
- Print exactly: "I don't see the monday connector active on this session. Install the monday connector at monday.com/mcp, then run
- If connector works, cache
user.idanduser.name. - Check
account.products(fromget_user_context) for an entry withkind: "crm". If not found, print: "This plugin requires a monday CRM account. Your current plan doesn't include the CRM product — visit monday.com/crm to start a trial." and stop. - Get the CRM product's numeric ID (needed for workspace creation — the
kindstring alone is not sufficient):
via{ account { products { id kind } } }all_monday_api. Find the entry withkind: "crm"and cache itsidascrmProductId. This ID is account-specific (e.g.,"1312540") — do not hardcode it.
PAUSE: do not write any
create_*call before Step 5, and never before Step 0 passes.
Step 1: Detect mode
- Default — confirm the full build plan once (batch) before executing. Confirms again only for delete operations.
- Silent — skip confirmations, stay on α scope (no β seed items). Triggered by "silently", "skip confirmations", or similar in the user's request.
- Proactive — ask once: "Proactive mode will create the board(s), groups, columns, AND seed example items. (a) Approve all, (b) Review each create call, (c) Skip seed items?". Cache the choice.
If undeclared, assume Default.
Hard safety rail regardless of mode: no deletes (boards, columns, items), no amount-column writes, no cross-workspace moves, no overwriting an existing same-named board, no modifying columns on boards the user didn't ask us to touch, no board creates outside the user-confirmed workspace.
Step 2: Discover — learn about the user's business
Goal: Get enough signal to propose a board shape without forcing the user into a taxonomy. The whole skill exists to bypass the "where do I start" paralysis — surfacing internal labels like "B2B sales" or "Outbound" defeats that.
2a: Website enrichment (preferred)
Ask first: "What's your company website? I'll read it to get context on your business — or describe your business in a sentence if you'd prefer."
- If a URL is provided →
WebFetchthe homepage. Extract: industry, product/service description, target customer (B2B/B2C, company size), any sales/CRM terminology used on the site (e.g., "clients", "projects", "leads", "cases"). Use this as the primary business context for Step 3 — skip the free-text question below entirely. - If no URL / user prefers to describe → fall through to 2b.
If WebFetch fails (404, timeout, paywalled) → fall through to 2b silently, don't surface the error.
2b: Free-text fallback
Ask one open prompt: "Tell me about your business — industry, what you sell, who you sell to, roughly how many deals/leads you track. One or two sentences."
2c: One clarifying follow-up (if needed)
Only if the description (from website or free-text) is genuinely under-specified for a column-set decision, ask one clarifying follow-up:
- Currency / deal-size unit if values are mentioned.
- Approximate pipeline volume (<50 / 50–500 / 500+) if it'll change between a single-board vs. two-board funnel.
Hard cap: 2 questions total across 2a–2c. Anything beyond that defeats the skill.
Step 3: Map description → internal archetype → board shape (Synthesize)
Goal: Translate the free-text description into a concrete board proposal. Internal mapping uses an archetype taxonomy as scaffolding — the user never sees the archetype label.
Internal archetype map (not user-visible)
| Signals in description | Internal archetype | Default board shape |
|---|---|---|
| Long sales cycle, account/stakeholder language ("contracts", "buyers", "procurement"), deal sizes >$1K | B2B sales | Single Deals board, pipeline as groups, rich columns |
| High volume / short cycle / consumer-facing ("orders", "customers", "products", e-commerce, retail) | B2C transactional | Orders + Customers (two boards), pipeline as status column |
| Project / hourly / engagement language ("clients", "retainers", "billable", "projects") | Services | Engagements + Clients, pipeline as groups, effort/hours columns |
| Outbound / lead-gen / top-of-funnel ("SDR", "cold outreach", "leads", "ICP") | Outbound | Leads + Deals (two-board funnel), status on Leads, groups on Deals |
| Mixed / unclear / industry-specific (recruiting, real estate, law firm, etc.) | Custom | Compose from primitives (see below) — don't force a fit |
Custom mode
When the description doesn't fit cleanly, compose the board structure from primitives rather than forcing an archetype:
- Primary entity board (e.g.,
Candidatesfor recruiting,Listingsfor real estate,Mattersfor a law firm) — name reflects the user's own language. - Pipeline mechanism (groups vs. status column) — pick groups for low-volume / high-touch, status column for high-volume.
- Secondary board if the description names two distinct entities (e.g.,
Candidates+Roles,Listings+Buyers). - Columns chosen from the standard set (Owner, Stage, Value, Probability, Date, Source, Notes) plus 1–3 industry-specific columns inferred from the description.
Output to user
Present a complete, named board structure as a markdown table. Use the user's own terminology wherever possible (if they said "matters", call the board "Matters" not "Cases"). Skip any internal archetype label.
For each proposed board:
- Board name (no plugin prefix).
- Group list with concrete labels.
- Column list with types (e.g.,
Stage (status),Owner (people),Value (numbers, $),Last touch (date)). - One line of rationale grounded in the user's description (not the archetype): "You mentioned tracking listings and buyers separately, so I split them across two boards."
Do not include workspace name here — workspace hasn't been resolved yet (Step 4). The batch confirm in Step 5 is where the workspace name appears.
Then ask: "Build this as-is, change anything before building, or describe your business differently?"
Hard rule: no writes until the user confirms.
Step 4: Resolve target workspace
Goal: Land in the right workspace without cluttering Main. Prefer existing CRM workspaces over creating new ones.
- From
get_user_context, get the workspace list. Then calllist_workspacesto get all writable workspaces. - Identify CRM workspaces: A workspace is likely CRM-native if its name contains "CRM" (case-insensitive) or if it was previously used for CRM boards. Surface CRM-named workspaces first in the options list.
- If the user has exactly one writable workspace → use it (skip ask).
- If multiple →
AskUserQuestionwith workspace names (CRM ones labeled[CRM]) + option "create a new one". - If "create a new one" → after confirming, call:
wherecreate_workspace({ name: "<user input or default 'CRM'>", workspaceKind: "open", accountProductId: "<crmProductId>" })crmProductIdis the numeric ID cached in Step 0 (e.g.,"1312540") — NOT the string"crm". Passing the numeric ID ties the workspace to the monday CRM product; omitting it or passing"crm"creates a generic monday workspace with no product association. - Idempotency: before any
create_board,searchfor existing boards in this workspace whose names match the proposed names (case-insensitive). If found:- Surface to user: "You already have a board named
<name>. (a) Skip this board, (b) Create alongside as<name> 2(I'll re-confirm the full plan before building), (c) Cancel and pick a different workspace?" - Option (b) updates the plan — show the revised full plan and ask for confirmation before any writes (even in Default mode).
- Never overwrite, never write into the existing board, never delete it.
- Surface to user: "You already have a board named
Step 5: Build α — create boards (Publish)
Goal: Execute the confirmed structure with idempotency, in a deterministic order.
Confirm-before-write (Default mode)
Before the first create_board call, print a single batched confirm:
"I'll create board(s) with columns total in workspace <workspace>. Want example items added after building? (yes / no) — Proceed? (yes / no / show plan again)."
This single confirm captures both the build plan and the β opt-in. Per-call confirmation only kicks in for delete operations (group deletes). Spamming the user with N confirms defeats the skill.
Build sequence
For each proposed board:
create_board({ boardName: "<name>", workspaceId, boardKind: "public" | "private" })— defaultpublicunless user said otherwise. Cache returnedboardId.- Replace default groups: monday creates a default "Group Title" / "New Group" entry on every new board. Query existing groups first, then:
- Rename the first default group to the first proposed group via
all_monday_apiusingupdate_groupmutation. create_groupfor remaining proposed groups.- If renaming fails, use
delete_groupmutation viaall_monday_api(Default mode confirms before delete) thencreate_groupcleanly. - See
references/monday-graphql-mutations.mdfor exact payloads.
- Rename the first default group to the first proposed group via
- For each proposed column:
create_column({ boardId, columnType: <type>, title: <title>, defaults: <settings> }). For status columns, pass labels viadefaults; for numbers columns, passunit.symbol. - Order matters for the user's mental model: create columns left-to-right in the order proposed (Stage first, then Owner, then Value, then dates, then long_text last). monday assigns column position by creation order.
- After each
create_*, mirror to chat: "Created columnOwner(people) onDeals.". Default mode runs through creates inside a confirmed plan; Silent runs through all; Proactive (b) confirms each; Proactive (c) skips seed step.
Step 6: Seed β (opt-in)
Goal: Show the shape with data — empty boards are intimidating.
Only runs if mode = Proactive (option a) OR user opted in at the Step 5 batch confirm.
For each created board, create_item for 5 example items distributed across the proposed groups/stages, with realistic but obviously-fake values:
- Names like
Acme Corp — Q3 expansion,Beta Industries — pilot deal(clearly fictional but no prefix pollution). - Stage spread: 1 New, 2 mid-funnel, 1 Won, 1 Lost (or shape-appropriate).
- Owner = the running user (so every example shows up in the user's "my items" filters).
- All other columns populated to demonstrate the data model.
Source = Claudeon a status column. The board was just created in Step 5 with this column included by default — Step 6 just sets the value. If for any reason the column wasn't created, prompt once: "Add aSourcecolumn so we can flag the example items? (yes / skip — keeps the items unflagged)".
Cap at 5 items per board, hard. The Source = Claude flag supports a clean cleanup loop later — user filters by source, deletes the examples manually once they have real data.
Step 7: Publish setup doc (Publish)
Goal: Leave a navigable summary so the user knows what was created and where to go next.
Idempotency: before creating, read_docs({ type: "workspace_ids", ids: ["<workspace id>"], order_by: "created_at", limit: 5 }) and look for the exact title — results are newest first and carry each doc's full body, so keep the page small; DOCUMENTS search can miss a doc created minutes ago and check it carries the Generated by Claude · workspace-builder footer. If found, skip creation and print:
"A setup doc from this session already exists: <doc url>. The build summary has been added to chat above."
Do not attempt to update the existing doc.
If no existing doc found, create_doc in the user's workspace, title CRM Setup — <Mon DD>, <YYYY>. Body:
# CRM Setup — <Mon DD>
## What was created
### Board: <Name>
- Workspace: <workspace>
- URL: <board url>
- Groups: <list>
- Columns: <list with types>
(Repeat per board.)
## Example items
<count> example items added per board, flagged `Source = Claude` on a status column. Filter by that source value to find and remove the examples once you've added real data.
## What's next
1. **Add your real deals.** Replace the examples or add fresh items.
2. **Try the morning briefing.** Once you have 5+ deals with stages set, run `/monday-crm:daily-briefing`.
3. **Set up automations.** Open the Automation Center on each board to wire status changes, due-date reminders, and lead routing.
4. **Audit hygiene later.** After 30 days, run `/monday-crm:data-cleanup` for a fill-rate audit.
---
Generated by Claude · workspace-builder · <ISO timestamp> · re-run `/monday-crm:workspace-builder` only if you want to scaffold an additional CRM (won't touch this one).
Step 8: Handoff to daily-briefing
If at least one board was created and the user is in Default/Proactive mode, print:
"Want to try the morning briefing now? Once you add a few real deals it'll prioritize your day. Run /monday-crm:daily-briefing whenever you're ready."
Silent mode skips this prompt.
Step 9: Close the loop
- Print a one-line summary:
Created <N> board(s), <M> columns, <K> seed items. Doc: <url | "doc creation failed — see summary above">. - If any write failed mid-run: list the failures and offer to retry only those — never re-run the whole skill on retry (would duplicate boards if Step 4 idempotency was bypassed).
Shared patterns
- No prefix on titles. Boards take the user's chosen names. Setup doc uses a plain title + the visible
Generated by Claude · workspace-builderfooter for findability + idempotency (no HTML comments — monday strips them). Source = Claudeon every seed item via a status column. No[Example]prefix.- Idempotency before every create — board-name collision check, doc same-day collision check (
read_docsby workspace + exact title). On doc collision: skip creation, surface existing link. - Safety rail. No deletes (except confirmed default-group cleanup on freshly-created boards), no amount-column writes, no cross-workspace creates, no writes outside the confirmed plan.
- Confirm in batches, not per-call — the whole skill exists to reduce friction; per-call confirms defeat it.
- Type-based column choices, not English-name-based — works on non-English monday installs.
- Use the user's terminology in board / group / column names, not the internal archetype names.
Output template
Setup doc (create_doc body)
# CRM Setup — Jun 15
## What was created
### Board: Deals
- Workspace: CRM
- URL: https://monday.com/boards/123456789
- Groups: New · Discovery · Proposal · Negotiation · Won · Lost
- Columns: Stage (status) · Owner (people) · Deal Value (numbers, $) · Probability (numbers, %) · Expected Close (date) · Last Touch (date) · Source (status) · Notes (long_text)
## Example items
5 example items added, flagged `Source = Claude` on the Source status column. Filter by that source value to find and remove the examples once you've added real data.
- Acme Corp — Q3 expansion (Discovery, $85K, Owner: Tom Ramu)
- Beta Industries — pilot (Proposal, $32K, Owner: Tom Ramu)
- Gamma Ltd — renewal (Won, $120K, Owner: Tom Ramu)
- Delta Co — trial (New, $15K, Owner: Tom Ramu)
- Epsilon Inc — churned (Lost, $28K, Owner: Tom Ramu)
## What's next
1. **Add your real deals.** Replace the examples or add fresh items.
2. **Try the daily brief.** Once you have 5+ deals with stages set, run `/monday-crm:daily-briefing`.
3. **Set up automations.** Open the Automation Center on each board to wire status changes, due-date reminders, and lead routing.
4. **Audit hygiene later.** After 30 days, run `/monday-crm:data-cleanup` for a fill-rate audit.
---
Generated by Claude · workspace-builder · 2026-06-15T09:00:00Z · re-run `/monday-crm:workspace-builder` only if you want to scaffold an additional CRM (won't touch this one).
Chat one-liner:
Created 1 board, 8 columns, 5 seed items. Doc: [url].
Error handling reference
| Failure | Behavior |
|---|---|
| Connector not installed | Step 0 stops; print install link + skill re-run command. |
| No writable workspace | Step 4 stops; print: "You don't have write access to any workspace. Ask a workspace admin, then re-run." |
| Board name collision | Step 4 idempotency prompt; option (b) re-confirms full plan before building. |
create_board fails (perms) | Stop and surface error verbatim — don't continue creating columns into a non-existent board. |
create_column fails on a column | Skip that column, log to chat, continue with the rest, list skipped in Step 9 summary. |
create_group fails | Skip; the board still works with default groups; flag in summary. |
| 429 rate limit | Backoff 3x (1s, 2s, 4s); on third fail, halt and print: "monday is rate-limiting; retry in 60s." |
| User halts mid-build | Keep writes up to halt point; Step 7 setup doc reflects partial state. |
| Setup doc create fails | Print the doc body in chat with banner "Couldn't publish the setup doc — copy the summary below." |
Completion criteria
- Step 0 (connector check) ran and passed.
- At least one board was created (or user explicitly cancelled at Step 3/4).
- No internal archetype label leaked into user-visible output (board/group/column names use the user's terminology).
- Every seed item carries
Source = Claudeon a status column (or the user explicitly skipped the source-column step). - The setup doc was created (with
Generated by Claude · workspace-builderfooter) or printed to chat on failure. - Safety rail held: no deletes outside default-group cleanup on freshly-created boards, no amount-column writes, no cross-workspace creates, no writes outside the confirmed plan.
- The chat summary lists any per-column failures.
MCP servers 1
Sponsors
Details
- Marketplace
- mondaycom/mcp
- Source
- plugins/monday-crm
- Author
- monday.com
- Category
- Crm
- License
- MIT
- Keywords
- monday, monday-crm, crm, sales, pipeline, forecast, daily-briefing, meeting-to-deal, data-cleanup, workspace-builder, sequence, automation, activity, timeline, activity-insights, win-loss