@thehammer/danx-dashboard-mcp 0.1.9 → 0.1.11

package/README.md

@@ -10,7 +10,10 @@ Each tool is a thin envelope over one HTTP route — Zod-validated at the MCP bo
 |---|---|
 | `DANXBOT_DASHBOARD_URL` | Dashboard base, e.g. `http://danxbot-dashboard:5555` (inside compose) or `http://localhost:5555` (host) |
 | `DANXBOT_DISPATCH_TOKEN` | Per-dispatch bearer — server validates via `requireUser`/dispatch-token checks |
-| `DANX_REPO_NAME` | Default repo scope appended as `?repo=<name>`; each tool's optional `repo` arg overrides it per-call for cross-repo reads/writes (unknown repo → 404) |
+| `DANX_REPO_NAME` | Repo half of the qualified board id |
+| `DANXBOT_BOARD_NAME` | Board-slug half of the qualified board id (the dispatch injects `board.slug` here) |
+
+BOARD-ONLY (DX-1171): board is the first-level concept; repo is DERIVED from board server-side, never passed. At boot the package composes the dispatch's qualified board id `<repo>:<slug>` from `DANX_REPO_NAME` + `DANXBOT_BOARD_NAME` and appends it as `?board=<id>` (and `body.board` on create) to every `/api/issues/*` request. Each tool exposes an optional `board` arg — a FULL qualified id `<repo>:<slug>` (e.g. `platform:the-supply-operations-hub`) — that overrides it per-call for cross-board reads/writes (unknown board → 404). The dashboard owns board→repo resolution; this package never sends `repo`.
 
 ## Tool surface
 

package/dist/handlers.js

@@ -24,26 +24,33 @@ export async function issueList(client, args) {
         query.limit = args.limit;
     if (args.offset !== undefined)
         query.offset = args.offset;
-    return client.request({ method: "GET", path: "", query, repo: args.repo });
+    // DX-1163 — the agent surface is lean by default: opt the route into the
+    // `IssueListRowLeanV2` projection (id/type/title/status/parent_id/
+    // assigned_agent/children-ids/priority). The SPA omits this and keeps the
+    // rich board row; `issue_get` still returns the full card body.
+    query.lean = true;
+    // DX-1171 — board-only: forward the qualified board id, no repo.
+    return client.request({ method: "GET", path: "", query, board: args.board });
 }
 // ---------------- issue_get ----------------
 export async function issueGet(client, args) {
     return client.request({
         method: "GET",
         path: `/${encodeURIComponent(args.id)}`,
-        repo: args.repo,
+        board: args.board,
     });
 }
