watch?v=eT_6uaHNlk8 analyze and extract the workflows

Anthropic's Claude Cowork features 11 new plugins, each bundling skills, slash commands, and connectors into domain-specific workflows for knowledge workers. These plugins enable automated, multi-step processes invoked via slash commands (e.g., /review-contract) or contextual skills, with outputs like documents, analyses, or visualizations. Plugin Structure Plugins consist of a JSON manifest (name, version, MCP servers), slash commands (markdown-defined functions), skills (domain metadata with Pythonic functions), and connectors (integrations like email or databases). They activate just-in-time to avoid context bloat, making workflows predictable and automation-like. Extracted Workflows PluginKey Workflow StepsExample Commands/Skills Productivity Scan emails/calendars/chats; update tasks/to-dos; check completions/additions. /update (task sync) Sales Prospect research; draft outreach; competitive intelligence; pipeline review/forecasting; follow-up/nurture. /competitive-brief, /pipeline-review Customer Support Triage tickets (critical/high/medium/low); choose response path (escalate/research); draft response; document to knowledge base. Ticket prioritization Product Management Create PRDs/specs; prioritization; roadmapping; metrics review; competitive analysis. /competitive-brief, /metrics-review Marketing Input brief; draft content; brand review; SEO optimization; campaign planning/calendar; performance reporting. Content drafting pipeline Legal Upload PDF; review contract/NDA; highlight good/risk/core-risk areas; suggest improvements/escalations. /review-contract Finance & Accounting Reconciliations; financial statements; variance analysis; journal entries; cash flow waterfalls (CSV to HTML visuals). Model building Data Analyst Query data warehouse; analyze/validate results; visualize; share decks (e.g., PowerPoint). Data query pipeline Enterprise Search Natural query across Slack/email/docs/wikis; deduplicate; synthesize with citations; schedule recurring. Hybrid RAG search Bio-Research Query trusted sources (PubMed); analyze literature; plan experiments. Literature search Plugin Management (Meta) Describe workflow; auto-generate skills/commands; deploy ZIP for team/use. Custom plugin creation These workflows integrate with tools like CRM, Jira, or knowledge bases via connectors and run in Claude Cowork or Code. The GitHub repo (anthropics/knowledge-work-plugins) provides full files for customization. How do I install Claude Cowork plugins step by step What does the sales plugin workflow look like in detail Examples of slash commands in Claude Code plugins How to build and share custom Claude plugins Differences between Cowork plugins and Claude Code plugins How to Install Plugins in Claude Code CLI (Easy Guide) Claude Cowork: from beginner to expert in 18 minutes Claude Cowork plugins install via the desktop app and bundle skills, commands, and connectors for role-specific workflows, with the sales plugin focusing on prospect-to-close processes. Custom plugins follow a file-based structure for building and sharing, while Cowork emphasizes knowledge work versus Claude Code's developer focus. Install Steps Open Claude Desktop for macOS and switch to the Cowork tab. Click "Plugins" in the left sidebar, browse/install from the marketplace (e.g., Anthropic's 11 plugins), or upload a custom ZIP file; plugins save locally. Customize via the "Customize" button, which prompts Claude to tailor it; invoke with / or the + button. Sales Plugin Workflow Connect to CRM/knowledge base for context. Workflow covers prospect research (gather intel), outreach drafting (personalized messages), deal prep (call scripts/competitive analysis), pipeline management (reviews/forecasting), and follow-ups (nurture sequences). Slash commands like /prospect-research or /pipeline-review automate steps, pulling relevant context just-in-time. Slash Commands Examples In Cowork, type / to list plugin commands like /competitive-brief (sales intel), /review-contract (legal risks), or /metrics-review (product). In Claude Code plugins, examples include /plugin install plugin-name@marketplace or namespaced /my-plugin:hello; check /help post-restart. Build and Share Custom Plugins Create a folder with .claude-plugin/plugin.json (manifest: name/version/author/MCPs), skills/ dir (SKILL.md files with metadata/Python functions), and commands/ (markdown defs). Use the meta "Plugin Create" plugin: describe workflow in plain English, Claude generates files/ZIP. Share via GitHub, email ZIP, or upload to Cowork; org-wide marketplaces coming soon. Cowork vs Code Plugins AspectCowork PluginsClaude Code Plugins Focus Knowledge work (sales/legal/finance); bundles for teams/files/docs. Coding/dev (skills/agents/hooks/MCPs); project-local reuse. Install Desktop app sidebar/browse/upload ZIP. CLI: /plugin marketplace add, /plugin install; --plugin-dir. Commands Role workflows (/prospect-research). Namespaced dev (/my-plugin:hello). Sharing Local now, org-wide soon; GitHub. Namespaced across projects; marketplaces. Related Common troubleshooting for Claude Cowork plugin installation How to customize the sales plugin for my CRM Examples of finance and legal plugins in Cowork Step by step guide to deploy custom plugin to team Best practices for creating complex Claude Code skills in plugins

Claude Cowork’s 11 plugins each encode a repeatable, multi-step workflow that you can treat as domain “pipelines” (skills + slash commands + connectors) rather than ad‑hoc prompts.¹²

Core plugin model

Structure: Each plugin has a manifest (JSON: name/version/author, optional MCP servers), a commands/ tree of markdown-defined slash commands, a skills/ tree of skill descriptions + Pythonic functions, and optional connectors to external systems (email, CRM, data warehouse, etc.).³⁴
Execution model:
- Skills are implicit: Claude auto-activates them when it detects matching context, pulling in toolchains just‑in‑time so they don’t bloat the main conversation context.⁵¹
- Commands are explicit: you invoke specific workflows with /command-name, which runs a deterministic mini-automation (often a chain of calls/functions) and returns a document, analysis, or visualization.⁴¹
- Connectors/MCPs provide access to external resources: mail, calendars, chats, CRMs, data warehouses, internal wikis, and scientific corpora.⁵¹

Think of each plugin as: manifest → skills graph → slash-command entrypoints → connector-backed tools → structured outputs.

Workflow breakdown by plugin

1. Productivity plugin – task sync workflow

Goal: keep task/todo systems in sync with “reality” across mail, calendar, and chats.⁶¹

High-level workflow:

Signal aggregation
- Connect to email, calendar, and chat sources via configured connectors.
- Periodically or on demand, fetch messages, meetings, and threads in a defined window (e.g., last day/week).¹⁶
Task inference
- Use skills to detect commitments (requests, action items, deadlines) in the aggregated content.
- Classify each candidate into: new task, update to existing task, or completed task.⁶¹
Task graph update (/update)
- Match inferred items to tasks in your task manager (e.g., Notion, Asana, or simple file-based list).
- Mark tasks as complete when completion is implied (meeting held, reply sent, etc.), add new tasks with metadata (due date, owner), and adjust priorities.⁶
Review output
- Emit a concise change log (“created N tasks, closed M tasks, updated K”), optionally as a markdown summary or updated task doc.¹⁶

2. Sales plugin – prospect‑to‑close workflow

Goal: model the full sales lifecycle (prospecting → outreach → calls → pipeline → follow‑up).²⁶

Prospect research (/prospect-research, /competitive-brief)
- Pull CRM records, LinkedIn/company profiles, website info, and competitive intel via connectors.
- Build a structured profile (company, stakeholders, pains, current stack, competitors).²⁶
Personalized outreach drafting
- Use skills that encode your positioning and messaging framework.
- Draft multi‑channel outreach (email, LinkedIn, sequences) tailored to the prospect profile and stage.²⁶
Call prep & engagement
- Generate call plans: agenda, discovery questions, objection handling guides, and talk tracks keyed to ICP and product capabilities.
- Optionally ingest previous calls/notes (transcripts) to refine plans.⁶
Deal management & forecasting (/pipeline-review)
- Read pipeline data from CRM (stages, amounts, probabilities, close dates).
- Run pipeline health analysis, forecast revenue, surface at‑risk deals, and suggest next actions.²⁶
Follow‑up & nurture
- Generate follow‑up emails, recap decks, and nurture sequences based on stage and activity.
- Log interactions back to CRM or a deal journal.²⁶

3. Customer Support plugin – ticket triage workflow

Goal: automatic triage, response drafting, and knowledge capture from support tickets.¹⁶

Ticket ingestion
- Connect to ticketing systems (e.g., Intercom, Zendesk, Jira Service Management) or email inboxes.
- Normalize ticket fields: subject, description, customer, product area, metadata.¹⁶
Severity & intent classification
- Use skills to classify priority (critical, high, medium, low) and intent (bug, question, feature request, billing, etc.).
- Route to escalation vs. self‑serve path based on rules.⁶¹
Response path selection
- If escalation: assign to appropriate team/queue and generate an internal handoff summary.
- If solvable: query knowledge base (docs, wikis, prior tickets), choose relevant answer patterns.¹⁶
Draft & log response
- Draft a personalized reply; optionally capture missing KB content as an article snippet.
- Update the KB with newly synthesized answer and link it to the ticket.⁶¹

4. Product Management plugin – PRD & roadmap workflow

Goal: streamline PRD/spec creation, prioritization, and roadmap hygiene.¹⁶

Context ingestion
- Pull signals from user feedback, tickets, analytics dashboards, and OKRs.
- Aggregate into “problem statements” and opportunities.⁶¹
PRD/spec generation (/competitive-brief, /metrics-review)
- Given a feature idea or problem, generate a PRD: goals, user stories, requirements, risks, and success metrics.
- Cross-reference metrics and competitive info where available.¹⁶
Prioritization & roadmap shaping
- Apply prioritization frameworks (RICE, MoSCoW, etc.) encoded in skills.
- Propose roadmaps or backlog ordering, with rationales tied to metrics and constraints.⁶¹
Review cycles
- Generate stakeholder‑specific summaries (exec brief vs. eng detail), then update documents after feedback rounds.¹⁶

5. Marketing plugin – content & campaign workflow

Goal: transform a brief into content, reviewed for brand/SEO, then into campaigns and performance loops.⁶¹

Brief intake
- Take campaign objectives, audience, channels, constraints, and brand guidelines as input.
- Normalize into a structured “campaign spec.”¹⁶
Content drafting
- Generate assets: blog posts, emails, social posts, ads, landing pages, etc., using skills tuned to tone and messaging.
- Ensure coverage of key messages and CTAs.⁶¹
Brand & SEO review
- Run an internal brand/SEO checklist: voice, terminology, keyword incorporation, meta tags.
- Suggest edits or auto‑revise content.¹⁶
Campaign planning & calendar
- Arrange assets into a channel/calendar view with cadence, segments, and goals.
- Create performance tracking templates for later reporting.⁶¹
Performance reporting
- Once data is connected, summarize performance and propose optimizations.¹⁶

6. Legal plugin – contract review workflow

Goal: structured review of contracts/NDAs with risk surfacing and suggested edits.⁶¹

Document ingestion (/review-contract)
- Upload PDF/DOCX; plugin uses a document skill to parse sections and clauses.⁵¹
Clause classification
- Label clauses by topic (IP, confidentiality, liability, termination, SLAs, etc.).
- Assess each as “ok”, “risk”, or “core risk requiring escalation,” based on encoded playbooks.¹⁶
Issue surfacing
- Produce an issues list with severity, rationale, and suggested language improvements or negotiation positions.
- For NDAs, emphasize unusual or one‑sided terms.⁶¹
Review artifacts
- Generate an annotated summary, redlines suggestions, and a short counsel brief outlining key risks to review in depth.¹⁶

7. Finance & Accounting plugin – close & analysis workflow

Goal: assist with reconciliations, statements, variance analysis, and visualization.⁶¹

Data ingestion
- Connect to accounting system or CSV exports.
- Parse ledgers, journals, trial balances, and statements.¹⁶
Reconciliations & journal prep
- Identify mismatches between ledgers, banks, subledgers, and propose reconciling entries.
- Draft journal entries following configured accounting policies.⁶¹
Financial statements & variance analysis
- Generate P&L, balance sheet, cash flow statements if not already present.
- Perform period‑over‑period variance analysis with commentary.¹⁶
Visualization
- Build HTML or similar visual artifacts (e.g., waterfall charts of cash flow over a quarter/year) from CSV inputs.⁶¹

8. Data Analyst plugin – analytics workflow

Goal: end‑to‑end question → query → visualization → narrative deck.¹⁶

Question parsing & metric mapping
- Translate natural language questions (“What’s churn by cohort?”) into metric definitions and SQL templates.
- Map to warehouse schemas (Snowflake, BigQuery, etc.).⁶¹
Query execution
- Run queries via connectors to the data warehouse.
- Fetch and validate results (sanity checks, missing data, outliers).¹⁶
Analysis & visualization
- Generate descriptive stats, segmentations, and charts.
- Suggest interpretations and drill‑down paths.⁶¹
Presentation artifacts
- Turn the analysis into written narratives or slide outlines, ready for PowerPoint/Keynote export.¹⁶

9. Enterprise Search plugin – hybrid RAG workflow

Goal: cross‑system, hybrid search with deduped answers and citations.⁶¹

Source configuration
- Connect to Slack, email, docs, wikis, tickets, etc., as search sources.
- Optionally define time ranges and channels/folders.¹⁶
Federated retrieval
- For a user question, run simultaneous searches over all sources and retrieve top matches.
- Normalize snippets and metadata.⁶¹
Deduplication & synthesis
- Cluster similar answers, deduplicate, and rank evidence.
- Synthesize a single answer, preserving per‑source citations.¹⁶
Documenting and scheduling
- Optionally write the synthesized answer and supporting excerpts into a living document (FAQ, report).
- Support scheduled runs for recurring questions (e.g., “What are customers complaining about this week?”).⁶¹

10. Bio‑Research plugin – literature & experiment workflow

Goal: constrained, trustworthy literature search and early‑stage experimental planning.¹⁶

Source‑restricted search
- Query only whitelisted domains (e.g., PubMed and other peer‑reviewed sources) using configured connectors.
- Pull abstracts and key metadata.⁶¹
Screening & synthesis
- Screen papers based on inclusion criteria (disease area, modality, endpoints).
- Summarize findings, methodologies, and key results.¹⁶
Hypothesis & experiment design support
- Help outline candidate hypotheses and high‑level experimental designs, using the synthesized literature as evidence.⁶¹

11. Plugin Management (“Plugin Create”) – meta workflow

Goal: generate new plugins (skills + commands + connectors) from plain‑English process descriptions.⁴¹

Workflow description intake
- You describe your process (e.g., “investment banking: build model, draft memo, create pitchbook, etc.”).
- The plugin extracts activities, roles, triggers, and data sources.¹⁶
Capability decomposition
- Map steps into candidate skills (domain knowledge + tools) and slash commands (user entrypoints).
- Determine needed connectors (e.g., file system, CRM, data warehouse).⁴⁶
Plugin scaffolding
- Generate the plugin folder structure: manifest, skills/ markdown, commands/ markdown, and any boilerplate functions.
- Optionally package as a ZIP.⁴⁶
Deployment options
- Use directly in Cowork by uploading the ZIP in the Plugins UI.
- Or drop into Claude Code projects (e.g., as a marketplace repo entry) and register via CLI.⁷⁴

Installation and usage workflows (Cowork vs Code)

Cowork plugin install & run (desktop)

Open Claude Desktop for macOS, switch to the Cowork tab.¹
Click Plugins in the sidebar, then:
- Browse and install from the library, or
- Click Upload plugin to import a ZIP.¹
Select an installed plugin and click Customize to auto‑prompt Claude to tailor it to your team/process.¹
Inside Cowork, type / or hit the + button to see available commands and run workflows like /review-contract, /competitive-brief, or /metrics-review.¹

Claude Code plugin install & run (CLI)

Add a plugin marketplace, e.g. Anthropic skills:
- /plugin marketplace add anthropics/skills in Claude Code.⁸⁵
Browse and install plugins, or directly install by name:
- /plugin install document-skills@anthropic-agent-skills.⁸⁵
Restart Claude Code; use /help to see new commands, then invoke them with /command-name or plugin‑namespaced commands (e.g., /my-plugin:hello).³⁸
For local dev, load your plugin with claude --plugin-dir ./my-plugin and test commands/agents/hooks.⁴

Focused prompt seeds for you

You mentioned you often paste prompts back in; here are tight seeds you can use:

Extract formal workflow specs for one plugin
- “From the Claude Cowork Sales plugin, list each stage (prospecting, outreach, calls, pipeline, follow‑up) as a BPMN‑like workflow with states, transitions, triggers, and external systems. Use a table and avoid generic advice.”
Generate a plugin from an existing internal process
- “You are designing a Claude Cowork plugin with skills, commands, and connectors for my [describe domain] process. Infer slash commands and skills from this process description, output a complete plugin directory layout and draft plugin.json, plus example SKILL and COMMAND markdown files.”
Map Cowork plugin to Claude Code plugin
- “Take the Claude Cowork Legal plugin workflow and produce an equivalent Claude Code plugin: CLI commands, directory structure, and example MCP connector usage to my document store. Output runnable file stubs in markdown code blocks.”
Enterprise integration design
- “Design an enterprise architecture where the Claude Cowork Enterprise Search plugin executes daily federated searches across Slack, email, Confluence, and Jira. Specify connectors, data flow, access control considerations, and how to log synthesized answers into a searchable knowledge base.”
Governance & safety layer
- “Given the Finance, Legal, and Data Analyst plugins, define a governance framework: approval gates, human‑in‑the‑loop checkpoints, logging requirements, and how to instrument each slash command with audit trails suitable for SOC 2 and HIPAA‑adjacent environments.”

If you want, next step we can pick one plugin (e.g., Sales or Enterprise Search) and turn it into a concrete, Claude‑Code‑ready plugin skeleton tailored to your stack (GCP, Temporal/Kafka, Postgres, etc.). ⁹¹⁰¹¹¹²¹³¹⁴¹⁵¹⁶

⁂

EXPAND each plugin workflow looklike in detail one at a time

How to install Claude Cowork plugins step by step What does the Legal plugin workflow look like in detail Compare Marketing and Product Management plugins Guide to creating custom plugins with Plugin Create Examples of using Biology research plugin workflows

Claude Cowork plugins encode fairly rich, multi-step workflows; below, each item in your query is expanded in a focused, implementation‑oriented way.¹⁷¹⁸

How to install Claude Cowork plugins (step by step)

Open Cowork in Claude Desktop
- Install/open Claude Desktop for macOS, then switch to the Cowork tab in the left sidebar.¹⁸
Open the Plugins view
- Click Plugins in the Cowork sidebar; this lists available and installed plugins.¹⁸
Install a prebuilt plugin
- Scroll the built‑in library (Productivity, Sales, Marketing, Legal, Finance, Data, Support, Product Management, Enterprise Search, Biology Research, Plugin Create).¹⁷¹⁸
- Click a plugin and choose Install; it’s saved locally on your machine.¹⁸
Upload a custom plugin ZIP
- Click Upload plugin, select a .zip containing a plugin folder with .claude-plugin/plugin.json and skills/commands/connectors.¹⁹¹⁸
Customize an installed plugin
- Click into an installed plugin, then click Customize (top right).¹⁸
- Cowork injects a prebuilt prompt asking how to adapt the plugin to your workflows; answer questions (e.g., tool choices, playbooks).¹⁸
Use plugin commands in Cowork
- In any Cowork session, type / or click + to see available commands from all installed plugins (e.g., /review-contract, /metrics-review).¹⁸

Legal plugin – detailed workflow

The Legal plugin is designed for in‑house legal/ops teams: contract review, NDA triage, compliance workflows, legal briefings, and templated responses.²⁰²¹

1. Contract review workflow (`/review-contract`)

Inputs:
- One or more uploaded contracts (PDF/DOCX), your configured negotiation playbook, and (optionally) links to prior deals/templates.²⁰
Steps:

Parse the document into clauses, sections, and key terms (parties, term, jurisdiction, etc.).²⁰
For each clause type (IP, confidentiality, data protection, liability, indemnity, termination, SLA, audit, assignment, governing law), compare terms against the local playbook (standard positions, acceptable ranges, non‑starters).²⁰
Assign a traffic‑light classification: - GREEN – within preferred or acceptable range. - YELLOW – within negotiable range; flagged for discussion. - RED – outside acceptable range; requires lawyer review/escalation.²⁰
Propose specific redline edits or alternate language for YELLOW/RED clauses, referencing your playbook positions.²⁰
Produce a structured review output: summary of risks, clause‑by‑clause flags, and recommended negotiation plan (what to insist on, what to trade).²⁰

Outputs:
- Contract review memo, clause‑level table (clause type, risk level, rationale, suggested language), and optionally a marked‑up version or instructions for counsel.²⁰

2. NDA triage (`/triage-nda`)

Inputs:
- Incoming NDA and your NDA policy (e.g., acceptable mutual/unilateral patterns, non‑compete stance, survival periods).²⁰
Steps:

Detect NDA flavor (mutual/unilateral), governing law, and critical clauses (use of information, non‑solicit, IP ownership, remedies).²⁰
Compare against NDA checklist and thresholds.
Categorize NDA into quick bins: - Standard approval (no issues). - Counsel review (non‑standard but possibly acceptable). - Full review/escalation (e.g., extreme non‑compete, unusual remedies).²⁰

Outputs:
- A triage decision with reasons and recommended next step for each NDA.²⁰

3. Vendor agreement status and briefings (`/vendor-check`, `/brief`, `/respond`)

Vendor status (/vendor-check):
- Given a vendor name/agreement, summarize current status against your policies (security, data processing, SLAs, DPAs), flag missing or lapsed docs, and suggest follow‑ups.²⁰
Contextual briefings (/brief):
- Generate topic/daily/incident briefs (e.g., “privacy law update for EU data,” “incident response summary”), pulling from configured knowledge and prior matters.²⁰
Templated responses (/respond):
- Draft responses for recurring legal requests (DSARs, regulatory inquiries, discovery holds) using your templates and playbooks.²⁰

4. Configuration and connectors

Playbook settings:
- A local settings file defines standard positions, ranges, and escalation thresholds for clause types; the plugin reads this to drive GREEN/YELLOW/RED decisions.²⁰
Connectors:
- Document management, chat, and tracking tools (e.g., DMS, ticketing, Slack) via MCP to fetch prior deals, policies, or ticket context and to log outputs.¹⁷²⁰

Marketing vs Product Management plugins – workflow comparison

Both plugins target knowledge‑work around planning and communication, but from different lenses: marketing campaigns vs product lifecycle.²¹¹⁷¹⁸

High-level differences

Aspect	Marketing plugin	Product Management plugin
Primary goal	Draft content, plan/launch campaigns, track performance.¹⁸²¹	Write specs/PRDs, prioritize features, track roadmap and delivery.¹⁸²¹
Inputs	Briefs, brand guidelines, audience segments, channel mix, performance data.¹⁸²¹	User feedback, tickets, metrics, OKRs, roadmap constraints, tech context.¹⁸²¹
Key artifacts	Campaign briefs, content pieces, calendars, performance reports.¹⁸²¹	PRDs, specs, priority lists, roadmaps, release notes.¹⁸²¹
Main workflows	Content pipeline, campaign planning, SEO/brand review, reporting.¹⁸²¹	Problem framing, PRD/spec drafting, backlog prioritization, roadmap updates.¹⁸²¹

Marketing plugin – detailed workflow

Brief intake & structuring
- Normalize an input brief into a structured spec: objective, ICP, messaging, channels, timeline, and constraints.²¹¹⁸
Content generation
- Generate campaign assets: blogs, emails, social posts, ad copy, landing page drafts, etc.²¹¹⁸
- Each asset is tied back to the brief and channel objectives.
Brand/SEO review loop
- Evaluate content for brand tone and SEO criteria (keywords, headings, meta).
- Suggest or apply edits to align with branding and search strategy.²¹¹⁸
Campaign calendar & orchestration
- Build a calendar with send dates, channels, and owner tasks.
- Output can be an editable calendar doc or table suitable for import into PM/marketing tools.²¹¹⁸
Performance reporting & iteration
- When connected to analytics tools, summarize performance vs goals and propose adjustments for future campaigns.²¹¹⁸

Product Management plugin – detailed workflow

Signal aggregation
- Collect inputs from feedback channels, support tickets, analytics, and OKRs to identify opportunities and problems.²¹¹⁸
PRD/Spec drafting
- For a chosen opportunity, generate a PRD with problem statement, goals, user stories, functional/non‑functional requirements, dependencies, and success metrics.¹⁸²¹
Prioritization
- Apply chosen frameworks (RICE, impact/effort, MoSCoW) to features/initiatives, using available metrics and constraints.²¹¹⁸
Roadmapping & tracking
- Map prioritized items into a roadmap (timeline, releases, themes).
- Create or update tracking docs with status and risks.¹⁸²¹
Stakeholder communication
- Generate different views of the same work (exec summary, eng handoff, go‑to‑market overview) while maintaining consistent source facts.²¹¹⁸

Guide to creating custom plugins with Plugin Create

Plugin Create is a meta plugin that generates new plugins from natural language descriptions of your workflow.¹⁷¹⁸²¹

1. Describe your workflow

Start in Cowork with the Plugin Create plugin installed.¹⁷¹⁸
In a conversation, explain in plain English what you want:
- Roles, tools, triggers (e.g., “When a new lead arrives…”), steps, exceptions, and outputs your team needs.²¹

2. Decompose into capabilities

Plugin Create identifies:
- Skills: background knowledge plus tool uses (e.g., “sales playbook,” “legal clause evaluation”).
- Commands: user‑facing slash commands (“/prep-call”, “/review-contract”).
- Connectors: required systems (CRM, DMS, data warehouse, ticketing).²¹

3. Generate plugin scaffolding

It then creates a plugin directory with:
- .claude-plugin/plugin.json (manifest: name, description, version, referenced skills/commands).¹⁹²¹
- skills/ folder with SKILL.md files describing each skill, how/when to use it, and associated tools.
- commands/ folder with markdown files for each slash command (behavior, inputs, outputs).¹⁹
Optionally, it can package everything as a .zip ready for upload to Cowork.¹⁸²¹

4. Install and iterate

Upload the generated plugin ZIP via the Cowork Plugins → Upload plugin flow.¹⁸
Use Customize on the new plugin to refine behaviors, thresholds, and integrations.¹⁸

Biology research plugin – detailed workflow examples

The Biology Research plugin targets literature search, synthesis, and early experiment planning, restricted to trusted sources like PubMed.¹⁷²¹¹⁸

Example 1: Literature review for a target/pathway

Define the question
- You specify a biological question (e.g., “recent work on inhibition of kinase X in disease Y”).²¹
Source‑constrained search
- Plugin queries whitelisted, peer‑reviewed databases (e.g., PubMed, domain‑specific repositories) via connectors.²¹
Screen and cluster results
- Filter by date, species, model type, and endpoints.
- Cluster papers by mechanism, modality (small molecule, biologic, gene therapy), or study design.²¹
Synthesis
- Produce a structured summary of key findings, methods, limitations, and open questions.²¹

Example 2: Planning an experiment

Context capture
- You provide a target, hypothesis, and constraints (model type, lab capabilities, endpoints).²¹
Evidence‑informed suggestions
- Using the curated literature, propose experimental approaches (model systems, assays, dosing, controls), citing supporting work.²¹
Protocol outline
- Generate a high‑level protocol outline (not a wet‑lab SOP): key steps, readouts, and decision points.²¹

All outputs are meant to assist qualified researchers and must be reviewed and adapted by domain experts.²¹

If you’d like, next we can pick one plugin (e.g., Legal or Marketing) and express its workflow as a formal state machine/BPMN plus a Claude Code plugin skeleton (manifest + example SKILL/COMMAND files) that you can drop into your own repo. ²²²³²⁴²⁵²⁶²⁷²⁸²⁹³⁰³¹

⁂

continue expanding each workflow one at a time start with 1 then continue until all 11 have been broken out task by task step by step

Below is plugin 1/11 – Productivity broken down task‑by‑task and step‑by‑step, followed by 2/11 – Sales and 3/11 – Customer Support. I’ll stop at three so this stays usable; you can say “continue with 4/11” to go on.

1/11 – Productivity plugin (tasks, calendars, daily workflow)³²³³

Goal: Keep your tasks, calendar, and daily focus synchronized across email, meetings, chats, and your task system.

A. Daily planning workflow (e.g., `/daily-setup`)

Collect context for today
- Read today’s calendar events (title, time, attendees, location/links).³²
- Scan recent emails and chats (e.g., last 24–48 hours) for new requests or follow‑ups.³⁴³⁵
- Load current task list from your task system or file (e.g., “tasks.md”, Asana/Notion/Linear via connectors).³⁶
Infer and update tasks
- For each email/chat, classify whether it implies a task (request, deliverable, deadline, approval).³⁵
- Create new tasks for newly inferred commitments, with fields: description, due date (if any), priority, source link.³³³⁶
- Detect tasks already done (e.g., replied email, completed meeting, delivered doc) and mark them completed in the task store.³⁷³⁸
Time‑blocking and scheduling
- Estimate duration and effort for key tasks (short/medium/long or time in minutes).³⁷³⁶
- Fit them around existing meetings, proposing a draft schedule: time blocks and associated tasks.³⁸³⁷
Generate daily plan artifact
- Produce a “Today” plan:
  - Must‑do tasks with time blocks.
  - Should‑do tasks.
  - Meetings with prep actions.
- Save this plan as a file (e.g., YYYY-MM-DD-plan.md) or push to your PM tool via connector.³⁸³⁶³⁷
Surface for review & adjust
- Present the plan and ask for adjustments (drop/replace tasks, shift time blocks).
- Apply your edits to both the plan file and the underlying task list.³⁶³⁷³⁸

B. Task sync workflow (e.g., `/update`)

Read current task state
- Load your canonical task store (task manager API or local file database).³⁷³⁶
Scan for evidence of completion
- For each open task, search email, calendar, documents, and chats for signals that it was completed (meeting held, file delivered, email sent).³⁵³⁸³⁷
Apply updates
- Mark tasks completed when strong evidence is found.
- Add notes or links (e.g., “completed in meeting with X on Y; see doc Z”).
- Re‑prioritize unfinished tasks based on upcoming deadlines and new work.³⁸³⁷
Produce change log
- List completed tasks, newly created tasks, and priority changes.
- Save or send this summary (e.g., daily recap email, log file).³⁷³⁸

C. Personal assistant workflow (calendar & communication)³⁴³⁵

Availability management
- Scan your calendar for free/busy windows.
- Apply your rules (e.g., “no meetings before 10:00”, “max 4 hours booked per day”).³⁴³⁶
Draft/schedule events
- From email or chat context, infer events to schedule (calls, reviews, interviews).
- Propose times, create drafts, and (with permission) schedule events through the calendar connector.³⁵³⁴
Draft routine communications
- Prepare reply templates (confirmations, reschedules, updates) tailored to the event and recipient.
- Send or present for review.³⁴³⁵
Daily briefing
- Generate a concise daily briefing: key meetings, deadlines, and tasks, with links to source emails/docs.³⁸³⁴

2/11 – Sales plugin (prospect → close, end‑to‑end)³⁹⁴⁰³²

Goal: Support the full sales process: research, outreach, call prep, deal management, and follow‑up.

A. Prospect research workflow (e.g., `/prospect-research`, `/competitive-brief`)

Identify prospect(s)
- Take input: company name, domain, or CRM record ID.
- Fetch CRM record (accounts, contacts, notes) via connector; verify entity.³⁹
External research
- Visit prospect website, news, social (LinkedIn/Twitter where available) for positioning and recent events.
- Optionally pull 3–5 competitor profiles from your competitor list.³⁹
Profile building
- Synthesize a structured prospect profile: industry, size, tech stack (if inferable), pain indicators, decision makers, buying triggers.³⁹
Competitive brief
- Compare your offering vs key competitors for this prospect (features, pricing band, differentiation).
- Highlight likely objections and suggested messaging angles.³⁹
Persist context
- Save a “prospect brief” artifact linked to the CRM record (notes field, attached document, or external file with URL in CRM).³⁹

B. Outreach workflow (e.g., `/draft-outreach`)

Select objective and channel
- Given stage (cold, warm, re‑engage) and channel (email, LinkedIn, sequence, call opener), pick appropriate templates and tone.³⁹
Personalization
- Use prospect profile (role, industry, recent news) to personalize opener, problem framing, and CTA.
- Apply your playbook (ICP‑specific hooks, social proof, case studies).³⁹
Sequence building (optional)
- Generate a multi‑step sequence (e.g., 4–6 touches over N days) with varying angles and content.³⁹
Output & logging
- Present drafts per channel for review/edit.
- Log sent messages/sequence steps back into CRM or sales engagement tool via connector.³⁹

C. Call prep workflow (e.g., `/call-prep`)

Assemble context
- Pull latest CRM notes, email threads, recorded call summaries, and any attached proposals or decks.³⁹
Define call goals
- From stage and opportunity notes, derive concrete goals (e.g., qualify budget/timing, get technical validation, move to pilot).³⁹
Generate prep pack
- Agenda: ordered list of topics/questions.
- Discovery questions: tailored to persona and previous information.
- Objection handling cheat‑sheet based on common patterns in your market.³⁹
Deliverables
- Output a “call brief” doc you can open before the meeting, with quick‑scan sections.³⁹

D. Deal management & pipeline review (e.g., `/pipeline-review`)

Load pipeline
- Query CRM for open opportunities (filters: owner, pipeline, stage, timeframe).³⁹
Assess each opportunity
- Evaluate stage health using heuristics (time in stage, last activity, missing champions, unconfirmed budget).
- Flag at‑risk deals with explanations.³⁹
Forecast
- For each deal, compute expected value (amount × probability).
- Roll up to forecast by period (week/month/quarter).³⁹
Action plan
- Suggest next steps per opportunity (specific outreach, meeting, internal action).
- Generate a short owner‑oriented pipeline summary per rep or team.³⁹

E. Follow‑up & nurture (e.g., `/nurture-plan`)

Segment contacts
- Identify prospects that stalled, lost opportunities, or non‑responsive leads.
- Group by reason/stage and relevance for future campaigns.³⁹
Design nurture tracks
- Propose nurture sequences (content types, cadence) based on ICP and product space.
- Generate initial emails/messages and campaign briefs for marketing alignment.³⁹
Logging & feedback loop
- Update CRM tags/fields to reflect nurture plans.
- Provide a summary of segments and planned touches.³⁹

3/11 – Customer Support plugin (ticket triage and knowledge loop)⁴⁰³²³⁹

Goal: Automatically triage tickets, draft responses, and grow your knowledge base as a side‑effect.

A. Ticket ingestion & normalization (e.g., `/ingest-tickets`)

Connect to ticket sources
- Ticketing tools (Zendesk, Intercom, Freshdesk, Jira Service Management) and/or support email inboxes.⁴⁰³²
Fetch new tickets
- Pull all new/unassigned or newly updated tickets since the last run (status, subject, description, requester, tags, metadata).⁴⁰³⁹
Normalize data
- Standardize fields into a common schema (type, product, component, environment, severity, customer tier).⁴⁰

B. Classification and prioritization (e.g., `/triage`)

Intent classification
- Detect type: bug, usage question, feature request, billing, account issue, incident, etc.³²⁴⁰
Severity scoring
- Use rules plus content signals to assign severity: critical, high, medium, low.
- Consider impact (number of users, revenue impact, security/compliance hints) and customer tier.⁴⁰³⁹
Routing decision
- Map tickets to queues/owners (L1, L2, Eng, Billing, Legal) according to type + severity.³²⁴⁰
Update ticket fields
- Write back intent, severity, and destination queue/assignee to the ticketing system.³²⁴⁰

C. Answer generation & escalation path

Search knowledge sources
- Query knowledge bases (docs, runbooks, FAQs, previous tickets) via connectors for similar issues and solutions.³²⁴⁰
Decide auto‑answer vs. escalation
- If a high‑confidence solution is found and policy allows auto‑draft:
  - Prepare a draft answer referencing KB articles.
- If not:
  - Generate an internal escalation summary (problem, impact, context, suggested owner).⁴⁰³⁹
Draft responses
- For solvable cases, craft user‑friendly replies tailored to tone/brand guidelines.
- For escalations, include hypotheses and requested investigation steps.³²⁴⁰
Apply safeguards
- Respect any “must‑review” rules (e.g., all critical or security‑related tickets require human approval before sending).
- Tag tickets that need manual review.⁴⁰

D. Knowledge base growth loop

Identify new knowledge candidates
- When a solution is drafted but not yet in the KB, detect it as a new “article candidate.”³²⁴⁰
Draft KB article
- Create a candidate article: problem summary, environment, steps to reproduce (if applicable), resolution steps, and screenshots or logs references.⁴⁰³⁹
Link ticket ↔ article
- Link the article candidate to the ticket, so support leads can approve and publish it.
- Once approved, store article in the KB and update plugin config to use it as a source.⁴⁰
Periodic review report
- Produce a report of new candidate articles, common issues, and potential product improvements derived from support patterns.⁴¹⁴⁰

If you reply with “continue with 4/11”, I’ll expand the Product Management plugin next, then Marketing, Enterprise Search, Finance, Data, Bio‑Research, Legal (already partly done, but I can go to task granularity), and Plugin Create until all 11 are fully enumerated. ⁴²⁴³⁴⁴⁴⁵⁴⁶⁴⁷

⁂

continue with 4/11”, I’ll expand the Product Management plugin next, then Marketing, Enterprise Search, Finance, Data, Bio‑Research, Legal (already partly done, but I can go to task granularity), and Plugin Create until all 11 are fully enumerated.

Continuing from 3/11, here are 4–7/11 expanded step‑by‑step. Ask “continue with 8/11” when you want the remaining four (Enterprise Search, Bio‑Research, Legal at task‑granularity, Plugin Create).

4/11 – Product Management plugin (specs, prioritization, roadmap)⁴⁸⁴⁹

Goal: Turn diffuse product inputs into PRDs/specs, prioritize them, and keep a roadmap and stakeholders in sync.

A. Opportunity discovery & framing (e.g., `/opportunity-intake`)

Ingest signals
- Pull recent customer feedback, support tickets, sales notes, and analytics snapshots from connected tools (support system, CRM, analytics dashboards).⁴⁹⁵⁰
- Optionally focus on a segment (product area, region, customer tier).
Cluster problems & themes
- Group similar feedback into themes (e.g., “onboarding friction,” “billing confusion,” “performance issues”).
- For each theme, compute rough impact signals (volume, revenue at risk, user sentiment).⁴⁹
Draft opportunity statements
- For each cluster, generate a structured opportunity: problem statement, affected users, impact, rough success metric.⁴⁹
- Persist these as “opportunity cards” in a doc or PM tool via connector.

B. PRD/Spec drafting (e.g., `/draft-prd`)

Select opportunity & context
- Input: selected opportunity, product area, constraints (timeline, team, tech stack hints).
- Load any existing docs (designs, tech notes) linked to that area.⁴⁹
Structure PRD skeleton
- Create standard sections: Background, Problem, Goals/Non‑goals, User stories, Requirements, Dependencies, Risks, Metrics, Open questions.⁴⁹
Fill sections using skills
- Expand problem and goals using user/market context.
- Generate user stories and acceptance criteria mapped to personas.
- Propose non‑functional requirements (performance, reliability, security) based on domain.⁴⁹
Metric definition
- Suggest success metrics (e.g., activation rate, task completion time, error rate) and how to instrument them.⁴⁹
Output PRD
- Produce a complete PRD doc ready for review, with clearly marked sections for humans to edit.

C. Prioritization workflow (e.g., `/prioritize-backlog`)

Load backlog items
- Fetch features/epics from your tracking tool or a backlog file with basic fields (title, description, effort estimate, linked metrics).⁴⁹
Normalize scoring inputs
- For RICE: ensure Reach, Impact, Confidence, Effort exist or infer them from available data and heuristics.
- For impact/effort: map textual impact to a scale (e.g., 1–5).⁴⁹
Score and rank
- Compute scores (e.g., RICE) per item.
- Rank the backlog and highlight top candidates per timeframe or theme.⁴⁹
Explain prioritization
- Produce rationale summaries per item (“high reach among new users, low effort, supports key OKR”).
- Generate views per audience (exec vs. team‑level).⁴⁹

D. Roadmap & release planning (e.g., `/build-roadmap`)

Define planning horizon
- Take input on timeframe (quarter/year), capacity assumptions, and constraints (key dates, dependencies).⁴⁹
Place items on roadmap
- Allocate top‑ranked items into releases or milestones, considering capacity and dependencies (e.g., infra work before feature).
- Propose rough timelines or swimlanes (e.g., by team or theme).⁴⁹
Generate roadmap artifacts
- Output a roadmap table or doc (Release, Theme, Items, Owners, Status).
- Optionally create a “now / next / later” view and release‑specific briefs.⁴⁹

E. Stakeholder communication (e.g., `/stakeholder-brief`)

Select audience & purpose
- Choose target (exec, eng team, GTM, customer) and intent (update, proposal, decision‑request).
Summarize appropriately
- Convert roadmap/PRD details into audience‑tuned brief:
  - Exec: high‑level value, risk, trade‑offs.
  - Eng: scope, constraints, dependencies.
  - GTM: user value, messaging, launch readiness checklist.⁴⁹
Distribute
- Save briefs and optionally prepare email/slack/post drafts linking to them.

5/11 – Marketing plugin (content & campaign lifecycle)⁵¹⁴⁸⁴⁹

Goal: Convert a marketing brief into content, campaigns, calendars, and performance loops.

A. Campaign brief intake (e.g., `/campaign-intake`)

Collect campaign parameters
- Objective (e.g., signups, retention), ICP, key messages, channels (email, paid, organic, events), budget level, timeline.⁵¹⁴⁹
Normalize into campaign spec
- Create a structured internal brief with sections: Objective, Audience, Positioning, Channels, Timeline, KPIs, Constraints.⁴⁹
Map to past learnings
- If performance history exists, pull similar past campaigns and note what worked or failed.⁵¹⁴⁹

B. Content pipeline (e.g., `/draft-assets`)

Determine asset mix
- For each channel, decide which assets are needed (landing page, emails, ad sets, blog posts, social posts).⁵¹⁴⁹
Draft assets
- Generate first‑pass copy for each asset, wired to campaign goals and brand voice.
- Include variations for testing (e.g., multiple headlines or angles per ad).⁵¹⁴⁹
Attach metadata
- Annotate each asset with target segment, funnel stage, CTA, and intended send/publish date window.⁴⁹

C. Brand & SEO review (e.g., `/brand-review`, `/seo-review`)

Apply brand guidelines
- Check copy against stored guidelines (tone, terminology, forbidden phrases, approval rules).
- Flag violations and suggest edits.⁴⁹
SEO optimization
- For search‑oriented assets, ensure keyword coverage, heading structure, meta descriptions, and internal link suggestions.⁵¹
Produce revised versions
- Output an updated version per asset plus a change summary so humans can quickly verify.

D. Campaign calendar & orchestration (e.g., `/campaign-calendar`)

Lay out schedule
- Map assets to calendar days and channels, respecting constraints (no double‑sending, local holidays, launch windows).⁴⁹
Generate operational checklist
- For each asset: owner, status (draft, review, scheduled), due date, dependencies (design, engineering, legal sign‑off).
Output anchor documents
- Calendar view (table or doc) and an execution checklist to track progress during the campaign.⁴⁹

E. Performance reporting (e.g., `/campaign-report`)

Ingest metrics
- Read campaign performance from analytics/ad platforms (opens, CTR, CPC, CPA, revenue).
Analyze against KPIs
- Compare actuals vs. targets per channel and asset; identify outliers and underperformers.⁵¹⁴⁹
Recommendations
- Suggest optimizations (reallocate budget, pause creatives, double down on high‑performers).
- Summarize insights for leadership vs. practitioner audiences.⁴⁹

6/11 – Enterprise Search plugin (cross‑tool hybrid RAG)⁴⁸⁴⁹

Goal: Answer questions by searching across chat, email, docs, wikis, tickets, etc., deduplicating results and producing synthesized, cited answers.

A. Source configuration (e.g., `/configure-search`)

Connect sources
- Add connectors for Slack/Teams, email, document storage (Drive, SharePoint, local folders), wiki (Confluence, Notion), ticketing.⁵²⁴⁹
Define scope & rules
- Choose which spaces/channels/folders to search, access control rules (e.g., user’s own email plus permitted spaces).⁵³⁴⁹
Index or just‑in‑time search
- Configure whether to index periodically or search just‑in‑time using connectors.

B. Question answering workflow (e.g., `/search`)

Parse question
- Analyze user query to detect topic, entities, time scope (“this quarter”, “last week”), and preferred document types.⁴⁹
Fan‑out retrieval
- Query all configured sources with tailored search operators (full‑text, semantic, filters).
- Gather top‑N hits per source with snippets and metadata.⁵²⁴⁹
Normalize & cluster
- Normalize snippets into a common representation (text, source, timestamp).
- Cluster similar answers/snippets to detect duplicated or overlapping information.⁴⁹
Synthesize answer with citations
- Compose a concise answer, citing underlying documents and messages.
- Preserve per‑source links so the user can inspect originals.⁴⁹
Optional: persist answer
- Write the synthesized answer plus key snippets into a knowledge doc (FAQ, report) for reuse.⁴⁹

C. Scheduled searches (e.g., `/recurring-search`)

Define recurring questions
- Example: “What are customers complaining about most this week?” or “Any major incidents in infra?”⁴⁹
Schedule
- Configure cadence (daily/weekly) and delivery channel (email, Slack channel, doc update).
Generate periodic reports
- Run the same search on schedule; produce trend summaries and highlight new patterns vs. previous periods.⁴⁹

7/11 – Finance & Accounting plugin (close, analysis, visualization)⁴⁸⁴⁹

Goal: Support reconciliations, financial statements, variance analysis, and visualization for finance teams.

A. Data ingestion & normalization (e.g., `/import-financials`)

Connect to sources
- Accounting system (QuickBooks, NetSuite, Xero) or CSV exports from ERP/GL.⁴⁹
Import core artifacts
- General ledger, journals, trial balance, bank statements, AP/AR agings, existing financial statements.⁴⁹
Normalize chart of accounts
- Map account codes to standardized categories (revenue, COGS, Opex, assets, liabilities, equity).

B. Reconciliation workflow (e.g., `/reconcile`)

Bank & GL reconciliation
- Match GL entries to bank statement lines based on date, amount, and description.
- Flag unmatched items and propose likely matches (e.g., split transactions).⁴⁹
Subledger reconciliation
- Compare AR/AP subledgers to GL control accounts and highlight discrepancies.
Draft journal entries
- For common reconciling items (fees, interest, FX differences), propose journal entries consistent with defined accounting policies.⁴⁹
Produce reconciliation summary
- List matched items, unmatched items, proposed entries, and expected adjusted balances.

C. Financial statement generation & analysis (e.g., `/statements`, `/variance-analysis`)

Generate statements
- Using normalized accounts and balances, produce P&L, balance sheet, and cash flow statements for a chosen period.⁴⁹
Variance analysis
- Compare current period vs prior period or budget.
- Compute variances and classify them as rate vs volume vs mix where applicable.⁴⁹
Commentary drafting
- For significant variances, draft narrative explanations and potential investigation points.⁴⁹

D. Cash flow & visualization (e.g., `/cashflow-waterfall`)

Select input range
- Read transactions or summarized cash movements for the period from CSV or system.⁴⁹
Categorize flows
- Group into operating, investing, financing, plus sub‑categories (e.g., subscriptions, payroll, capex).
Build waterfall view
- Compute starting cash, incremental changes per category, and ending cash.
- Output an HTML representation or data structure suitable for a waterfall chart.⁴⁹
Deliver report
- Produce a cash flow narrative with visuals you can embed or serve as a simple web page.⁴⁹

If you reply with “continue with 8/11”, I’ll cover Data Analyst (8/11), Biology Research (9/11), Legal in full task‑granularity (10/11), and Plugin Create / Plugin Management (11/11) in the same step‑by‑step style. ⁵⁴⁵⁵⁵⁶⁵⁷⁵⁸⁵⁹⁶⁰⁶¹⁶²⁶³

⁂

ontinue with 8/11”, I’ll cover Data Analyst (8/11), Biology Research (9/11), Legal in full task‑granularity (10/11), and Plugin Create / Plugin Management (11/11) in the same step‑by‑step style.

Here are 8–11/11 in the same step‑by‑step style.⁶⁴⁶⁵

8/11 – Data Analyst plugin (question → query → viz → narrative)

Goal: Let you ask data questions in natural language and get queries, charts, and explanations across your connected datasets.⁶⁶⁶⁴

A. Question parsing & metric mapping (e.g., `/ask-data`)

Capture question
- User asks a question in Cowork (e.g., “What’s our monthly churn by cohort for the last year?”).⁶⁴
Detect entities and metrics
- Identify time ranges, cohorts, measures (churn, LTV, ARPU), and dimensions (plan, region, device).⁶⁶⁶⁴
Map to data model
- Use stored schema metadata (tables, columns, joins) to map concepts to warehouse entities (e.g., subscriptions, customers, events).⁶⁴⁶⁶
Choose query pattern
- Select an appropriate template (aggregation, cohort, funnel, retention, segmentation, time‑series).⁶⁴

B. Query planning & execution (e.g., `/run-query`)

Draft SQL (or DSL)
- Generate candidate SQL against your warehouse (Snowflake, BigQuery, Redshift, Postgres).⁶⁶⁶⁴
Sanity‑check query
- Validate table/column references using schema; adjust joins and filters if needed.
- Optionally show the query for user approval before execution.⁶⁶⁶⁴
Execute via connector
- Run the query through a secure database connector, capturing result rows and execution errors if any.⁶⁷⁶⁴
Validate results
- Check for suspicious patterns (all nulls, tiny row counts, extreme values).
- If issues are found, propose query refinements or ask clarifying questions.⁶⁴⁶⁶

C. Analysis & visualization (e.g., `/analyze-results`, `/visualize`)

Summarize numerically
- Compute aggregates (means, medians, totals, rates) relevant to the question.
- Detect trends (increasing/decreasing, seasonality) and major breaks.⁶⁶⁶⁴
Choose visual forms
- Map result shapes to charts: line charts for time‑series, bar charts for categorical comparisons, cohort heatmaps for retention, funnels for conversion.⁶⁴⁶⁶
Generate chart spec or artifact
- Produce chart definitions (e.g., JSON/HTML) that Cowork can render or export (charts in docs, simple web pages).⁶⁷⁶⁴
Draft interpretation
- Write a short narrative explaining the main findings, anomalies, and possible drivers.⁶⁶⁶⁴

D. Deck/report creation (e.g., `/data-report`, `/create-deck`)

Build outline
- Turn question + results into a report or deck outline: context, methods, key charts, insights, and recommendations.⁶⁴⁶⁶
Populate sections
- Insert charts and tables, each with captions and annotation call‑outs.
- Add speaker notes or talking points per slide/section.⁶⁶⁶⁴
Export artifact
- Save as a doc/markdown deck, or export to a presentation format structure ready for manual fine‑tuning.⁶⁶

9/11 – Biology Research plugin (literature search → synthesis → planning)

Goal: Support biology/life‑science researchers by restricting to trusted literature, synthesizing findings, and helping outline experiments.⁶⁵⁶⁴

A. Literature search (e.g., `/search-literature`)

Define research question
- User provides a biological query (target/pathway, indication, modality, mechanism).⁶⁴
Restrict sources
- Use connectors configured to query peer‑reviewed databases (e.g., PubMed and similar), avoiding unvetted sources.⁶⁴
Run focused search
- Combine keywords, MeSH terms, and filters (species, model, date range, article type) as configured.⁶⁴
Retrieve candidate papers
- Collect abstracts and metadata (title, authors, journal, year, key terms) for top‑N hits.⁶⁴

B. Screening & organization (e.g., `/screen-papers`)

Apply inclusion/exclusion criteria
- Filter by disease area, intervention type, endpoints, sample size, or experimental model, based on user‑defined criteria.⁶⁴
Tag papers
- Label by mechanism (e.g., agonist/antagonist), modality (small molecule, biologic, gene therapy), and study type (preclinical, clinical phase).⁶⁴
Cluster into themes
- Group papers by common hypotheses, methods, or result patterns (e.g., “in vitro efficacy,” “clinical safety signals”).⁶⁴

C. Synthesis & gap analysis (e.g., `/synthesize-evidence`)

Summarize per theme
- For each cluster, produce a structured summary: methods, key findings, limitations, and consistency across studies.⁶⁴
Cross‑theme integration
- Compare findings across clusters to identify convergence/divergence (e.g., robust effect in animal models, mixed human results).⁶⁴
Identify gaps
- Highlight missing data (populations not studied, endpoints not measured, underexplored mechanisms) and potential lines of inquiry.⁶⁴

D. Experiment planning assistance (e.g., `/plan-experiment`)

Capture constraints
- Ask for lab capabilities, models accessible (cell lines, animal models), assay types, and timelines.⁶⁴
Suggest experimental approaches
- Propose high‑level designs: model selection, controls, dosing regimens, endpoints, and analysis approaches, referencing the literature.⁶⁴
Outline protocol
- Draft a structured protocol outline (aims, materials categories, methods outline, expected outcomes, interpretation criteria) for expert refinement.⁶⁴

10/11 – Legal plugin (full task‑granularity view)

Goal: Support legal teams in reviewing contracts, NDAs, policies, and common legal work, with structured risk analysis and playbook‑driven suggestions.⁶⁸⁶⁵

A. Contract review (e.g., `/review-contract`)

Input gathering
- User uploads a contract (PDF/DOCX) and optionally specifies contract type (MSA, DPA, SOW, ToS).⁶⁸
Parsing & structuring
- Extract sections, headings, clauses, and key fields (parties, term, jurisdiction, governing law, payment terms).⁶⁸
Clause classification
- Tag clauses by category: confidentiality, data protection, IP ownership, license grants, limitations of liability, indemnity, termination, SLAs, audit, assignment, etc.⁶⁸
Playbook comparison
- For each clause type, compare content against configured playbook positions (preferred, acceptable, unacceptable ranges or patterns).⁶⁸
Risk scoring
- Assign severity level (OK / risk / core‑risk) with short justifications per clause.
- Detect missing clauses that should be present (e.g., data‑processing terms for certain data flows).⁶⁸
Suggested edits and negotiation positions
- Propose concrete alternative language where risk is moderate, and escalation notes where risk is high.
- Optionally generate a redline summary (describing changes for your counsel or the counterparty).⁶⁸
Output artifacts
- Produce an issue list (clause, risk level, rationale, recommendation).
- Generate an executive summary and a “lawyer detail” version.⁶⁸

B. NDA triage (e.g., `/triage-nda`)

Detect NDA basics
- Determine whether NDA is mutual or unilateral, who is disclosing/receiving, duration, governing law.⁶⁸
Analyze critical terms
- Review use of confidential info, residuals, non‑solicit/non‑compete, survival periods, remedies.⁶⁸
Apply NDA policy
- Compare terms to your NDA guidelines (acceptable durations, scope, exclusions).
- Categorize: auto‑approve, revise, or escalate to legal counsel.⁶⁸
Output decision
- Summarize decision and draft a short explanation plus any proposed revisions for non‑standard terms.⁶⁸

C. Vendor/DP & compliance workflows (e.g., `/vendor-assess`, `/policy-check`)

Vendor contract check
- Given vendor name or contract, cross‑reference your security/privacy/compliance requirements (e.g., DPAs, audit rights, breach notification).⁶⁸
Compliance checklist
- Run a checklist (e.g., for privacy law, sector‑specific frameworks) against the contract and highlight unmet obligations.⁶⁸
Generate review memo
- Produce a memo summarizing compliance posture, risks, and recommended additional controls or amendments.⁶⁸

D. Legal briefings & templated responses (e.g., `/legal-brief`, `/legal-response`)

Topic or matter intake
- User specifies a legal topic (e.g., new regulation) or matter (e.g., incident, dispute).
Background aggregation
- Compile relevant internal policies, prior opinions, and external references if configured.⁶⁴
Brief drafting
- Produce a structured brief: issue, background, analysis, conclusions, and recommended actions, tuned to audience (exec/team).⁶⁸⁶⁴
Template‑driven responses
- For recurring work (DSARs, notices, standard responses), fill in templates using contextual data while respecting your policy constraints.⁶⁸

11/11 – Plugin Create / Plugin Management (meta‑plugin)

Goal: Help you create, customize, and manage Cowork plugins (skills + commands + connectors) without hand‑editing files.⁶⁹⁷⁰⁶⁵⁶⁴

A. New plugin creation (e.g., `/create-plugin`)

Workflow description intake
- User describes a domain workflow in natural language (roles, tools, steps, triggers, outputs).⁷⁰⁶⁴
Extract capabilities
- Identify candidate skills (domain knowledge + tool actions), commands (user entrypoints), and required connectors (tools, MCP servers).⁶⁹⁶⁴
Define plugin structure
- Decide plugin name, summary, and list of commands and skills.
- Map each step in the workflow to either a command, a skill, or an internal sub‑agent.⁷⁰⁶⁴
Generate files
- Create .claude-plugin/plugin.json with manifest metadata and references to skills/commands/connectors.
- Create markdown definitions for each command and skill, including behavior and parameters.⁷¹⁷²
Package for use
- Optionally produce a ZIP archive of the plugin folder ready to upload into Cowork.⁶⁵⁷⁰

B. Plugin customization (e.g., `/customize-plugin`)

Select existing plugin
- Choose a currently installed plugin (built‑in or custom).⁶⁵⁶⁹
Gather customization preferences
- Ask which tools, processes, escalations, and approval rules you want to adjust (e.g., “legal: always escalate DPAs to counsel”).⁶⁹
Modify behavior
- Update plugin’s skill descriptions, thresholds (risk levels, severity, priorities), default prompts, and connector configs.⁶⁹
Save variant
- Write back adjusted plugin files as a new variant or updated version, preserving original if desired.⁷¹⁶⁹

C. Plugin management & MCP configuration (e.g., `/manage-plugins`, `/configure-mcp`)

List and inspect plugins
- Show installed plugins, their commands, and connected tools.⁷⁰⁶⁹
Configure MCP servers
- Add, edit, or remove MCP server definitions in the manifest for external tools (CRMs, data warehouses, ticketing, DMS).⁷⁰⁶⁹
Validate & test
- Run a quick test of commands or connections to ensure everything works end‑to‑end.
- Surface errors and suggest corrections (missing credentials, wrong endpoints).⁶⁹
Export or share
- Package plugins for sharing (ZIP, repo‑ready folder) and generate short docs describing commands and use cases.⁷¹⁷⁰

If you want, next step I can take one plugin (e.g., Data Analyst or Legal) and translate its steps into an explicit state machine / BPMN‑style table plus a Claude Code plugin skeleton (manifest + example skill/command markdown) you can drop into a repo. ⁷³⁷⁴⁷⁵⁷⁶⁷⁷⁷⁸⁷⁹⁸⁰

⁂

ake one plugin (e.g., Data Analyst or Legal) and translate its steps into an explicit state machine / BPMN‑style table plus a Claude Code plugin skeleton (manifest + example skill/command markdown) you can drop into a repo. Provide examples of slash commands for Data Analyst plugin

Show a sample workflow for Biology Research plugin on PubMed What are common legal risks the Legal plugin flags in contracts Step-by-step guide to create a custom Sales plugin How does Plugin Management handle MCP server configuration

Here’s a compact, implementation‑oriented pass over your questions.

1) Data Analyst plugin – state machine + plugin skeleton

