cowork-setup

name	cowork-setup
description	One-shot setup that wires Digital Marketing Pro for team usage in Anthropic Cowork. Verifies the Cowork sandbox, checks for a Google Drive integration, creates the canonical Drive folder layout, and confirms team-ready brand-state routing. Use this the first time a Cowork user installs DMP OR when brand profiles aren't persisting across sessions.
argument-hint	[--brand <name>] [--drive-root <folder-name>]
effort	low

/digital-marketing-pro:cowork-setup

The one-time setup that makes Digital Marketing Pro persistent in Cowork by a team. Wires up the Cowork → Drive routing so brand profiles, campaign plans, audit reports, and run records survive past the end of the current Cowork session.

Why this skill exists

Cowork is the friendliest Anthropic surface for marketers — agency teams, in-house marketers, growth ops — who don't live in a terminal. The natural team workflow is "everyone uses Cowork; brand state and outputs live in our shared Drive". But DMP's filesystem layer was designed for local Claude Code (writes to ~/.claude-marketing/ on the host machine). In Cowork that path is the per-session Linux sandbox — vanishes at session end, invisible to the team.

${CLAUDE_PLUGIN_DATA} does not help here either. Anthropic's plugin docs describe it as the persistent per-plugin storage path. In Cowork it resolves to a session-scoped VM mount that disappears the same way (open: claude-code#51398). Every OAuth-backed MCP plugin hits the same wall.

v3.12.0 fixed this with environment-aware routing: when Cowork is detected AND a Drive MCP is configured, brand profiles and reports round-trip through Drive instead of the ephemeral sandbox. This skill is the one-shot setup that ensures both conditions are true before you start producing real work.

Behavior

Step 1 — Verify Cowork environment

python "${CLAUDE_PLUGIN_ROOT}/scripts/plugin-metadata.py" --section environment

Parse the JSON. Three branches:

environment == "cowork-sandbox" — Proceed to Step 2.

environment == "claude-code-windows" / "-mac" / "-linux" — Tell the user:

"You're running in local Claude Code, not Cowork. The Cowork-specific Drive routing isn't needed here — brand state at ~/.claude-marketing/ persists on your host as designed. If you ALSO want Drive backups for team sharing, you can run this skill anyway and it'll mirror state to Drive as a backup. Want to proceed?"

Only proceed if the user confirms.

environment == "unknown" — Show the indicators from the JSON and ask the user where they're running, then proceed assuming Cowork (since unknown-from-Cowork is the most likely case).

Step 2 — Verify a Drive MCP is connected

Scan your available tools for any Google Drive MCP. Common signatures:

• mcp__<id>__create_file, mcp__<id>__read_file_content, mcp__<id>__search_files, mcp__<id>__list_folder_items — Anthropic-platform Drive integration (Settings → Integrations → Google Drive in Cowork)
• mcp__pipedream-google-drive__* — Pipedream aggregator
• mcp__composio-google-drive__* — Composio
• mcp__zapier-google-drive__* — Zapier
• Any tool whose name combines "drive" with "create" / "upload" / "search"

If a Drive MCP is found: confirm to the user which one ("Found: Anthropic platform Google Drive integration. I'll use this.") and proceed to Step 3.

If NO Drive MCP is found: stop the wizard with a clear message:

"Cowork-mode DMP needs a Google Drive integration before it can persist brand state for your team. Easiest setup (60 seconds):

1. In Cowork, click your profile menu → Settings → Integrations
2. Find Google Drive in the list → click Connect
3. Sign in with the Google account that owns your team's shared Drive
4. Come back here and re-run /digital-marketing-pro:cowork-setup

Alternative: a Notion MCP also works as a persistence target — DMP will treat each brand as a Notion page. If you'd prefer that route, add Notion to your Cowork Integrations panel and re-run this skill."

Step 3 — Verify or create the canonical Drive folder

Default folder name: DigitalMarketingPro (under "My Drive" or wherever the user prefers). If --drive-root <name> was passed, use that instead.

Use the Drive MCP to:

1. Search for a top-level folder named DigitalMarketingPro (or the user's --drive-root)
2. If it exists, confirm the user wants to use it. Show its URL.
3. If it doesn't exist, create it. Show the URL of the new folder.

Then create the subfolder skeleton:

DigitalMarketingPro/
├── _brands/                  <- brand profile JSONs persist here per brand
├── _runs/                    <- per-run checkpoints (resume across sessions)
├── _plans/                   <- yearly + quarterly + campaign plans
└── (brand folders created on first content/audit/campaign run)
    └── <brand name>/
        ├── strategy/
        ├── seo/
        ├── campaigns/
        ├── audits/
        └── reports/

Don't create empty brand subfolders yet — those auto-create during the first run for that brand. Just _brands/, _runs/, and _plans/ need to exist.

Step 4 — Store the Drive root reference + team namespace

Multi-team isolation: ask the user "what's your team's Drive root folder name?" (default: DigitalMarketingPro). Different teams use different folder names → automatic namespace isolation. Examples:

• Solo / small team: DigitalMarketingPro (default)
• Agency named "ACME": ACME DigitalMarketingPro
• Two distinct teams sharing one Drive: each picks their own name

Then write the config via the canonical script (NOT a hand-written JSON file — use the script so the format stays in sync with the rest of the toolchain):

python "${CLAUDE_PLUGIN_ROOT}/scripts/drive-sync-state.py" --action write-config --data '{
  "environment": "cowork-sandbox",
  "drive_root_folder_name": "<team folder name chosen>",
  "drive_root_folder_id": "<id from Step 3>",
  "drive_root_folder_url": "<webViewLink from Step 3>",
  "drive_mcp_tool_prefix": "<prefix detected in Step 2, e.g. mcp__abc123__>"
}'

The script writes to ~/.claude-marketing/_cowork-config.json and adds a configured_at timestamp automatically.

Future Cowork sessions: every DMP operation (brand-setup, status, seo-audit, campaign-plan, etc.) reads this config first. If it exists AND the Drive folder still exists, all I/O routes to that root. If a different team picked a different folder name, their config lives at the same path but points elsewhere — no collision.

To verify it was written correctly:

python "${CLAUDE_PLUGIN_ROOT}/scripts/drive-sync-state.py" --action read-config

Step 5 — Set the user's expectations

Show a clean summary:

Digital Marketing Pro is now wired for Cowork team usage:

Environment:           Cowork sandbox (Linux)
Drive integration:     <name>
Output root in Drive:  My Drive/<folder name> (link)
Config saved at:       ~/.claude-marketing/_cowork-config.json

What this means in practice:

- /digital-marketing-pro:brand-setup -> profile lands in
  Drive/<folder>/_brands/<brand-slug>/profile.json (persists across sessions)
- /digital-marketing-pro:campaign-plan -> plan lands in
  Drive/<folder>/<brand>/campaigns/<YYYY-MM>/<slug>/PLAN.md
- /digital-marketing-pro:seo-audit -> audit + intermediates land in
  Drive/<folder>/<brand>/audits/<date>/
- /digital-marketing-pro:status -> reads brand state from Drive first,
  falls back to local sandbox if Drive call fails
- /digital-marketing-pro:resume -> picks up an interrupted run by
  pulling its checkpoint files from Drive/<folder>/_runs/

Your team accesses everything via Google Drive directly. No
Cowork-specific paths to remember.

Next step:
  /digital-marketing-pro:brand-setup "Your Brand Name"

Step 6 — Optional: kick off a brand setup

If --brand <name> was passed, automatically launch /digital-marketing-pro:brand-setup "<name>" after the summary. This makes the very first run "one command, fully set up."

How the Cowork-aware skills use this config

When the routing is configured, brand-setup writes locally to ~/.claude-marketing/{brand}/profile.json AND records a pending Drive upload via drive-sync-state.py --action add-pending-upload. The agent then reads the pending list and uses its Drive MCP to push the file to <root>/_brands/{brand}/profile.json. On a future Cowork session, the agent reverses this: it reads _cowork-config.json, sees the team's Drive root, downloads <root>/_brands/{brand}/profile.json to the local sandbox, and marks it profile-mark-downloaded so the local hash matches the Drive copy.

Concretely: after every state-mutating DMP operation, the agent runs:

python "${CLAUDE_PLUGIN_ROOT}/scripts/drive-sync-state.py" --action profile-needs-upload --brand <brand>

If needs_upload: true, the agent uses its Drive MCP to upload the file and then runs --action profile-mark-uploaded with the Drive file ID returned by the MCP.

What this skill does NOT do

• It does not change DMP's behavior in local Claude Code (where host filesystem is fine).
• It does not migrate existing local-mode brands to Drive. To do that after the fact: re-run /digital-marketing-pro:brand-setup "<brand>" in Cowork after this skill finishes — the brand-setup skill will upload the local profile to Drive.
• It does not create a service-account JSON. Cowork-mode uses the MCP path exclusively (no Google Cloud setup needed).
• It does not check whether your Drive has enough space. Brand profiles + plans are tiny (<100KB typical), so this is rarely a concern, but flag it if you hit a quota error during a real run.
• It does not replace the local fallback — if a Drive call fails for any reason, DMP still writes locally and re-queues the upload.

See also

• /digital-marketing-pro:status — confirm Cowork+Drive is detected after setup
• /digital-marketing-pro:brand-setup — actual brand setup (now Drive-default in Cowork)
• /digital-marketing-pro:doctor — per-action readiness check (now reports Cowork+Drive routing too)
• scripts/plugin-metadata.py --section environment — the underlying probe
• README "Cowork team usage" section — canonical doc for which surface to use