mondaycom avatar

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-mcp

Run it inside Claude Code after adding the marketplace with /plugin marketplace add mondaycom/mcp.

Contents

Discovered from source

Skills 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-insights returns aggregated counts — not individual activity records. For activity history with content, use get-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_id is 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 saysgroupByNotes
"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

  1. 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.

  1. If a board name is clear from the argument → mcp__plugin_monday-crm_monday__search or mcp__plugin_monday-crm_monday__get_board_info to resolve the ID.
  2. If multiple CRM boards exist → ask: "Which board should I analyze — Deals, Contacts, or Leads?"
  3. 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, pass userIds
  • Item/deal name mentioned → resolve item ID, pass itemIds (or redirect to get-timeline-items for content)

aggregationType: default count. Use sum / avg for duration questions ("how long were the calls").


Step 3: Fetch and synthesize

  1. Call mcp__plugin_monday-crm_monday__get-activity-insights with resolved parameters.
  2. 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."
  3. 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

FailureBehavior
Connector missingStop; print install prompt.
Board not resolvedAsk user to specify the board.
Tool unavailable"Activity insights aren't available on the connector for your account yet."
No resultsConfirm date range; suggest widening.
Rep name not foundAsk for clarification or list available reps via list_users_and_teams.
Item-level content requestRedirect to get-timeline-items; get-activity-insights operates at board level.

Completion criteria

  • Connector check passed.
  • board_id resolved 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)

TriggerActionAccounts
Status changes to somethingMove item to group9,821
Status changes to somethingNotify someone6,482
Status changes to somethingSet date6,341
Item createdNotify someone / assign / set date10,019
Date arrivesNotify / change status4,972
Button clickedAny action3,015
Status changes from X to YMove / notify1,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 today as 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_automations returns 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

  1. mcp__plugin_monday-crm_monday__get_user_context. On error → print install prompt, stop.

Step 1: Detect intent

IntentTrigger 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

  1. Extract board reference from argument (Deals, Contacts, Leads, or specific name).
  2. If mentioned → mcp__plugin_monday-crm_monday__search or get_user_context favorites.
  3. 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

  1. mcp__plugin_monday-crm_monday__list_automations({ boardId }).
  2. Format as table: Name, Trigger, Status.
  3. Note legacy automations as read-only.
  4. Offer next action: "Want to turn any off, or set up a new one?"

Step 5: Manage (activate / deactivate / delete)

  1. Resolve ID via list_automations if needed.
  2. For delete: explicit irreversibility warning: "Delete '[name]'? This can't be undone. (yes / cancel)"
  3. mcp__plugin_monday-crm_monday__manage_automations({ workflowId, action }).
  4. 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

FailureBehavior
Connector missingStep 0 stops; print install prompt.
Board not foundBroaden search; ask user.
needs_clarificationPresent unresolved fields; gather answers; retry once.
Date arithmetic requestedExplain 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 legacySame as above.
Create fails after retrySurface 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_clarification handled: 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-activity to 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)

  1. Argument given: numeric → board id; text → search({ searchType: "BOARD", searchTerm: <arg>, strategy: "SPEED" }). One match → use it; several → AskUserQuestion.
  2. No argument: scan get_user_context favorites 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
  3. Nothing found → search for "crm", then "deals", then "contacts".
  4. Still nothing → standalone (Step 2c).
  5. Several boards of the same type → AskUserQuestion with the board names plus "all of them". Remember the choice for the session.
  6. 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:

TypeSignals
pipelinea status column with stage-like labels (an is_done: true or Won/Lost label) + a numbers column with a currency unit
leadsa status column without is_done and lead-like labels (New, Contacted, Qualified, Disqualified)
contactsmostly text / email / phone columns, no Won/Lost pattern
accountscompany-named items with numbers (revenue/ARR) and status columns
generalanything 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.