-export async function issueCreate(client, args, defaultRepo) {
-    // Resolve the target repo ONCE: per-call `args.repo` override (target
-    // another registered repo) wins, else the dispatch's `DANX_REPO_NAME`.
-    // `repo` lives in BOTH the query string (via http-client) AND the body
-    // (server requires it inside the JSON envelope per
-    // `write/create.ts::validate`). Sending only one fails-loud — the
-    // duplication is intentional. The dashboard 404s an unknown repo.
-    const repo = args.repo ?? defaultRepo;
+export async function issueCreate(client, args, defaultBoard) {
+    // Resolve the target board ONCE: per-call `args.board` override (a
+    // qualified `<repo>:<slug>` id) wins, else the dispatch's env-derived
+    // board. `board` lives in BOTH the query string (via http-client) AND
+    // the body (the create route reads it from the JSON envelope, as
+    // `repo` did pre-DX-1171). Sending only one fails-loud — the
+    // duplication is intentional. The dashboard owns board→repo and 404s
+    // an unknown board.
+    const board = args.board ?? defaultBoard;
     const body = {
-        repo,
+        board,
         type: args.type,
         title: args.title,
         description: args.description,
@@ -56,13 +63,13 @@ export async function issueCreate(client, args, defaultRepo) {
         body.effort_level = args.effort_level;
     if (args.phase_children !== undefined)
         body.phase_children = args.phase_children;
-    return client.request({ method: "POST", path: "", body, repo });
+    return client.request({ method: "POST", path: "", body, board });
 }
 export async function issueEdit(client, args) {
-    // `repo` is a transport concern (query), NOT a patch field — pull it
+    // `board` is a transport concern (query), NOT a patch field — pull it
     // out of `rest` so it never leaks into the `/edit` body (the server
     // 400s on non-allowlisted keys).
-    const { id, repo, ...rest } = args;
+    const { id, board, ...rest } = args;
     // Strip undefined so we don't send `{title: undefined}` — JSON.stringify
     // drops them anyway but explicit is clearer.
     const body = {};
@@ -74,30 +81,30 @@ export async function issueEdit(client, args) {
         method: "PATCH",
         path: `/${encodeURIComponent(id)}/edit`,
         body,
-        repo,
+        board,
     });
 }
 export async function issueTransition(client, args) {
-    const { id, repo, ...body } = args;
+    const { id, board, ...body } = args;
     return client.request({
         method: "POST",
         path: `/${encodeURIComponent(id)}/transition`,
         body,
-        repo,
+        board,
     });
 }
 export async function issueTriage(client, args) {
-    const { id, repo, ...body } = args;
+    const { id, board, ...body } = args;
     return client.request({
         method: "POST",
         path: `/${encodeURIComponent(id)}/triage`,
         body,
-        repo,
+        board,
     });
 }
 export async function issueComment(client, args) {
     const idEnc = encodeURIComponent(args.id);
-    const repo = args.repo;
+    const board = args.board;
     if (args.action === "add") {
         if (typeof args.text !== "string") {
             throw new Error("issue_comment action=add requires text");
@@ -106,7 +113,7 @@ export async function issueComment(client, args) {
             method: "POST",
             path: `/${idEnc}/comments`,
             body: { text: args.text },
-            repo,
+            board,
         });
     }
     if (args.action === "edit") {
@@ -120,7 +127,7 @@ export async function issueComment(client, args) {
             method: "PATCH",
             path: `/${idEnc}/comments/${args.comment_id}`,
             body: { text: args.text },
-            repo,
+            board,
         });
     }
     // delete
@@ -130,12 +137,12 @@ export async function issueComment(client, args) {
     return client.request({
         method: "DELETE",
         path: `/${idEnc}/comments/${args.comment_id}`,
-        repo,
+        board,
     });
 }
 export async function issueDependency(client, args) {
     const idEnc = encodeURIComponent(args.id);
-    const repo = args.repo;
+    const board = args.board;
     if (args.action === "add") {
         if (args.kind === undefined) {
             throw new Error("issue_dependency action=add requires kind");
@@ -151,7 +158,7 @@ export async function issueDependency(client, args) {
                 target_id: args.target_id,
                 reason: args.reason ?? "",
             },
-            repo,
+            board,
         });
     }
     // remove
@@ -166,12 +173,12 @@ export async function issueDependency(client, args) {
         // agent that types the wrong reason gets a refusal here at MCP
         // arg-validation, not a confusing 400 envelope.
         body: { reason: "recorded_in_error" },
-        repo,
+        board,
     });
 }
 export async function issueRequiresHuman(client, args) {
     const idEnc = encodeURIComponent(args.id);
-    const repo = args.repo;
+    const board = args.board;
     if (args.set) {
         if (typeof args.reason !== "string") {
             throw new Error("issue_requires_human set=true requires reason");
@@ -183,21 +190,21 @@ export async function issueRequiresHuman(client, args) {
             method: "POST",
             path: `/${idEnc}/requires-human`,
             body: { reason: args.reason, steps: args.steps },
-            repo,
+            board,
         });
     }
     return client.request({
         method: "DELETE",
         path: `/${idEnc}/requires-human`,
-        repo,
+        board,
     });
 }
 export async function issueRetro(client, args) {
-    const { id, repo, ...body } = args;
+    const { id, board, ...body } = args;
     return client.request({
         method: "PUT",
         path: `/${encodeURIComponent(id)}/retro`,
         body,
-        repo,
+        board,
     });
 }

package/dist/http-client.js

