@llodev/pm-tasks-trello 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# @llodev/pm-tasks-trello
+
+## 1.0.0
+
+### Major Changes
+
+- [`a571ab1`](https://github.com/llodev/skills/commit/a571ab1537ea7d3fe61c7b89c5be0f08d01f3838) - First stable release of the pm-tasks-\* family.
+
+  - `@llodev/pm-tasks-core` — Phases 1–3 extraction pipeline (input → sections → generic card), 6 CRUD verbs (`task.create`, `checklist.check`, `task.close`, `task.due-date.set`, `task.assignee.add`, `task.comment.add`), autonomous-mode contract (allowlist + scope + rate-limit + audit log), shared init UX library.
+  - `@llodev/pm-tasks-trello` — Trello adapter on the canonical generic card. Paste-friendly output, MCP-driven publish, autonomous mode against a board allowlist.
+  - `@llodev/pm-tasks-asana` — Asana adapter with workspace/project/section + custom-field + subtask-inheritance support. Paste, MCP-driven publish, autonomous mode.
+
+  Architecture, contract, and CRUD vocabulary documented in `docs/specs/2026-06-11-pm-tasks-design.md` and `docs/plans/2026-06-11-pm-tasks-v1.md`.
+
+### Patch Changes
+
+- Updated dependencies [[`a571ab1`](https://github.com/llodev/skills/commit/a571ab1537ea7d3fe61c7b89c5be0f08d01f3838)]:
+  - @llodev/pm-tasks-core@1.0.0
+
+## 0.1.0 (unreleased)
+
+- Initial extraction from `plan-to-task-cards` Phase 5 (Trello).
+- 6 CRUD verbs (create, checklist.check, close, due-date.set, assignee.add, comment.add).
+- Autonomous mode behind `[autonomous]` sentinel + allowlist.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LLDev Information Solutions
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# @llodev/pm-tasks-trello
+
+Trello adapter for the `@llodev/pm-tasks-*` family. Convert implementation plans into Trello cards (paste-ready or published via MCP) and operate them (`checklist.check`, `task.close`, `task.comment.add`, etc.).
+
+## Install
+
+```bash
+# npm (with skillpm or Claude Code marketplace)
+npm i @llodev/pm-tasks-core @llodev/pm-tasks-trello
+
+# Vercel CLI (install core manually too)
+npx skills add llodev/skills/pm-tasks-core
+npx skills add llodev/skills/pm-tasks-trello
+```
+
+## Setup the MCP
+
+Claude Code:
+
+```bash
+claude mcp add trello -s project -- npx -y atlassian-trello-mcp
+```
+
+Approve via `/mcp` in chat. Export env vars in your shell:
+
+```bash
+export TRELLO_API_KEY=...
+export TRELLO_TOKEN=...
+```
+
+Cursor/Windsurf: see [`references/mcp-config.md`](references/mcp-config.md).
+
+## Setup the config
+
+```bash
+npx @llodev/pm-tasks-trello init
+```
+
+Walk through the prompts. Output: `.trello.json` (repo) or `~/.config/llodev/pm-tasks/trello.json` (global).
+
+## Use
+
+- `"publish this plan as Trello cards"` → publish flow
+- `"check item 3 on task X in Trello"` → CRUD op
+- `"close card Y"` → close
+- `"[autonomous] create task in trello from plan @docs/plans/X.md"` → autonomous (requires `autonomous.enabled: true` in config)
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: pm-tasks-trello
+description: >-
+  Trello adapter for the @llodev/pm-tasks-* family. Use when the user mentions
+  Trello, asks to "create card", "publish to Trello", "post to Trello",
+  "publish", or uses --publish; OR for CRUD on existing cards (check
+  checklist item, close card, change due-date, add member, comment); OR when
+  invoked autonomously by another agent with [autonomous] / --auto sentinel.
+  Modes: paste-ready (no MCP needed), MCP publish (via atlassian-trello-mcp),
+  autonomous (write-through with allowlist). Implements 6 CRUD verbs
+  (task.create, checklist.check, task.close, task.due-date.set,
+  task.assignee.add, task.comment.add) from
+  pm-tasks/pm-tasks-core/references/contract.md. Requires @llodev/pm-tasks-core
+  installed.
+license: MIT
+metadata:
+  version: 1.0.0
+  tags:
+    - agent-skill
+    - trello
+    - plan-to-tasks
+    - pm-tools
+  family: pm-tasks
+  role: adapter
+  tool: trello
+compatibility:
+  agents:
+    - claude-code
+    - cursor
+    - codex
+    - windsurf
+    - cline
+    - roo-code
+---
+
+# pm-tasks-trello
+
+Adapter for Trello within the `@llodev/pm-tasks-*` family. Use the core skill's extraction phases, then apply Trello formatting and optionally publish/operate via the `atlassian-trello-mcp` MCP server.
+
+## Routing
+
+| Mode        | Trigger                                                                                  | Path                                                                     |
+| ----------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
+| Paste-only  | "format as Trello card" without MCP intent                                               | Phase 3 (core) → Phase 4 (this skill, format only) → output paste blocks |
+| MCP publish | "publish to Trello", "create on Trello", "--publish"                                     | Phase 3 → Phase 4 → Phase 5 (publish via MCP)                            |
+| Autonomous  | `[autonomous]` or `--auto` in prompt OR `LLODEV_PM_TASKS_AUTONOMOUS=1`                   | Phase 3 → Phase 4 → Phase 5b (write-through, no preview)                 |
+| CRUD ops    | "check item N on task X", "close card Y", "add Alice to task Z", "comment on task X"     | Phase 6 (operations, direct verb dispatch)                               |
+
+## Phase 4 — Trello formatting
+
+**MANDATORY — READ ENTIRE FILE** [`references/format.md`](references/format.md) before producing any Trello-specific output. Then apply [`anti-patterns/tools.md`](anti-patterns/tools.md) § Trello.
+
+## Phase 5 — MCP publish
+
+**Prerequisites:** `atlassian-trello-mcp` configured (see [`references/mcp-config.md`](references/mcp-config.md)). Env vars `TRELLO_API_KEY` + `TRELLO_TOKEN` in shell.
+
+Strict order: 5.1 config discovery → 5.2.5 resolve labels/member → 5.2 preview & approval → 5.3 publish via MCP → 5.4 error handling.
+
+Full sequence in [`references/publish.md`](references/publish.md).
+
+## Phase 5b — Autonomous
+
+Skip 5.2 preview & approval. Apply autonomous-mode contract from [`pm-tasks/pm-tasks-core/references/autonomous-mode.md`](../pm-tasks-core/references/autonomous-mode.md). Tool-specific overlay in [`references/autonomous.md`](references/autonomous.md). Audit log entries per [`pm-tasks/pm-tasks-core/references/audit-log-format.md`](../pm-tasks-core/references/audit-log-format.md).
+
+## Phase 6 — CRUD operations (existing cards)
+
+For verbs other than `task.create`, jump directly to the operation. **MANDATORY — READ ENTIRE FILE** [`references/operations.md`](references/operations.md) which lists verb → MCP tool mapping and `<task-ref>` resolution for Trello URLs/IDs.
+
+## Standalone fallback
+
+If `@llodev/pm-tasks-core` is not installed: ask the user for minimum input (title + checklist items) and produce a paste-ready Trello card from this content alone. Quality is degraded — no scope/audience/fidelity inference. Print: *"Install `@llodev/pm-tasks-core` for the full flow."*
+
+## Config
+
+Lookup order: `<git-root>/.trello.json` → `~/.config/llodev/pm-tasks/trello.json` → abort with init instructions. Schema: [`schemas/config.json`](schemas/config.json). Secrets NEVER in JSON — only env vars / keychain.
+
+## Init
+
+```
+npx @llodev/pm-tasks-trello init
+```
+
+See [`pm-tasks/pm-tasks-core/references/init-ux.md`](../pm-tasks-core/references/init-ux.md) for the shared flow.

package/anti-patterns/tools.md

@@ -0,0 +1,45 @@
+# Trello ingestion anti-patterns
+
+Apply **only** when Phase 4 targets Trello (after reading [`../references/format.md`](../references/format.md)). These are paste/rendering pitfalls that **generic markdown** intuition gets wrong.
+
+**Load this entire file** in Phase 4. **Do NOT load** for generic-only output.
+
+---
+
+## Paste health and fallbacks (canonical)
+
+Use when preview looks wrong **or** the user says paste mangled formatting. **Authoritative detail** also lives in [`../references/format.md`](../references/format.md).
+
+| Target     | Healthy paste                                                                                                                                           | If it degrades → fallback                                                                                                            |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| **Trello** | **No Markdown tables** anywhere in DESCRIPTION (timeline, tiers, grids) — bullets or `**Key:** value` lines only. Checklist lines **flat**, no nesting. | Flatten tables → bullets; reread § _Tables vs paste_ in [`../references/format.md`](../references/format.md).                        |
+
+**Switching tools mid-thread:** re-run Phase 4 **exclusive** load for the **new** tool; do not carry Trello rules into another adapter (see **Cross-tool** below).
+
+---
+
+## Trello
+
+**NEVER** leave **Markdown tables** in descriptions or timelines intended for Trello. **Why:** Trello descriptions do **not** render tables — users see garbage rows. Replace with bullets or a compact key-value bullet list.
+
+**NEVER** use nested markdown (`- item\n  - child`) inside **checklist items**. **Why:** Trello checklist lines are flat; nesting is misleading or stripped.
+
+**NEVER** assume parent/child **card URLs** exist before cards are created. **Why:** links are placeholders until created; prefer explicit note: `"create child cards then replace #link placeholders"`.
+
+**NEVER** exceed **~80 chars** on titles without warning. **Why:** truncates in board view; title rule in [`pm-tasks/pm-tasks-core/references/generic-card.md`](../../pm-tasks-core/references/generic-card.md) exists for this.
+
+**NEVER** call `create_card` / `trello_create_checklist` before the user confirms the Phase 5 preview. **Why:** creates real board objects without approval.
+
+**NEVER** pass label **names** to `create_card` — only **`idLabels`** (and **`idMembers`** with member IDs) resolved from `.trello.json`. **Why:** the API rejects names; wrong IDs attach to the wrong board.
+
+**NEVER** guess `boardId`, `listId`, `labels[].id`, or `members[].id` when `.trello.json` exists. **Why:** stale or invented IDs put cards on the wrong board or column; refresh via the discovery flow in [`../references/mcp-config.md`](../references/mcp-config.md) § **MCP config discovery**.
+
+**NEVER** auto-create labels with `trello_create_label` during publish unless the user explicitly asks. **Why:** pollutes the board palette; omit unknown names and report **omitted**.
+
+**NEVER** commit the active token user (or any per-developer member id) into `members[]` in `.trello.json`. **Why:** the file is shared in git; resolve "me" at runtime via `trello_get_member({ memberId: "me" })` at Phase 5.2.5 — each developer's `TRELLO_TOKEN` resolves to themselves without editing the repo.
+
+---
+
+## Cross-tool
+
+**NEVER** apply one tool's quirks to another after switching targets mid-chat. **Why:** user said "actually use Jira/Asana" — re-read the matching adapter reference + **re-apply only that adapter's rules** instead of these.

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@llodev/pm-tasks-trello",
+  "version": "1.0.0",
+  "description": "Trello adapter for the @llodev/pm-tasks-* family. Use when the user mentions Trello (create card, publish to Trello, post to Trello, --publish, check checklist item, close card, comment on card) or wants to publish a plan as Trello cards. Modes: paste-ready (no MCP needed), MCP publish (via atlassian-trello-mcp), autonomous (sentinel [autonomous] / --auto). Implements 6 CRUD verbs from @llodev/pm-tasks-core/references/contract.md. REQUIRES: @llodev/pm-tasks-core installed (skillpm / Claude Code marketplace cascade auto; Vercel CLI users install manually).",
+  "license": "MIT",
+  "homepage": "https://github.com/llodev/skills/tree/main/pm-tasks/pm-tasks-trello",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/llodev/skills.git",
+    "directory": "pm-tasks/pm-tasks-trello"
+  },
+  "files": [
+    "SKILL.md",
+    "schemas",
+    "references",
+    "anti-patterns",
+    "scripts",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "agent-skill",
+    "trello",
+    "plan-to-tasks",
+    "pm-tools",
+    "atlassian-trello-mcp"
+  ],
+  "type": "module",
+  "bin": {
+    "pm-tasks-trello-init": "./scripts/init.mjs"
+  },
+  "dependencies": {
+    "@llodev/pm-tasks-core": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/references/autonomous.md

@@ -0,0 +1,45 @@
+# Autonomous mode — Trello overlay
+
+Supplements [`pm-tasks/pm-tasks-core/references/autonomous-mode.md`](../../pm-tasks-core/references/autonomous-mode.md) with Trello-specific guidance.
+
+## Scope semantics
+
+`autonomous.scope.boards` → values are Trello board IDs (24-char hex). Operations targeting any card outside these boards fail `OUT_OF_SCOPE`.
+
+`autonomous.scope.lists` → values are list IDs. For `task.create`, the target list MUST be in this set. For `task.close`, the destination list (`closeListAlias` resolved) MUST be in this set.
+
+## Allowlist defaults (suggested by `init`)
+
+```json
+"autonomous": {
+  "enabled": false,
+  "allow": ["task.create", "checklist.check", "task.close", "task.comment.add"],
+  "scope": { "boards": [], "lists": [] },
+  "rateLimit": { "writesPerMinute": 30, "commentsPerMinute": 10 },
+  "auditLog": "~/.local/share/llodev/pm-tasks/trello/audit.log"
+}
+```
+
+Note `enabled: false` and empty `scope.*` — user must explicitly turn on AND populate scope. Init prints a warning explaining why.
+
+## Audit log entries — verb-specific shape
+
+```jsonl
+{"ts":"...","verb":"task.create","tool":"trello","ok":true,"id":"<cardId>","url":"https://trello.com/c/<shortLink>","name":"...","clientToken":"...","scope":{"board":"<boardId>","list":"<listId>"},"session":"..."}
+{"ts":"...","verb":"checklist.check","tool":"trello","ok":true,"id":"<cardId>","item":"<checkItem name>","session":"..."}
+{"ts":"...","verb":"task.close","tool":"trello","ok":true,"id":"<cardId>","session":"..."}
+{"ts":"...","verb":"task.due-date.set","tool":"trello","ok":true,"id":"<cardId>","due":"2026-07-01T00:00:00Z","session":"..."}
+{"ts":"...","verb":"task.assignee.add","tool":"trello","ok":true,"id":"<cardId>","userAlias":"me","session":"..."}
+{"ts":"...","verb":"task.comment.add","tool":"trello","ok":true,"id":"<cardId>","commentId":"<actionId>","clientToken":"...","session":"..."}
+```
+
+## Rate-limit handling
+
+`atlassian-trello-mcp` returns HTTP 429 with `Retry-After` header. Adapter inspects the error, returns `{ ok: false, code: "RATE_LIMITED", details: { retryAfterSeconds: <n> } }`. Skill does NOT auto-retry — caller decides.
+
+## Failure recovery for partial `task.create`
+
+If `create_card` succeeds but `trello_create_checklist` or `trello_create_check_item` fails:
+
+- Return `{ ok: false, code: "MCP_ERROR" }` with `details: { partialCard: { id, url }, completedSteps: [...], failedStep: "..." }`.
+- Caller can retry with same `clientToken` — idempotency check finds the partial card, only retries the failed steps.

package/references/format.md

@@ -0,0 +1,113 @@
+# Trello Formatting Reference
+
+## Tables vs paste (critical)
+
+Markdown **tables do not render** in Trello descriptions — pasted `|` grids show as unusable prose.
+
+When filling **`DESCRIPTION`** (and any prose meant for paste): **flatten all tables** from the generic card (timeline, tier summary, deliverables grids, etc.) into **bullets** or lines like `**Optimistic:** 4h`, `**Realistic:** 6h`.
+
+**Routing tables inside _this_ file** (checklist naming, labels) are **instructions for you** mapping blocks → structure. **Never** copy those tables into the card body.
+
+Paste/rendering **NEVER** rules: [`../anti-patterns/tools.md`](../anti-patterns/tools.md) (Trello section).
+
+---
+
+## Card anatomy
+
+Trello cards have: **title**, **description** (Markdown, free-text), **labels** (colored tags), **checklist(s)** (named, checkboxes), **due date**, and **attachments**. There is no native "ticket type" or hierarchy — parent/child cards are simulated with links.
+
+## Title
+
+- Max ~100 chars (Trello truncates in board view around 80).
+- Format: `[Area] — PhaseN (summary)` — matches the generic format, no change needed.
+
+## Description
+
+Trello descriptions render Markdown. Use the generic description block as-is.
+
+Additional Trello conventions:
+
+- Add a **Spec/Plan links** block at the top if the files are in a git repo with a URL:
+  ```
+  📄 [Spec](https://github.com/.../spec.md) · [Plan](https://github.com/.../plan.md)
+  ```
+- Separate sections with `---` (renders as horizontal rule).
+- Trello does **not** render tables — replace the Deliverables table with a bullet list if you used one.
+
+## Checklists
+
+Trello supports **multiple named checklists on one card**. Split as follows:
+
+| Generic block     | Trello checklist name           |
+| ----------------- | ------------------------------- |
+| Pre-flight        | `Pre-flight`                    |
+| Block A / Group 1 | `Implementation — [Block Name]` |
+| Block B / Group 2 | `Implementation — [Block Name]` |
+| ...               | (one checklist per block)       |
+| Verification      | `Verification`                  |
+
+For small cards (≤10 tasks total), use a single `Checklist` instead of splitting.
+
+Trello checklist item format: plain text, no markdown inside items.
+
+```
+Task 1 — scaffold workspace (config files)
+Task 2 — extend env schema with Firebase vars (TDD)
+```
+
+Avoid nesting. Trello items are flat. **Do not** prefix items with `✅` / `[x]` in the paste payload — Trello's native checkboxes track state.
+
+If you show a **sample** checklist to the user outside the paste block, plain `✅` is fine for readability.
+
+## Labels
+
+Trello labels are **board-scoped** and identified by **ID** in the API. When `.trello.json` exists, use only label **names** listed in `labels[]` — do not invent labels or use empty-name color stubs from the board.
+
+For paste output, the agent infers candidate labels from the generic card content (file paths it touches, plan keywords, the LABELS block) and matches them against `labels[]` by `name` or `alias`. If a candidate has no match in `labels[]` (e.g. `phase-2`, `ddd`), omit it and list under **omitted** in the wrapper — do not call `trello_create_label` unless the user explicitly asks.
+
+Apply **3–5** named labels max (board gets noisy beyond that).
+
+## Due date
+
+Set to the **realistic** estimate from the timeline section, starting from today.
+
+If the estimate is a range (e.g. "4–6h"), set the due date at the end of the realistic window.
+
+## Parent / child cards (large phases)
+
+For phases with >15 tasks (like a large BC):
+
+1. Create one **parent card** with the full description and a link to the plan.
+2. Create one **child card per block**, titled `[Phase] — Block [X]: [Block Name]`.
+3. In the parent card description, link to each child card:
+   ```
+   ### Sub-cards
+   - [Block A — Workspace + VOs](#link)
+   - [Block B — Core domain](#link)
+   - [Block C — Application](#link)
+   ```
+4. Add the `epic` or `parent` label to the parent card.
+
+## Output format for Trello
+
+When outputting for Trello, present the content as:
+
+```
+--- TRELLO CARD ---
+
+TITLE:
+[title here]
+
+DESCRIPTION (paste into card description):
+[description markdown]
+
+CHECKLISTS:
+[for each block, list: "Checklist name → items"]
+
+LABELS: [comma-separated — names from .trello.json labels[] only]
+
+MEMBER: [username, "me", or omit]
+
+DUE DATE: [date or relative like "3 days from now"]
+---
+```

package/references/mcp-config.md

@@ -0,0 +1,225 @@
+# Trello MCP Configuration
+
+The MCP server (`atlassian-trello-mcp`, run via `npx`) is identical across agents. Only the config file location and the JSON/TOML envelope differ. Env vars `TRELLO_API_KEY` + `TRELLO_TOKEN` must be set in the shell that launches the agent — they are inherited by the MCP child process.
+
+## MCP setup — Claude Code
+
+Project-scoped MCP servers live in `.mcp.json` at the repo root. Register via CLI:
+
+```bash
+claude mcp add trello -s project -- npx -y atlassian-trello-mcp
+```
+
+Then approve via `/mcp` in the chat. Claude Code does NOT interpolate `${env:VAR}` — env vars must be set in the parent shell.
+
+## MCP setup — Cursor
+
+```json
+// .cursor/mcp.json
+{
+  "mcpServers": {
+    "trello": {
+      "command": "npx",
+      "args": ["-y", "atlassian-trello-mcp"],
+      "env": {
+        "TRELLO_API_KEY": "${env:TRELLO_API_KEY}",
+        "TRELLO_TOKEN": "${env:TRELLO_TOKEN}"
+      }
+    }
+  }
+}
+```
+
+Cursor supports `${env:VAR}` interpolation.
+
+## MCP setup — Codex
+
+Codex reads MCP servers from `~/.codex/config.toml` (TOML, not JSON):
+
+```toml
+[mcp_servers.trello]
+command = "npx"
+args = ["-y", "atlassian-trello-mcp"]
+
+[mcp_servers.trello.env]
+TRELLO_API_KEY = "<your-key>"
+TRELLO_TOKEN = "<your-token>"
+```
+
+For env-var indirection, prefer storing the actual values in your OS keychain and templating them in via your shell init.
+
+## MCP setup — Windsurf
+
+```json
+// ~/.codeium/windsurf/mcp_config.json
+{
+  "mcpServers": {
+    "trello": {
+      "command": "npx",
+      "args": ["-y", "atlassian-trello-mcp"],
+      "env": {
+        "TRELLO_API_KEY": "${env:TRELLO_API_KEY}",
+        "TRELLO_TOKEN": "${env:TRELLO_TOKEN}"
+      }
+    }
+  }
+}
+```
+
+Same shape as Cursor; supports `${env:VAR}` interpolation.
+
+## MCP setup — Cline and Roo Code
+
+Both read from a JSON settings file under the VS Code user-data dir (Cline: `cline_mcp_settings.json`; Roo Code: `roo_code_mcp_settings.json` or `mcp_settings.json` depending on version). Same envelope as Cursor:
+
+```json
+{
+  "mcpServers": {
+    "trello": {
+      "command": "npx",
+      "args": ["-y", "atlassian-trello-mcp"],
+      "env": {
+        "TRELLO_API_KEY": "<your-key>",
+        "TRELLO_TOKEN": "<your-token>"
+      }
+    }
+  }
+}
+```
+
+## MCP setup — other MCP-capable agents
+
+The server is constant: `npx -y atlassian-trello-mcp` with env vars `TRELLO_API_KEY` + `TRELLO_TOKEN`. Consult your agent's MCP docs for the config file location and exact JSON/TOML envelope. The server name (`atlassian-trello-mcp`) and required env vars do not change.
+
+---
+
+## Board config (`.trello.json`)
+
+The adapter expects Trello metadata at the **repository root** in `.trello.json` (or `~/.config/llodev/pm-tasks/trello.json` as a global fallback). **Read the full file** before Phase 4 (formatting) and Phase 5 (publish).
+
+The authoritative schema is [`../schemas/config.json`](../schemas/config.json) (JSON Schema 2020-12). The shape below mirrors that schema field-for-field.
+
+### Top-level keys
+
+| Key            | Required | Purpose                                                                                          |
+| -------------- | -------- | ------------------------------------------------------------------------------------------------ |
+| `$schema`      | optional | URL pointer for editor IDE hover validation.                                                     |
+| `version`      | **yes**  | Const `"1"` — schema version of this file.                                                       |
+| `workspace`    | optional | Free-text workspace label (informational, not used by the API).                                  |
+| `boards[]`     | **yes**  | Catalog of accessible boards: `{ id, name?, alias, url? }`.                                      |
+| `lists[]`      | **yes**  | Catalog of board columns: `{ boardAlias, id, name?, alias }`.                                    |
+| `labels[]`     | optional | Catalog of named labels: `{ boardAlias, id, name?, color?, alias }`.                             |
+| `members[]`    | optional | Catalog of board members: `{ id, username?, fullName?, alias }`. **Do NOT include a personal "me" entry** committed to git — resolve at runtime (see below). |
+| `defaults`     | optional | `{ boardAlias?, listAlias?, closeListAlias? }` — preferred defaults when the user omits them.    |
+| `taskAliases[]`| optional | Stable aliases for individual cards: `{ alias, id, url? }`.                                      |
+| `autonomous`   | optional | Autonomous-mode envelope (see [`./autonomous.md`](./autonomous.md) for full spec).               |
+
+`alias` everywhere is `^[a-z0-9-]+$` — used by the agent as a stable, human-friendly key. `id` is the 24-char Trello object ID returned by the API.
+
+### Example (matches the schema)
+
+```json
+{
+  "$schema": "https://llodev.github.io/skills/schemas/pm-tasks-trello.json",
+  "version": "1",
+  "workspace": "llodev",
+  "boards": [
+    { "id": "6a2b574aefe6fe9621a3d5a7", "name": "Skills", "alias": "skills", "url": "https://trello.com/b/bR5bbtoH" }
+  ],
+  "lists": [
+    { "boardAlias": "skills", "id": "6a2b57600f0f20cbea2277f0", "name": "Backlog", "alias": "backlog" },
+    { "boardAlias": "skills", "id": "6a2b576292aee4b8eeb82ed1", "name": "WIP",     "alias": "wip" },
+    { "boardAlias": "skills", "id": "6a2b5767058f005c9c063a8b", "name": "Done",    "alias": "done" }
+  ],
+  "labels": [
+    { "boardAlias": "skills", "id": "6a2b574aefe6fe9621a3d5d2", "name": "core",    "color": "green",  "alias": "core" },
+    { "boardAlias": "skills", "id": "6a2b574aefe6fe9621a3d5d7", "name": "adapter", "color": "blue",   "alias": "adapter" }
+  ],
+  "members": [
+    { "id": "67d978bb...", "username": "alice", "fullName": "Alice Example", "alias": "alice" }
+  ],
+  "defaults": {
+    "boardAlias": "skills",
+    "listAlias": "backlog",
+    "closeListAlias": "done"
+  }
+}
+```
+
+Secrets (`TRELLO_API_KEY`, `TRELLO_TOKEN`) NEVER live in this file. Use env vars or your OS keychain.
+
+### Resolving "me" at runtime (NOT in committed config)
+
+`me` is **whoever owns the Trello token in the environment** (`TRELLO_TOKEN`), not a fixed user in git.
+
+At Phase **5.2.5**, call `trello_get_member` with `memberId: "me"` and use the returned `id` for `idMembers`. **Do not** add the current user to `members[]` in the committed file — each developer's token resolves to themselves.
+
+Optional: if the resolved `id` is not in `members[]` (not on the board), **warn** in the preview but still allow assign if the API accepts it; otherwise **stop** and ask to invite the member to the board.
+
+To assign someone else by default, omit it from the config and let the user pass it explicitly in the prompt, OR add an explicit member alias to `members[]` and reference it in the prompt by alias.
+
+### List resolution
+
+```
+listAlias = userProvided ?? defaults.listAlias
+listId    = lists.find(l => l.alias === listAlias && l.boardAlias === boardAlias)?.id
+```
+
+If `listAlias` is provided but not in `lists[]`, **stop** and list valid aliases — do not invent list IDs.
+
+### Board resolution
+
+```
+boardAlias = userProvided ?? defaults.boardAlias
+boardId    = boards.find(b => b.alias === boardAlias)?.id
+```
+
+If the user picks a board not in `boards[]`, refresh via MCP (`trello_get_user_boards`) and offer to merge into `.trello.json`.
+
+---
+
+## MCP config discovery (Phase 5.1)
+
+Read `.trello.json` at the **project root** (full file, no range limits) before publish.
+
+**If `.trello.json` is missing or has no `boards[]`:**
+
+1. `trello_get_user_boards` (`filter: "open"`) — present board names, ask which board(s).
+2. `get_lists` with each `boardId` — present list names; offer Backlog/WIP/Done as defaults if present.
+3. `trello_get_board_labels` — merge **named** labels only into `labels[]` (skip `name: ""` stubs).
+4. `trello_get_board_members` — fill `members[]` only with the board roster (NOT the active token user).
+5. Offer to write `.trello.json` with resolved IDs — **never** add the active token's user to `members[]`.
+
+**Never ask the user for 24-char IDs directly** — always resolve from names via MCP.
+
+**Refreshing a stale config** when the board changed in the Trello UI: re-run the discovery tools above for the active board and offer to merge updates into `.trello.json` (preserve `defaults` choices unless the user asks to switch).
+
+**MCP server:** `atlassian-trello-mcp` (see setup sections above); env `TRELLO_API_KEY` + `TRELLO_TOKEN`.
+
+---
+
+## Resolve labels and member (Phase 5.2.5)
+
+**Run before** the preview (Phase 5.2) so resolved values appear in the confirmation block.
+
+1. Start with the labels mentioned in the generic card's **LABELS** block.
+2. For each label name → look up `labels[].id` by matching `label.name` (exact) or `label.alias` against the entry in the card.
+3. Build `idLabels: string[]` (dedupe).
+4. Resolve member:
+   - `"me"` → `trello_get_member({ memberId: "me" })` → use returned `id` (and show `fullName` / `username` in preview).
+   - Explicit `alias` from `members[]` → use that entry's `id`.
+   - Omitted → no `idMembers`.
+   - User override in the preview wins.
+5. Emit **LABELS / MEMBER (resolved)** in the conversational wrapper — not inside the paste-only card body.
+
+```
+LABELS (resolved):
+  core    → 6a2b574aefe6fe9621a3d5d2
+  adapter → 6a2b574aefe6fe9621a3d5d7
+MEMBER (resolved):
+  Alice Example (me, current token) → 67d978bb...
+```
+
+If a label is mentioned but absent from `labels[]` → **do not** add to `idLabels`; list it under **omitted** (optional: offer `trello_create_label` only on explicit user request).
+
+If a member alias is referenced but not in `members[]` → **stop**; list valid aliases.

package/references/operations.md

@@ -0,0 +1,45 @@
+# Trello CRUD operations (v1)
+
+Maps each verb from [`pm-tasks/pm-tasks-core/references/crud-vocabulary.md`](../../pm-tasks-core/references/crud-vocabulary.md) to `atlassian-trello-mcp` tool calls.
+
+## Verb → MCP tool
+
+| Verb | MCP tool | Params (key ones) |
+|---|---|---|
+| `task.create` | `create_card` | `listId`, `name`, `desc`, `pos`, `due`, `labelIds[]`, `memberIds[]`, optional checklist via follow-up `trello_create_checklist` + `trello_create_check_item` |
+| `checklist.check` | `trello_update_check_item` | `cardId`, `checkItemId`, `state: "complete"` |
+| `task.close` | `move_card` | `cardId`, `listId` = config `defaults.closeListAlias` resolved |
+| `task.due-date.set` | `update_card` | `cardId`, `due` (ISO 8601 or `null`) |
+| `task.assignee.add` | `trello_add_member_to_card` | `cardId`, `memberId` |
+| `task.comment.add` | `trello_add_comment` | `cardId`, `text` (prefixed with `[ct:<clientToken>]` if provided) |
+
+## `<task-ref>` resolution for Trello
+
+Implementation steps in adapter's runtime logic:
+
+1. **URL match** — pattern `^https?://trello\.com/c/([A-Za-z0-9]+)`. Group 1 is the short-link, usable as `cardId` in all MCP calls.
+2. **Native ID** — 24-char hex (e.g. `6a2b574aefe6fe9621a3d5a7`) → use as-is.
+3. **`taskAliases` lookup** — match `alias` in config, resolve to `id`/`url`.
+4. **clientToken match (audit log)** — newest entry with matching `clientToken` in `~/.local/share/llodev/pm-tasks/trello/audit.log`.
+5. **Name partial (audit log)** — case-insensitive substring on `name`, newest first, filter by `scope.boards`.
+6. **Otherwise** → `{ ok: false, code: "REF_NOT_RESOLVED", candidates: [list of last 5 created in scope] }`.
+
+## Idempotency
+
+- `task.create` — checks card description for `[ct:<token>]` marker via `trello_get_list_cards` on target list.
+- `checklist.check` — fetches checkItem state via `trello_get_check_item` first; skips MCP call if already `complete`.
+- `task.close` — fetches current list via `get_card`; skips if already in `closeListAlias`.
+- `task.due-date.set` — fetches `due` via `get_card`; skips if equal.
+- `task.assignee.add` — fetches `members` of card via `get_card`; skips if memberId already in list.
+- `task.comment.add` — fetches last 20 comments via `trello_get_card_actions`; skips if any starts with `[ct:<token>]`.
+
+## Result envelope (Trello-specific `details`)
+
+| Verb | `details` fields |
+|---|---|
+| `task.create` | `{ shortLink, dateLastActivity, checklists: [{id,name,items: [{id,name}]}] }` |
+| `checklist.check` | `{ checklistId, checkItemId }` |
+| `task.close` | `{ previousListId, newListId }` |
+| `task.due-date.set` | `{ previousDue, newDue }` |
+| `task.assignee.add` | `{ memberId, username }` |
+| `task.comment.add` | `{ commentId }` |

package/references/publish.md

@@ -0,0 +1,107 @@
+# Trello Publish Sequence
+
+## Preview and approval (Phase 5.2)
+
+Before any write MCP call, show:
+
+```
+Ready to create on Trello:
+
+  Board : [boardName]
+  List  : [listName]
+  Title : [card title]
+  Checklists:
+    Pre-flight         (N items)
+    Block A — [name]   (N items)
+    ...
+    Verification       (N items)
+  Labels: [names] → IDs: [idLabels summary or count]
+  Member: [fullName] ([username]) → [memberId]
+  Due date: [date or omitted]
+
+Create now? [y] confirm · [n] cancel · [e] edit title/list/member/labels first
+```
+
+- **y / confirm** → proceed to publish sequence
+- **n / cancel** → stop; paste-ready output remains the artifact
+- **e / edit** → adjust title/board/list/due date/member/labels, show preview again
+
+**NEVER** call write MCP tools (`create_card`, `trello_create_checklist`, etc.) before confirmation.
+
+When **Phase 5** runs (MCP create), add after § Resolve labels and member and **before** § Preview:
+
+```
+CREATE_CARD (API):
+  idList    : [listId]
+  idLabels  : ["...", ...]  (omit key if empty)
+  idMembers : ["..."]       (omit key if unassigned)
+```
+
+---
+
+## Publish via MCP (Phase 5)
+
+Invoked from [`../SKILL.md`](../SKILL.md) Phase 5 after § **Preview and approval** confirmation and § **Resolve labels and member** complete. **NEVER** call write MCP tools before confirmation.
+
+**Description body:** use [`pm-tasks/pm-tasks-core/references/generic-card.md`](../../pm-tasks-core/references/generic-card.md) **Description** block **without** Out of scope / Next step (see [`../anti-patterns/tools.md`](../anti-patterns/tools.md)).
+
+### Publish sequence
+
+Execute in order; stop and report on first failure.
+
+**Step 1 — Create the card**
+
+Call `create_card` with:
+
+- `name` = card title (from Phase 4)
+- `desc` = card description (from Phase 4, Markdown; no tables — flatten per § Tables vs paste)
+- `idList` = resolved `listId` from § List resolution
+- `due` = due date if set (ISO 8601), otherwise omit
+- `idLabels` = array from Phase 5.2.5 (omit key if empty)
+- `idMembers` = `[memberId]` when assigned (omit key if none)
+
+Capture returned `id` / `shortUrl` as `cardId`.
+
+Prefer **assigning labels and member at create** — fewer API calls and atomic card state. Use `trello_add_label_to_card` / `trello_add_member_to_card` only when adding after create (e.g. user amended labels in **e** flow).
+
+**Step 2 — Create checklists**
+
+For each named checklist block (Pre-flight, one per implementation block, Verification):
+
+1. `trello_create_checklist`: `{ cardId, name: "Pre-flight" }` → capture `checklistId`
+2. Per item: `trello_create_check_item`: `{ checklistId, name: "plain text, no markdown" }`
+
+Order: Pre-flight → implementation blocks in plan order → Verification last.
+
+**Rate limit:** Trello allows 300 req/10s per key. A card with 8 checklists × 5 items ≈ 50 calls — within limits.
+
+**Step 3 — Fallback labels/member (optional)**
+
+Only if Step 1 omitted `idLabels` / `idMembers` but Phase 5.2.5 resolved new values after create:
+
+- `trello_add_label_to_card` per `labelId`
+- `trello_add_member_to_card` per `memberId`
+
+**Step 4 — Confirm**
+
+```
+✓ Card created: [shortUrl from create_card]
+  Board : [board.name] → [listName]
+  Member: [fullName or "unassigned"]
+  Checklists: N created, M items total
+  Labels: [names applied] (omitted: [names with no match in labels[]])
+```
+
+### Error handling
+
+| Failure                               | Action                                                                                                |
+| ------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| MCP not connected                     | Abort Phase 5; deliver paste-ready output (Phase 4); check MCP server config and `TRELLO_*` env vars  |
+| `boardId` / `listId` not resolved     | Re-run § **MCP config discovery**; do not guess IDs                                                   |
+| Label name not in `.trello.json`      | Skip that label; continue; report under **omitted**; do not auto-create labels                        |
+| Member not in `members[]`             | Stop before create; list valid usernames                                                              |
+| Card creation fails                   | Abort; report error; no checklists created                                                            |
+| Checklist creation fails mid-sequence | Report card URL; which checklists succeeded vs "add manually"                                         |
+| Label/member fallback fails           | Report card URL; list what was applied at create vs failed fallback                                   |
+
+**NEVER** leave a partial card without reporting what was and wasn't created.

package/schemas/config.json

@@ -0,0 +1,130 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://llodev.github.io/skills/schemas/pm-tasks-trello.json",
+  "title": "pm-tasks-trello config",
+  "type": "object",
+  "required": ["version", "boards", "lists"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": { "type": "string" },
+    "version": { "const": "1" },
+    "workspace": { "type": "string" },
+    "boards": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "alias"],
+        "additionalProperties": false,
+        "properties": {
+          "id": { "type": "string", "minLength": 8 },
+          "name": { "type": "string" },
+          "alias": { "type": "string", "pattern": "^[a-z0-9-]+$" },
+          "url": { "type": "string", "format": "uri" }
+        }
+      }
+    },
+    "lists": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["boardAlias", "id", "alias"],
+        "additionalProperties": false,
+        "properties": {
+          "boardAlias": { "type": "string" },
+          "id": { "type": "string", "minLength": 8 },
+          "name": { "type": "string" },
+          "alias": { "type": "string", "pattern": "^[a-z0-9-]+$" }
+        }
+      }
+    },
+    "labels": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["boardAlias", "id", "alias"],
+        "additionalProperties": false,
+        "properties": {
+          "boardAlias": { "type": "string" },
+          "id": { "type": "string", "minLength": 8 },
+          "name": { "type": "string" },
+          "color": { "type": "string" },
+          "alias": { "type": "string", "pattern": "^[a-z0-9-]+$" }
+        }
+      }
+    },
+    "members": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "alias"],
+        "additionalProperties": false,
+        "properties": {
+          "id": { "type": "string", "minLength": 8 },
+          "username": { "type": "string" },
+          "fullName": { "type": "string" },
+          "alias": { "type": "string", "pattern": "^[a-z0-9-]+$" }
+        }
+      }
+    },
+    "defaults": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "boardAlias": { "type": "string" },
+        "listAlias": { "type": "string" },
+        "closeListAlias": { "type": "string" }
+      }
+    },
+    "taskAliases": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["alias", "id"],
+        "additionalProperties": false,
+        "properties": {
+          "alias": { "type": "string", "pattern": "^[a-z0-9-]+$" },
+          "id": { "type": "string" },
+          "url": { "type": "string", "format": "uri" }
+        }
+      }
+    },
+    "autonomous": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "allow": {
+          "type": "array",
+          "items": {
+            "enum": [
+              "task.create",
+              "checklist.check",
+              "task.close",
+              "task.due-date.set",
+              "task.assignee.add",
+              "task.comment.add"
+            ]
+          }
+        },
+        "scope": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "boards": { "type": "array", "items": { "type": "string" } },
+            "lists": { "type": "array", "items": { "type": "string" } }
+          }
+        },
+        "rateLimit": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "writesPerMinute": { "type": "integer", "minimum": 1, "maximum": 600 },
+            "commentsPerMinute": { "type": "integer", "minimum": 1, "maximum": 600 }
+          }
+        },
+        "auditLog": { "type": "string" }
+      }
+    }
+  }
+}