ConceptTypeTitle hintsBoard types
Stage / statusstatusstage, statusall
Ownerpeopleowner, rep, assignedall
Valuenumbers (currency)value, amount, revenuepipeline, accounts
Probabilitynumbers (%)probability, %pipeline
Close datedateclose, expected, targetpipeline
Last touchdatetouch, interaction, contactedall
Next follow-updatefollow-up, next stepcontacts, accounts
Companytextcompany, account, organizationcontacts, 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 }); follow nextCursor while has_more, up to 2,000 items (above that, add a sampling note). Use board_insights for 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 in tldr verbosity.

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.

SectionRule
Tasks due todayin the Step 5f list
Closing todayclose date = today, not terminal
Slippingclose date in the past, not terminal
Going coldlast touch (after the 5d correction) more than 14 days ago
Follow-uplast touch more than 7 days ago and probability ≥ 50%
On trackprobability ≥ 70%, last touch within 7 days, close date within 30 days
New this weekcreated in the last 7 days
Recent meetingsStep 5e meetings, matched first
Yesterday's movementsStep 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

  1. 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)

  1. 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.
  2. Idempotency (one brief per day per target):
    • Item: get_updates({ objectType: "Item", objectIds: ["<item id>"], limit: 25 }); if an update contains daily-briefing · <today YYYY-MM-DD>, post the new brief as a reply (create_update with parentId of 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 with update_doc (add_markdown_content, starting with ## Refreshed at <HH:MM>).
  3. 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.
  4. 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> }).
  5. 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).

  1. Resolve the recipient: list_users_and_teams({ name: "<name>" }); if no name was given, ask.
  2. 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

FailureBehavior
Connector missingStep 0 stops with the install message
No CRM boardStandalone brief (Step 2c)
Board over 2,000 active itemsCap, note the sampling, totals from board_insights
Activity / updates 403Note in Data hygiene; continue
Timeline call fails for an itemUse the date column for that item
Notetaker unavailableLeave out Recent meetings
429Back off 3 times, then stop with a retry message
Publish permission errorDoc, then chat only
Same-day brief already postedReply (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 / doc or 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 with Generated by Claude · data-cleanup footer.
  • β (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 by change_item_column_values. For country columns, use: change_multiple_column_values with column_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.

  1. Try mcp__plugin_monday-crm_monday__get_user_context.
  2. 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.
  3. If it works, cache user.id + user.name for 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.

  1. If the user passed a board via argument: numeric → use as boardId directly; string → mcp__plugin_monday-crm_monday__search with searchType: "BOARD". One match → use it; multiple → AskUserQuestion.
  2. If no argument: get_user_context → scan relevantBoards + favorites for names matching deals|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-builder to 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:

  1. Missing data — required fields (stage, owner, value, close_date) blank on >25% of items; compute fill-rate per column.
  2. Stalled groups — groups with no item updates in >30 days.
  3. Column drift — columns populated on <5% of items over 90 days (likely abandoned → suggest archive).
  4. Automation gaps — stage-based automations absent on deal boards (probe via all_monday_api; if scope unavailable, skip with note).
  5. 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 typeAudit ruleFixable here?
Missing emailemail column empty AND contact name present AND company resolvable (see note below)✅ (heuristic guess from company domain — flagged with Source = guessed)
Missing phonephone column empty❌ (no source — flag only)
Phone formatPhone present but no country code, or contains letters / >2 separators✅ (E.164 normalization)
Country code missingcountry column empty AND phone has parseable country code OR email domain has CCTLD✅
Email caseMixed-case (John.Doe@Acme.COM)✅ (lowercase)
Stale last-touchdate last-touch >90d AND stage active✅ (set to "today" only if user picks; never overwrites a more-recent date)
Owner missingpeople owner empty AND stage active✅ (bulk-assign within a user-picked group/scope)
Stage driftitems in non-canonical groups; user explicitly wants normalization✅ (bulk-set within user-picked scope)
Amount missingnumbers value empty AND stage past "qualifying"❌ (flag only — forecast integrity rail)
Source missingstatus 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., 1 for US, 44 for UK) → prepend +.
    • Edge case: phone is too short (<7 digits) or too long (>15 digits) → skip with reason "unparseable".
  • 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_api with {"countryCode": "<ISO2>", "countryName": "<name>"} shape.
  • Country code from email CCTLD: if email ends in .uk / .de / .fr etc. and country empty → infer.
  • Email guess: for items with name + resolvable company domain, try <firstname>.<lastname>@<domain> lowercase. Add a Source = guessed status 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

  1. 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?"
  2. 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.
  3. 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)."
  4. 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