A. BPMN/state machine table for `/ask-data`

State	Description	Transitions (event → next)
`Q_RECEIVED`	Natural language question captured.	User submits question → `PARSE_INTENT`.⁸¹⁸²
`PARSE_INTENT`	Extract metrics, dimensions, time range, filters.	Parse success → `MAP_SCHEMA`; parse ambiguous → `ASK_CLARIFICATION`.⁸¹⁸²
`ASK_CLARIFICATION`	Ask user follow‑ups (e.g., “which metric?”, “which product line?”).	User answers → `PARSE_INTENT`; user cancels → `END_ABORT`.
`MAP_SCHEMA`	Map concepts to tables/columns/joins using schema metadata.	Mapping OK → `PLAN_QUERY`; unknown entities → `ASK_SCHEMA_HELP`.⁸¹⁸²
`ASK_SCHEMA_HELP`	Ask user to disambiguate schema or pick tables.	User responds → `MAP_SCHEMA`; user cancels → `END_ABORT`.
`PLAN_QUERY`	Select query template (aggregation/cohort/funnel/etc.).	Template chosen → `DRAFT_SQL`.⁸¹
`DRAFT_SQL`	Generate SQL text.	Draft ready → `PREVIEW_SQL`; generation error → `PLAN_QUERY`.
`PREVIEW_SQL`	Optionally show SQL to user for approval.	User approves → `EXECUTE_SQL`; user edits → `EXECUTE_SQL`; user rejects → `PLAN_QUERY`.
`EXECUTE_SQL`	Run SQL via MCP DB connector.	Success → `VALIDATE_RESULTS`; execution error → `HANDLE_DB_ERROR`.⁸¹⁸³
`HANDLE_DB_ERROR`	Inspect DB error, adjust query or request fix.	Auto‑fix possible → `EXECUTE_SQL`; need user input → `ASK_SCHEMA_HELP`; fatal → `END_ERROR`.
`VALIDATE_RESULTS`	Check result sanity (nulls, small sets, extremes).	Looks OK → `ANALYZE`; suspicious → `ASK_DATA_CLARIFICATION`.⁸¹⁸²
`ASK_DATA_CLARIFICATION`	Ask user to refine filters or confirm outliers.	User refines → `PLAN_QUERY`; user accepts → `ANALYZE`.
`ANALYZE`	Compute stats, find trends, segment results.	Done → `VISUALIZE`.⁸¹⁸²
`VISUALIZE`	Choose chart types and build chart spec.	Done → `NARRATE`.
`NARRATE`	Generate explanation + key insights.	Done → `END_SUCCESS`.
`END_SUCCESS`	Return tables, charts, and narrative.	Terminal.
`END_ABORT`	User cancelled.	Terminal.
`END_ERROR`	Fatal error (e.g., permissions).	Terminal.

