/digital-marketing-pro:cowork-setup

Script location. If your host does not set ${CLAUDE_PLUGIN_ROOT}, the scripts are in this plugin's scripts/ folder, next to skills/. Run them with Python 3.10 or newer: python, or python3 where python is not found (macOS, many Linux systems).

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.

Run it the first time a team installs DMP in Cowork, when brand profiles stop persisting across Cowork sessions, or when switching to a different team's Drive root folder. Examples: /digital-marketing-pro:cowork-setup, ... --brand acme, ... --drive-root "ACME DigitalMarketingPro".

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/brands/{brand-slug}/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