FailureBehavior
Connector missingStep 0 stops; print install link.
No board foundStep 2 stops; suggest workspace-builder.
Empty selection at Step 4Skip writes; publish summary doc with audit only.
0 fixable gapsPrint "Board's already clean — N flag-only items in summary doc."
429 rate limitBackoff 3x; halt on third with partial summary.
Per-item permission errorSkip, log, continue.
Column type changed mid-runSkip that column on that item, continue.
User haltKeep writes done; emit partial summary with last-written item ID.
Email-guess accuracy concernStrong 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-cleanup footer.
  • 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 = guessed flag (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_dashboard with 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-cleanup before publishing.

Step 0: Connector check

Goal: Fail fast if the user has no monday MCP connection.

  1. Try mcp__plugin_monday-crm_monday__get_user_context.
  2. 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.
  3. If connector works, cache user.id and user.name for 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.

  1. Detect Default / Silent / Proactive per shared pattern.
  2. If no period declared, AskUserQuestion: "Which period? (a) this quarter, (b) next 90 days, (c) custom." Store period_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).

  1. get_board_info(boardId).
  2. get_column_type_info for any ambiguous column.
  3. If no forecast-category column exists AND the user wants commit vs best-case split: prompt the user — "I can add a Forecast Category column (Commit / Best-case / Pipeline / Omit). OK?" Only create via create_column in 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:

  1. Idempotency: search({ searchType: "DASHBOARDS", searchTerm: "Forecast <period>", creatorIds: [<user id>], strategy: "SPEED" }). A result titled exactly Forecast — <period> is this skill's earlier dashboard: add or refresh widgets on it instead of creating a second one. Dashboards carry no marker — create_dashboard has no description field — so the exact name plus the creator is the key.
  2. create_dashboard({ name: "Forecast — <period>", workspace_id: "<board's workspace id>", board_ids: ["<board id>"] }).
  3. For each bucket × month: create_widget(dashboardId, ...) — see Widget call shapes below.
  4. 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.

  1. list_users_and_teams → resolve sales leader.
  2. Before granting access, ask: "Share this dashboard with [name]? They'll get a notification and viewer access. (yes / no)"
  3. On confirmation: all_monday_api GraphQL mutation to grant viewer permission on the dashboard.
  4. 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 (with Generated by Claude · forecast in 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 (search DASHBOARDS) 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:

WidgetTypeValue
Closed-wonNumber$120K (1 deal)
CommittedNumber$85K (1 deal)
Best-caseNumber$32K (1 deal)
PipelineNumber$48K (2 deals)
Buckets × close monthStacked barJun / Jul / Aug
Committed + best-case detailTableAcme 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

ErrorBehaviour
Connector missing / auth errorPrint install URL, stop immediately.
No board found matching queryAsk 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 periodSurface count = 0, ask if period or board is correct before stopping.
429 rate limitPause 2 s, retry up to 3× with exponential backoff; surface if still failing.
create_widget partially failsKeep the dashboard, list failed widgets, offer retry.
Same-day artifact already existsIdempotency 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 search DASHBOARDS).
  • 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-insights is 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-deal instead 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.

  1. Try mcp__plugin_monday-crm_monday__get_user_context. On error → print install prompt, stop.
  2. Try mcp__plugin_monday-crm_monday__get-custom-activities.
  3. If successful → cache the list of activity types (id, name, icon) for use in Step 3. Set activities_available: true.
  4. If permission error or tool unavailable → set activities_available: false. The skill can still operate with create-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:

IntentTrigger 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.

  1. 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)
  2. If name extracted → mcp__plugin_monday-crm_monday__search({ searchType: "ITEMS", searchTerm: "<name>", strategy: "SPEED" }) (retry with strategy: "BALANCED" if nothing comes back).

    • Single result → use it.
    • search returns boardId but no board name: resolve names from get_user_context relevant boards, or get_board_info for 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_page on likely boards (Deals, Contacts, Leads). Still zero → ask user.
  3. If no name in argument → ask: "Which CRM item should I log this activity on? (company name, deal name, or contact name)"

  4. 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:

  1. 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)
  2. Map the type to the closest entry returned by get-custom-activities by name (e.g. "Call", "Phone call", "Meeting"). If unclear, present the returned types: "What type of activity? ( / note)"
  3. If no returned type fits (many accounts have no "Call" type — e.g. only Email, Meeting, Task), log it as a note prefixed Call: or Meeting: 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_id is numeric; custom_activity_id is the id from get-custom-activities (not the name); timestamp is ISO 8601; put attendees and follow-up in content as text. For meetings with a duration, add start_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

  1. mcp__plugin_monday-crm_monday__get-timeline-items({ item_id, limit: 25 }); entries come newest first, so follow cursor only until entries predate the requested window.
  2. Parse time filter from argument (this week / last 7 days / today / default last 10).
  3. Format output as a table with Date, Type, Summary columns.
  4. If zero activities: "No activities on in . Want to log one now?"
  5. 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.

  1. Retrieve timeline: mcp__plugin_monday-crm_monday__get-timeline-items({ item_id, limit: 25 }).
  2. Present recent entries; resolve which one is being corrected from context or by asking.
  3. 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)

  1. mcp__plugin_monday-crm_monday__create-timeline-note({ item_id, content: "Correction to <type> from <date>: <correction>" }).
  2. 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

FailureBehavior
Connector missingStep 0 stops; print install link.
Activity types unavailableDegrade to notes; inform user.
CRM item not foundBroaden search; ask user.
Create fails (invalid type)Fall back to create-timeline-note; inform user.
Correction note failsSurface error; suggest editing in monday CRM UI.
Timeline empty on readOffer 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 recap update per matched deal (key points, commitments, open questions, stage signal), each carrying a ref 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

  1. 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.
  2. Internal domain: get_user_context does not return the user's email. Take it from get_board_info on the Deals board (Step 4) when creator.id equals 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, set internal_domain = none. Never fall back to a vendor domain. With internal_domain = none, only addresses the user confirms as theirs count as internal.
  3. explore_meetings({ limit: 1 }). Results → notetaker_available: true. Auth, permission or not-enabled error → notetaker_available: false and 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:

ModeWritesConfirmation
Default (if undeclared)recaps, sync doc, plus confirmed stage edits, last-touch dates and opt-in contactsone batched confirmation (Step 7)
Silentrecaps and sync doc only. Stage edits, last-touch, contacts and nudges are never written; they are listed under "Pending your review" in the sync docnone
Proactiveeverything in Default plus nudgesasked 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

  1. Parse the argument: "today", "yesterday", "last N days", "since YYYY-MM-DD". Default: last 24h.
  2. If no window was given, say once: "Using last 24h. Add 'yesterday', 'last 7 days' or 'since YYYY-MM-DD' to change the range."
  3. Window over 14 days → confirm with AskUserQuestion and state the cost: it may pull up to 200 meetings and take several minutes.

Step 3: Pull meetings

3a — Notetaker (notetaker_available: true)

  1. 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.
  2. 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.
  3. 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

  1. Deals board: scan get_user_context favorites and relevant boards for deal|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.
  2. 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.
  3. 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 — a text column, or a mirror column showing the linked account or company (use its displayed text); many boards have neither, so the deal name is also used for company matching — owner people, stage status, last-touch date (title hint touch / contact / interaction; skip if none), value numbers (read only), and any board_relation column pointing at Contacts.
    • Contacts: email, company text, phone, owner people, a board_relation column pointing at the Deals board (optional), a source status column (optional).
  4. Stage labels: from the stage column's labels, Won = labels with is_done: true; Lost = label text containing lost / perdido / verloren / perdu. No is_done label → ask which label means Won. Keep every label's id and text — Step 6 may only propose, and Step 7c only write, labels from this list. 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).
  5. 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 }); follow nextCursor while has_more, up to 2,000 deals (above that, add a sampling note). Check the filter shape with get_column_type_info({ columnType: "status", fetchMode: "guidelines" }) if the call is rejected.