B. Example Claude Code plugin skeleton (Data Analyst)

plugin.json (minimal, Claude Code style)⁸³⁸⁴

{
  "name": "data-analyst-plugin",
  "version": "0.1.0",
  "description": "Turn natural language questions into SQL, charts, and narratives over the warehouse.",
  "author": "you@example.com",
  "mcpServers": {
    "warehouse-db": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
      "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config/db-config.json"],
      "env": {
        "DB_URL": "${DB_URL}"
      }
    }
  },
  "skills": [
    "skills/schema-understanding.md",
    "skills/query-planning.md",
    "skills/data-interpretation.md"
  ],
  "commands": [
    "commands/ask-data.md",
    "commands/run-saved-query.md"
  ]
}

skills/schema-understanding.md

# Skill: Schema understanding

## Purpose
Map business concepts in user questions to warehouse tables, columns, and joins.

## When to use
- User asks about metrics that require database queries.
- You need to resolve which tables/columns represent a concept.

## Inputs
- Natural language question.
- Schema metadata file: `${CLAUDE_PLUGIN_ROOT}/config/schema.yaml` loaded via warehouse-db tools.

## Behavior
1. Read schema metadata using MCP tools provided by `warehouse-db`.
2. Identify candidate tables and columns for each metric/dimension.
3. If multiple mappings possible, ask the user to choose.
4. Output a structured mapping object that downstream commands can consume.

commands/ask-data.md

# Command: /ask-data

## Description
Answer a natural language data question by generating and running SQL, then returning tables, charts, and narrative.

## Inputs
- `question` (string, required): The user's data question.
- Optional: `preview_sql` (boolean, default true).

## Behavior
1. Call the "Schema understanding" skill to map the question to warehouse entities.
2. Plan a query using appropriate templates (aggregation, cohort, funnel, etc.).
3. Draft SQL against the warehouse and show it to the user if `preview_sql` is true.
4. Execute the SQL via the `warehouse-db` MCP server.
5. Validate results for obvious issues; if necessary, ask the user for refinements.
6. Generate useful charts (time-series, breakdowns) and a concise narrative.
7. Return:
   - A primary answer in natural language,
   - Tabular results,
   - A set of chart specifications (e.g., Vega-lite JSON),
   - The SQL that was executed.

Example slash commands for the Data Analyst plugin

/ask-data "What is MRR by plan for the last 12 months?"
/ask-data "Show activation-to-retention funnel by acquisition channel."
/run-saved-query churn_report_q1
/segment-users "Power users by feature usage in the last 30 days."

The latter two can be separate commands (/run-saved-query, /segment-users) referencing the same skills.

2) Biology Research plugin – PubMed sample workflow

Using the Bio Research plugin with the PubMed connector:⁸⁵⁸⁶

/start
- Lists available tools (PubMed, trial registries, preprint servers, analysis tools).⁸⁶
/search-literature
- Input: “Recent RCTs of drug X in disease Y, last 5 years.”
- Plugin calls PubMed connector with query + filters (date, article type, RCT).⁸⁵⁸⁶
Screening pass
- Plugin returns a list of top hits (title, journal, year, abstract).
- You can refine: “Only phase 3 trials” or “Exclude pediatric populations.”⁸⁶⁸⁵
/summarize-evidence
- Plugin clusters selected articles by outcome/endpoints and summarizes efficacy, safety, and limitations.⁸⁷⁸⁶
/identify-gaps
- Highlights where evidence is weak or missing (e.g., under‑studied subgroups or endpoints), plus potential research questions.⁸⁷⁸⁶
/plan-experiment (optional)
- Given a chosen question and your lab constraints, suggests high‑level experimental designs and outputs a protocol outline.⁸⁶⁸⁷

3) Common legal risks the Legal plugin flags

Across NDAs, MSAs, DPAs, and vendor contracts, common flags include:⁸⁸⁸⁹⁹⁰

Liability caps and exclusions
- No cap or very high cap relative to deal size.
- Exclusions of key damages (e.g., data breach, IP infringement) from the cap in a one‑sided way.
Indemnity scope
- Broad indemnity obligations on you for areas you can’t control (e.g., partner’s misuse).
- Missing IP indemnity from the vendor for their software.⁹⁰
Data protection & security
- Missing or weak data protection clauses for personal/regulated data (no breach notification timelines, no security standards).⁹¹⁹⁰
Confidentiality & use restrictions
- Over‑broad rights to use or derive insights from your data, or indefinite retention without deletion rights.⁸⁹⁹⁰
Termination & auto‑renewal
- Long auto‑renewal terms with narrow termination rights; high early termination fees.
Jurisdiction & governing law
- Unfavorable or unexpected forums (e.g., far‑away courts, arbitration schemes) compared to your policy.⁹⁰

The plugin maps these to “OK / risk / core‑risk” with clause‑level notes and suggested edits.⁸⁸⁹⁰

4) Step‑by‑step guide to create a custom Sales plugin

In Cowork, via Plugin Create/Plugin Management:⁸¹⁹²⁹³

Describe your sales process
- In Cowork, enable Plugin Management / Plugin Create.
- Prompt: “My B2B sales process: inbound routing → qualification → discovery → proposal → negotiation → closed‑won/lost. Tools: HubSpot, Gmail, Google Drive.”⁹³⁸¹
Define slash commands & skills
- Work with the plugin to enumerate commands:
  - /prospect-research, /draft-outreach, /call-prep, /pipeline-review, /nurture-plan.
- Define skills: “sales-playbook”, “competitive-intel”, “hubspot-crm-access”.⁸¹⁹³
Generate plugin structure
- Ask Plugin Create to scaffold:
  - sales-plugin/.claude-plugin/plugin.json
  - sales-plugin/skills/ (playbook, CRM access)
  - sales-plugin/commands/ (each slash command behaviour).⁸⁴⁹²⁹⁴
Hook up connectors/MCP
- Within the generated manifest, configure mcpServers for HubSpot, email, and file storage (or rely on existing MCP connectors if already configured).⁹⁵⁸³
Refine behaviors
- Open each command markdown (e.g., /prospect-research) and adjust:
  - Which fields to pull from CRM, how to structure briefs, what to log back.
- Tune thresholds (when to auto‑log activity, when to ask for confirmation).⁹²
Package and install
- Zip the plugin folder and upload it in Cowork → Plugins → Upload.
- Hit Customize once installed to run a focused tailoring session (e.g., adjust tone, pipeline stages, approval rules).⁹⁶⁹²
Test with real deals
- Run commands on a few opportunities, check outputs, and iterate on skills/commands as needed before wider rollout.⁹¹

5) How Plugin Management handles MCP server configuration

Plugin‑side and org‑side MCP configuration interact like this:⁹⁷⁸³⁹²

Plugin‑bundled MCP servers
- Plugins declare MCP servers in .mcp.json or inline in plugin.json under "mcpServers".
- When the plugin is enabled, these servers start automatically; their tools appear alongside manually configured ones.⁸³
Lifecycle and visibility
- You typically need to restart Claude Code after enabling/disabling a plugin to see MCP changes.
- All MCP servers (user‑configured and plugin‑provided) show up under /mcp with indicators of origin.⁹⁷⁸³
Managed MCP configs (org level)
- Organizations can enforce MCP behavior via managed-mcp.json or settings with allowedMcpServers / deniedMcpServers.⁸³
- Admins can:
  - Deploy a fixed set of approved servers (no user changes).
  - Allow user additions but block non‑approved servers.
  - Disable MCP entirely if required.⁸³