@@ -6,7 +6,7 @@ export class DashboardHttpClient {
         this.fetchImpl = fetchImpl;
     }
     async request(args) {
-        const url = this.buildUrl(args.path, args.query, args.repo);
+        const url = this.buildUrl(args.path, args.query, args.board);
         const headers = {
             Authorization: `Bearer ${this.config.token}`,
             Accept: "application/json",
@@ -47,7 +47,7 @@ export class DashboardHttpClient {
         }
         return { ok: false, status: res.status, body: parsed };
     }
-    buildUrl(path, extraQuery, repoOverride) {
+    buildUrl(path, extraQuery, boardOverride) {
         const base = this.config.baseUrl.replace(/\/+$/, "");
         const [rawPath, existingQs] = path.split("?", 2);
         let cleanPath;
@@ -58,7 +58,7 @@ export class DashboardHttpClient {
             cleanPath = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
         }
         const params = new URLSearchParams(existingQs ?? "");
-        params.set("repo", repoOverride ?? this.config.repo);
+        params.set("board", boardOverride ?? this.config.board);
         if (extraQuery) {
             for (const [k, v] of Object.entries(extraQuery)) {
                 if (v === undefined || v === null)

package/dist/index.js

@@ -22,12 +22,22 @@
  *   - issue_requires_human   POST/DELETE /api/issues/:id/requires-human
  *   - issue_retro            PUT    /api/issues/:id/retro
  *
+ * BOARD-ONLY (DX-1171): board is the first-level concept; repo is
+ * DERIVED from board server-side, never passed. The package composes the
+ * dispatch's qualified board id (`<repo>:<slug>`) at boot from
+ * DANX_REPO_NAME + DANXBOT_BOARD_NAME and sends it as `board` — the
+ * dashboard owns board→repo resolution.
+ *
  * Env at boot (validated fail-loud — missing → process.exit(1)):
  *   DANXBOT_DASHBOARD_URL   dashboard base (e.g. http://danxbot-dashboard:5555)
  *   DANXBOT_DISPATCH_TOKEN  per-dispatch bearer
- *   DANX_REPO_NAME          default repo scope, appended as ?repo=<name>;
- *                           each tool's optional `repo` arg overrides it
- *                           per-call for cross-repo reads/writes
+ *   DANX_REPO_NAME          repo half of the qualified board id
+ *   DANXBOT_BOARD_NAME      board-slug half of the qualified board id
+ *                           (the dispatch injects `board.slug` here);
+ *                           composed as `<repo>:<slug>` and appended as
+ *                           ?board=<id>. Each tool's optional `board` arg
+ *                           (a full qualified id) overrides it per-call
+ *                           for cross-board reads/writes.
  *
  * Envelope contract: every tool returns the dashboard's response body
  * verbatim wrapped as `{ok, status, body}`. Refusals (4xx with the v2
@@ -48,10 +58,15 @@ function readEnvOrDie(name) {
     }
     return v;
 }
+// Compose the dispatch's qualified board id (`<repo>:<slug>`) from the
+// two env halves the worker injects. DANXBOT_BOARD_NAME already carries
+// the board SLUG at the spawn site (src/dispatch/core.ts sets it from
+// `board.slug`), so a plain join yields the canonical id — no transform.
+// Both halves are fail-loud required (Core Principle 1 — no fallback).
 const config = {
     baseUrl: readEnvOrDie("DANXBOT_DASHBOARD_URL"),
     token: readEnvOrDie("DANXBOT_DISPATCH_TOKEN"),
-    repo: readEnvOrDie("DANX_REPO_NAME"),
+    board: `${readEnvOrDie("DANX_REPO_NAME")}:${readEnvOrDie("DANXBOT_BOARD_NAME")}`,
 };
 const client = new DashboardHttpClient(config);
 const server = new McpServer({
@@ -90,20 +105,23 @@ const TRANSITION_ACTIONS = [
     "reopen",
 ];
 const TRIAGE_VERDICTS = ["approve", "cancel", "keep", "defer"];
-// Optional per-call repo override shared by every tool. Omitted → the
-// server binding's DANX_REPO_NAME is used; provided → that registered
-// repo is targeted instead (the dashboard 404s an unknown repo). Spread
-// into each tool's Zod input object so cross-repo work is reachable from
-// any dispatch without rebinding the MCP server.
-const repoField = {
-    repo: z
+// Optional per-call board override shared by every tool. Omitted → the
+// dispatch's env-derived board (`<repo>:<slug>`) is used; provided → that
+// board is targeted instead (the dashboard owns board→repo and 404s an
+// unknown board). The override is a FULL qualified board id
+// (`<repo>:<slug>`, e.g. `platform:the-supply-operations-hub`) — never a
+// bare slug, since a slug alone is not globally unique. Spread into each
+// tool's Zod input object so cross-board work is reachable from any
+// dispatch without rebinding the MCP server.
+const boardField = {
+    board: z
         .string()
         .min(1)
         .optional()
-        .describe("Target another registered repo; omit to use this dispatch's repo. Unknown repo → 404."),
+        .describe("Target another board by its qualified id `<repo>:<slug>` (e.g. `platform:the-supply-operations-hub`); omit to use this dispatch's board. Unknown board → 404."),
 };
 // ---------------- issue_list ----------------
-server.tool("issue_list", "List issues for the dispatch's repo by default via GET /api/issues. Pass `repo` to list another registered repo instead (unknown repo → 404). Filters: q (free-text search matched case-insensitively over title + description — use this to find cards by keyword), type, parent_id (string id, null for root-only), dispatchable_derived (boolean — server-computed pickup-ready gate), assigned_agent, include_closed (default false — excludes completed_at/cancelled_at). Returns ALL matching cards (no row cap unless you pass limit). Response body shape: {issues: Issue[]} — lean board rows that do NOT carry the `description` body; call issue_get for a card's full description. Server-side numeric-suffix ordering so DX-10 follows DX-9. Use this instead of grepping .danxbot/issues/ — the DB-backed route is the source of truth post-DX-704.", {
+server.tool("issue_list", "List issues for the dispatch's board by default via GET /api/issues. Board-scoped; defaults to the dispatch's board. Pass `board` (a qualified id `<repo>:<slug>`) to list another board instead (unknown board → 404). Filters: q (free-text search matched case-insensitively over title + description — use this to find cards by keyword), type, parent_id (string id, null for root-only), dispatchable_derived (boolean — server-computed pickup-ready gate), assigned_agent, include_closed (default false — excludes completed_at/cancelled_at). Returns ALL matching cards (no row cap unless you pass limit). Response body shape: {issues: Issue[]} — LEAN agent rows (DX-1163): each row carries ONLY {id, type, title, status, parent_id, assigned_agent, children (ids), priority}. UI-only board fields (children_detail, counts, triage_ice_total, blocked_descendants, conflict_on, child_assignments, requires_human_child_count, latest_work_dispatch, primary_attachment) and the `description` body are NOT included — call issue_get for the full card. Server-side numeric-suffix ordering so DX-10 follows DX-9. Use this instead of grepping .danxbot/issues/ — the DB-backed route is the source of truth post-DX-704.", {
     q: z.string().optional(),
     status_derived: z.string().optional(),
     type: z.enum(ISSUE_TYPES).optional(),
@@ -113,15 +131,15 @@ server.tool("issue_list", "List issues for the dispatch's repo by default via GE
     include_closed: z.boolean().optional(),
     limit: z.number().int().positive().max(1000).optional(),
     offset: z.number().int().nonnegative().optional(),
-    ...repoField,
+    ...boardField,
 }, async (args) => jsonResult(await issueList(client, args)));
 // ---------------- issue_get ----------------
-server.tool("issue_get", "Fetch a single hydrated issue via GET /api/issues/:id. Issue ids are globally unique across repos, so this resolves from any dispatch regardless of `repo`. Returns the full card (every joined child collection: ac, comments, dependencies, requires_human steps, retro action items + commits, triage history) plus the ancestor chain walked via parent_id. 404 envelope on unknown id.", {
+server.tool("issue_get", "Fetch a single hydrated issue via GET /api/issues/:id. Board-scoped; defaults to the dispatch's board. Issue ids are globally unique, so this resolves from any dispatch regardless of `board`. Returns the full card (every joined child collection: ac, comments, dependencies, requires_human steps, retro action items + commits, triage history) plus the ancestor chain walked via parent_id. 404 envelope on unknown id.", {
     id: z.string().min(1),
-    ...repoField,
+    ...boardField,
 }, async (args) => jsonResult(await issueGet(client, args)));
 // ---------------- issue_create ----------------
-server.tool("issue_create", "Create a fresh card via POST /api/issues. Defaults to the dispatch's repo; pass `repo` to create the card in another registered repo (forwarded into body.repo + ?repo=; unknown repo → 404). INVARIANT: type=Epic REQUIRES non-empty phase_children[] (epic-with-phases atomicity per DX-575) and the route atomically inserts the epic + every phase in ONE transaction. Non-Epic types REFUSE phase_children[] with 400. Status defaults to Review (no lifecycle timestamps stamped on create). parent_id optional. ac items take {title}; phase children inherit the new epic's id as parent_id.", {
+server.tool("issue_create", "Create a fresh card via POST /api/issues. Board-scoped; defaults to the dispatch's board. Pass `board` (a qualified id `<repo>:<slug>`) to create the card on another board (forwarded into body.board + ?board=; unknown board → 404). INVARIANT: type=Epic REQUIRES non-empty phase_children[] (epic-with-phases atomicity per DX-575) and the route atomically inserts the epic + every phase in ONE transaction. Non-Epic types REFUSE phase_children[] with 400. Status defaults to Review (no lifecycle timestamps stamped on create). parent_id optional. ac items take {title}; phase children inherit the new epic's id as parent_id.", {
     type: z.enum(ISSUE_TYPES),
     title: z.string().min(1),
     description: z.string(),
@@ -137,8 +155,8 @@ server.tool("issue_create", "Create a fresh card via POST /api/issues. Defaults
         effort_level: z.enum(EFFORT_VALUES).nullable().optional(),
     }))
         .optional(),
-    ...repoField,
-}, async (args) => jsonResult(await issueCreate(client, args, config.repo)));
+    ...boardField,
+}, async (args) => jsonResult(await issueCreate(client, args, config.board)));
 // ---------------- issue_edit ----------------
 server.tool("issue_edit", "Patch prose fields only via PATCH /api/issues/:id/edit. ALLOWED keys: title, description, ac, effort_level, parent_id. ANY OTHER KEY (lifecycle timestamps, triage state, dependencies, retro, requires_human, blocked/dispatch gates) returns 400 with offending_keys[] and a pointer to the dedicated semantic handler — use issue_transition / issue_triage / issue_comment / issue_dependency / issue_requires_human / issue_retro instead. AC replacement is wholesale soft-delete + reinsert with fresh ordinals; check_item_id linkage survives via title match.", {
     id: z.string().min(1),
@@ -152,7 +170,7 @@ server.tool("issue_edit", "Patch prose fields only via PATCH /api/issues/:id/edi
         .optional(),
     effort_level: z.enum(EFFORT_VALUES).nullable().optional(),
     parent_id: z.string().nullable().optional(),
-    ...repoField,
+    ...boardField,
 }, async (args) => jsonResult(await issueEdit(client, args)));
 // ---------------- issue_transition ----------------
 server.tool("issue_transition", "Stamp a lifecycle transition via POST /api/issues/:id/transition. **THIS IS THE ONLY WAY TO MOVE A CARD'S LIFECYCLE STATE** — DX-835 separated card lifecycle (this tool) from dispatch finalization (`mcp__danxbot__danxbot_complete`). The worker no longer infers card moves from `danxbot_complete.status`; agents that want the card to move MUST call this tool BEFORE calling `danxbot_complete`. Actions: ready (Review→ToDo), pickup (ToDo→In Progress — server checks every dispatch gate: ready_at, blocked_at, requires_human_reason, depends_on partners terminal, conflict_on partners idle; refuses 409 with failed_gate naming the cause; pass manual:true for OPERATOR-SESSION self-pickup — stamps dispatch_kind 'manual', bypasses every card-flow gate except terminal/deleted/already-dispatched, and the worker NEVER auto-transitions the card: no orphan-heal rollback, no Epic auto-rollup — use this whenever the work happens in YOUR current session rather than a worker dispatch, DX-946), rollback_pickup, **complete** (stamps completed_at — moves card to Done; this is YOUR explicit decision, not a side effect of danxbot_complete; REFUSES 409 on Epic if any phase child non-terminal — see non_terminal_phases[]), cancel (stamps cancelled_at — terminal), **block** (requires non-empty reason — stamps blocked_at + blocked_reason + clears dispatch; USE THIS when the CARD itself cannot proceed without human intervention; distinct from env-fault dispatch failures which use `danxbot_complete({status:'failed'})`), unblock, archive (parks to Backlog, clears ready_at), reopen (terminal→active, clears completed_at/cancelled_at/archived_at). Terminal cards refuse every action except reopen. Ladder timestamps preserved — forward stamps never clear earlier ones (CLAUDE.md Core Principle 2).", {
@@ -162,7 +180,7 @@ server.tool("issue_transition", "Stamp a lifecycle transition via POST /api/issu
     summary: z.string().optional(),
     dispatch_id: z.string().min(1).optional(),
     manual: z.boolean().optional(),
-    ...repoField,
+    ...boardField,
 }, async (args) => jsonResult(await issueTransition(client, args)));
 // ---------------- issue_triage ----------------
 server.tool("issue_triage", "Record a triage verdict via POST /api/issues/:id/triage. Verdicts: approve (stamps ready_at — moves to ToDo, clears triage TTL), cancel (stamps cancelled_at — terminal), keep (refreshes triage_expires_at by ttl_seconds — defaults 7 days, card stays at Review), defer (stamps archived_at, clears ready_at — parks to Backlog). ICE components optional but recorded when present (total = i+c+e). Reason is REQUIRED non-empty. REFUSES 409 on terminal cards.", {
@@ -177,7 +195,7 @@ server.tool("issue_triage", "Record a triage verdict via POST /api/issues/:id/tr
     })
         .optional(),
     ttl_seconds: z.number().positive().optional(),
-    ...repoField,
+    ...boardField,
 }, async (args) => jsonResult(await issueTriage(client, args)));
 // ---------------- issue_comment ----------------
 server.tool("issue_comment", "Comment CRUD via /api/issues/:id/comments[/:cid]. action=add → POST {text} (server stamps author from bearer + auto-incrementing ordinal); action=edit → PATCH /:cid {text}; action=delete → DELETE /:cid (soft-delete, audit trail preserved — comments are NEVER hard-deleted). Client-supplied author is IGNORED (server-stamped to prevent impersonation).", {
@@ -185,7 +203,7 @@ server.tool("issue_comment", "Comment CRUD via /api/issues/:id/comments[/:cid].
     action: z.enum(["add", "edit", "delete"]),
     comment_id: z.number().int().positive().optional(),
     text: z.string().min(1).optional(),
-    ...repoField,
+    ...boardField,
 }, async (args) => jsonResult(await issueComment(client, args)));
 // ---------------- issue_dependency ----------------
 server.tool("issue_dependency", "Dependency CRUD via /api/issues/:id/dependencies[/:did]. action=add → POST {kind, target_id, reason} where kind ∈ {depends_on, conflict_on}. depends_on adds are CYCLE-CHECKED (BFS from target back to source — 409 if loop). Idempotent: re-adding a live triple returns the existing id. Self-loops refuse 409. action=remove → DELETE /:did. The server REQUIRES the literal reason=\"recorded_in_error\" on removal (encodes \"removal means NOT related, never satisfied\") — this MCP boundary hardcodes it, so callers do not pass reason on remove.", {
@@ -195,7 +213,7 @@ server.tool("issue_dependency", "Dependency CRUD via /api/issues/:id/dependencie
     target_id: z.string().min(1).optional(),
     reason: z.string().optional(),
     dependency_id: z.number().int().positive().optional(),
-    ...repoField,
+    ...boardField,
 }, async (args) => jsonResult(await issueDependency(client, args)));
 // ---------------- issue_requires_human ----------------
 server.tool("issue_requires_human", "Set or clear the requires_human dispatch gate via /api/issues/:id/requires-human. set=true → POST {reason, steps[]} — sets requires_human_reason (the dispatch gate per DX-704 — poller refuses pickup while non-null), set_by from bearer, set_at NOW(), REPLACES the step rows (prior soft-deleted, fresh ordinals). set=false → DELETE — clears the columns and soft-deletes every live step. Terminal cards refuse 409 on set.", {
@@ -203,7 +221,7 @@ server.tool("issue_requires_human", "Set or clear the requires_human dispatch ga
     set: z.boolean(),
     reason: z.string().optional(),
     steps: z.array(z.string().min(1)).optional(),
-    ...repoField,
+    ...boardField,
 }, async (args) => jsonResult(await issueRequiresHuman(client, args)));
 // ---------------- issue_retro ----------------
 server.tool("issue_retro", "Replace the retro block via PUT /api/issues/:id/retro. Body: {good, bad, action_item_ids[], commits[]}. REFUSES 409 unless the card is terminal (completed_at OR cancelled_at) — retro ships when work concludes. Replace semantics: good/bad upsert; action_item_ids[] + commits[] soft-delete prior live rows and insert with fresh ordinals. action_item_ids[] entries MUST match <PREFIX>-N. commits[] entries take {sha, subject?}.", {
@@ -215,13 +233,13 @@ server.tool("issue_retro", "Replace the retro block via PUT /api/issues/:id/retr
         sha: z.string().min(1),
         subject: z.string().optional(),
     })),
-    ...repoField,
+    ...boardField,
 }, async (args) => jsonResult(await issueRetro(client, args)));
 // ---------------- main ----------------
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`danx-dashboard-mcp running on stdio (dashboard=${config.baseUrl}, repo=${config.repo})`);
+    console.error(`danx-dashboard-mcp running on stdio (dashboard=${config.baseUrl}, board=${config.board})`);
 }
 main().catch((err) => {
     console.error(`[danx-dashboard-mcp] fatal: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-dashboard-mcp",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Stdio MCP server wrapping danxbot's dashboard /api/issues/* normalized DB-backed HTTP routes for dispatched agents (DX-704 Phase 2).",
   "license": "MIT",
   "type": "module",