Step 5: Match meetings to deals

For each meeting:

  1. External attendees = attendees whose domain is not internal_domain and 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.
  2. 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 trailing corp, inc, hq, group, labs, app or team (acmecorp ↔ "Acme"). Anything looser does not count (applebees is 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.
  3. 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".
  4. 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.
  5. 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 is low. Moving to procurement or legal review is not a win. Only high signals enter the plan; low ones 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 same AskUserQuestion call: "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:

  1. Column edits first (only if approved — not in Silent, not after "skip column edits"): one change_item_column_values call per deal carrying both edits: { boardId, itemId, columnValues: "{\"<stage col>\": {\"label\": \"<existing label>\"}, \"<last-touch col>\": {\"date\": \"YYYY-MM-DD\"}}" }. Never pass createLabelsIfMissing. Never write the value column. If the call fails, list the edit under "Pending your review".
  2. 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 groupId out — the board's default group is used.
  • Include the relation key only if a board_relation column to the Deals board exists, and the source key only if a source status column already has a Claude label. 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

  1. 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 exactly Meeting sync — <Mon DD, YYYY> exists, append to it with update_doc (see references/templates.md).
  2. 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> }).
  3. No Deals board (Step 4), or both calls fail → print the sync doc in chat instead.
  4. 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_domain set from the user's email, or none for 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-sequences takes an optional board_id. Without it, it returns only your sequences (ones you created), across boards — not every sequence on a board. With board_id it returns all sequences on that board, including teammates'. To find a sequence by name, try without board_id first; if it isn't there, resolve the board (ask if needed) and retry with board_id.
  • create-sequence documents no personalization placeholders: a {{name}} in an automatic_email body was sent literally in a live test. Never add {{...}} variables to step bodies yourself.
  • create-sequence has a built-in gate system: call it with what you have; if anything's missing the tool returns CONFIRMATION_REQUIRED with exact instructions — follow them verbatim, never pre-empt the gates.
  • enroll-item-in-sequence takes board_id, sequenceId, and itemIds (array of string IDs).

Tools (MCP)

  • get-board-sequences — list all sequences on a board, or only the user's own sequences when board_id is omitted.
  • get-sequence-analytics — per-run, level, and step analytics for one sequence.
  • get-contact-journey — all sequences a contact/item is enrolled in (needs board_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 retrying create-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

  1. Try mcp__plugin_monday-crm_monday__get_user_context. On error → print install prompt, stop.
  2. 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:

IntentTrigger 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).

  1. If user named a board → mcp__plugin_monday-crm_monday__search or get_board_info to resolve it. On ambiguity, present top results and ask.
  2. If no board named:
    • For list: call get-board-sequences without board_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?"

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_specified gate → follow the returned instructions verbatim: use search to list boards, present as-is, ask user to pick, retry.
  • steps_not_specified gate → follow the returned instructions verbatim: ask user to build steps one at a time or create empty. Never invent steps.
  • connections_not_specified gate (triggered when automatic_email steps need sender/emailColumnId) → the gate returns the user's mailboxes. Ask which one to send from and pass its connectionId + provider as sender; resolve emailColumnId via get_board_info; retry. If the gate says there is no connected mailbox, call show_connect_integration, wait for the user to connect, confirm with check-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

  1. Resolve the sequence: mcp__plugin_monday-crm_monday__get-board-sequences({ board_id }), or without board_id to find it by name — if the name isn't among your own sequences, retry with the board's board_id → present list, ask which sequence if not named.
  2. Resolve the items: extract from the argument (company/contact names) or ask "Which contacts or leads do you want to enroll?". Use search or get_board_items_page to get item_ids.
  3. 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)

  1. mcp__plugin_monday-crm_monday__enroll-item-in-sequence({ board_id, sequenceId, itemIds: ["<id>", ...] }).
  2. 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

  1. Resolve the sequence (board → get-board-sequences → pick by name).
  2. 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)"
  1. mcp__plugin_monday-crm_monday__activate-sequence({ sequenceId }) or mcp__plugin_monday-crm_monday__deactivate-sequence({ sequenceId }).
  2. Report the new state.