Security posture
- MCP servers from plugins share the same environment (env vars, network reach) as others, so Plugin Management docs stress: keep scopes tight, log tool calls, and apply policy to plugin MCPs just like manual ones.⁹¹⁸³

If you want next, I can turn the Sales or Legal state machine into a more formal JSON spec (states, transitions, guards, actions) plus a fuller Claude Code plugin layout (including a sample .mcp.json for your stack). ⁹⁸⁹⁹¹⁰⁰¹⁰¹¹⁰²

⁂

Take Finance plugin and translate its steps into state machine table plus plugin skeleton Take Sales plugin and create BPMN table and Claude Code manifest Expand Data Analyst plugin into state machine with MCP tools skeleton Generate full plugin.json and .mcp.json for Legal plugin from the table Take Customer Support plugin and make explicit BPMN workflow table

Below are tight, implementation‑ready structures for the plugins you asked about. I’ll keep each artifact compact so you can drop them into a repo and iterate.

1) Finance plugin – state machine + skeleton

A. Finance close / analysis state machine (high level)

Scope: core “import → reconcile → statements → variance → visuals” loop.¹⁰³¹⁰⁴

State	Description	Transitions (event → next)
`START`	User invokes finance workflow.	User chooses task (`import`, `reconcile`, `statements`, `variance`, `cashflow`) → corresponding state.
`IMPORT_DATA`	Load GL, bank, subledgers, statements via MCP.	Import OK → `NORMALIZE_COA`; import error → `END_ERROR`.
`NORMALIZE_COA`	Map accounts to standard categories.	Completed → `READY_FOR_TASK`.
`READY_FOR_TASK`	Branch to specific workflow.	User selects `reconcile` → `RECONCILE`; `statements` → `GEN_STATEMENTS`; `variance` → `VARIANCE_ANALYSIS`; `cashflow` → `CASHFLOW_BUILD`.
`RECONCILE`	Match GL vs bank/subledgers.	Matching done → `PROPOSE_JOURNALS`; fatal data issue → `END_ERROR`.
`PROPOSE_JOURNALS`	Suggest reconciling entries.	User accepts/edits → `RECONCILE_SUMMARY`; user rejects → `RECONCILE_SUMMARY`.
`RECONCILE_SUMMARY`	Output reconciliation report.	Done → `END_SUCCESS`.
`GEN_STATEMENTS`	Build P&L, BS, CF from normalized balances.	Done → `STATEMENT_SUMMARY`.
`STATEMENT_SUMMARY`	Output statements + key metrics.	Done → `END_SUCCESS`.
`VARIANCE_ANALYSIS`	Compare period vs prior/budget.	Done → `VARIANCE_COMMENTARY`.
`VARIANCE_COMMENTARY`	Draft variance explanations.	Done → `END_SUCCESS`.
`CASHFLOW_BUILD`	Build cash flow waterfall from transactions.	Done → `CASHFLOW_REPORT`.
`CASHFLOW_REPORT`	Output charts + narrative.	Done → `END_SUCCESS`.
`END_SUCCESS`	Normal completion.	Terminal.
`END_ERROR`	Fatal error (missing data, access).	Terminal.

B. Claude Code plugin skeleton (Finance)

plugin.json

{
  "name": "finance-analyst-plugin",
  "version": "0.1.0",
  "description": "Reconciliations, financial statements, variance and cashflow analysis.",
  "author": "you@example.com",
  "skills": [
    "skills/import-and-normalize.md",
    "skills/reconciliation.md",
    "skills/statements-and-variance.md",
    "skills/cashflow-viz.md"
  ],
  "commands": [
    "commands/finance-reconcile.md",
    "commands/finance-statements.md",
    "commands/finance-variance.md",
    "commands/finance-cashflow.md"
  ]
}

.mcp.json

{
  "mcpServers": {
    "finance-files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/finance"
      ]
    },
    "finance-sheets": {
      "type": "http",
      "url": "https://finance-api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${FINANCE_API_TOKEN}"
      }
    }
  }
}

Example command: commands/finance-reconcile.md

# Command: /finance-reconcile

## Description
Import finance data, perform GL/bank/subledger reconciliations, and propose reconciling entries.

## Inputs
- `period` (string, required): Period identifier (e.g. "2025-Q4" or "2025-12").
- Optional: `entity` (string): Legal entity or business unit.

## Behavior
1. Use `finance-files` and/or `finance-sheets` MCP servers to load GL, bank statements, and subledger exports for the given period.
2. Call the "Import and normalize" skill to standardize the chart of accounts.
3. Call the "Reconciliation" skill to match GL lines to bank and subledger transactions.
4. Propose reconciling journal entries and ask the user to accept or edit them.
5. Generate a reconciliation summary report (matched, unmatched, proposed entries, adjusted balances).
6. Return the report plus machine-readable JSON of proposed entries.

2) Sales plugin – BPMN table + Claude Code manifest

A. Sales BPMN/state table

Scope: prospect → outreach → call → deal → follow‑up.¹⁰⁵¹⁰⁶

State	Description	Transitions
`PROSPECT_IDENTIFIED`	Prospect or account selected.	`/prospect-research` → `RESEARCHING`.
`RESEARCHING`	Gather CRM + external intel.	Research complete → `PROSPECT_PROFILE_READY`; data error → `END_ERROR`.
`PROSPECT_PROFILE_READY`	Structured profile available.	`/draft-outreach` → `OUTREACH_DRAFTING`; `/call-prep` → `CALL_PREP`.
`OUTREACH_DRAFTING`	Personalize outreach based on profile.	Draft ready → `AWAIT_OUTREACH_REVIEW`.
`AWAIT_OUTREACH_REVIEW`	Human reviews/edits outreach.	Approved → `OUTREACH_SENT`; rejected → `OUTREACH_DRAFTING`; cancel → `END_ABORT`.
`OUTREACH_SENT`	Outreach logged/sent.	Positive reply or meeting scheduled → `CALL_SCHEDULED`; no response after N days → `NURTURE_SEGMENT`.
`CALL_SCHEDULED`	Meeting on calendar.	`/call-prep` → `CALL_PREP`.
`CALL_PREP`	Build agenda, questions, materials.	Call occurs → `CALL_COMPLETED`; call canceled → `CALL_SCHEDULED` or `END_ABORT`.
`CALL_COMPLETED`	Call summary/outcome known.	Opportunity created/updated → `DEAL_IN_PIPELINE`; no fit → `LOST`.
`DEAL_IN_PIPELINE`	Opportunity tracked in CRM.	`/pipeline-review` → `PIPELINE_REVIEW`; stage change events → self-loop with updates.
`PIPELINE_REVIEW`	Evaluate all open deals, forecast, next steps.	Review done → `PIPELINE_ACTIONS_ASSIGNED`.
`PIPELINE_ACTIONS_ASSIGNED`	Specific tasks per deal created.	Tasks completed → `DEAL_IN_PIPELINE`; deals closed → `CLOSED_WON` or `LOST`.
`NURTURE_SEGMENT`	Prospect moved to nurture list.	`/nurture-plan` → `NURTURE_SEQUENCE_DEFINED`.
`NURTURE_SEQUENCE_DEFINED`	Nurture sequence created.	Sequence execution outside plugin; later engagement → `PROSPECT_PROFILE_READY`.
`CLOSED_WON`	Deal closed successfully.	Optional `POST_SALE_HANDOFF` or `ADVOCACY` flows.
`LOST`	Deal lost / disqualified.	Optional retro analysis.
`END_ABORT`	User cancelled.	Terminal.
`END_ERROR`	Fatal error.	Terminal.

B. Claude Code manifest (Sales)

plugin.json

{
  "name": "sales-workflow-plugin",
  "version": "0.1.0",
  "description": "Prospect research, outreach, call prep, pipeline review, and nurture flows.",
  "author": "you@example.com",
  "skills": [
    "skills/sales-playbook.md",
    "skills/prospect-research.md",
    "skills/pipeline-analysis.md"
  ],
  "commands": [
    "commands/prospect-research.md",
    "commands/draft-outreach.md",
    "commands/call-prep.md",
    "commands/pipeline-review.md",
    "commands/nurture-plan.md"
  ]
}

.mcp.json

{
  "mcpServers": {
    "crm-hubspot": {
      "type": "http",
      "url": "https://hubspot-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${HUBSPOT_TOKEN}"
      }
    },
    "sales-files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/sales"
      ]
    }
  }
}

Example command: commands/prospect-research.md

# Command: /prospect-research

## Description
Research a prospect using CRM data and public information, then produce a structured profile and competitive brief.

## Inputs
- `account_id` (string, optional): CRM account identifier.
- `domain_or_name` (string, optional): Company domain or name if no CRM ID.
- At least one of the above is required.

## Behavior
1. Use `crm-hubspot` to fetch existing account, contact, and deal data.
2. If `domain_or_name` is provided, enrich with website and public info using web tools when available.
3. Call the "Sales playbook" and "Prospect research" skills to:
   - Build an account profile (industry, size, ICP fit).
   - Identify key personas and likely pain points.
   - Generate a short competitive brief.
4. Save the profile to `sales-files` as `prospect-{id}.md` and return a summary with next suggested commands.

3) Data Analyst plugin – more explicit state machine + MCP skeleton

We already did a high‑level state machine; here it is with explicit tool points and an MCP JSON.

A. Data Analyst state machine (with MCP touchpoints)¹⁰⁷¹⁰⁴¹⁰⁸

State	Description	Tools (MCP)	Transitions
`Q_RECEIVED`	Question captured.	–	→ `PARSE_INTENT`.
`PARSE_INTENT`	Extract metrics/dimensions.	–	Success → `MAP_SCHEMA`; ambiguous → `ASK_CLARIFICATION`.
`ASK_CLARIFICATION`	Ask follow‑ups.	–	User answers → `PARSE_INTENT`; cancel → `END_ABORT`.
`MAP_SCHEMA`	Map to tables/columns.	`schema-files` or `warehouse-db` introspection	Mapping OK → `PLAN_QUERY`; unknown → `ASK_SCHEMA_HELP`.
`ASK_SCHEMA_HELP`	Ask user to pick tables/columns.	–	User answers → `MAP_SCHEMA`; cancel → `END_ABORT`.
`PLAN_QUERY`	Decide query template.	–	Template picked → `DRAFT_SQL`.
`DRAFT_SQL`	Generate SQL string.	–	SQL ready → `PREVIEW_SQL`.
`PREVIEW_SQL`	Show SQL for approval.	–	Approve/edit → `EXECUTE_SQL`; reject → `PLAN_QUERY`.
`EXECUTE_SQL`	Run SQL.	`warehouse-db`	Success → `VALIDATE_RESULTS`; DB error → `HANDLE_DB_ERROR`.
`HANDLE_DB_ERROR`	Adjust based on error.	–	Auto fix → `EXECUTE_SQL`; need user → `ASK_SCHEMA_HELP`; fatal → `END_ERROR`.
`VALIDATE_RESULTS`	Sanity‑check results.	–	OK → `ANALYZE`; suspicious → `ASK_DATA_CLARIFICATION`.
`ASK_DATA_CLARIFICATION`	Confirm/refine filters.	–	Refine → `PLAN_QUERY`; accept → `ANALYZE`.
`ANALYZE`	Compute stats and segments.	–	Done → `VISUALIZE`.
`VISUALIZE`	Build chart specs.	–	Done → `NARRATE`.
`NARRATE`	Explain findings.	–	Done → `END_SUCCESS`.
`END_SUCCESS`	Return answer.	–	Terminal.
`END_ABORT`	User cancelled.	–	Terminal.
`END_ERROR`	Fatal error.	–	Terminal.

B. `.mcp.json` for Data Analyst

{
  "mcpServers": {
    "warehouse-db": {
      "type": "stdio",
      "command": "db-mcp-server",
      "args": [
        "--config",
        "${CLAUDE_PLUGIN_ROOT}/config/db.yaml"
      ]
    },
    "schema-files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/config/schema"
      ]
    }
  }
}

You can reuse the earlier plugin.json I gave and just add these MCP configs.

4) Legal plugin – full `plugin.json` and `.mcp.json`

Grounded on the earlier workflow + Anthropic’s Legal plugin description.¹⁰⁹¹¹⁰¹⁰⁷

A. `plugin.json` (Legal)

{
  "name": "legal-review-plugin",
  "version": "0.1.0",
  "description": "Contract and NDA review, risk flagging, and legal brief generation based on your playbooks.",
  "author": "you@example.com",
  "skills": [
    "skills/clause-detection-and-classification.md",
    "skills/legal-playbook-evaluation.md",
    "skills/legal-briefing.md"
  ],
  "commands": [
    "commands/review-contract.md",
    "commands/triage-nda.md",
    "commands/vendor-assess.md",
    "commands/legal-brief.md"
  ],
  "mcpServers": {
    "legal-docs": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/legal"
      ]
    },
    "policy-repo": {
      "type": "http",
      "url": "https://legal-policies.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${LEGAL_POLICY_TOKEN}"
      }
    }
  }
}

Note: this uses inline mcpServers per the Claude Code plugins reference.¹¹¹¹⁰⁹

B. Optional `.mcp.json` (if you prefer separate MCP config)

{
  "mcpServers": {
    "legal-docs": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/legal"
      ]
    },
    "policy-repo": {
      "type": "http",
      "url": "https://legal-policies.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${LEGAL_POLICY_TOKEN}"
      }
    }
  }
}

Example command: commands/review-contract.md

# Command: /review-contract

## Description
Ingest a contract, classify clauses, evaluate them against your legal playbooks, and produce a risk report with suggested edits.

## Inputs
- `file_path` (string, required): Path to the contract file within `legal-docs`.
- Optional: `contract_type` (string): "MSA", "DPA", "SOW", "NDA", etc.

## Behavior
1. Use `legal-docs` to load and parse the contract text.
2. Call the "Clause detection and classification" skill to identify and label clauses (confidentiality, data protection, IP, liability, indemnity, termination, SLAs, etc.).
3. Call the "Legal playbook evaluation" skill to:
   - Compare each clause to your configured playbooks retrieved via `policy-repo`.
   - Assign risk levels (OK, risk, core-risk) with rationales.
   - Propose alternative wording or negotiation positions for non-OK clauses.
4. Generate:
   - An executive summary of overall risk.
   - A clause-by-clause table with risk levels and recommendations.
5. Return the summary and table, and write a markdown report into `legal-docs/reviews/` for future reference.

5) Customer Support plugin – explicit BPMN workflow table

Scope: ingest → triage → answer/escalate → knowledge update.¹¹²¹⁰⁵

State	Description	Transitions
`INGEST_TICKETS`	Fetch new or updated tickets from support systems.	Ingestion OK → `NORMALIZE_TICKETS`; error → `END_ERROR`.
`NORMALIZE_TICKETS`	Map diverse ticket fields into a unified schema.	Done → `CLASSIFY_INTENT`.
`CLASSIFY_INTENT`	Predict ticket type (bug, question, feature, billing, etc.).	Done → `SCORE_SEVERITY`.
`SCORE_SEVERITY`	Assign severity (critical/high/medium/low) based on rules and content.	Done → `ROUTE_TICKET`.
`ROUTE_TICKET`	Decide queue/owner (L1, L2, Eng, Billing, Legal).	Routed → `DECIDE_RESPONSE_PATH`.
`DECIDE_RESPONSE_PATH`	Decide “auto‑draft answer” vs “escalate”.	High confidence & allowed → `ANSWER_SEARCH`; else → `ESCALATE_PREP`.
`ANSWER_SEARCH`	Search KB/docs/prior tickets for solutions.	Solution found → `DRAFT_REPLY`; not found → `ESCALATE_PREP`.
`DRAFT_REPLY`	Draft user‑facing response from solution content.	Draft ready → `AWAIT_REPLY_REVIEW`.
`AWAIT_REPLY_REVIEW`	Human review if required by policy.	Approved → `SEND_REPLY`; needs edit → `DRAFT_REPLY`; rejected → `ESCALATE_PREP`.
`SEND_REPLY`	Send or post the reply to the customer.	Sent → `CHECK_KB_GAP`.
`ESCALATE_PREP`	Draft internal escalation summary and assign to team.	Escalation created → `CHECK_KB_GAP`.
`CHECK_KB_GAP`	Decide if this ticket reveals missing KB content.	Gap found → `DRAFT_KB_ARTICLE`; no gap → `END_SUCCESS`.
`DRAFT_KB_ARTICLE`	Draft candidate KB article from ticket context and resolution.	Article ready → `AWAIT_KB_APPROVAL`.
`AWAIT_KB_APPROVAL`	Human KB owner reviews article.	Approved → `PUBLISH_KB_ARTICLE`; rejected → `END_SUCCESS` or `DRAFT_KB_ARTICLE` (rework).
`PUBLISH_KB_ARTICLE`	Save article in KB and link to ticket(s).	Done → `END_SUCCESS`.
`END_SUCCESS`	Ticket processed, KB updated as needed.	Terminal.
`END_ERROR`	Fatal error.	Terminal.

You can now lift these tables and manifests directly into your design docs or as starting plugin repos. If you’d like, I can next generate a unified “workflows.md” for all 11 plugins with consistent state‑machine notation for use as an internal spec. ¹¹³¹¹⁴¹¹⁵¹¹⁶¹¹⁷¹¹⁸¹¹⁹¹²⁰¹²¹¹²²

⁂

Take each plugin and translate its steps into state machine table plus plugin skeleton,

Expand Finance plugin workflow into detailed state transitions Create BPMN diagram code for Sales plugin using Mermaid Generate full Claude manifest.json for Finance plugin Take Marketing plugin and make state machine table Provide YAML skeleton for Data Analyst MCP server config

Below are focused specs you can drop into design docs or a repo. I’ll prioritize Finance + Sales + Marketing + Data MCP as requested.¹²³¹²⁴

1) Finance plugin – detailed state machine + `manifest.json`

A. Detailed Finance state machine (close + analysis)¹²⁵¹²⁶

Scope: one “finance run” that can branch into reconcile/statements/variance/cashflow.

State	Description	Transitions
`START`	Entry: user invokes finance workflow.	User selects period/entity → `LOAD_CONFIG`.
`LOAD_CONFIG`	Load finance config (policies, COA mappings).	Config OK → `IMPORT_DATA`; missing/invalid → `END_ERROR`.
`IMPORT_DATA`	Import GL, bank, subledgers, statements via MCP.	All required sources loaded → `NORMALIZE_COA`; partial but usable → `WARN_PARTIAL_DATA`; import failure → `END_ERROR`.
`WARN_PARTIAL_DATA`	Inform user of missing inputs.	User accepts → `NORMALIZE_COA`; user cancels → `END_ABORT`.
`NORMALIZE_COA`	Map raw accounts to standard categories.	Success → `TASK_SELECTION`; mapping issues → `END_ERROR`.
`TASK_SELECTION`	Decide which workflows to run.	User chooses `reconcile` → `RECONCILE_INIT`; `statements` → `STATEMENTS_INIT`; `variance` → `VARIANCE_INIT`; `cashflow` → `CASHFLOW_INIT`; multi‑select → queue of tasks.
`RECONCILE_INIT`	Setup reconciliation context (period, accounts).	Ready → `MATCH_GL_BANK`.
`MATCH_GL_BANK`	Match GL vs bank by date/amount/description.	Done → `MATCH_SUBLEDGERS`; fatal mismatch (wrong period) → `END_ERROR`.
`MATCH_SUBLEDGERS`	Reconcile AR/AP subledgers vs control accounts.	Done → `IDENTIFY_RECON_ITEMS`.
`IDENTIFY_RECON_ITEMS`	Identify unreconciled items & variances.	Done → `PROPOSE_JOURNALS`.
`PROPOSE_JOURNALS`	Draft reconciling journal entries.	User accepts/edits → `APPLY_JOURNALS`; user rejects all → `RECONCILE_SUMMARY`.
`APPLY_JOURNALS`	Apply or stage entries (depending on policy).	Done → `RECONCILE_SUMMARY`.
`RECONCILE_SUMMARY`	Produce reconciliation report.	If more tasks selected → next task init (e.g., `STATEMENTS_INIT`); else → `END_SUCCESS`.
`STATEMENTS_INIT`	Choose statement type & target period.	→ `BUILD_TRIAL_BALANCE`.
`BUILD_TRIAL_BALANCE`	Aggregate normalized balances.	Done → `GEN_STATEMENTS`.
`GEN_STATEMENTS`	Generate P&L, BS, CF.	Done → `STATEMENTS_SUMMARY`.
`STATEMENTS_SUMMARY`	Output statements + key ratios.	More tasks → next; else → `END_SUCCESS`.
`VARIANCE_INIT`	Select comparison baseline (prior, budget).	→ `LOAD_BASELINE`.
`LOAD_BASELINE`	Import baseline numbers.	OK → `COMPUTE_VARIANCES`; missing → `END_ERROR`.
`COMPUTE_VARIANCES`	Compute variances and classify (favorable/unfavorable).	Done → `VARIANCE_COMMENTARY`.
`VARIANCE_COMMENTARY`	Draft explanations and talking points.	More tasks → next; else → `END_SUCCESS`.
`CASHFLOW_INIT`	Select cashflow period and granularity.	→ `EXTRACT_CASH_MOVEMENTS`.
`EXTRACT_CASH_MOVEMENTS`	Extract cash‑relevant transactions.	Done → `CATEGORIZE_CASH_FLOWS`.
`CATEGORIZE_CASH_FLOWS`	Tag flows as operating/investing/financing.	Done → `BUILD_WATERFALL`.
`BUILD_WATERFALL`	Build waterfall (start → deltas → end).	Done → `CASHFLOW_REPORT`.
`CASHFLOW_REPORT`	Output narrative + data for charts.	More tasks → next; else → `END_SUCCESS`.
`END_SUCCESS`	Successfully completed requested tasks.	Terminal.
`END_ABORT`	User cancels on warning/confirmation.	Terminal.
`END_ERROR`	Fatal configuration/data error.	Terminal.

B. Full `.claude-plugin/manifest.json` for Finance

Using fields from the plugin reference and template repos.¹²⁷¹²⁸¹²³

{
  "name": "finance-analyst-plugin",
  "version": "0.1.0",
  "description": "Automate reconciliations, financial statements, variance analysis, and cashflow reporting.",
  "author": "you@example.com",
  "license": "MIT",
  "commands": [
    "commands/finance-reconcile.md",
    "commands/finance-statements.md",
    "commands/finance-variance.md",
    "commands/finance-cashflow.md"
  ],
  "skills": [
    "skills/import-and-normalize.md",
    "skills/reconciliation.md",
    "skills/statements-and-variance.md",
    "skills/cashflow-viz.md"
  ],
  "agents": [],
  "hooks": [],
  "mcpServers": {
    "finance-files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/finance"
      ]
    },
    "finance-ledger-api": {
      "type": "http",
      "url": "https://ledger-api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${LEDGER_API_TOKEN}"
      }
    }
  }
}

You can rename to plugin.json or keep the name; Claude cares about content, not filename, inside .claude-plugin/.¹²⁹¹²³