package/scripts/init.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+// pm-tasks-trello init — interactive config bootstrapper
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import {
+  promptScope,
+  promptYesNo,
+  multiSelect,
+  writeConfig,
+  validateConfig,
+  probeMCP,
+  printInstructions,
+} from "@llodev/pm-tasks-core/init-lib";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+async function loadSchema() {
+  const raw = await readFile(path.join(ROOT, "schemas", "config.json"), "utf8");
+  return JSON.parse(raw);
+}
+
+async function trelloProbe() {
+  // The MCP runs in a different process. To probe within this script, call the
+  // Trello REST API directly with env vars TRELLO_API_KEY + TRELLO_TOKEN.
+  // We use this only to enumerate boards/lists/labels/members for the user.
+  const { TRELLO_API_KEY: KEY, TRELLO_TOKEN: TOKEN } = process.env;
+  if (!KEY || !TOKEN) throw new Error("auth: TRELLO_API_KEY or TRELLO_TOKEN missing");
+  const url = (p) => `https://api.trello.com/1${p}?key=${KEY}&token=${TOKEN}`;
+  const j = async (p) => {
+    const r = await fetch(url(p));
+    if (!r.ok) throw new Error(`HTTP ${r.status}`);
+    return r.json();
+  };
+  return {
+    getBoards: () => j("/members/me/boards?filter=open&fields=id,name,url"),
+    getLists: (boardId) => j(`/boards/${boardId}/lists?filter=open&fields=id,name`),
+    getLabels: (boardId) => j(`/boards/${boardId}/labels?fields=id,name,color`),
+    getMembers: (boardId) => j(`/boards/${boardId}/members?fields=id,username,fullName`),
+    getMe: () => j("/members/me?fields=id,username,fullName"),
+  };
+}
+
+function aliasOf(name) {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+async function run() {
+  console.log("\n@llodev/pm-tasks-trello init\n");
+
+  const { path: outPath } = await promptScope("trello");
+
+  const probe = await probeMCP({
+    tool: "trello",
+    probeCommand: async () => {
+      const api = await trelloProbe();
+      await api.getMe();
+      return api;
+    },
+  });
+
+  if (probe.unauthenticated) {
+    printInstructions([
+      "Trello MCP detected, but credentials missing.",
+      "Set them in your shell and re-run:",
+      "  export TRELLO_API_KEY=...",
+      "  export TRELLO_TOKEN=...",
+    ]);
+    return;
+  }
+
+  if (!probe.mcpAvailable) {
+    printInstructions([
+      "Trello MCP not available. Configure it first:",
+      "  claude mcp add trello -s project -- npx -y atlassian-trello-mcp",
+      "See references/mcp-config.md for details. Re-run this init afterward.",
+    ]);
+    return;
+  }
+
+  const api = probe.result;
+  const me = await api.getMe();
+  const boards = await api.getBoards();
+
+  const pickedBoards = await multiSelect(
+    "Available boards (select 1+):",
+    boards.map((b) => ({ label: `${b.name} (${b.id})`, value: b })),
+  );
+  if (!pickedBoards.length) {
+    console.error("no board selected, aborting");
+    process.exit(1);
+  }
+
+  const out = {
+    $schema: "https://llodev.github.io/skills/schemas/pm-tasks-trello.json",
+    version: "1",
+    boards: [],
+    lists: [],
+    labels: [],
+    members: [{ id: me.id, username: me.username, fullName: me.fullName, alias: "me" }],
+    defaults: {},
+  };
+
+  for (const b of pickedBoards) {
+    const alias = aliasOf(b.name);
+    out.boards.push({ id: b.id, name: b.name, alias, url: b.url });
+    const lists = await api.getLists(b.id);
+    const pickedLists = await multiSelect(
+      `Lists in "${b.name}":`,
+      lists.map((l) => ({ label: l.name, value: l })),
+    );
+    for (const l of pickedLists) {
+      out.lists.push({ boardAlias: alias, id: l.id, name: l.name, alias: aliasOf(l.name) });
+    }
+    const labels = (await api.getLabels(b.id)).filter((x) => x.name);
+    for (const l of labels) {
+      out.labels.push({
+        boardAlias: alias,
+        id: l.id,
+        name: l.name,
+        color: l.color,
+        alias: aliasOf(l.name),
+      });
+    }
+  }
+
+  if (out.boards.length === 1) {
+    out.defaults.boardAlias = out.boards[0].alias;
+    const backlog = out.lists.find((l) => /backlog|todo|to.do/i.test(l.name));
+    const done = out.lists.find((l) => /done|published|concluído/i.test(l.name));
+    if (backlog) out.defaults.listAlias = backlog.alias;
+    if (done) out.defaults.closeListAlias = done.alias;
+  }
+
+  const wantAuto = await promptYesNo(
+    "Enable autonomous mode? (adds an autonomous block with conservative defaults)",
+  );
+  if (wantAuto) {
+    out.autonomous = {
+      enabled: false,
+      allow: ["task.create", "checklist.check", "task.close", "task.comment.add"],
+      scope: { boards: out.boards.map((b) => b.id), lists: out.lists.map((l) => l.id) },
+      rateLimit: { writesPerMinute: 30, commentsPerMinute: 10 },
+      auditLog: "~/.local/share/llodev/pm-tasks/trello/audit.log",
+    };
+    printInstructions([
+      "autonomous block added with enabled:false.",
+      "Review scope.boards and scope.lists in the JSON before enabling.",
+    ]);
+  }
+
+  const schema = await loadSchema();
+  const valid = await validateConfig(out, schema);
+  if (!valid.ok) {
+    console.error("invalid config:", JSON.stringify(valid.errors, null, 2));
+    process.exit(1);
+  }
+
+  await writeConfig(outPath, out);
+  printInstructions([
+    `Config written to ${outPath}.`,
+    "Try it in Claude Code: 'create a Trello card from this plan'.",
+    "Reminder: secrets belong in env vars or OS keychain — never in this JSON.",
+  ]);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  run().catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });
+}