Step 7: Execute — Duplicate

  1. Resolve the sequence (board → list → pick).

HITL GATE: "Duplicate ''? The copy will start as INACTIVE. (yes / cancel)"

  1. mcp__plugin_monday-crm_monday__duplicate-sequence({ sequenceId }).
  2. Report: "Created '' (INACTIVE). Activate it? (yes / later)"

Step 8: Execute — Analyze

  1. Resolve the sequence (board → list → pick).
  2. mcp__plugin_monday-crm_monday__get-sequence-analytics({ sequenceId }).
  3. 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
  1. Flag drop-offs: if open rate drops >15pp between consecutive email steps, surface it.
  2. If analytics are empty: "No analytics yet — this sequence hasn't sent any messages."

Step 9: Execute — Contact journey

  1. Resolve the contact item (search by name → item_id; ask for board if unclear).
  2. mcp__plugin_monday-crm_monday__get-contact-journey({ board_id, item_id }).
  3. 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 | — |
  1. If empty: " isn't enrolled in any sequences."
  2. 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-sequence always 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

FailureBehavior
Connector missingStep 0 stops; print install link.
Permission error on sequence toolsSuggest checking CRM Sequences is enabled in account settings.
Board not foundBroaden search; ask user to confirm board name.
Sequence not foundList all on board; ask user to pick.
Enroll — sequence INACTIVEOffer to activate first.
Enroll — partial failureReport succeeded and failed item IDs.
Named sequence not in your own listRetry get-board-sequences with the board's board_id (it may belong to a teammate).
get-contact-journey errorsSay the history couldn't be read and point to the item in monday; no retry loop.
Analytics emptyInform 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 requestRedirect 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-sequence gates 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.

  1. 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.
  2. 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

  1. Resolve the deal: item link, or search by name. If several match, list them (name, owner, value, stage) and ask which one.
  2. 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).
  3. 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).
  4. 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-briefing on 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_value events on the stage column. previous_value.label.text is the old label, value.label.text the new one.
  • move_pulse_from_group events for group moves (for example Active Deals to Closed Won).
  • create_pulse for creation and its source (form, import, manual).
  • Owner changes (update_column_value on 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:

SignalHow
Stage changesCount of stage changes, and how many were backward moves (for example Negotiation back to Proposal)
Time per stageDays between consecutive stage changes. Flag the longest stage
Total cycleFirst 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 slipsNumber of times expected close date moved later, and total days pushed
Value changesStart value, final value, direction and size of each change
Probability driftClose probability at each stage change, if tracked
Owner changesCount and timing. A handover close to the close date is a risk signal
Skipped stagesPipeline stages never visited
Who changed itIf 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:

SignalHow
Activity volumeCount by type, and per stage if you can map dates to the stage history
CadenceAverage days between touches. Longest silent gap and when it happened
Last touch before closeDays between the last activity and the close
ResponsivenessFor emails, inbound versus outbound counts and the typical reply lag in each direction
Multi-threadingDistinct contacts involved. A single-threaded deal is a risk signal
MeetingsNumber held, and whether a meeting happened in each late stage
Customer voiceObjections, budget, timing, competitors, champions, blockers (see the privacy note below)
Rep voiceCommitments, 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_activity call with their ids in itemIds (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:

FieldBest column typeNotes
Full analysis textLong textShort mode: the 7a text. Deep mode: the 7a text plus top drivers, under 3,000 characters
Win or loss reasonStatus or dropdownSuggest the closest existing label. Never create new labels without asking
Top driverDropdown, status or textOptional
Cycle length (days)NumbersOptional
Longest silence (days)NumbersOptional
ArtifactLink, files, or monday doc columnSee "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, then finalize_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_doc and 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, with Generated by Claude · workspace-builder · <ISO timestamp> + Generated by Claude · workspace-builder in 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 = Claude on 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-crm to 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. See references/monday-graphql-mutations.md for 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-briefing to start the daily-ops loop.
  • To data-cleanup: After 30 days of use, suggest /monday-crm:data-cleanup for 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: true on 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 descriptionBoards to propose
Sales rep / AE / closing dealsDeals + Contacts
SDR / BDR / outbound / lead genLeads + Deals
Sales manager / team leadDeals — suggest dashboards manually
Account manager / renewals / CSMAccounts + Contacts + Deals
Full team / full CRM setupDeals + Contacts + Leads + Accounts
Solo founder / small teamDeals 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.

  1. Try mcp__plugin_monday-crm_monday__get_user_context.
  2. 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-builder again."
    • Stop.
  3. If connector works, cache user.id and user.name.
  4. Check account.products (from get_user_context) for an entry with kind: "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.
  5. Get the CRM product's numeric ID (needed for workspace creation — the kind string alone is not sufficient):
    { account { products { id kind } } }
    
    via all_monday_api. Find the entry with kind: "crm" and cache its id as crmProductId. 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 → WebFetch the 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 descriptionInternal archetypeDefault board shape
Long sales cycle, account/stakeholder language ("contracts", "buyers", "procurement"), deal sizes >$1KB2B salesSingle Deals board, pipeline as groups, rich columns
High volume / short cycle / consumer-facing ("orders", "customers", "products", e-commerce, retail)B2C transactionalOrders + Customers (two boards), pipeline as status column
Project / hourly / engagement language ("clients", "retainers", "billable", "projects")ServicesEngagements + Clients, pipeline as groups, effort/hours columns
Outbound / lead-gen / top-of-funnel ("SDR", "cold outreach", "leads", "ICP")OutboundLeads + Deals (two-board funnel), status on Leads, groups on Deals
Mixed / unclear / industry-specific (recruiting, real estate, law firm, etc.)CustomCompose 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., Candidates for recruiting, Listings for real estate, Matters for 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.

  1. From get_user_context, get the workspace list. Then call list_workspaces to get all writable workspaces.
  2. 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.
  3. If the user has exactly one writable workspace → use it (skip ask).
  4. If multiple → AskUserQuestion with workspace names (CRM ones labeled [CRM]) + option "create a new one".
  5. If "create a new one" → after confirming, call:
    create_workspace({ name: "<user input or default 'CRM'>", workspaceKind: "open", accountProductId: "<crmProductId>" })
    
    where crmProductId is 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.
  6. Idempotency: before any create_board, search for 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.

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:

  1. create_board({ boardName: "<name>", workspaceId, boardKind: "public" | "private" }) — default public unless user said otherwise. Cache returned boardId.
  2. 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_api using update_group mutation.
    • create_group for remaining proposed groups.
    • If renaming fails, use delete_group mutation via all_monday_api (Default mode confirms before delete) then create_group cleanly.
    • See references/monday-graphql-mutations.md for exact payloads.
  3. For each proposed column: create_column({ boardId, columnType: <type>, title: <title>, defaults: <settings> }). For status columns, pass labels via defaults; for numbers columns, pass unit.symbol.
  4. 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.
  5. After each create_*, mirror to chat: "Created column Owner (people) on Deals.". 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 = Claude on 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 a Source column 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-builder footer for findability + idempotency (no HTML comments — monday strips them).
  • Source = Claude on every seed item via a status column. No [Example] prefix.
  • Idempotency before every create — board-name collision check, doc same-day collision check (read_docs by 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

FailureBehavior
Connector not installedStep 0 stops; print install link + skill re-run command.
No writable workspaceStep 4 stops; print: "You don't have write access to any workspace. Ask a workspace admin, then re-run."
Board name collisionStep 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 columnSkip that column, log to chat, continue with the rest, list skipped in Step 9 summary.
create_group failsSkip; the board still works with default groups; flag in summary.
429 rate limitBackoff 3x (1s, 2s, 4s); on third fail, halt and print: "monday is rate-limiting; retry in 60s."
User halts mid-buildKeep writes up to halt point; Step 7 setup doc reflects partial state.
Setup doc create failsPrint 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 = Claude on a status column (or the user explicitly skipped the source-column step).
  • The setup doc was created (with Generated by Claude · workspace-builder footer) 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