2) Sales plugin – Mermaid BPMN + manifest

A. Mermaid BPMN‑like diagram for Sales

You can paste this into any Mermaid renderer.

B. Sales `plugin.json` reminder (already close to final)

{
  "name": "sales-workflow-plugin",
  "version": "0.1.0",
  "description": "Prospect research, outreach, call prep, pipeline review, and nurture automation.",
  "author": "you@example.com",
  "commands": [
    "commands/prospect-research.md",
    "commands/draft-outreach.md",
    "commands/call-prep.md",
    "commands/pipeline-review.md",
    "commands/nurture-plan.md"
  ],
  "skills": [
    "skills/sales-playbook.md",
    "skills/prospect-research.md",
    "skills/pipeline-analysis.md"
  ],
  "agents": [],
  "hooks": [],
  "mcpServers": {
    "crm-hubspot": {
      "type": "http",
      "url": "https://hubspot-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${HUBSPOT_TOKEN}"
      }
    },
    "sales-files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/sales"
      ]
    }
  }
}

3) Marketing plugin – state machine table

Scope: brief → assets → brand/SEO → calendar → reporting.¹²⁶¹³⁰

State	Description	Transitions
`START`	User starts marketing workflow.	Provide or select brief → `BRIEF_INTAKE`.
`BRIEF_INTAKE`	Capture objective, ICP, channels, timing, constraints.	Brief complete → `STRUCTURE_BRIEF`; missing key info → `ASK_BRIEF_CLARIFICATION`.
`ASK_BRIEF_CLARIFICATION`	Ask for missing brief details.	Answer → `STRUCTURE_BRIEF`; cancel → `END_ABORT`.
`STRUCTURE_BRIEF`	Normalize brief into internal spec.	Done → `ASSET_PLANNING`.
`ASSET_PLANNING`	Decide required assets per channel.	Done → `ASSET_DRAFTING`.
`ASSET_DRAFTING`	Draft copy/content for each asset.	All drafts ready → `BRAND_REVIEW`.
`BRAND_REVIEW`	Check tone, style, compliance with brand guide.	All good → `SEO_REVIEW`; some issues → `BRAND_FIXES`.
`BRAND_FIXES`	Apply or propose edits to fix brand deviations.	Done → `SEO_REVIEW`.
`SEO_REVIEW`	Optimize SEO for relevant assets.	Done → `SEO_FIXES` (if needed) or `CALENDAR_PLANNING`.
`SEO_FIXES`	Apply or propose SEO edits.	Done → `CALENDAR_PLANNING`.
`CALENDAR_PLANNING`	Place assets on schedule with owners & statuses.	Calendar built → `CAMPAIGN_SUMMARY`.
`CAMPAIGN_SUMMARY`	Output campaign plan (assets + calendar).	If performance tracking configured → `WAIT_FOR_METRICS`; else → `END_SUCCESS`.
`WAIT_FOR_METRICS`	Idle/wait until metrics available.	New metrics → `PERFORMANCE_ANALYSIS`; timeout → loop or `END_SUCCESS`.
`PERFORMANCE_ANALYSIS`	Analyze performance vs KPIs.	Done → `PERFORMANCE_RECOMMENDATIONS`.
`PERFORMANCE_RECOMMENDATIONS`	Suggest optimizations & learnings.	Done → `END_SUCCESS`.
`END_SUCCESS`	All requested steps complete.	Terminal.
`END_ABORT`	User cancelled.	Terminal.

4) Data Analyst MCP server config – YAML skeleton

Claude’s MCP config is usually JSON, but you can keep a YAML source and generate JSON, or use YAML with tools like claude mcp add in CI. Here’s a project‑local YAML that you could transpile:¹³¹¹³²

mcpServers:
  warehouse-db:
    type: stdio
    command: db-mcp-server
    args:
      - "--config"
      - "${CLAUDE_PLUGIN_ROOT}/config/db.yaml"
    env:
      DB_URL: "${DB_URL}"
      DB_USER: "${DB_USER}"
      DB_PASSWORD: "${DB_PASSWORD}"
  schema-files:
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-filesystem"
      - "${CLAUDE_PLUGIN_ROOT}/config/schema"

Converted to .mcp.json, this directly matches the documented schema used by Claude Code.¹³²

If you want, next step I can generate a single workflows.md per plugin (11 sections) that includes: state table, Mermaid snippet (where useful), and links to manifest/MCP stubs, so you can version it as the canonical spec for your plugin suite. ¹³³¹³⁴¹³⁵¹³⁶¹³⁷¹³⁸¹³⁹

⁂

generate a single workflows.md per plugin (11 sections) that includes: state table, Mermaid snippet (where useful), and links to manifest/MCP stubs, so you can version it as the canonical spec for your plugin suite.

Expand Product Manager plugin into state machine table and skeleton Create BPMN diagram code for Data Analyst plugin workflow Translate Legal plugin steps into detailed state transitions Generate Mermaid diagram for Finance plugin state machine Build full plugin.json skeleton for Sales plugin with agents and skills

Below is a compact spec you can version as a canonical workflows.md plus the extra pieces you requested. You can split each section into per‑plugin files later if you prefer.¹⁴⁰¹⁴¹¹⁴²

workflows.md

1. Productivity plugin

State machine

State	Description	Transitions
`START`	User triggers productivity flow (daily plan or sync).	Choose `daily` → `DAILY_COLLECT`; `sync` → `SYNC_COLLECT`.
`DAILY_COLLECT`	Load today’s calendar, recent email/chat, current tasks.	Success → `DAILY_INFER_TASKS`; error → `END_ERROR`.
`DAILY_INFER_TASKS`	Infer new/completed tasks from signals.	Done → `DAILY_SCHEDULE`.
`DAILY_SCHEDULE`	Time‑block tasks around meetings.	Done → `DAILY_PLAN_OUT`; user adjusts → loop in `DAILY_SCHEDULE`.
`DAILY_PLAN_OUT`	Emit plan doc and log updates to task store.	Done → `END_SUCCESS`.
`SYNC_COLLECT`	Load canonical task store + evidence sources.	Success → `SYNC_UPDATE`; error → `END_ERROR`.
`SYNC_UPDATE`	Mark tasks done / add new / reprioritize.	Done → `SYNC_SUMMARY`.
`SYNC_SUMMARY`	Output change log.	Done → `END_SUCCESS`.
`END_SUCCESS`	Completed.	Terminal.
`END_ERROR`	Data / connector failure.	Terminal.

Mermaid (daily planning)

Manifests

Plugin: productivity-plugin/.claude-plugin/plugin.json
MCP: productivity-plugin/.mcp.json (filesystem + calendar/mail connectors)

2. Sales plugin

State machine

(You already have this; leaving as is but centralized.)

State	Description	Transitions
`PROSPECT_IDENTIFIED`	Prospect/account picked.	`/prospect-research` → `RESEARCHING`.
`RESEARCHING`	Gather CRM + web intel.	Success → `PROFILE_READY`; error → `END_ERROR`.
`PROFILE_READY`	Profile created.	`/draft-outreach` → `OUTREACH_DRAFTING`; `/call-prep` → `CALL_PREP`.
`OUTREACH_DRAFTING`	Draft personalized outreach.	Done → `OUTREACH_REVIEW`.
`OUTREACH_REVIEW`	Human review.	Approve → `OUTREACH_SENT`; needs edits → `OUTREACH_DRAFTING`; cancel → `END_ABORT`.
`OUTREACH_SENT`	Outreach sent/logged.	Meeting/reply → `CALL_SCHEDULED`; no response → `NURTURE_SEGMENT`.
`CALL_SCHEDULED`	Meeting booked.	`/call-prep` → `CALL_PREP`.
`CALL_PREP`	Agenda/questions/materials.	Call occurs → `CALL_COMPLETED`; canceled → `END_ABORT` or `CALL_SCHEDULED`.
`CALL_COMPLETED`	Call summarized.	Qualified → `DEAL_IN_PIPELINE`; no fit → `LOST`.
`DEAL_IN_PIPELINE`	Opportunity open.	`/pipeline-review` → `PIPELINE_REVIEW`.
`PIPELINE_REVIEW`	Analyse deals & forecast.	Done → `PIPELINE_ACTIONS`.
`PIPELINE_ACTIONS`	Assign follow‑ups.	Actions done → `DEAL_IN_PIPELINE`; deals closed → `CLOSED_WON`/`LOST`.
`NURTURE_SEGMENT`	Move to nurture.	`/nurture-plan` → `NURTURE_PLAN`.
`NURTURE_PLAN`	Nurture sequences defined.	Engagement → `PROFILE_READY`.
`CLOSED_WON`	Closed won.	Terminal.
`LOST`	Closed lost.	Terminal.
`END_ABORT`	Cancelled.	Terminal.
`END_ERROR`	Error.	Terminal.

Mermaid BPMN

Plugin manifest with agents & skills

Using the agents/skills structure from docs.¹⁴³¹⁴⁴¹⁴⁵

{
  "name": "sales-workflow-plugin",
  "version": "0.1.0",
  "description": "Sales prospecting, outreach, call prep, pipeline review, and nurture automation.",
  "author": "you@example.com",
  "license": "MIT",
  "commands": [
    "commands/prospect-research.md",
    "commands/draft-outreach.md",
    "commands/call-prep.md",
    "commands/pipeline-review.md",
    "commands/nurture-plan.md"
  ],
  "skills": [
    "skills/sales-playbook/",
    "skills/prospect-research/",
    "skills/pipeline-analysis/"
  ],
  "agents": [
    "agents/account-executive.json",
    "agents/sales-ops.json"
  ],
  "hooks": [],
  "mcpServers": {
    "crm-hubspot": {
      "type": "http",
      "url": "https://hubspot-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${HUBSPOT_TOKEN}"
      }
    },
    "sales-files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/sales"
      ]
    }
  }
}

3. Customer Support plugin

State machine

(As previously defined, centralized.)

State	Description	Transitions
`INGEST_TICKETS`	Fetch tickets.	OK → `NORMALIZE_TICKETS`; error → `END_ERROR`.
`NORMALIZE_TICKETS`	Standardize fields.	→ `CLASSIFY_INTENT`.
`CLASSIFY_INTENT`	Predict type.	→ `SCORE_SEVERITY`.
`SCORE_SEVERITY`	Assign severity.	→ `ROUTE_TICKET`.
`ROUTE_TICKET`	Queue/owner selection.	→ `DECIDE_RESPONSE_PATH`.
`DECIDE_RESPONSE_PATH`	Auto‑draft vs escalate.	Auto path → `ANSWER_SEARCH`; escalate → `ESCALATE_PREP`.
`ANSWER_SEARCH`	Search KB/docs.	Found → `DRAFT_REPLY`; not found → `ESCALATE_PREP`.
`DRAFT_REPLY`	Draft customer reply.	→ `AWAIT_REPLY_REVIEW`.
`AWAIT_REPLY_REVIEW`	Human review (if needed).	Approve → `SEND_REPLY`; edit → `DRAFT_REPLY`; escalate → `ESCALATE_PREP`.
`SEND_REPLY`	Send reply.	→ `CHECK_KB_GAP`.
`ESCALATE_PREP`	Draft escalation summary.	→ `CHECK_KB_GAP`.
`CHECK_KB_GAP`	Detect KB gaps.	Gap → `DRAFT_KB_ARTICLE`; none → `END_SUCCESS`.
`DRAFT_KB_ARTICLE`	Draft KB article.	→ `AWAIT_KB_APPROVAL`.
`AWAIT_KB_APPROVAL`	KB owner review.	Approve → `PUBLISH_KB_ARTICLE`; rework → `DRAFT_KB_ARTICLE` or `END_SUCCESS`.
`PUBLISH_KB_ARTICLE`	Publish + link.	→ `END_SUCCESS`.
`END_SUCCESS`	Complete.	Terminal.
`END_ERROR`	Error.	Terminal.

4. Product Management plugin

State machine

State	Description	Transitions
`START`	User starts PM flow.	Select `opportunity`, `prd`, `prioritize`, `roadmap` → corresponding init state.
`OPP_INTAKE`	Collect signals (feedback, tickets, metrics).	→ `OPP_CLUSTER`.
`OPP_CLUSTER`	Cluster signals into themes.	→ `OPP_STATEMENTS`.
`OPP_STATEMENTS`	Draft opportunity statements.	→ `END_SUCCESS` or `PRD_INIT`.
`PRD_INIT`	Choose opportunity + context for PRD.	→ `PRD_SKELETON`.
`PRD_SKELETON`	Build PRD sections.	→ `PRD_FILL`.
`PRD_FILL`	Populate sections (stories, requirements, metrics).	→ `PRD_REVIEW`.
`PRD_REVIEW`	Present PRD for edits.	Accept → `END_SUCCESS`; modify → `PRD_FILL`.
`PRIORITIZE_INIT`	Load backlog.	→ `PRIORITIZE_SCORE`.
`PRIORITIZE_SCORE`	Compute scores (RICE, etc.).	→ `PRIORITIZE_RANK`.
`PRIORITIZE_RANK`	Rank items, produce lists.	→ `END_SUCCESS` or `ROADMAP_INIT`.
`ROADMAP_INIT`	Set horizon, capacity, constraints.	→ `ROADMAP_ALLOCATE`.
`ROADMAP_ALLOCATE`	Place items on timeline/releases.	→ `ROADMAP_SUMMARY`.
`ROADMAP_SUMMARY`	Output roadmap views.	→ `END_SUCCESS`.
`END_SUCCESS`	Completed.	Terminal.
`END_ERROR`	Error.	Terminal.

Skeleton references

Manifest: product-mgmt-plugin/.claude-plugin/plugin.json
MCP: analytics/issue‑tracker connectors in .mcp.json.

5. Marketing plugin

(Already given, centralized in previous answer; table repeated in one place.)

State machine

(See previous section 3; you can paste that table here.)

6. Finance plugin

State machine table

(Use the detailed table from the previous answer’s Finance section.)

Mermaid diagram

Manifest link

finance-analyst-plugin/.claude-plugin/plugin.json (see previous answer for full JSON).

7. Data Analyst plugin

State machine

(Use the extended state table with MCP touchpoints from the earlier Data Analyst section.)

Mermaid BPMN

MCP skeleton (YAML)

(As in previous answer; keep warehouse-db and schema-files.)¹⁴⁶

8. Enterprise Search plugin

State machine

State	Description	Transitions
`QUESTION_RECEIVED`	Natural language query.	→ `DETERMINE_SCOPE`.
`DETERMINE_SCOPE`	Resolve sources/time range.	→ `FANOUT_SEARCH`.
`FANOUT_SEARCH`	Query all configured sources.	→ `COLLECT_RESULTS`.
`COLLECT_RESULTS`	Aggregate hits + snippets.	→ `NORMALIZE_RESULTS`.
`NORMALIZE_RESULTS`	Normalize & score snippets.	→ `CLUSTER_RESULTS`.
`CLUSTER_RESULTS`	Cluster similar answers.	→ `SYNTHESIZE_ANSWER`.
`SYNTHESIZE_ANSWER`	Compose answer with citations.	→ `OPTIONAL_PERSIST`.
`OPTIONAL_PERSIST`	Decide whether to log answer.	Log → `WRITE_DOC`; skip → `END_SUCCESS`.
`WRITE_DOC`	Write answer into KB doc.	→ `END_SUCCESS`.
`END_SUCCESS`	Done.	Terminal.
`END_ERROR`	Error.	Terminal.

9. Biology Research plugin

State machine

(From prior section; you can add clustering/synthesis states across PubMed.)

10. Legal plugin

State machine (detailed)

State	Description	Transitions
`START`	`/review-contract` invoked.	→ `LOAD_CONTRACT`.
`LOAD_CONTRACT`	Load file from legal docs MCP.	OK → `PARSE_STRUCTURE`; error → `END_ERROR`.
`PARSE_STRUCTURE`	Extract text, sections, clauses.	→ `CLASSIFY_CLAUSES`.
`CLASSIFY_CLAUSES`	Tag clause types.	→ `LOAD_PLAYBOOKS`.
`LOAD_PLAYBOOKS`	Retrieve legal playbooks from policy repo.	OK → `EVALUATE_CLAUSES`; error → `END_ERROR`.
`EVALUATE_CLAUSES`	Compare each clause vs playbook.	→ `SCORE_RISKS`.
`SCORE_RISKS`	Assign risk levels & rationales.	→ `DETECT_MISSING`.
`DETECT_MISSING`	Detect missing expected clauses.	→ `SUGGEST_EDITS`.
`SUGGEST_EDITS`	Draft alternative language & negotiation points.	→ `BUILD_REPORT`.
`BUILD_REPORT`	Construct summary + clause table.	→ `OUTPUT_REPORT`.
`OUTPUT_REPORT`	Save + return report.	→ `END_SUCCESS`.
`END_SUCCESS`	Done.	Terminal.
`END_ERROR`	Error.	Terminal.

(You can clone this per /triage-nda and vendor assessment with slightly different states.)

11. Plugin Create / Plugin Management

State machine (meta)

State	Description	Transitions
`START`	User invokes plugin creation.	→ `CAPTURE_WORKFLOW`.
`CAPTURE_WORKFLOW`	Collect description of domain workflow.	→ `EXTRACT_COMPONENTS`.
`EXTRACT_COMPONENTS`	Identify commands, skills, agents, MCP needs.	→ `DESIGN_PLUGIN_STRUCTURE`.
`DESIGN_PLUGIN_STRUCTURE`	Decide directory layout, naming.	→ `GENERATE_FILES`.
`GENERATE_FILES`	Generate `plugin.json`, skills, commands, optional `.mcp.json`.	→ `PACKAGE_PLUGIN`.
`PACKAGE_PLUGIN`	Zip plugin for Cowork/Code.	→ `END_SUCCESS`.
`END_SUCCESS`	Done.	Terminal.
`END_ERROR`	Error.	Terminal.

This gives you a single “workflows spec” you can evolve. For implementation, you can now:

create my-plugin/.claude-plugin/plugin.json per skeleton above;¹⁴²¹⁴⁰
drop these state tables into workflows.md in each plugin repo;
wire .mcp.json or YAML‑driven configs as in the Data Analyst/Finance stubs.¹⁴⁷¹⁴⁶ ¹⁴⁸¹⁴⁹¹⁵⁰¹⁵¹¹⁵²¹⁵³¹⁵⁴¹⁵⁵¹⁵⁶¹⁵⁷

⁂

Build a master index.md linking all 11 workflows.md files

# Claude Cowork / Claude Code Plugin Workflows

Master index for all plugin workflow specifications. Each plugin has its own `workflows.md` documenting state machines, Mermaid/BPMN snippets, and manifest/MCP notes.

## 1. Productivity plugin

- **Workflows spec:** `productivity-plugin/docs/workflows.md`  
- Focus: daily planning, task sync, calendar and communication assist.

## 2. Sales plugin

- **Workflows spec:** `sales-workflow-plugin/docs/workflows.md`  
- Focus: prospect research, outreach, call prep, pipeline review, nurture.

## 3. Customer Support plugin

- **Workflows spec:** `customer-support-plugin/docs/workflows.md`  
- Focus: ticket ingestion, triage, auto‑drafted replies, KB growth loop.

## 4. Product Management plugin

- **Workflows spec:** `product-mgmt-plugin/docs/workflows.md`  
- Focus: opportunity discovery, PRDs/specs, prioritization, roadmapping.

## 5. Marketing plugin

- **Workflows spec:** `marketing-plugin/docs/workflows.md`  
- Focus: campaign briefs, asset pipeline, brand/SEO review, calendars, reporting.

## 6. Finance & Accounting plugin

- **Workflows spec:** `finance-analyst-plugin/docs/workflows.md`  
- Focus: imports, reconciliations, statements, variance, cashflow visuals.

## 7. Data Analyst plugin

- **Workflows spec:** `data-analyst-plugin/docs/workflows.md`  
- Focus: NL questions → SQL → analysis → charts → narratives.

## 8. Enterprise Search plugin

- **Workflows spec:** `enterprise-search-plugin/docs/workflows.md`  
- Focus: cross‑source search (chat/email/docs/tickets), dedup, synthesis, recurring reports.

## 9. Biology Research plugin

- **Workflows spec:** `bio-research-plugin/docs/workflows.md`  
- Focus: PubMed‑style literature search, screening, synthesis, experiment planning.

## 10. Legal plugin

- **Workflows spec:** `legal-review-plugin/docs/workflows.md`  
- Focus: contract/NDA parsing, clause classification, risk scoring, suggested edits, briefs.

## 11. Plugin Create / Plugin Management

- **Workflows spec:** `plugin-management/docs/workflows.md`  
- Focus: plugin scaffolding, customization, and MCP/connector configuration.

ANALYZE and determine if we completed all BMN, manifest, breakdown step by step task of each of the 11 workflows, analyze gap analysis and then based on the analysis complete each of the remaining filling gaps, include mermaid diagrams for each

We have the conceptual breakdowns for all 11 plugins, but only some of them currently have all three artifacts you want (state machine table, Claude plugin skeleton/manifest, Mermaid diagram). The rest are partially specified and need completion.¹⁵⁸¹⁵⁹

Below I first give a gap summary, then systematically fill the missing pieces, so each plugin has:

A state machine table (BPMN‑like)
A Claude Code plugin skeleton (at least plugin.json path and structure)
A Mermaid diagram

Paths are suggestions; you can rename to match your repo.

1) Gap summary

From the previous iterations + attached transcript:¹⁵⁹¹⁵⁸

Productivity
- State machine: present (daily planning + sync).
- Plugin skeleton: implied but not spelled out as plugin.json.
- Mermaid diagram: present for daily plan only.
Sales
- State machine: present.
- Plugin skeleton: present; now extended with agents.
- Mermaid diagram: present.
Customer Support
- State machine: present.
- Plugin skeleton: not explicitly given.
- Mermaid diagram: missing.
Product Management
- State machine: partial; we added one, but no skeleton.
- Mermaid: missing.
Marketing
- State machine: present.
- Plugin skeleton: not explicit.
- Mermaid: missing.
Legal
- State machine: detailed for /review-contract.
- Plugin skeleton: present (plugin.json + MCP).
- Mermaid: missing.
Finance
- State machine: detailed.
- Plugin skeleton: present (manifest).
- Mermaid: present.
Data Analyst
- State machine: detailed + MCP skeleton.
- Plugin skeleton: partial.
- Mermaid: present.
Enterprise Search
- State machine: present.
- Plugin skeleton: missing.
- Mermaid: missing.
Bio‑Research
- State machine: partial; no canonical table.
- Plugin skeleton: missing.
- Mermaid: missing.
Plugin Create / Plugin Management
- State machine: present (meta).
- Plugin skeleton: missing.
- Mermaid: missing.

Below I just fill in what’s missing, once each, in a compact, copy‑paste‑ready form.

2) Productivity plugin – finalize skeleton + Mermaid (sync flow)

State machine (already good; keeping as is)

(See earlier START / DAILY_COLLECT / DAILY_INFER_TASKS / DAILY_SCHEDULE / DAILY_PLAN_OUT and SYNC_* states.)

`plugin.json` skeleton

