@thehammer/danx-dashboard-mcp 0.1.156 → 0.1.158

package/dist/field-tree.js

@@ -1,17 +1,19 @@
 /**
  * DX-3426 — the shared recursive FIELD-TREE shape.
  *
- * The dashboard's single-card and batch card reads (`issue_get` today;
- * `issue_list` / `plan_get` in later cards, per DX-3426's own follow-up scope)
- * take a nested JSON tree instead of a flat field-GROUP list: each key names a
- * field or relation of the resource at that level, and each value is either
- * `true` (the field, or a relation's child with its default fields), a
- * non-negative integer (a cursor-paged relation's own page ARGUMENT — e.g.
- * `{"comments": {"limit": 10, "before": 812}}`, where `limit`/`before` are
- * themselves plain integer values inside the nested object), or another
+ * The dashboard's single-card, batch card and plan reads (`issue_get`,
+ * `issue_list`, `plan_get` — DX-3428) take a nested JSON tree instead of a
+ * flat field-GROUP list: each key names a field or relation of the resource
+ * at that level, and each value is either `true` (the field, or a relation's
+ * child with its default fields), a non-negative integer (a cursor-paged
+ * relation's own `limit` argument), an opaque cursor STRING (a paged
+ * relation's `before` — DX-3428: not every relation's cursor is a plain
+ * integer, e.g. a plan event's visibility-scanned row id), a non-empty
+ * STRING or ARRAY OF STRINGS (a relation's own declared, non-paging argument
+ * — e.g. `records`' `kind`, `events`' `kinds`/`origin`/`writer`), or another
  * field tree (a relation's child with a NAMED field selection). Example:
  *
- *   {"description": true, "ac": true, "problems": {"solutions": {"steps": true}, "decisions": true}, "comments": {"limit": 10}}
+ *   {"description": true, "ac": true, "problems": {"solutions": {"steps": true}, "decisions": true}, "comments": {"limit": 10}, "records": {"kind": "goal"}}
  *
  * One schema, one module — every tool that accepts a field tree imports THIS
  * export rather than redeclaring the shape, so the recursion is defined once
@@ -28,8 +30,15 @@
 import { z } from "zod";
 /**
  * The shared schema. A record whose values are `true`, a non-negative
- * integer, or the same schema recursively — generic on purpose (no
- * issue-specific field names baked in here) so `issue_list` / `plan_get` can
- * reuse it unchanged in their own later cards.
+ * integer, a non-empty string, a non-empty array of non-empty strings, or
+ * the same schema recursively — generic on purpose (no issue/plan-specific
+ * field names baked in here) so every tool that reads a resource tree
+ * reuses it unchanged.
  */
-export const fieldTreeSchema = z.lazy(() => z.record(z.union([z.literal(true), z.number().int().nonnegative(), fieldTreeSchema])));
+export const fieldTreeSchema = z.lazy(() => z.record(z.union([
+    z.literal(true),
+    z.number().int().nonnegative(),
+    z.string().min(1),
+    z.array(z.string().min(1)).min(1),
+    fieldTreeSchema,
+])));

package/dist/handlers.js

@@ -65,21 +65,6 @@ export const ISSUE_BATCH_GET_MAX = 100;
  * `__tests__/handlers.test.ts` asserts the two agree.
  */
 export const LIST_PAGE_MAX_LIMIT = 1000;