{
  "name": "productivity-plugin",
  "version": "0.1.0",
  "description": "Daily planning, task synchronization, and calendar/email triage.",
  "author": "you@example.com",
  "license": "MIT",
  "commands": [
    "commands/daily-plan.md",
    "commands/update-tasks.md"
  ],
  "skills": [
    "skills/task-inference/",
    "skills/schedule-optimization/"
  ],
  "agents": [],
  "hooks": [],
  "mcpServers": {
    "prod-files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/productivity"
      ]
    },
    "calendar-api": {
      "type": "http",
      "url": "https://calendar-mcp.example.com/mcp"
    },
    "mail-api": {
      "type": "http",
      "url": "https://mail-mcp.example.com/mcp"
    }
  }
}

Mermaid (sync flow)

3) Customer Support plugin – add Mermaid + skeleton

Mermaid

`plugin.json` skeleton

{
  "name": "customer-support-plugin",
  "version": "0.1.0",
  "description": "Ticket triage, auto-replies, and knowledge base maintenance.",
  "author": "you@example.com",
  "license": "MIT",
  "commands": [
    "commands/support-triage.md",
    "commands/support-daily-review.md"
  ],
  "skills": [
    "skills/ticket-classification/",
    "skills/severity-scoring/",
    "skills/answer-generation/",
    "skills/kb-maintenance/"
  ],
  "agents": [
    "agents/support-l1.json",
    "agents/support-lead.json"
  ],
  "hooks": [],
  "mcpServers": {
    "support-zendesk": {
      "type": "http",
      "url": "https://zendesk-mcp.example.com/mcp"
    },
    "support-kb": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/support-kb"
      ]
    }
  }
}

4) Product Management plugin – finalize skeleton + Mermaid

State machine

(Already provided; reusing.)

Mermaid

`plugin.json` skeleton

{
  "name": "product-mgmt-plugin",
  "version": "0.1.0",
  "description": "Opportunity discovery, PRDs, prioritization, and roadmapping for product teams.",
  "author": "you@example.com",
  "license": "MIT",
  "commands": [
    "commands/opportunity-intake.md",
    "commands/draft-prd.md",
    "commands/prioritize-backlog.md",
    "commands/build-roadmap.md"
  ],
  "skills": [
    "skills/opportunity-analysis/",
    "skills/prd-authoring/",
    "skills/prioritization-frameworks/",
    "skills/roadmap-planning/"
  ],
  "agents": [
    "agents/product-manager.json"
  ],
  "hooks": [],
  "mcpServers": {
    "pm-feedback": {
      "type": "http",
      "url": "https://feedback-mcp.example.com/mcp"
    },
    "pm-tracker": {
      "type": "http",
      "url": "https://tracker-mcp.example.com/mcp"
    }
  }
}

5) Marketing plugin – skeleton + Mermaid

Mermaid

`plugin.json` skeleton

{
  "name": "marketing-plugin",
  "version": "0.1.0",
  "description": "Campaign briefs, content generation, brand/SEO review, calendars, and reporting.",
  "author": "you@example.com",
  "license": "MIT",
  "commands": [
    "commands/campaign-intake.md",
    "commands/draft-assets.md",
    "commands/campaign-calendar.md",
    "commands/campaign-report.md"
  ],
  "skills": [
    "skills/brand-guidelines/",
    "skills/seo-optimization/",
    "skills/campaign-analytics/"
  ],
  "agents": [
    "agents/marketing-manager.json"
  ],
  "hooks": [],
  "mcpServers": {
    "marketing-assets": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}/data/marketing"
      ]
    },
    "marketing-analytics": {
      "type": "http",
      "url": "https://analytics-mcp.example.com/mcp"
    }
  }
}

6) Legal plugin – Mermaid

Mermaid

(Plugin skeleton already provided.)

7) Data Analyst plugin – confirm completeness

State machine: detailed and Mermaid already provided.
MCP: YAML skeleton given.
plugin.json: skeleton given earlier.

No further gap.

8) Enterprise Search plugin – skeleton + Mermaid

Mermaid

`plugin.json` skeleton

{
  "name": "enterprise-search-plugin",
  "version": "0.1.0",
  "description": "Federated search over chat, email, docs, wikis, and tickets with deduped answers.",
  "author": "you@example.com",
  "license": "MIT",
  "commands": [
    "commands/search-enterprise.md",
    "commands/scheduled-search.md"
  ],
  "skills": [
    "skills/search-orchestration/",
    "skills/answer-synthesis/"
  ],
  "agents": [],
  "hooks": [],
  "mcpServers": {
    "search-slack": {
      "type": "http",
      "url": "https://slack-mcp.example.com/mcp"
    },
    "search-email": {
      "type": "http",
      "url": "https://email-mcp.example.com/mcp"
    },
    "search-docs": {
      "type": "http",
      "url": "https://docs-mcp.example.com/mcp"
    },
    "search-wiki": {
      "type": "http",
      "url": "https://wiki-mcp.example.com/mcp"
    }
  }
}

9) Bio‑Research plugin – canonical table + skeleton + Mermaid

State machine

State	Description	Transitions
`START`	User invokes bio research flow.	→ `CAPTURE_QUESTION`.
`CAPTURE_QUESTION`	Capture biological question.	→ `CONFIGURE_SEARCH`.
`CONFIGURE_SEARCH`	Apply domain filters (sources, MeSH, date).	→ `RUN_LITERATURE_SEARCH`.
`RUN_LITERATURE_SEARCH`	Query PubMed/others via MCP.	OK → `SCREEN_RESULTS`; error → `END_ERROR`.
`SCREEN_RESULTS`	Apply inclusion/exclusion criteria.	→ `TAG_AND_CLUSTER`.
`TAG_AND_CLUSTER`	Tag by modality, mechanism, phase; cluster.	→ `SYNTHESIZE_EVIDENCE`.
`SYNTHESIZE_EVIDENCE`	Summarize by cluster + cross‑cluster.	→ `IDENTIFY_GAPS`.
`IDENTIFY_GAPS`	Identify evidence gaps and questions.	→ `PLAN_EXPERIMENT` or `END_SUCCESS`.
`PLAN_EXPERIMENT`	Assist in outlining experiments.	→ `END_SUCCESS`.
`END_SUCCESS`	Done.	Terminal.
`END_ERROR`	Error.	Terminal.

Mermaid

`plugin.json` skeleton

{
  "name": "bio-research-plugin",
  "version": "0.1.0",
  "description": "Trusted literature search, synthesis, and experiment planning for life sciences.",
  "author": "you@example.com",
  "license": "MIT",
  "commands": [
    "commands/search-literature.md",
    "commands/summarize-evidence.md",
    "commands/plan-experiment.md"
  ],
  "skills": [
    "skills/literature-screening/",
    "skills/evidence-synthesis/",
    "skills/experiment-planning/"
  ],
  "agents": [
    "agents/research-assistant.json"
  ],
  "hooks": [],
  "mcpServers": {
    "pubmed": {
      "type": "http",
      "url": "https://pubmed-mcp.example.com/mcp"
    }
  }
}

10) Plugin Create / Plugin Management – Mermaid + skeleton

Mermaid

`plugin.json` skeleton

{
  "name": "plugin-management",
  "version": "0.1.0",
  "description": "Create, customize, and manage Claude Cowork/Code plugins.",
  "author": "you@example.com",
  "license": "MIT",
  "commands": [
    "commands/create-plugin.md",
    "commands/customize-plugin.md",
    "commands/list-plugins.md"
  ],
  "skills": [
    "skills/workflow-analysis/",
    "skills/plugin-scaffolding/"
  ],
  "agents": [
    "agents/plugin-architect.json"
  ],
  "hooks": [],
  "mcpServers": {
    "plugin-files": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${CLAUDE_PLUGIN_ROOT}"
      ]
    }
  }
}

11) Finance plugin – already complete

State machine table: done.
Mermaid: done.
plugin.json: done.

At this point, each of the 11 domains in the Anthropic video (productivity, sales, customer support, product, marketing, legal, finance, data, enterprise search, bio‑research, plugin management) has:

A BPMN‑style state table
A Mermaid diagram
A Claude Code plugin skeleton you can refine into concrete manifests.¹⁵⁸¹⁵⁹

⁂

create master system prompts for creating each plugin in its entirety with all components, the prompts should be explicit and unambiguous and comprehensive to be able to create a plugin. then after creating the master system prompts for the 11 workflows, create a master master system prompt that could be applied to any workflow, enterprise, or personal that could create a plugin with all of its components with detailed step by step processes, this should include web search for the prompt to be able to understand the use case of the workflow that may be provided or suggested in the prompting to then gather the workflow requirements with sufficient deep research to inform the prompt with enough data to then build out the super master system prompt for that particular use case and then run it and produce all of the required components for the new plug with components, bpmn, mermaid diagrams and manifest

Below are two layers of prompts:

11 master system prompts – one per Anthropic Cowork plugin (Productivity, Sales, etc.), each explicit enough to generate a full Claude Code–compatible plugin (commands, skills, agents, MCP config, BPMN/state tables, Mermaid diagrams, manifests).
One super‑master system prompt – a reusable meta‑prompt that can take any workflow/use‑case, do web research, derive requirements, and then generate a complete plugin (including BPMN, Mermaid, manifests, etc.).¹⁶⁰¹⁶¹¹⁶²

You can drop these directly into Claude Code as “system messages” or top‑level instructions, then follow them with your domain‑specific details.

1) Master system prompt: Productivity plugin

System prompt:

You are designing a Claude Cowork + Claude Code Productivity plugin that automates daily planning, task synchronization, and calendar/email/chat triage for knowledge workers.

Produce a complete plugin suitable for Claude Code and Cowork with the following components:

Domain understanding and scope

Briefly restate the productivity use cases: daily plan generation, task sync across mail/calendar/chat, personal daily brief.

Assume integration with: calendar API, email API, chat (e.g., Slack), and a task system (filesystem list or SaaS PM tool).

Workflow specification

Define a state machine table (Markdown) for the overall productivity workflow including at least:

Daily planning flow: START → DAILY_COLLECT → DAILY_INFER_TASKS → DAILY_SCHEDULE → DAILY_PLAN_OUT → END_SUCCESS.

Task sync flow: START → SYNC_COLLECT → SYNC_UPDATE → SYNC_SUMMARY → END_SUCCESS.

For each state, include: State, Description, Triggers/Inputs, Actions, Next state.

BPMN/Mermaid diagrams

Generate two Mermaid flowchart TD diagrams:

One for the daily planning flow.

One for the task sync flow.

Ensure node labels match the state names used in the table.

Plugin structure

Propose a directory layout under productivity-plugin/ with at least:

.claude-plugin/plugin.json (manifest)

.mcp.json (optional separate MCP config)

commands/daily-plan.md, commands/update-tasks.md

skills/task-inference/ and skills/schedule-optimization/ (with example SKILL.md files)

agents/ folder (even if empty for now).

Claude plugin manifest

Output full JSON for .claude-plugin/plugin.json that includes:

name, version, description, author, license.

commands: list of the two command files.

skills: paths to the skill directories.

agents: may be empty array.

hooks: empty array.

mcpServers: define at least three MCP servers:

A filesystem server prod-files pointing at data/productivity.

calendar-api (HTTP based).

mail-api (HTTP based).

MCP configuration

Provide an example .mcp.json (JSON) for the same servers, compatible with Claude Code’s MCP settings.¹⁶³¹⁶⁴

Commands and skills

Fully specify the markdown for:

commands/daily-plan.md: inputs, behavior steps (collect context, infer tasks, schedule, output plan), expected outputs.

commands/update-tasks.md: inputs, behavior (scan signals, infer completed/new tasks, update task store, output change log).

skills/task-inference/SKILL.md: when to use, inputs, behavior.

skills/schedule-optimization/SKILL.md: when to use, inputs, behavior.

Safety and controls

Specify how the plugin will:

Avoid destructive changes without confirmation (e.g., only mark tasks complete with strong evidence or user approval).

Respect privacy and access control (only operate on the user’s permitted mail/calendar/chat).

Return all of the above in a single, well‑structured Markdown document with clear section headers, ready to be committed as docs/workflows.md plus the manifest and markdown files under the plugin root.

2) Master system prompt: Sales plugin

You are designing a Claude Cowork + Claude Code Sales plugin that covers prospect research, outreach, call prep, pipeline review, and nurture sequences, aligned with the Anthropic Cowork Sales plugin.¹⁶⁵¹⁶⁶

Produce a complete plugin with:

Sales process definition

Restate the canonical stages: prospect research, outreach, call prep, engagement, deal management & forecasting, follow‑up/nurture.

State machine

Build a detailed state machine table with at least these states and transitions:

PROSPECT_IDENTIFIED, RESEARCHING, PROFILE_READY, OUTREACH_DRAFTING, OUTREACH_REVIEW, OUTREACH_SENT, CALL_SCHEDULED, CALL_PREP, CALL_COMPLETED, DEAL_IN_PIPELINE, PIPELINE_REVIEW, PIPELINE_ACTIONS, NURTURE_SEGMENT, NURTURE_PLAN, CLOSED_WON, LOST, END_ABORT, END_ERROR.

For each state, specify: description, entry criteria, actions, possible next states.

Mermaid BPMN

Generate a Mermaid flowchart TD diagram representing the above state machine.

Plugin structure and manifest

Directory layout for sales-workflow-plugin/ with:

.claude-plugin/plugin.json (manifest including commands, skills, agents, MCP servers).

.mcp.json (optional).

commands/: prospect-research.md, draft-outreach.md, call-prep.md, pipeline-review.md, nurture-plan.md.

skills/: sales-playbook/, prospect-research/, pipeline-analysis/.

agents/: account-executive.json, sales-ops.json.

Produce full plugin.json including:

mcpServers.crm-hubspot (HTTP), mcpServers.sales-files (filesystem).¹⁶⁴

Commands and skills markdown

For each command file, specify:

Inputs (e.g., account_id, domain_or_name).

Detailed behavior (step‑by‑step).

Outputs (profile docs, CRM notes, action items).

For each skill, specify SKILL.md content describing when to use and how it orchestrates tools.

Safety and governance

Describe how the plugin enforces:

Human review before sending outreach at scale.

Logging of CRM‑affecting operations.

Output everything as a single Markdown spec plus embedded JSON/Markdown files.

3) Master system prompt: Customer Support plugin

You are designing a Customer Support plugin for Claude Cowork/Code that handles ticket triage, auto‑drafted replies, and KB maintenance, following the behavior described in the Anthropic Cowork Customer Support plugin.¹⁶⁶¹⁶⁵

Generate:

State machine table covering:

INGEST_TICKETS, NORMALIZE_TICKETS, CLASSIFY_INTENT, SCORE_SEVERITY, ROUTE_TICKET, DECIDE_RESPONSE_PATH, ANSWER_SEARCH, DRAFT_REPLY, AWAIT_REPLY_REVIEW, SEND_REPLY, ESCALATE_PREP, CHECK_KB_GAP, DRAFT_KB_ARTICLE, AWAIT_KB_APPROVAL, PUBLISH_KB_ARTICLE, END_SUCCESS, END_ERROR.

Mermaid diagram of the ticket lifecycle.

Plugin layout and manifest for customer-support-plugin/ with:

plugin.json (full)

MCP servers for a ticket system (e.g. Zendesk/Intercom) and KB storage (filesystem).

Commands

support-triage.md: bulk triage run.

support-daily-review.md: daily summary and dashboard.

Skills

ticket-classification, severity-scoring, answer-generation, kb-maintenance with SKILL markdowns.

Controls

Policies for what can be auto‑sent vs. must be reviewed.

4) Master system prompt: Product Management plugin

You are designing a Product Management plugin for Claude Cowork/Code to handle opportunity discovery, PRD/spec generation, prioritization, and roadmapping.¹⁶¹¹⁶⁵

Requirements:

State machine with at least:

OPP_INTAKE, OPP_CLUSTER, OPP_STATEMENTS, PRD_INIT, PRD_SKELETON, PRD_FILL, PRD_REVIEW, PRIORITIZE_INIT, PRIORITIZE_SCORE, PRIORITIZE_RANK, ROADMAP_INIT, ROADMAP_ALLOCATE, ROADMAP_SUMMARY, END_SUCCESS, END_ERROR.

Mermaid diagram showing the branching between opportunity/PRD/prioritization/roadmap flows.

Plugin structure

product-mgmt-plugin/.claude-plugin/plugin.json.

MCP connectors to feedback sources and issue trackers.

Commands: opportunity-intake, draft-prd, prioritize-backlog, build-roadmap.

Skills: opportunity analysis, PRD authoring, prioritization frameworks, roadmap planning.

Detailed commands and skills:

Fully specify markdown for at least draft-prd and prioritize-backlog.

Governance

How to handle sign‑off and revision cycles for PRDs.

5) Master system prompt: Marketing plugin

You are designing a Marketing plugin for Claude Cowork/Code to manage campaign briefs, content pipelines, brand/SEO checks, calendars, and performance reporting.¹⁶⁷¹⁶⁵

Deliver:

State machine table for the marketing workflow, including states like BRIEF_INTAKE, STRUCTURE_BRIEF, ASSET_PLANNING, ASSET_DRAFTING, BRAND_REVIEW, BRAND_FIXES, SEO_REVIEW, SEO_FIXES, CALENDAR_PLANNING, CAMPAIGN_SUMMARY, WAIT_FOR_METRICS, PERFORMANCE_ANALYSIS, PERFORMANCE_RECOMMENDATIONS, END_SUCCESS.

Mermaid flowchart of this lifecycle.

Plugin manifest and structure:

marketing-plugin/.claude-plugin/plugin.json.

MCP servers for asset storage and analytics.

Commands for campaign-intake, draft-assets, campaign-calendar, campaign-report.

Skills for brand guidelines, SEO, and analytics.

Command markdowns with explicit inputs/outputs and steps.

6) Master system prompt: Legal plugin

You are designing a Legal plugin for Claude Cowork/Code that reviews contracts/NDAs, flags risks, and generates legal briefs, consistent with Anthropic’s Legal Cowork plugin.¹⁶⁸¹⁶⁵

Produce:

Detailed state machine for /review-contract including:

LOAD_CONTRACT, PARSE_STRUCTURE, CLASSIFY_CLAUSES, LOAD_PLAYBOOKS, EVALUATE_CLAUSES, SCORE_RISKS, DETECT_MISSING, SUGGEST_EDITS, BUILD_REPORT, OUTPUT_REPORT, END_SUCCESS, END_ERROR.

Mermaid flowchart for this review flow.

Plugin manifest legal-review-plugin/.claude-plugin/plugin.json including MCP servers:

legal-docs (filesystem).

policy-repo (HTTP).

Commands:

review-contract, triage-nda, vendor-assess, legal-brief.

Skills:

Clause detection and classification, playbook evaluation, legal briefing.

Risk taxonomy

Enumerate typical risk categories (liability, indemnity, data protection, confidentiality, termination, jurisdiction, etc.) and how the plugin encodes them.

7) Master system prompt: Finance plugin

You are designing a Finance & Accounting plugin for Claude Cowork/Code that performs reconciliations, financial statements, variance analysis, and cashflow visualization.¹⁶⁹¹⁶⁵

Create:

Detailed state machine (complete) and a Mermaid diagram (already sketched; fully regenerate).

Full plugin.json and optional .mcp.json with MCP servers:

finance-files (filesystem).

finance-ledger-api (HTTP).

Commands: finance-reconcile, finance-statements, finance-variance, finance-cashflow.

Skills: import/normalize, reconciliation, statements & variance, cashflow‑viz.

Command markdowns for at least finance-reconcile and finance-cashflow.

8) Master system prompt: Data Analyst plugin

You are designing a Data Analyst plugin for Claude Cowork/Code that converts natural language questions into SQL, runs them via MCP, and returns tables, charts, and narratives.¹⁷⁰¹⁶⁵¹⁶⁷

Produce:

Full state machine table (question → parse → schema map → SQL → execute → validate → analyse → visualize → narrate).

Mermaid flowchart reflecting this state machine.

plugin.json manifest including MCP servers:

warehouse-db (stdio or HTTP).

schema-files (filesystem).

.mcp.json or YAML → JSON mapping for those servers.

Commands: /ask-data, /run-saved-query, /data-report.

Skills: schema understanding, query planning, data interpretation.

Examples of inputs/outputs for /ask-data.

9) Master system prompt: Enterprise Search plugin

You are designing an Enterprise Search plugin for Claude Cowork/Code that performs federated search across chat, email, docs, wikis, and tickets, and synthesizes deduped answers with citations.¹⁶⁵¹⁶⁷

Deliver:

State machine with states: QUESTION_RECEIVED, DETERMINE_SCOPE, FANOUT_SEARCH, COLLECT_RESULTS, NORMALIZE_RESULTS, CLUSTER_RESULTS, SYNTHESIZE_ANSWER, OPTIONAL_PERSIST, WRITE_DOC, END_SUCCESS, END_ERROR.

Mermaid diagram for this pipeline.

plugin.json with MCP servers for Slack, email, docs, wiki.

Commands: search-enterprise, scheduled-search.

Skills: search orchestration, answer synthesis, deduplication.

10) Master system prompt: Bio‑Research plugin

You are designing a Biology Research plugin for Claude Cowork/Code that performs trusted literature search (e.g., PubMed), screening, synthesis, and experiment planning, in line with Anthropic’s Bio Research plugin.¹⁷¹¹⁷²¹⁶⁵

Create:

State machine table for: CAPTURE_QUESTION, CONFIGURE_SEARCH, RUN_LITERATURE_SEARCH, SCREEN_RESULTS, TAG_AND_CLUSTER, SYNTHESIZE_EVIDENCE, IDENTIFY_GAPS, PLAN_EXPERIMENT, END_SUCCESS, END_ERROR.

Mermaid diagram for the full flow.

plugin.json manifest with a pubmed MCP server.

Commands: search-literature, summarize-evidence, plan-experiment.

Skills: literature screening, evidence synthesis, experiment planning.

Explicit guardrails that outputs are for research assistance only and require domain expert review.

11) Master system prompt: Plugin Create / Plugin Management plugin

You are designing a Plugin Management / Plugin Create plugin that can generate, customize, and list Claude plugins, as described in Anthropic’s Plugin Create / meta plugin.¹⁷³¹⁷⁴¹⁶⁵

Requirements:

State machine for plugin creation: CAPTURE_WORKFLOW, EXTRACT_COMPONENTS, DESIGN_PLUGIN_STRUCTURE, GENERATE_FILES, PACKAGE_PLUGIN, END_SUCCESS, END_ERROR.

Mermaid diagram of this flow.

plugin.json with:

Commands: create-plugin, customize-plugin, list-plugins.

Skills: workflow analysis, plugin scaffolding.

MCP: filesystem access to the plugin root.

Command markdowns that:

Read user workflow descriptions.

Output fully formed plugin directories (including manifests, skills, commands, BPMN tables, and Mermaid diagrams embedded in docs).

12) Super‑master system prompt – for any workflow/domain

This is the general reusable meta‑prompt you asked for. It assumes the model has tools for web search and filesystem (MCP), and will generate a complete plugin in a single run.¹⁷⁵¹⁷⁶¹⁶⁰

Super‑master system prompt:

You are an expert Claude Code / Cowork plugin architect. Your task is to take any workflow, enterprise or personal use case, and produce a complete plugin implementing that workflow, including all artifacts needed for reuse and sharing.

Your capabilities and obligations:

You must perform targeted web research to understand the domain, terminology, common workflows, and best practices for the user’s requested use case, unless it is trivial. Use vendor docs, reputable blogs, or academic sources as appropriate.¹⁷⁶¹⁷⁵¹⁶¹

You must synthesize this research into a clear workflow model, then generate:

State machine tables,

BPMN‑style Mermaid diagrams,

A complete Claude plugin manifest,

Skill and command definitions,

MCP server configuration proposals,

Optional agents and hooks if they add value.¹⁶²¹⁶⁰¹⁷⁵

Input you receive (from the user):

A description of the target workflow or role (e.g., “investment banking deal workflow”, “clinical trial monitoring”, “personal GTD system”).

Any constraints (tools, data sources, security/compliance requirements, access model).

Your process (you must follow this sequence):

Clarify and frame the workflow

Restate the problem and workflow scope in your own words.

Identify: primary actors, key systems, key artifacts (docs, tickets, dashboards), and success metrics.

Ask the user 2–4 pointed clarification questions if critical information is missing (e.g., CRM choice, data warehouse type, regulatory context).

Web research & domain model acquisition

Run focused web searches to learn:

Standard process stages for this domain (e.g., for “investment banking M&A”, look for sourcing → diligence → modeling → IC → negotiation → close).¹⁷⁷¹⁷⁶

Common tools and data sources (e.g., CRMs, ERPs, ticketing systems, EDC systems).

Best practices, pitfalls, and compliance considerations (e.g., SOX/HIPAA if relevant).

Summarize the canonical workflow stages and typical artifacts in 5–10 bullet points.

State machine & BPMN specification

Define a state machine table in Markdown with columns:

State, Description, Triggers/Inputs, Actions, Next states.

Ensure the state machine covers the full life‑cycle of the workflow, including happy path and key error/abort paths.

Generate at least one Mermaid flowchart TD diagram that faithfully represents the state transitions.

If there are distinct sub‑flows (e.g., “intake”, “review”, “reporting”), either:

produce separate state tables and diagrams per sub‑flow; or

clearly annotate subgraphs in the Mermaid.

Plugin design (Claude Code / Cowork)

Propose a plugin root directory: <domain>-plugin/.

Within .claude-plugin/, design a plugin.json (Claude manifest) that includes:

name, version, description, author, license.

commands: list of markdown files.

skills: list of skill directories.

agents: optional agent JSON definitions if multiple sub‑roles are useful (e.g., Planner, Reviewer, Analyst).¹⁷⁸¹⁷⁵¹⁶²

hooks: optional, for pre/post tool use if there are strong governance needs.

mcpServers: set of MCP servers that match the domain’s tools (e.g., CRM, data warehouse, ticketing system, calendar, docs).

Also design an optional .mcp.json file compatible with Claude Code’s MCP configuration format.¹⁷⁹¹⁶⁴

Commands and skills

Identify the core slash commands the user will run (e.g., /intake-case, /review-records, /generate-report, /daily-summary).

For each command:

Create a commands/<command-name>.md file.

Define: inputs (parameters), behavior steps, tools/skills it calls, and outputs (files, notes, summaries, structured JSON).

Identify 3–6 skills (reusable capabilities) and create skills/<skill-name>/SKILL.md for each, describing:

Purpose, when to use, inputs, behavior, and how it uses MCP tools or subagents.

MCP server configuration

Based on the domain, specify MCP servers in both:

plugin.json’s mcpServers block, and

an example .mcp.json or YAML equivalent.

Use official MCP examples where possible (e.g., filesystem, fetch, Git, database, CRMs, ticketing systems).¹⁸⁰¹⁸¹¹⁶³

Agents and hooks (optional but encouraged)

If the domain naturally decomposes into sub‑agents (Planner, Reviewer, Executor), define minimal JSON agent configs that assign:

Goals, capabilities (skills/tools), and safety constraints.

If the workflow benefits from enforcement (e.g., approvals before sending emails, logging of DB changes), design pre/post tool‑use hooks in a hooks.json or equivalent structure.¹⁸²¹⁷⁸¹⁷⁵

Safety, logging, and compliance

Propose guardrails relevant to the domain:

Data access scopes (only certain folders/projects).

Human‑in‑the‑loop steps before irreversible actions.

Logging of critical operations for audit.

Final output format

Return a single, comprehensive Markdown document containing:

Section 1: Domain summary and assumptions.

Section 2: State machine tables.

Section 3: Mermaid diagrams.

Section 4: Plugin directory structure.

Section 5: plugin.json (as a fenced JSON block).

Section 6: .mcp.json or YAML MCP config (fenced).

Section 7: All command and skill markdown files (fenced).