-/**
- * `plan_get`'s `cards_limit` when omitted — mirrors the server's
- * `src/issues/list-page.ts#PLAN_GET_CARDS_DEFAULT_LIMIT`;
- * `__tests__/handlers.test.ts` asserts the two agree.
- */
-export const PLAN_GET_CARDS_DEFAULT_LIMIT = 200;
-/**
- * DX-3027 — `plan_get`'s `events_limit` default/max — mirrors the server's
- * `src/issues/plans-routes.ts#PLAN_GET_EVENTS_DEFAULT_LIMIT` /
- * `PLAN_GET_EVENTS_MAX_LIMIT`. Deliberately smaller than `LIST_PAGE_MAX_LIMIT`
- * above — an event page is read far more often, and a wide page defeats the
- * point of a cursor. `__tests__/handlers.test.ts` asserts the two agree.
- */
-export const PLAN_GET_EVENTS_DEFAULT_LIMIT = 50;
-export const PLAN_GET_EVENTS_MAX_LIMIT = 200;
 /**
  * Fetch one card via `GET /api/issues/:id`, or many via
  * `GET /api/issues/batch?ids=...` (DX-2727) — a real batch read that keeps
@@ -1024,32 +1009,17 @@ export async function issueAttach(client, args, deps = {}) {
 const PLANS_BASE_PATH = "/api/plans";
 const PLAN_SESSIONS_BASE_PATH = "/api/plan-sessions";
 /**
- * DX-2727 — the plan_get field-group taxonomy: the ONE copy in this package
- * (the `plan_get` zod enum in `index.ts` reads this const, and the type is
- * derived from it). The published package cannot import server source at
- * runtime, so it stays a literal; `__tests__/handlers.test.ts` imports the
- * server's `src/issues/plan-field-groups.ts#PLAN_FIELD_GROUPS` and asserts
- * the two are equal, so drift fails a test rather than a live call.
- * `records` is the union of every kind; `records:<kind>` narrows to one.
- */
-export const PLAN_FIELD_GROUPS = [
-    "cards",
-    "records",
-    "records:goal",
-    "records:rule",
-    "records:caveat",
-    "architecture",
-    "sessions",
-    "notes",
-    "events",
-];
-/**
- * DX-3027 — every kind `plan_get`'s `events_kinds` filter accepts. The ONE
- * copy in this package (the `plan_get` zod enum in `index.ts` reads this
- * const), duplicated from the server's `src/issues/db/plan-events.ts#PLAN_EVENT_KINDS`
- * because the published package cannot import server source at runtime.
- * `__tests__/handlers.test.ts` asserts the two are equal, so drift fails a
- * test rather than a live call.
+ * DX-3428 — every kind the plan resource's `events` relation accepts as a
+ * `kinds` filter (`{"events": {"kinds": [...]}}`). The ONE copy in this
+ * package (the `resource_fields`-describable `events` relation validates the
+ * same set server-side), duplicated from the server's
+ * `src/issues/db/plan-events.ts#PLAN_EVENT_KINDS` because the published
+ * package cannot import server source at runtime — kept here purely for a
+ * CONSUMER'S typed convenience (`PlanEventKind`); the MCP tool schema itself
+ * no longer enumerates it (DX-3428 moved `plan_get` onto the generic,
+ * resource-agnostic `fieldTreeSchema` every field-tree tool shares — see
+ * `field-tree.ts`). `__tests__/handlers.test.ts` asserts the two are equal,
+ * so drift fails a test rather than a live call.
  */
 export const PLAN_EVENT_KINDS = [
     "comment_added",
@@ -1087,10 +1057,11 @@ export const PLAN_EVENT_KINDS = [
     "plan_auto_sign_off_changed",
 ];
 /**
- * DX-3027 — every origin `plan_get`'s `events_origin` filter accepts.
+ * DX-3428 — every origin the `events` relation's `origin` filter accepts.
  * Mirrors the server's `src/issues/db/plan-events.ts#PlanEventOrigin`
  * (itself `ActivityOrigin`) — same drift protection as `PLAN_EVENT_KINDS`
- * above.
+ * above, and likewise kept only for a consumer's typed convenience (not read
+ * by the MCP tool schema any more).
  */
 export const PLAN_EVENT_ORIGINS = ["operator", "agent", "machine"];
 /**
@@ -1113,31 +1084,19 @@ export async function planList(client, args = {}) {
 }
 /**
  * One plan — its cheap scalars by default, or opt into its cards, its goals
- * + rules + caveats, its architecture sections, and the sessions working on
- * it via `fields` (DX-2727). One call rather than several, which is what
- * keeps this tool surface small enough to be worth an agent's context even
- * once every part of a plan is opt-in rather than always-on.
+ * + rules + caveats, its architecture sections, its sessions and its event
+ * ledger via a field TREE (DX-3428, replacing the retired flat field-GROUP
+ * list). One call rather than several, which is what keeps this tool
+ * surface small enough to be worth an agent's context even once every part
+ * of a plan is opt-in rather than always-on.
  */
 export async function planGet(client, args = {}) {
     const query = {};
-    if (args.fields !== undefined && args.fields.length > 0) {
-        query.fields = args.fields.join(",");
-    }
-    if (args.cards_offset !== undefined)
-        query.cards_offset = args.cards_offset;
-    if (args.cards_limit !== undefined)
-        query.cards_limit = args.cards_limit;
-    if (args.events_limit !== undefined)
-        query.events_limit = args.events_limit;
-    if (args.events_before !== undefined)
-        query.events_before = args.events_before;
-    if (args.events_kinds !== undefined && args.events_kinds.length > 0) {
-        query.events_kinds = args.events_kinds.join(",");
+    // DX-3428 — the tree travels as ONE JSON-encoded query param, exactly like
+    // `issue_get`/`issue_list`'s own `fields` (see `issueGet` above).
+    if (args.fields !== undefined && Object.keys(args.fields).length > 0) {
+        query.fields = JSON.stringify(args.fields);
     }
-    if (args.events_origin !== undefined)
-        query.events_origin = args.events_origin;
-    if (args.events_writer !== undefined)
-        query.events_writer = args.events_writer;
     return client.request({
         method: "GET",
         path: args.plan_id === undefined ? "/mine" : `/${args.plan_id}/full`,

package/dist/http-client.js

@@ -1,6 +1,10 @@
+import { assertVersionFloorSatisfied, MCP_MIN_VERSION_HEADER } from "./version-floor.js";
 export class DashboardHttpClient {
     config;
     fetchImpl;
+    // DX-3597 — true once this instance has made ONE request, regardless of
+    // outcome. Drives the "first call OR any 4xx" version-floor check below.
+    hasCheckedVersionFloor = false;
     constructor(config, fetchImpl = fetch) {
         this.config = config;
         this.fetchImpl = fetchImpl;
@@ -50,6 +54,18 @@ export class DashboardHttpClient {
         catch (err) {
             throw new Error(`[danx-dashboard-mcp] network failure on ${args.method} ${url}: ${err instanceof Error ? err.message : String(err)}`);
         }
+        // DX-3597 — proactive on the first call this instance ever makes
+        // (regardless of outcome: a stale client can otherwise look fine for a
+        // while on routes whose shape didn't change), and on every subsequent
+        // 4xx (a response that might otherwise read as an ordinary caller
+        // error when it's really "you're running an old MCP"). Throws
+        // McpOutdatedError instead of returning below when this package is
+        // behind the floor — see version-floor.ts's own doc.
+        const isFirstCall = !this.hasCheckedVersionFloor;
+        this.hasCheckedVersionFloor = true;
+        if (isFirstCall || (res.status >= 400 && res.status < 500)) {
+            assertVersionFloorSatisfied(res.headers.get(MCP_MIN_VERSION_HEADER));
+        }
         const text = await res.text();
         let parsed = null;
         if (text !== "") {

package/dist/index.js

@@ -108,7 +108,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { DashboardHttpClient } from "./http-client.js";
-import { issueAttach, issueChecklist, issueComment, issueCreate, issueDependency, issueEdit, issueGet, issueList, issueProblem, issueQualityGate, issueQualityGateVerdict, issueRetireBranch, issueRetro, issueSolution, issueTransition, issueTriage, briefGetPage, briefList, briefSetPage, failureCategoryCreate, failureCategoryList, failureCategoryUpdate, dispatchTranscriptSearch, planAddArchitectureSection, planAddCard, planAddNote, planAddRecord, planConnect, planCreate, planDeleteArchitectureSection, planDeleteNote, planDeleteRecord, planGet, PLAN_FIELD_GROUPS, PLAN_EVENT_KINDS, PLAN_EVENT_ORIGINS, PLAN_STATUSES, ISSUE_BATCH_GET_MAX, LIST_PAGE_MAX_LIMIT, PLAN_GET_CARDS_DEFAULT_LIMIT, PLAN_GET_EVENTS_DEFAULT_LIMIT, PLAN_GET_EVENTS_MAX_LIMIT, planGetArchitectureSection, planGetRecord, planList, planRemoveCard, planRename, planReorderArchitectureSection, planUpdateArchitectureSection, planUpdateNote, planUpdateRecord, qualityGateInstruction, resourceFields, } from "./handlers.js";
+import { issueAttach, issueChecklist, issueComment, issueCreate, issueDependency, issueEdit, issueGet, issueList, issueProblem, issueQualityGate, issueQualityGateVerdict, issueRetireBranch, issueRetro, issueSolution, issueTransition, issueTriage, briefGetPage, briefList, briefSetPage, failureCategoryCreate, failureCategoryList, failureCategoryUpdate, dispatchTranscriptSearch, planAddArchitectureSection, planAddCard, planAddNote, planAddRecord, planConnect, planCreate, planDeleteArchitectureSection, planDeleteNote, planDeleteRecord, planGet, PLAN_STATUSES, ISSUE_BATCH_GET_MAX, LIST_PAGE_MAX_LIMIT, planGetArchitectureSection, planGetRecord, planList, planRemoveCard, planRename, planReorderArchitectureSection, planUpdateArchitectureSection, planUpdateNote, planUpdateRecord, qualityGateInstruction, resourceFields, } from "./handlers.js";
 import { PRIORITY_TIER_WORDS } from "./priority.js";
 import { fieldTreeSchema } from "./field-tree.js";
 function readEnvOrDie(name) {
@@ -915,62 +915,29 @@ strictTool("plan_list", "List every plan, and learn which plan THIS session is c
         .optional()
         .describe("Filter to one computed status: awaiting-session, planning, building, awaiting-sign-off, complete. Omit for every plan."),
 }, async (args) => jsonResult(await planList(client, args)));
-strictTool("plan_get", "Read a plan. Pass `plan_id` to read ANY plan; OMIT to read the plan this session is connected to — omitting while connected to none fails loud `{error: \"session_not_connected\"}`, connect first. A BARE call (no `fields`) returns ONLY the plan's cheap scalars: `{plan, boards, cardCount, bucketCounts, status, session, sessionListenerAttached, available_field_groups}` — no cards, records, or architecture body. `plan` carries `{id, ref, name, createdAt}`; `ref` is the plan's short reference (`PLN-<id>`) — cite that, not the bare id. `status` is computed fresh on every read, never stored — see `plan_list` for the four values and what each means. Pass `fields` to opt into: `cards` (member cards, paged via `cards_offset`/`cards_limit` — see their own field descriptions — in stable card-reference order: board prefix then card number, pages never repeat/skip unless membership changes between reads; response carries `cards_total`), `records` (every goal+rule+caveat, keyed by kind) or `records:goal` / `records:rule` / `records:caveat` (one kind, cheaper), `architecture` (`{sections: [{id, planId, contentHash, title, content, sortOrder, createdAt, updatedAt}]}`), `sessions` (every session connected to the plan), `events` (the plan's durable event ledger — every human action and bridge message, paged/filtered via `events_limit`/`events_before`/`events_kinds`/`events_origin`/`events_writer` — see their own field descriptions; response carries `events: {items: [{id, at, kind, writer, origin, originSessionId, targetSessionId, cardId, cardTitle, boardId, detail}], next_cursor}`, `next_cursor` null on the last page; an event on a card whose board you cannot read is left out, plan-level events are always visible). `session`/`sessionListenerAttached` and `available_field_groups` ride every response regardless. `sessionListenerAttached` is `false` for a few seconds right after `plan_connect` while the plugin's event bridge starts; still `false` after that while connected means the plan's card events are not reaching you — tell the operator. ALWAYS `plan_get`/`plan_get_architecture_section` immediately before `plan_update_architecture_section`/`plan_delete_architecture_section` and pass the returned `contentHash` back as `base_hash`.", {
+strictTool("plan_get", 
+// DX-3428 — the retired flat field-GROUP list (`cards`, `records:<kind>`,
+// `cards_offset`/`cards_limit`, `events_*`) is replaced by a JSON field
+// TREE against the plan resource — the SAME `fieldTreeSchema` `issue_get`/
+// `issue_list` already take (`./field-tree.ts`). Every former query param
+// now lives INSIDE the tree as a relation argument.
+"Read a plan. Pass `plan_id` to read ANY plan; OMIT to read the plan this session is connected to — omitting while connected to none fails loud `{error: \"session_not_connected\"}`, connect first. A BARE call (no `fields`) returns ONLY the plan's cheap scalars: `{id, ref, name, created_at, signed_off_at, signed_off_by, auto_sign_off, boards, card_count, bucket_counts, status, session, sessionListenerAttached}` — no cards, records, or architecture body. `ref` is the plan's short reference (`PLN-<id>`) — cite that, not the bare id. `status` is computed fresh on every read, never stored — see `plan_list` for the four values and what each means. Pass a `fields` tree to opt into: `cards` (member cards — the ISSUE resource itself, so any of `issue_get`'s own fields/relations may be nested under it, e.g. `{\"cards\": {\"title\": true, \"status\": true}}`; cursor-paged via `{\"limit\": N, \"before\": \"<cursor>\"}`, response carries a sibling `cards_page: {limit, total, next_cursor}`), `records` (every goal+rule+caveat) or `{\"records\": {\"kind\": \"goal\"}}` / `{\"kind\": [\"goal\",\"rule\"]}` (narrow to one or more kinds, cheaper), `architecture_sections` (`[{id, plan_id, content_hash, title, content, sort_order, created_at, updated_at}]`), `sessions` (every session connected to the plan), `notes` (the latest milestone-timeline page), `events` (the plan's durable event ledger — every human action and bridge message; cursor-paged via `{\"limit\": N, \"before\": \"<cursor>\"}` plus the filter args `{\"kinds\": [...], \"origin\": \"...\", \"writer\": \"...\"}`; response carries `events` rows plus a sibling `events_page: {limit, total, next_cursor}`; `next_cursor` null on the last page; an event on a card whose board you cannot read is left out, plan-level events are always visible). Call `resource_fields({resource:\"plan\"})` for the full, current list of what a tree may name — never guess a name; unknown → 400 `unknown_field`. `session`/`sessionListenerAttached` ride every response regardless (not part of the tree — they describe YOUR session, not the plan). `sessionListenerAttached` is `false` for a few seconds right after `plan_connect` while the plugin's event bridge starts; still `false` after that while connected means the plan's card events are not reaching you — tell the operator. ALWAYS `plan_get`/`plan_get_architecture_section` immediately before `plan_update_architecture_section`/`plan_delete_architecture_section` and pass the returned `content_hash`/`contentHash` back as `base_hash`.", {
     plan_id: z
         .number()
         .int()
         .positive()
         .optional()
         .describe("A plan id from `plan_list`. Omit to read the plan this session is connected to."),
-    fields: z
-        .array(z.enum(PLAN_FIELD_GROUPS))
-        .optional()
-        .describe("Opt-in field-GROUPS: cards, records (every kind) or records:goal/records:rule/records:caveat (one kind), architecture, sessions, notes, events. Absent/empty = cheap scalars only (plan, boards, cardCount, bucketCounts) plus session state."),
-    cards_offset: z
-        .number()
-        .int()
-        .nonnegative()
-        .optional()
-        .describe("Where the `cards` page starts (default 0). Requires `fields:[\"cards\"]`. Page with cards_offset while cards_offset + cards.length < cards_total."),
-    cards_limit: z
-        .number()
-        .int()
-        .positive()
-        .max(LIST_PAGE_MAX_LIMIT)
-        .optional()
-        .describe("How many cards one page holds, 1.." + LIST_PAGE_MAX_LIMIT + " (default " + PLAN_GET_CARDS_DEFAULT_LIMIT + "). Requires `fields:[\"cards\"]`."),
-    events_limit: z
-        .number()
-        .int()
-        .positive()
-        .max(PLAN_GET_EVENTS_MAX_LIMIT)
-        .optional()
-        .describe("how many ledger events one page holds, 1.." + PLAN_GET_EVENTS_MAX_LIMIT + " (default " + PLAN_GET_EVENTS_DEFAULT_LIMIT + "). Requires `fields` to include `events`."),
-    events_before: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("an opaque cursor from a previous page's `next_cursor`. Omit for the newest page. Requires `fields` to include `events`."),
-    events_kinds: z
-        .array(z.enum(PLAN_EVENT_KINDS))
-        .optional()
-        .describe("only these event kinds. Omit for every kind. Requires `fields` to include `events`."),
-    events_origin: z
-        .enum(PLAN_EVENT_ORIGINS)
-        .optional()
-        .describe("only events with this origin. Omit for every origin. Requires `fields` to include `events`."),
-    events_writer: z
-        .string()
-        .min(1)
+    fields: fieldTreeSchema
         .optional()
-        .describe("only events with this exact writer name. Omit for every writer. Requires `fields` to include `events`."),
+        .describe("A field tree (see tool description); absent/empty = cheap scalars only. `resource_fields({resource:\"plan\"})` names every valid key."),
 }, async (args) => jsonResult(await planGet(client, args)));
 strictTool("plan_create", "Create a new, empty plan. Global — not board-scoped. Adds no cards, records, or architecture sections, and does not connect any session (call `plan_connect` separately). Returns `{plan: {id, ref, name, createdAt}}` — `ref` is the short reference (`PLN-<id>`). Use `plan.id` with `plan_connect` to start working on it, or `plan_get({plan_id})` to browse.", {
     name: z.string().min(1).describe("The plan's name — shown in the Plans list."),
 }, async (args) => jsonResult(await planCreate(client, args)));
 strictTool("plan_connect", 
 // DX-2735: trimmed with the problem tools to stay inside the work-profile budget.
-"Connect THIS session to a plan. ONE CALL IS ENOUGH TO START: the reply carries `{session, movedFrom, browserInstruction, briefing, listenerHealth}` — `browserInstruction` is a server-built action to take NOW: it names the plan's URL and tells you to open it (in-app browser if you have one, else default), keep that tab open for the whole session without navigating it away, and use a different tab for your own browsing — the operator's tab for following and talking to you. Returned on every connect, including a re-connect, so it doubles as the post-context-loss reminder. `briefing` is every goal/rule/caveat (ref+body), every architecture section (id+title), the plan's own ref/name/status, a first page of open cards (id/type/status/title/openProblemCount/assignedAgent) with a `morePagesHint` when more exist, and the closed-card count — usually replacing the `plan_get({fields:[...]})` + card batch-read a fresh session used to need. A session is on AT MOST ONE plan: connecting elsewhere MOVES it, and `movedFrom: {id, name} | null` says which plan it left (null = no plan, or already this one). Binds only your OWN session, resolved from the session id this server forwards; afterwards every plan WRITE tool acts on this plan and takes no plan id. `listenerHealth` reports the event bridge's state — `null` (no session), or `{attached, state: \"unattached\"|\"credential_mismatch\"|\"healthy\", nextStep}` naming a concrete fix per unhealthy state (same shape `plan_list`/`plan_get` report). Once healthy, every comment, answer, problem added and block/unblock on this plan's cards reaches the session unpolled, relayed by the plugin's event bridge as a line like `[DX-8 \"Title\" repo:board] newms87 answered \"<statement>\": chose \"Pause E2E\"`. Pass `title` (call `get_session({session_id:\"self\"})` first and forward its `title` verbatim) so the dashboard shows the same name Claude does — this server cannot read it itself.", {
+"Connect THIS session to a plan. ONE CALL IS ENOUGH TO START: the reply carries `{session, movedFrom, browserInstruction, briefing, listenerHealth}` — `browserInstruction` is a server-built action to take NOW: it names the plan's URL and tells you to open it (in-app browser if you have one, else default), keep that tab open for the whole session without navigating it away, and use a different tab for your own browsing — the operator's tab for following and talking to you. Returned on every connect, including a re-connect, so it doubles as the post-context-loss reminder. `briefing` is every goal/rule/caveat (ref+body), every architecture section (id+title), the plan's own ref/name/status, a first page of open cards (id/type/status/title/openProblemCount/assignedAgent) with a `morePagesHint` when more exist, and the closed-card count — usually replacing the `plan_get({fields: {...}})` + card batch-read a fresh session used to need. A session is on AT MOST ONE plan: connecting elsewhere MOVES it, and `movedFrom: {id, name} | null` says which plan it left (null = no plan, or already this one). Binds only your OWN session, resolved from the session id this server forwards; afterwards every plan WRITE tool acts on this plan and takes no plan id. `listenerHealth` reports the event bridge's state — `null` (no session), or `{attached, state: \"unattached\"|\"credential_mismatch\"|\"healthy\", nextStep}` naming a concrete fix per unhealthy state (same shape `plan_list`/`plan_get` report). Once healthy, every comment, answer, problem added and block/unblock on this plan's cards reaches the session unpolled, relayed by the plugin's event bridge as a line like `[DX-8 \"Title\" repo:board] newms87 answered \"<statement>\": chose \"Pause E2E\"`. Pass `title` (call `get_session({session_id:\"self\"})` first and forward its `title` verbatim) so the dashboard shows the same name Claude does — this server cannot read it itself.", {
     plan_id: z.number().int().positive().describe("The plan id, from `plan_list`."),
     title: z
         .string()
@@ -994,7 +961,7 @@ async (args) => {
         }),
     });
 });
-strictTool("plan_add_record", "Add a goal, rule or caveat to your connected plan (see `kind`'s own values below for what each means — never progress/status/session notes, those are card comments). `body` is one plain statement, at most 250 characters (400 if longer); detail goes in markdown `context`. Allocates a permanent reference (`G-1`, `R-4`, `CAV-12`). Takes no plan id; not connected → `plan_connect` first. Returns the created record plus `records_count` (that kind's live count, not the whole list) — read the list with `plan_get({fields:[\"records:<kind>\"]})`.", {
+strictTool("plan_add_record", "Add a goal, rule or caveat to your connected plan (see `kind`'s own values below for what each means — never progress/status/session notes, those are card comments). `body` is one plain statement, at most 250 characters (400 if longer); detail goes in markdown `context`. Allocates a permanent reference (`G-1`, `R-4`, `CAV-12`). Takes no plan id; not connected → `plan_connect` first. Returns the created record plus `records_count` (that kind's live count, not the whole list) — read the list with `plan_get({fields: {records: {kind: \"<kind>\"}}})`.", {
     kind: z.enum(["goal", "rule", "caveat"]).describe("goal = outcome, rule = constraint, caveat = architecture trade-off."),
     body: z.string().min(1).describe("One plain statement, at most 250 characters. Details go in `context`."),
     context: z.string().optional().describe("Markdown detail behind the statement: evidence, history, examples."),
@@ -1016,7 +983,7 @@ strictTool("plan_delete_record", 'Soft-delete a goal/rule/caveat; its reference
     record_id: z.number().int().positive().describe("The record id to delete."),
     content_hash: z.string().describe("The record's `contentHash` from your last read. Required."),
 }, async (args) => jsonResult(await planDeleteRecord(client, args)));
-strictTool("plan_add_note", "Write a milestone note to a plan's timeline — a MILESTONE, not a log: use for a card (or group) finishing, an important decision, or a meaningful goal/rule/caveat/architecture change; routine progress stays a card comment. Terse: `title` at most 60 characters, `body` at most 250 (400 if too long, naming the limit). Links resolve on read into their target (a card's title, a record's ref+body, a section's title); an unknown card, unparseable/foreign record ref, or unknown/foreign section id is refused 400 naming which one. A card link needn't be a plan member; a record/section link must belong to THIS plan. `author` is stamped server-side. Takes an explicit `plan_id` (like `plan_remove_card`/`plan_rename`) so a dispatched worker with no plan connection can still write. Unknown plan → 404. Returns the new note plus `notes_count` (the plan's total live count, not the latest page) — read the timeline with `plan_get({fields:[\"notes\"]})`.", {
+strictTool("plan_add_note", "Write a milestone note to a plan's timeline — a MILESTONE, not a log: use for a card (or group) finishing, an important decision, or a meaningful goal/rule/caveat/architecture change; routine progress stays a card comment. Terse: `title` at most 60 characters, `body` at most 250 (400 if too long, naming the limit). Links resolve on read into their target (a card's title, a record's ref+body, a section's title); an unknown card, unparseable/foreign record ref, or unknown/foreign section id is refused 400 naming which one. A card link needn't be a plan member; a record/section link must belong to THIS plan. `author` is stamped server-side. Takes an explicit `plan_id` (like `plan_remove_card`/`plan_rename`) so a dispatched worker with no plan connection can still write. Unknown plan → 404. Returns the new note plus `notes_count` (the plan's total live count, not the latest page) — read the timeline with `plan_get({fields: {notes: true}})`.", {
     plan_id: z.number().int().positive().describe("The plan id, from `plan_list`."),
     title: z.string().min(1).describe("At most 60 characters."),
     body: z.string().min(1).describe("The wrap-up, at most 250 characters."),
@@ -1042,7 +1009,7 @@ strictTool("plan_delete_note", 'Soft-delete a plan note. `content_hash` must be
     note_id: z.number().int().positive().describe("The note id to delete."),
     content_hash: z.string().describe("The note's `contentHash` from your last read. Required."),
 }, async (args) => jsonResult(await planDeleteNote(client, args)));
-strictTool("plan_add_card", "Add an existing card, from ANY board, to the plan this session is connected to. Idempotent (re-adding is a no-op; a card may sit in several plans). Adds MEMBERSHIP only, never edits the card. Takes no plan id — resolved from your connected session. Not connected → `{error: \"session_not_connected\"}`. Unknown card → 404. Returns `{card_id, member: true, cards_count}` (the plan's total member-card count, not the full list — a plan can hold hundreds; read it with `plan_get({fields:[\"cards\"]})`, paged).", {
+strictTool("plan_add_card", "Add an existing card, from ANY board, to the plan this session is connected to. Idempotent (re-adding is a no-op; a card may sit in several plans). Adds MEMBERSHIP only, never edits the card. Takes no plan id — resolved from your connected session. Not connected → `{error: \"session_not_connected\"}`. Unknown card → 404. Returns `{card_id, member: true, cards_count}` (the plan's total member-card count, not the full list — a plan can hold hundreds; read it with `plan_get({fields: {cards: true}})`, cursor-paged).", {
     card_id: z.string().min(1).describe("An existing card id, e.g. `DX-2683`."),
 }, async (args) => jsonResult(await planAddCard(client, args)));
 strictTool("plan_remove_card", "Remove a card from a plan — sibling of `plan_add_card`, any board. Idempotent (removing a non-member is a no-op). Removes MEMBERSHIP only — never touches the card itself or its membership in other plans. Unlike `plan_add_card`, takes an EXPLICIT `plan_id` — you may remove from any plan you can name. Unknown plan → 404. Returns `{card_id, member: false, cards_count}` (see `plan_add_card`).", {

package/dist/version-floor.js

@@ -0,0 +1,128 @@
+/**
+ * DX-3597 — this package's half of the MCP-version-floor guard whose
+ * server-side half shipped in DX-3525 (`src/mcp-contract.ts`,
+ * `src/dashboard/serve-request.ts`, `src/resources/field-tree.ts`, all in
+ * the main danxbot repo — this package cannot import them, see below).
+ *
+ * The dashboard stamps `X-Danx-Mcp-Min-Version` on every routed `/api/*`
+ * response with its currently-advertised floor (`MIN_MCP_VERSION` in
+ * `src/mcp-contract.ts` — DX-3597 made that floor track the version where
+ * an MCP-exposed contract last changed, not "whatever's currently
+ * published"; see that file's module doc for the full decision).
+ *
+ * `DashboardHttpClient.request()` (`./http-client.ts`) reads this header on
+ * the FIRST call this process makes (regardless of outcome — a proactive
+ * check, since a stale client can otherwise appear to work for a while on
+ * routes whose shape didn't change) and on every subsequent 4xx (a response
+ * that might otherwise read as an ordinary caller error, when it's really
+ * "you're running an old MCP"). When this package's own version is behind
+ * the advertised floor, it throws `McpOutdatedError` instead of returning
+ * the ordinary envelope — the same "throw rather than fabricate/silently
+ * pass through" contract `http-client.ts` already applies to a 5xx/network
+ * failure (see that file's own doc): an outdated MCP is exactly that class
+ * of failure, nothing the calling tool can meaningfully work around.
+ *
+ * Everything here is duplicated, not imported, from the server's
+ * `src/mcp-contract.ts` — this package is an INDEPENDENTLY PUBLISHED npm
+ * artifact (DX-2103) and cannot depend on the danxbot service's own `src/`
+ * tree. Keep the header name, the package name, and the version-compare
+ * behavior in agreement with that file by hand when either changes.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Must match `MCP_MIN_VERSION_HEADER` in danxbot's `src/mcp-contract.ts` verbatim. */
+export const MCP_MIN_VERSION_HEADER = "X-Danx-Mcp-Min-Version";
+/** Must match `MCP_PACKAGE_NAME` in danxbot's `src/mcp-contract.ts` verbatim. */
+export const MCP_PACKAGE_NAME = "@thehammer/danx-dashboard-mcp";
+/**
+ * Numeric-dotted version compare (major.minor.patch, ...) — mirrors
+ * `compareMcpVersions` in danxbot's `src/mcp-contract.ts` behavior
+ * byte-for-byte (duplicated, not imported — see module doc). Both sides of
+ * this contract have only ever used plain numeric dotted versions, so this
+ * throws rather than silently falling back to a lexical compare, which
+ * would misorder "0.1.9" vs "0.1.10".
+ */
+export function compareMcpVersions(a, b) {
+    const parse = (v) => {
+        if (!/^\d+(\.\d+)*$/.test(v)) {
+            throw new Error(`[danx-dashboard-mcp] "${v}" is not a plain numeric dotted version (major.minor.patch)`);
+        }
+        return v.split(".").map(Number);
+    };
+    const pa = parse(a);
+    const pb = parse(b);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const da = pa[i] ?? 0;
+        const db = pb[i] ?? 0;
+        if (da !== db)
+            return da - db;
+    }
+    return 0;
+}
+let cachedOwnVersion;
+/**
+ * Reads this package's OWN version from its `package.json` — always present
+ * next to `dist/` (or `src/`, under `npm run dev`'s `tsx`) at runtime even
+ * though `files: ["dist","README.md"]` excludes it from the tarball
+ * MANIFEST: npm always includes `package.json` in what it publishes and
+ * what it installs, regardless of `files` (the same guarantee `README` /
+ * `LICENSE` / the `main` entry get) — this reads the copy npm actually
+ * installed next to this module, not danxbot's own source tree. Both
+ * `dist/version-floor.js` and `src/version-floor.ts` sit exactly one
+ * directory below the package root, so `../package.json` resolves
+ * correctly under both the published (dist) and dev (`tsx src/index.ts`)
+ * shapes. Memoized — the version cannot change mid-process.
+ */
+export function readOwnVersion() {
+    if (cachedOwnVersion !== undefined)
+        return cachedOwnVersion;
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkgJsonPath = join(here, "..", "package.json");
+    const raw = readFileSync(pkgJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.version !== "string") {
+        throw new Error(`[danx-dashboard-mcp] could not read this package's own version from ${pkgJsonPath}`);
+    }
+    cachedOwnVersion = parsed.version;
+    return cachedOwnVersion;
+}
+/** Test-only escape hatch — real callers never need to override the memoized read. */
+export function __resetOwnVersionCacheForTests() {
+    cachedOwnVersion = undefined;
+}
+/**
+ * Thrown by `assertVersionFloorSatisfied` when this package is running
+ * behind the server's advertised floor. Carries structured `have`/`need`
+ * fields (not just a prose message) so a caller that wants to branch on
+ * "is this specifically an outdated-MCP failure" can check `error.code`
+ * rather than pattern-match the message text.
+ */
+export class McpOutdatedError extends Error {
+    code = "mcp_outdated";
+    have;
+    need;
+    constructor(have, need) {
+        super(`[danx-dashboard-mcp] mcp_outdated: this MCP is running ${MCP_PACKAGE_NAME}@${have}, but the dashboard ` +
+            `requires >= ${need}. Restart your Claude Code session to pick up the published update.`);
+        this.name = "McpOutdatedError";
+        this.have = have;
+        this.need = need;
+    }
+}
+/**
+ * Compares this package's own version against the floor a response header
+ * advertised. No-ops (returns) when compatible, or when `headerValue` is
+ * `null`/empty (an old-enough server, or a test stub, that never stamped
+ * one — nothing to compare against). Throws `McpOutdatedError` when this
+ * package is behind.
+ */
+export function assertVersionFloorSatisfied(headerValue) {
+    if (!headerValue)
+        return;
+    const have = readOwnVersion();
+    if (compareMcpVersions(have, headerValue) < 0) {
+        throw new McpOutdatedError(have, headerValue);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-dashboard-mcp",
-  "version": "0.1.156",
+  "version": "0.1.158",
   "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",