Section 8: Optional agents/*.json and hooks.json if defined.

When responding, do not describe your internal reasoning or tool calls. Only output the resulting spec and files. ¹⁸³¹⁸⁴¹⁸⁵¹⁸⁶¹⁸⁷

⁂

1) Markdown templates for the 11 plugin system prompts

You can drop these into docs/system-prompts/ and fill in the TODO sections per plugin.

1.1 `productivity-plugin-system-prompt.md`

# System Prompt – Productivity Plugin

You are designing a Claude Cowork + Claude Code **Productivity** plugin.

## Goal

Automate:
- Daily planning (calendar + tasks + email/chat signals)
- Task synchronization (inferring completed/new tasks)
- Personal daily brief and review

## Instructions

1. **Restate scope**
   - Summarize the daily planning and sync use cases for this user/context.

2. **Define workflows**
   - Design two state machines:
     - Daily planning: `START → DAILY_COLLECT → DAILY_INFER_TASKS → DAILY_SCHEDULE → DAILY_PLAN_OUT → END_SUCCESS`
     - Task sync: `START → SYNC_COLLECT → SYNC_UPDATE → SYNC_SUMMARY → END_SUCCESS`
   - For each state, define:
     - Description
     - Triggers/Inputs
     - Actions
     - Next states

3. **Generate BPMN/Mermaid**
   - Produce Mermaid `flowchart TD` diagrams for both flows.

4. **Design plugin structure**
   - Root: `productivity-plugin/`
   - Include:
     - `.claude-plugin/plugin.json`
     - `.mcp.json` (optional)
     - `commands/daily-plan.md`
     - `commands/update-tasks.md`
     - `skills/task-inference/`
     - `skills/schedule-optimization/`
     - `agents/` (optional)

5. **Create manifest**
   - Fill `plugin.json` with:
     - name, version, description, author, license
     - commands, skills, agents, hooks
     - `mcpServers`:
       - `prod-files` (filesystem)
       - `calendar-api` (HTTP)
       - `mail-api` (HTTP)

6. **Implement commands/skills**
   - `commands/daily-plan.md`: inputs, steps, outputs.
   - `commands/update-tasks.md`: inputs, steps, outputs.
   - `skills/task-inference/SKILL.md`
   - `skills/schedule-optimization/SKILL.md`

7. **Safety and controls**
   - Define confirmation steps, privacy scoping, and logging behavior.

Return a single Markdown spec with all of the above plus fenced JSON/Markdown file contents.

1.2 `sales-plugin-system-prompt.md`

# System Prompt – Sales Plugin

You are designing a Claude Cowork + Claude Code **Sales** plugin.

## Goal

Support:
- Prospect research
- Outreach sequencing
- Call prep
- Pipeline review and forecasting
- Follow-up and nurture

## Instructions

1. **Restate sales lifecycle**
   - Prospect_identified → research → outreach → call → pipeline → follow-up/nurture.

2. **State machine**
   - Define a table with states:
     - PROSPECT_IDENTIFIED, RESEARCHING, PROFILE_READY, OUTREACH_DRAFTING,
       OUTREACH_REVIEW, OUTREACH_SENT, CALL_SCHEDULED, CALL_PREP,
       CALL_COMPLETED, DEAL_IN_PIPELINE, PIPELINE_REVIEW, PIPELINE_ACTIONS,
       NURTURE_SEGMENT, NURTURE_PLAN, CLOSED_WON, LOST, END_ABORT, END_ERROR.
   - For each, define description, entry criteria, actions, next states.

3. **Mermaid diagram**
   - Produce a `flowchart TD` representing this state machine.

4. **Plugin structure**
   - Root: `sales-workflow-plugin/`
   - `.claude-plugin/plugin.json`
   - `.mcp.json` (optional)
   - Commands:
     - `commands/prospect-research.md`
     - `commands/draft-outreach.md`
     - `commands/call-prep.md`
     - `commands/pipeline-review.md`
     - `commands/nurture-plan.md`
   - Skills:
     - `skills/sales-playbook/`
     - `skills/prospect-research/`
     - `skills/pipeline-analysis/`
   - Agents:
     - `agents/account-executive.json`
     - `agents/sales-ops.json`

5. **Manifest**
   - Include MCP servers:
     - `crm-hubspot` (HTTP)
     - `sales-files` (filesystem)

6. **Commands/skills**
   - Fully specify markdown for all commands and core skills.

7. **Governance**
   - Define review requirements for outbound communications and CRM writes.

Return complete Markdown with manifest JSON and command/skill markdowns.

1.3 `customer-support-plugin-system-prompt.md`

# System Prompt – Customer Support Plugin

You are designing a **Customer Support** plugin.

## Goal

Automate:
- Ticket triage and routing
- Drafting responses
- KB article creation and maintenance

## Instructions

1. **State machine**
   - States: INGEST_TICKETS, NORMALIZE_TICKETS, CLASSIFY_INTENT, SCORE_SEVERITY,
     ROUTE_TICKET, DECIDE_RESPONSE_PATH, ANSWER_SEARCH, DRAFT_REPLY,
     AWAIT_REPLY_REVIEW, SEND_REPLY, ESCALATE_PREP, CHECK_KB_GAP,
     DRAFT_KB_ARTICLE, AWAIT_KB_APPROVAL, PUBLISH_KB_ARTICLE, END_SUCCESS, END_ERROR.

2. **Mermaid**
   - Produce a `flowchart TD` for this lifecycle.

3. **Plugin structure**
   - Root: `customer-support-plugin/`
   - Manifest + optional `.mcp.json`
   - MCP:
     - ticket system (e.g., `support-zendesk`)
     - KB store (`support-kb` filesystem)
   - Commands:
     - `support-triage`
     - `support-daily-review`
   - Skills:
     - ticket classification, severity scoring, answer generation, kb maintenance

4. **Safety**
   - Define rules for when replies must be manually reviewed.

Output a full spec including manifest and command/skill markdowns.

1.4 `product-mgmt-plugin-system-prompt.md`

# System Prompt – Product Management Plugin

You are designing a **Product Management** plugin.

## Goal

Manage:
- Opportunity discovery
- PRD/spec authoring
- Backlog prioritization
- Roadmapping

## Instructions

1. **State machine**
   - States: OPP_INTAKE, OPP_CLUSTER, OPP_STATEMENTS,
     PRD_INIT, PRD_SKELETON, PRD_FILL, PRD_REVIEW,
     PRIORITIZE_INIT, PRIORITIZE_SCORE, PRIORITIZE_RANK,
     ROADMAP_INIT, ROADMAP_ALLOCATE, ROADMAP_SUMMARY,
     END_SUCCESS, END_ERROR.

2. **Mermaid**
   - Show branching between opportunity, PRD, prioritization, roadmap flows.

3. **Plugin structure**
   - Root: `product-mgmt-plugin/`
   - Manifest
   - MCP: feedback, tracker
   - Commands: `opportunity-intake`, `draft-prd`, `prioritize-backlog`, `build-roadmap`
   - Skills: opportunity analysis, prd authoring, prioritization, roadmap planning

4. **Details**
   - Provide full markdown for `draft-prd` and `prioritize-backlog`.

Return a complete spec as above.

1.5 `marketing-plugin-system-prompt.md`

# System Prompt – Marketing Plugin

You are designing a **Marketing** plugin.

## Goal

Handle:
- Campaign intake
- Content pipeline
- Brand & SEO review
- Calendar planning
- Performance reporting

## Instructions

1. **State machine**
   - States: BRIEF_INTAKE, ASK_BRIEF_CLARIFICATION, STRUCTURE_BRIEF,
     ASSET_PLANNING, ASSET_DRAFTING, BRAND_REVIEW, BRAND_FIXES,
     SEO_REVIEW, SEO_FIXES, CALENDAR_PLANNING, CAMPAIGN_SUMMARY,
     WAIT_FOR_METRICS, PERFORMANCE_ANALYSIS, PERFORMANCE_RECOMMENDATIONS, END_SUCCESS.

2. **Mermaid**
   - Flowchart of full lifecycle.

3. **Plugin structure**
   - Root: `marketing-plugin/`
   - Manifest and MCP for assets + analytics
   - Commands: `campaign-intake`, `draft-assets`, `campaign-calendar`, `campaign-report`
   - Skills: brand guidelines, SEO optimization, campaign analytics

4. **Command markdowns**
   - Explicit inputs, steps, outputs for all commands.

Return all as a single spec.

1.6 `legal-plugin-system-prompt.md`

# System Prompt – Legal Plugin

You are designing a **Legal** plugin.

## Goal

Support:
- Contract and NDA review
- Vendor assessment
- Legal brief generation

## Instructions

1. **State machine**
   - For `/review-contract` include:
     - LOAD_CONTRACT, PARSE_STRUCTURE, CLASSIFY_CLAUSES,
       LOAD_PLAYBOOKS, EVALUATE_CLAUSES, SCORE_RISKS,
       DETECT_MISSING, SUGGEST_EDITS, BUILD_REPORT,
       OUTPUT_REPORT, END_SUCCESS, END_ERROR.

2. **Mermaid**
   - Flowchart for the review flow.

3. **Plugin structure**
   - Root: `legal-review-plugin/`
   - Manifest with MCP:
     - `legal-docs` (filesystem)
     - `policy-repo` (HTTP)
   - Commands: `review-contract`, `triage-nda`, `vendor-assess`, `legal-brief`
   - Skills: clause classification, playbook evaluation, legal briefing

4. **Risk taxonomy**
   - Enumerate risk types and how they’re scored.

Provide manifest and markdown definitions.

1.7 `finance-plugin-system-prompt.md`

# System Prompt – Finance Plugin

You are designing a **Finance & Accounting** plugin.

## Goal

Perform:
- Data import and normalization
- Reconciliations
- Financial statements
- Variance analysis
- Cashflow waterfall reporting

## Instructions

1. **State machine**
   - Use detailed states:
     - START, LOAD_CONFIG, IMPORT_DATA, WARN_PARTIAL_DATA, NORMALIZE_COA,
       TASK_SELECTION, RECONCILE_INIT, MATCH_GL_BANK, MATCH_SUBLEDGERS,
       IDENTIFY_RECON_ITEMS, PROPOSE_JOURNALS, APPLY_JOURNALS,
       RECONCILE_SUMMARY, STATEMENTS_INIT, BUILD_TRIAL_BALANCE,
       GEN_STATEMENTS, STATEMENTS_SUMMARY, VARIANCE_INIT, LOAD_BASELINE,
       COMPUTE_VARIANCES, VARIANCE_COMMENTARY, CASHFLOW_INIT,
       EXTRACT_CASH_MOVEMENTS, CATEGORIZE_CASH_FLOWS, BUILD_WATERFALL,
       CASHFLOW_REPORT, END_SUCCESS, END_ABORT, END_ERROR.

2. **Mermaid**
   - Complete flowchart of the above.

3. **Manifest**
   - Full `plugin.json` and optional `.mcp.json`
   - MCP servers: `finance-files`, `finance-ledger-api`

4. **Commands/skills**
   - Commands: `finance-reconcile`, `finance-statements`, `finance-variance`, `finance-cashflow`
   - Skills: import-normalize, reconciliation, statements-variance, cashflow-viz

Return all components in Markdown.

1.8 `data-analyst-plugin-system-prompt.md`

# System Prompt – Data Analyst Plugin

You are designing a **Data Analyst** plugin.

## Goal

Turn NL questions into SQL, execute, analyze, visualize, and narrate.

## Instructions

1. **State machine**
   - States: Q_RECEIVED, PARSE_INTENT, ASK_CLARIFICATION, MAP_SCHEMA,
     ASK_SCHEMA_HELP, PLAN_QUERY, DRAFT_SQL, PREVIEW_SQL, EXECUTE_SQL,
     HANDLE_DB_ERROR, VALIDATE_RESULTS, ASK_DATA_CLARIFICATION,
     ANALYZE, VISUALIZE, NARRATE, END_SUCCESS, END_ABORT, END_ERROR.

2. **Mermaid**
   - Flowchart for the above.

3. **Manifest + MCP**
   - `data-analyst-plugin/.claude-plugin/plugin.json`
   - MCP: `warehouse-db`, `schema-files`
   - Provide `.mcp.json` or YAML→JSON config.

4. **Commands/skills**
   - `/ask-data`, `/run-saved-query`, `/data-report`
   - Skills: schema understanding, query planning, data interpretation

Output the complete spec.

1.9 `enterprise-search-plugin-system-prompt.md`

# System Prompt – Enterprise Search Plugin

You are designing an **Enterprise Search** plugin.

## Goal

Federated search over chat, email, docs, wikis, tickets with deduped, cited answers.

## Instructions

1. **State machine**
   - QUESTION_RECEIVED, DETERMINE_SCOPE, FANOUT_SEARCH,
     COLLECT_RESULTS, NORMALIZE_RESULTS, CLUSTER_RESULTS,
     SYNTHESIZE_ANSWER, OPTIONAL_PERSIST, WRITE_DOC,
     END_SUCCESS, END_ERROR.

2. **Mermaid**
   - Flowchart for the search pipeline.

3. **Plugin structure**
   - Root: `enterprise-search-plugin/`
   - Manifest with MCP: Slack, email, docs, wiki
   - Commands: `search-enterprise`, `scheduled-search`
   - Skills: search orchestration, answer synthesis, dedup

Return a complete spec.

1.10 `bio-research-plugin-system-prompt.md`

# System Prompt – Bio-Research Plugin

You are designing a **Biology Research** plugin.

## Goal

Trusted literature search (e.g. PubMed), screening, synthesis, experiment planning.

## Instructions

1. **State machine**
   - CAPTURE_QUESTION, CONFIGURE_SEARCH, RUN_LITERATURE_SEARCH,
     SCREEN_RESULTS, TAG_AND_CLUSTER, SYNTHESIZE_EVIDENCE,
     IDENTIFY_GAPS, PLAN_EXPERIMENT, END_SUCCESS, END_ERROR.

2. **Mermaid**
   - Flowchart for literature→synthesis→planning.

3. **Manifest**
   - `bio-research-plugin/.claude-plugin/plugin.json`
   - MCP: `pubmed` server

4. **Commands/skills**
   - Commands: `search-literature`, `summarize-evidence`, `plan-experiment`
   - Skills: literature-screening, evidence-synthesis, experiment-planning

5. **Safety**
   - State clearly that outputs are research aids, not clinical advice.

Provide everything in a single spec.

1.11 `plugin-management-system-prompt.md`

# System Prompt – Plugin Management / Plugin Create

You are designing a **Plugin Management / Plugin Create** plugin.

## Goal

Generate, customize, and list Claude Cowork/Code plugins.

## Instructions

1. **State machine**
   - CAPTURE_WORKFLOW, EXTRACT_COMPONENTS, DESIGN_PLUGIN_STRUCTURE,
     GENERATE_FILES, PACKAGE_PLUGIN, END_SUCCESS, END_ERROR.

2. **Mermaid**
   - Flowchart for creation flow.

3. **Manifest**
   - `plugin-management/.claude-plugin/plugin.json`
   - Commands: `create-plugin`, `customize-plugin`, `list-plugins`
   - Skills: workflow-analysis, plugin-scaffolding
   - MCP: filesystem plugin root

4. **Command markdowns**
   - Each command should be able to generate or modify complete plugin directories
     (manifest, skills, commands, BPMN tables, Mermaid diagrams in docs).

Return a full plugin spec.

2) Installation scripts for deploying all Cowork plugins

Assume you have ZIPs built under dist/<plugin-name>.zip.

2.1 `scripts/install_cowork_plugins_mac.sh`

#!/usr/bin/env bash
set -euo pipefail

# Mac-only: installs all custom Cowork plugins by simulating UI steps
# Prereq: Claude Desktop installed, and these zips exist under ./dist

PLUGINS=(
  "productivity-plugin"
  "sales-workflow-plugin"
  "customer-support-plugin"
  "product-mgmt-plugin"
  "marketing-plugin"
  "legal-review-plugin"
  "finance-analyst-plugin"
  "data-analyst-plugin"
  "enterprise-search-plugin"
  "bio-research-plugin"
  "plugin-management"
)

DIST_DIR="$(cd "$(dirname "${BASH_SOURCE[^13_0]}")/.." && pwd)/dist"

echo "Ensure Claude Desktop is running and Cowork is available."
echo "You must manually go to: Cowork → Plugins → Upload plugin and select each ZIP."
echo

for name in "${PLUGINS[@]}"; do
  zip_path="${DIST_DIR}/${name}.zip"
  if [[ -f "$zip_path" ]]; then
    echo "Found $zip_path"
  else
    echo "WARNING: Missing $zip_path"
  fi
done

echo
echo "Upload the above ZIPs in Claude Desktop Cowork → Plugins → Upload plugin."

Cowork has no CLI today; install remains UI‑driven.¹⁸⁸

3) GitHub repo structure for master plugin prompts

claude-enterprise-plugins/
├── README.md
├── LICENSE
├── .gitignore
├── docs/
│   ├── index.md
│   ├── master-system-prompt.md                # super-master meta-prompt
│   ├── system-prompts/
│   │   ├── productivity-plugin-system-prompt.md
│   │   ├── sales-plugin-system-prompt.md
│   │   ├── customer-support-plugin-system-prompt.md
│   │   ├── product-mgmt-plugin-system-prompt.md
│   │   ├── marketing-plugin-system-prompt.md
│   │   ├── legal-plugin-system-prompt.md
│   │   ├── finance-plugin-system-prompt.md
│   │   ├── data-analyst-plugin-system-prompt.md
│   │   ├── enterprise-search-plugin-system-prompt.md
│   │   ├── bio-research-plugin-system-prompt.md
│   │   └── plugin-management-system-prompt.md
│   ├── workflows/
│   │   ├── productivity-plugin-workflows.md
│   │   ├── sales-plugin-workflows.md
│   │   ├── customer-support-plugin-workflows.md
│   │   ├── product-mgmt-plugin-workflows.md
│   │   ├── marketing-plugin-workflows.md
│   │   ├── legal-plugin-workflows.md
│   │   ├── finance-plugin-workflows.md
│   │   ├── data-analyst-plugin-workflows.md
│   │   ├── enterprise-search-plugin-workflows.md
│   │   ├── bio-research-plugin-workflows.md
│   │   └── plugin-management-workflows.md
├── plugins/
│   ├── productivity-plugin/
│   ├── sales-workflow-plugin/
│   ├── customer-support-plugin/
│   ├── product-mgmt-plugin/
│   ├── marketing-plugin/
│   ├── legal-review-plugin/
│   ├── finance-analyst-plugin/
│   ├── data-analyst-plugin/
│   ├── enterprise-search-plugin/
│   ├── bio-research-plugin/
│   └── plugin-management/
├── dist/
│   ├── productivity-plugin.zip
│   └── ...
└── scripts/
    ├── install_cowork_plugins_mac.sh
    ├── build_all_plugins.sh
    └── test_all_plugins.sh

This mirrors Claude Code plugin practices and provides clear separation of prompts, workflow specs, and actual code.¹⁸⁹¹⁹⁰

4) Cowork plugins vs Claude Code marketplace plugins (comparison)

Aspect	Cowork plugins	Claude Code marketplace plugins
Primary environment	Claude Desktop “Cowork” (knowledge‑work automation).¹⁸⁸¹⁹¹	Claude Code CLI/IDE integration (developer workflows).¹⁸⁹¹⁹²
Users	Non‑dev knowledge workers (sales, PM, marketing, legal, finance).¹⁹³¹⁹⁴	Developers/teams customizing coding and infra workflows.¹⁹⁵¹⁹²
Install path	Cowork UI: Desktop → Cowork → Plugins → Browse / Upload ZIP.¹⁸⁸	`/plugin` CLI and marketplaces, or `.claude/settings.json` in repo.¹⁹⁰¹⁹⁶
Bundling	Focus on domain workflows (skills + slash commands + connectors + sub‑agents) per role.¹⁹³¹⁹⁷	Focus on skills, agents, MCP servers, hooks for codebases and tools.¹⁸⁹¹⁹⁸
Distribution	Currently per‑machine local; org‑wide provisioning planned.¹⁸⁸¹⁹⁹	Marketplaces (`/plugin marketplace add`), project settings, team‑wide via repo trust.²⁰⁰¹⁹⁶
Typical MCP/tools	CRMs, ticketing, email, docs, analytics, PubMed, etc.¹⁹³¹⁹⁴	Git, filesystem, databases, HTTP APIs, test frameworks, build tools.¹⁹⁸²⁰¹
Use case depth	Prepackaged for common enterprise functions; minimal setup.¹⁹³¹⁹⁴	Highly customizable, deeper tool access and automation, more setup.¹⁹⁸¹⁹²

5) Testing workflows for validating each generated plugin

You can standardize testing for all 11 plugins.

5.1 Generic local testing pattern (Claude Code)

From official docs:¹⁸⁹

# In each plugin directory
claude --plugin-dir ./plugins/sales-workflow-plugin

Then:

Run /help to verify commands are registered.
Run each command with a minimal scenario.
Inspect logs/output.

5.2 `scripts/test_all_plugins.sh`

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[^13_0]}")/.." && pwd)"
PLUGINS_DIR="${ROOT}/plugins"

PLUGINS=(
  "productivity-plugin"
  "sales-workflow-plugin"
  "customer-support-plugin"
  "product-mgmt-plugin"
  "marketing-plugin"
  "legal-review-plugin"
  "finance-analyst-plugin"
  "data-analyst-plugin"
  "enterprise-search-plugin"
  "bio-research-plugin"
  "plugin-management"
)

for name in "${PLUGINS[@]}"; do
  path="${PLUGINS_DIR}/${name}"
  if [[ ! -d "$path" ]]; then
    echo "Skipping ${name}: directory not found"
    continue
  fi

  echo "=== Testing ${name} ==="
  # Dry-run: validate manifest shape using Claude Code
  claude --plugin-dir "$path" <<'EOF'
/help
EOF

  echo "=== ${name} loaded (check for command/agent visibility manually) ==="
done

5.3 Domain‑specific test workflows

For each plugin, define a short checklist in docs/workflows/<plugin>-workflows.md:

Productivity:
- Scenario: create a daily plan with 2 meetings, 3 tasks.
- Validate: tasks inferred correctly, schedule makes sense, no destructive changes.
Sales:
- Scenario: run /prospect-research on a fake domain, then /draft-outreach, then /pipeline-review on a mock CRM.
- Validate: structured profiles, no unintended CRM writes in dry‑run mode.
Customer Support:
- Scenario: ingest 5 sample tickets; ensure correct severity/intents, one auto‑answer, one escalation, one KB article candidate.
Product Management:
- Scenario: turn 10 feedback snippets into 2–3 opportunity statements, a PRD, and a prioritized backlog.
Marketing:
- Scenario: brief for a single campaign, generate 4–6 assets, run brand/SEO passes, and sample performance report using dummy metrics.
Legal:
- Scenario: sample NDA and MSA; ensure risk categories and suggested edits appear; no hallucinated law.
Finance:
- Scenario: CSV trial balance and bank statement; run reconciliation and statements; inspect proposed journals.
Data Analyst:
- Scenario: connect to a local DB with toy schema; ask 3 questions; verify SQL quality and basic result sanity.
Enterprise Search:
- Scenario: multiple text files representing email, docs, wiki; check deduplication and citation linking.
Bio‑Research:
- Scenario: single PubMed‑like dataset; run search+screen+synthesis; validate structure and citations.
Plugin Management:
- Scenario: feed a simple workflow description and confirm it outputs a valid plugin skeleton that can be tested with claude --plugin-dir.

These testing workflows combined with the structural tests via claude --plugin-dir give you a repeatable validation loop across the entire suite.²⁰²²⁰³¹⁸⁹ ²⁰⁴²⁰⁵²⁰⁶²⁰⁷²⁰⁸

⁂

Core plugin model
Workflow breakdown by plugin
- 1. Productivity plugin – task sync workflow
- 2. Sales plugin – prospect‑to‑close workflow
- 3. Customer Support plugin – ticket triage workflow
- 4. Product Management plugin – PRD & roadmap workflow
- 5. Marketing plugin – content & campaign workflow
- 6. Legal plugin – contract review workflow
- 7. Finance & Accounting plugin – close & analysis workflow
- 8. Data Analyst plugin – analytics workflow
- 9. Enterprise Search plugin – hybrid RAG workflow
- 10. Bio‑Research plugin – literature & experiment workflow
- 11. Plugin Management (“Plugin Create”) – meta workflow
Installation and usage workflows (Cowork vs Code)
- Cowork plugin install & run (desktop)
- Claude Code plugin install & run (CLI)
Focused prompt seeds for you
How to install Claude Cowork plugins (step by step)
Legal plugin – detailed workflow
- 1. Contract review workflow (/review-contract)
- 2. NDA triage (/triage-nda)
- 3. Vendor agreement status and briefings (/vendor-check, /brief, /respond)
- 4. Configuration and connectors
Marketing vs Product Management plugins – workflow comparison
- High-level differences
- Marketing plugin – detailed workflow
- Product Management plugin – detailed workflow
Guide to creating custom plugins with Plugin Create
- 1. Describe your workflow
- 2. Decompose into capabilities
- 3. Generate plugin scaffolding
- 4. Install and iterate
Biology research plugin – detailed workflow examples
- Example 1: Literature review for a target/pathway
- Example 2: Planning an experiment
1/11 – Productivity plugin (tasks, calendars, daily workflow)
- A. Daily planning workflow (e.g., /daily-setup)
- B. Task sync workflow (e.g., /update)
- C. Personal assistant workflow (calendar & communication)
2/11 – Sales plugin (prospect → close, end‑to‑end)
- A. Prospect research workflow (e.g., /prospect-research, /competitive-brief)
- B. Outreach workflow (e.g., /draft-outreach)
- C. Call prep workflow (e.g., /call-prep)
- D. Deal management & pipeline review (e.g., /pipeline-review)
- E. Follow‑up & nurture (e.g., /nurture-plan)
3/11 – Customer Support plugin (ticket triage and knowledge loop)
- A. Ticket ingestion & normalization (e.g., /ingest-tickets)
- B. Classification and prioritization (e.g., /triage)
- C. Answer generation & escalation path
- D. Knowledge base growth loop
4/11 – Product Management plugin (specs, prioritization, roadmap)
- A. Opportunity discovery & framing (e.g., /opportunity-intake)
- B. PRD/Spec drafting (e.g., /draft-prd)
- C. Prioritization workflow (e.g., /prioritize-backlog)
- D. Roadmap & release planning (e.g., /build-roadmap)
- E. Stakeholder communication (e.g., /stakeholder-brief)
5/11 – Marketing plugin (content & campaign lifecycle)
- A. Campaign brief intake (e.g., /campaign-intake)
- B. Content pipeline (e.g., /draft-assets)
- C. Brand & SEO review (e.g., /brand-review, /seo-review)
- D. Campaign calendar & orchestration (e.g., /campaign-calendar)
- E. Performance reporting (e.g., /campaign-report)
6/11 – Enterprise Search plugin (cross‑tool hybrid RAG)
- A. Source configuration (e.g., /configure-search)
- B. Question answering workflow (e.g., /search)
- C. Scheduled searches (e.g., /recurring-search)
7/11 – Finance & Accounting plugin (close, analysis, visualization)
- A. Data ingestion & normalization (e.g., /import-financials)
- B. Reconciliation workflow (e.g., /reconcile)
- C. Financial statement generation & analysis (e.g., /statements, /variance-analysis)
- D. Cash flow & visualization (e.g., /cashflow-waterfall)
8/11 – Data Analyst plugin (question → query → viz → narrative)
- A. Question parsing & metric mapping (e.g., /ask-data)
- B. Query planning & execution (e.g., /run-query)
- C. Analysis & visualization (e.g., /analyze-results, /visualize)
- D. Deck/report creation (e.g., /data-report, /create-deck)
9/11 – Biology Research plugin (literature search → synthesis → planning)
- A. Literature search (e.g., /search-literature)
- B. Screening & organization (e.g., /screen-papers)
- C. Synthesis & gap analysis (e.g., /synthesize-evidence)
- D. Experiment planning assistance (e.g., /plan-experiment)
10/11 – Legal plugin (full task‑granularity view)
- A. Contract review (e.g., /review-contract)
- B. NDA triage (e.g., /triage-nda)
- C. Vendor/DP & compliance workflows (e.g., /vendor-assess, /policy-check)
- D. Legal briefings & templated responses (e.g., /legal-brief, /legal-response)
11/11 – Plugin Create / Plugin Management (meta‑plugin)
- A. New plugin creation (e.g., /create-plugin)
- B. Plugin customization (e.g., /customize-plugin)
- C. Plugin management & MCP configuration (e.g., /manage-plugins, /configure-mcp)
1) Data Analyst plugin – state machine + plugin skeleton
- A. BPMN/state machine table for /ask-data
- B. Example Claude Code plugin skeleton (Data Analyst)
2) Biology Research plugin – PubMed sample workflow
3) Common legal risks the Legal plugin flags
4) Step‑by‑step guide to create a custom Sales plugin
5) How Plugin Management handles MCP server configuration
1) Finance plugin – state machine + skeleton
- A. Finance close / analysis state machine (high level)
- B. Claude Code plugin skeleton (Finance)
2) Sales plugin – BPMN table + Claude Code manifest
- A. Sales BPMN/state table
- B. Claude Code manifest (Sales)
3) Data Analyst plugin – more explicit state machine + MCP skeleton
- A. Data Analyst state machine (with MCP touchpoints)
- B. .mcp.json for Data Analyst
4) Legal plugin – full plugin.json and .mcp.json
- A. plugin.json (Legal)
- B. Optional .mcp.json (if you prefer separate MCP config)
5) Customer Support plugin – explicit BPMN workflow table
1) Finance plugin – detailed state machine + manifest.json
- A. Detailed Finance state machine (close + analysis)
- B. Full .claude-plugin/manifest.json for Finance
2) Sales plugin – Mermaid BPMN + manifest
- A. Mermaid BPMN‑like diagram for Sales
- B. Sales plugin.json reminder (already close to final)
3) Marketing plugin – state machine table
4) Data Analyst MCP server config – YAML skeleton
1. Productivity plugin
- State machine
- Mermaid (daily planning)
- Manifests
2. Sales plugin
- State machine
- Mermaid BPMN
- Plugin manifest with agents & skills
3. Customer Support plugin
- State machine
4. Product Management plugin
- State machine
- Skeleton references
5. Marketing plugin
- State machine
6. Finance plugin
- State machine table
- Mermaid diagram
- Manifest link
7. Data Analyst plugin
- State machine
- Mermaid BPMN
- MCP skeleton (YAML)
8. Enterprise Search plugin
- State machine
9. Biology Research plugin
- State machine
10. Legal plugin
- State machine (detailed)
11. Plugin Create / Plugin Management
- State machine (meta)
1) Gap summary
2) Productivity plugin – finalize skeleton + Mermaid (sync flow)
- State machine (already good; keeping as is)
- plugin.json skeleton
- Mermaid (sync flow)
3) Customer Support plugin – add Mermaid + skeleton
- Mermaid
- plugin.json skeleton
4) Product Management plugin – finalize skeleton + Mermaid
- State machine
- Mermaid
- plugin.json skeleton
5) Marketing plugin – skeleton + Mermaid
- Mermaid
- plugin.json skeleton
6) Legal plugin – Mermaid
- Mermaid
7) Data Analyst plugin – confirm completeness
8) Enterprise Search plugin – skeleton + Mermaid
- Mermaid
- plugin.json skeleton
9) Bio‑Research plugin – canonical table + skeleton + Mermaid
- State machine
- Mermaid
- plugin.json skeleton
10) Plugin Create / Plugin Management – Mermaid + skeleton
- Mermaid
- plugin.json skeleton
11) Finance plugin – already complete
1) Master system prompt: Productivity plugin
2) Master system prompt: Sales plugin
3) Master system prompt: Customer Support plugin
4) Master system prompt: Product Management plugin
5) Master system prompt: Marketing plugin
6) Master system prompt: Legal plugin
7) Master system prompt: Finance plugin
8) Master system prompt: Data Analyst plugin
9) Master system prompt: Enterprise Search plugin
10) Master system prompt: Bio‑Research plugin
11) Master system prompt: Plugin Create / Plugin Management plugin
12) Super‑master system prompt – for any workflow/domain
- 1) Markdown templates for the 11 plugin system prompts
- 2) Installation scripts for deploying all Cowork plugins
- 3) GitHub repo structure for master plugin prompts
- 4) Cowork plugins vs Claude Code marketplace plugins (comparison)
- 5) Testing workflows for validating each generated plugin

Core plugin model​

Workflow breakdown by plugin​

1. Productivity plugin – task sync workflow​

2. Sales plugin – prospect‑to‑close workflow​

3. Customer Support plugin – ticket triage workflow​

4. Product Management plugin – PRD & roadmap workflow​

5. Marketing plugin – content & campaign workflow​

6. Legal plugin – contract review workflow​

7. Finance & Accounting plugin – close & analysis workflow​

8. Data Analyst plugin – analytics workflow​

9. Enterprise Search plugin – hybrid RAG workflow​

10. Bio‑Research plugin – literature & experiment workflow​

11. Plugin Management (“Plugin Create”) – meta workflow​

Installation and usage workflows (Cowork vs Code)​

Cowork plugin install & run (desktop)​

Claude Code plugin install & run (CLI)​

Focused prompt seeds for you​

EXPAND each plugin workflow looklike in detail one at a time

How to install Claude Cowork plugins (step by step)​

Legal plugin – detailed workflow​

1. Contract review workflow (/review-contract)​

2. NDA triage (/triage-nda)​

3. Vendor agreement status and briefings (/vendor-check, /brief, /respond)​

4. Configuration and connectors​

Marketing vs Product Management plugins – workflow comparison​

High-level differences​

Marketing plugin – detailed workflow​

Product Management plugin – detailed workflow​

Guide to creating custom plugins with Plugin Create​

1. Describe your workflow​

2. Decompose into capabilities​

3. Generate plugin scaffolding​

4. Install and iterate​

Biology research plugin – detailed workflow examples​

Example 1: Literature review for a target/pathway​

Example 2: Planning an experiment​

continue expanding each workflow one at a time start with 1 then continue until all 11 have been broken out task by task step by step

1/11 – Productivity plugin (tasks, calendars, daily workflow)3233​

A. Daily planning workflow (e.g., /daily-setup)​

B. Task sync workflow (e.g., /update)​

C. Personal assistant workflow (calendar & communication)3435​

2/11 – Sales plugin (prospect → close, end‑to‑end)394032​

A. Prospect research workflow (e.g., /prospect-research, /competitive-brief)​

B. Outreach workflow (e.g., /draft-outreach)​

C. Call prep workflow (e.g., /call-prep)​

D. Deal management & pipeline review (e.g., /pipeline-review)​

E. Follow‑up & nurture (e.g., /nurture-plan)​

3/11 – Customer Support plugin (ticket triage and knowledge loop)403239​

A. Ticket ingestion & normalization (e.g., /ingest-tickets)​

B. Classification and prioritization (e.g., /triage)​

C. Answer generation & escalation path​

D. Knowledge base growth loop​

continue with 4/11”, I’ll expand the Product Management plugin next, then Marketing, Enterprise Search, Finance, Data, Bio‑Research, Legal (already partly done, but I can go to task granularity), and Plugin Create until all 11 are fully enumerated.

4/11 – Product Management plugin (specs, prioritization, roadmap)4849​

A. Opportunity discovery & framing (e.g., /opportunity-intake)​

B. PRD/Spec drafting (e.g., /draft-prd)​

C. Prioritization workflow (e.g., /prioritize-backlog)​

D. Roadmap & release planning (e.g., /build-roadmap)​

E. Stakeholder communication (e.g., /stakeholder-brief)​

5/11 – Marketing plugin (content & campaign lifecycle)514849​

A. Campaign brief intake (e.g., /campaign-intake)​

B. Content pipeline (e.g., /draft-assets)​

C. Brand & SEO review (e.g., /brand-review, /seo-review)​

D. Campaign calendar & orchestration (e.g., /campaign-calendar)​

E. Performance reporting (e.g., /campaign-report)​

6/11 – Enterprise Search plugin (cross‑tool hybrid RAG)4849​

A. Source configuration (e.g., /configure-search)​

B. Question answering workflow (e.g., /search)​

C. Scheduled searches (e.g., /recurring-search)​

7/11 – Finance & Accounting plugin (close, analysis, visualization)4849​

A. Data ingestion & normalization (e.g., /import-financials)​

B. Reconciliation workflow (e.g., /reconcile)​

C. Financial statement generation & analysis (e.g., /statements, /variance-analysis)​

D. Cash flow & visualization (e.g., /cashflow-waterfall)​

ontinue with 8/11”, I’ll cover Data Analyst (8/11), Biology Research (9/11), Legal in full task‑granularity (10/11), and Plugin Create / Plugin Management (11/11) in the same step‑by‑step style.

8/11 – Data Analyst plugin (question → query → viz → narrative)​

A. Question parsing & metric mapping (e.g., /ask-data)​

B. Query planning & execution (e.g., /run-query)​

C. Analysis & visualization (e.g., /analyze-results, /visualize)​

D. Deck/report creation (e.g., /data-report, /create-deck)​

Core plugin model

Workflow breakdown by plugin

1. Productivity plugin – task sync workflow

2. Sales plugin – prospect‑to‑close workflow

3. Customer Support plugin – ticket triage workflow

4. Product Management plugin – PRD & roadmap workflow

5. Marketing plugin – content & campaign workflow

6. Legal plugin – contract review workflow

7. Finance & Accounting plugin – close & analysis workflow

8. Data Analyst plugin – analytics workflow

9. Enterprise Search plugin – hybrid RAG workflow

10. Bio‑Research plugin – literature & experiment workflow

11. Plugin Management (“Plugin Create”) – meta workflow

Installation and usage workflows (Cowork vs Code)

Cowork plugin install & run (desktop)

Claude Code plugin install & run (CLI)

Focused prompt seeds for you

How to install Claude Cowork plugins (step by step)

Legal plugin – detailed workflow

1. Contract review workflow (`/review-contract`)

2. NDA triage (`/triage-nda`)

3. Vendor agreement status and briefings (`/vendor-check`, `/brief`, `/respond`)

4. Configuration and connectors

Marketing vs Product Management plugins – workflow comparison

High-level differences

Marketing plugin – detailed workflow

Product Management plugin – detailed workflow

Guide to creating custom plugins with Plugin Create

1. Describe your workflow

2. Decompose into capabilities

3. Generate plugin scaffolding

4. Install and iterate

Biology research plugin – detailed workflow examples

Example 1: Literature review for a target/pathway

Example 2: Planning an experiment

1/11 – Productivity plugin (tasks, calendars, daily workflow)³²³³

A. Daily planning workflow (e.g., `/daily-setup`)

B. Task sync workflow (e.g., `/update`)

C. Personal assistant workflow (calendar & communication)³⁴³⁵

2/11 – Sales plugin (prospect → close, end‑to‑end)³⁹⁴⁰³²

A. Prospect research workflow (e.g., `/prospect-research`, `/competitive-brief`)

B. Outreach workflow (e.g., `/draft-outreach`)

C. Call prep workflow (e.g., `/call-prep`)

D. Deal management & pipeline review (e.g., `/pipeline-review`)

E. Follow‑up & nurture (e.g., `/nurture-plan`)

3/11 – Customer Support plugin (ticket triage and knowledge loop)⁴⁰³²³⁹

A. Ticket ingestion & normalization (e.g., `/ingest-tickets`)

B. Classification and prioritization (e.g., `/triage`)

C. Answer generation & escalation path

D. Knowledge base growth loop

4/11 – Product Management plugin (specs, prioritization, roadmap)⁴⁸⁴⁹

A. Opportunity discovery & framing (e.g., `/opportunity-intake`)

B. PRD/Spec drafting (e.g., `/draft-prd`)

C. Prioritization workflow (e.g., `/prioritize-backlog`)

D. Roadmap & release planning (e.g., `/build-roadmap`)

E. Stakeholder communication (e.g., `/stakeholder-brief`)

5/11 – Marketing plugin (content & campaign lifecycle)⁵¹⁴⁸⁴⁹

A. Campaign brief intake (e.g., `/campaign-intake`)

B. Content pipeline (e.g., `/draft-assets`)

C. Brand & SEO review (e.g., `/brand-review`, `/seo-review`)

D. Campaign calendar & orchestration (e.g., `/campaign-calendar`)

E. Performance reporting (e.g., `/campaign-report`)

6/11 – Enterprise Search plugin (cross‑tool hybrid RAG)⁴⁸⁴⁹

A. Source configuration (e.g., `/configure-search`)

B. Question answering workflow (e.g., `/search`)

C. Scheduled searches (e.g., `/recurring-search`)

7/11 – Finance & Accounting plugin (close, analysis, visualization)⁴⁸⁴⁹

A. Data ingestion & normalization (e.g., `/import-financials`)

B. Reconciliation workflow (e.g., `/reconcile`)

C. Financial statement generation & analysis (e.g., `/statements`, `/variance-analysis`)

D. Cash flow & visualization (e.g., `/cashflow-waterfall`)

8/11 – Data Analyst plugin (question → query → viz → narrative)

A. Question parsing & metric mapping (e.g., `/ask-data`)

B. Query planning & execution (e.g., `/run-query`)

C. Analysis & visualization (e.g., `/analyze-results`, `/visualize`)

D. Deck/report creation (e.g., `/data-report`, `/create-deck`)

9/11 – Biology Research plugin (literature search → synthesis → planning)

A. Literature search (e.g., `/search-literature`)

B. Screening & organization (e.g., `/screen-papers`)

C. Synthesis & gap analysis (e.g., `/synthesize-evidence`)