@thehammer/danx-dashboard-mcp 0.1.150 → 0.1.154

package/README.md

@@ -21,7 +21,7 @@ All exposed as `mcp__danx-dashboard__<name>` once wired through the workspace `m
 
 | Tool | HTTP | Notes |
 |---|---|---|
-| `issue_list` | `GET /api/issues` | filters: `type`, `parent_id` (null → root-only), `dispatchable_derived`, `assigned_agent`, `include_closed`, `limit`, `offset` |
+| `issue_list` | `GET /api/issues` | filters: `type`, `parent_id` (null → root-only), `dispatchable_derived`, `assigned_agent`, `include_closed`, `limit`, `offset`. `fields` (DX-3427) is the SAME recursive field tree `issue_get` takes, against the same issue resource — list-row fields (`ac_total`, `comments_count`, `waiting_on`, `quality_gates`, `next_pre_gate`, …) sit alongside every detail field. See `resource_fields` |
 | `issue_get` | `GET /api/issues/:id` or `GET /api/issues/batch` | Pass `id` for one card, or `ids[]` (DX-2727, at most 100) to resolve many across boards in ONE call — global, so `ids` with `board` throws; per-id `not_found` rather than a whole-call 404. Minimal scalars by default; `fields` (DX-3426) opts in via a recursive field TREE — `{"description": true, "problems": {"solutions": true}, "comments": {"limit": 10}}` — not a flat group list; a cursor-paged relation (today only `comments`) takes its page args (`limit`/`before`) inside its own nested object, so paging now works on the batch form too. See `resource_fields` |
 | `resource_fields` | `GET /api/resources/:resource/fields` | DX-3426 — what an `issue_get`-style field tree may name for one resource: `{resource, description, always, hashes, fields, relations}`. Install-global, no `board`. `resource: "issue"` is the root; a relation's own `resource` in the response is what to call this again with, one level deeper |
 | `issue_create` | `POST /api/issues` | Epic REQUIRES non-empty `phase_children[]` (atomic insert). `title` = short domain-naming label; `summary` = 1–3 plain-language sentences, always shown; `description` = the collapsed "Context" body. Root and every phase child take their own `summary` |

package/dist/handlers.js

@@ -25,19 +25,21 @@ import { readFile } from "node:fs/promises";
 import { basename, extname, isAbsolute } from "node:path";
 import { resolvePriority } from "./priority.js";
 /**
- * `filter`/`fields`/`sort` are JSON/CSV-encoded onto the query string (the
- * route parses `?filter=<JSON>`, `?fields=a,b`, `?sort=<JSON>` — see
- * `src/issues/read/reader.ts#parseEnvelope`); each is omitted entirely when
- * empty so the wire carries no `{}`/`[]` noise. `board` stays a flat
- * top-level param, resolved by the HTTP client exactly as before.
+ * `filter`/`fields`/`sort` are JSON-encoded onto the query string (the route
+ * parses `?filter=<JSON>`, `?fields=<JSON>`, `?sort=<JSON>` — see
+ * `src/issues/read/reader.ts#parseEnvelope` + `handleGetIssues`); each is
+ * omitted entirely when empty so the wire carries no `{}`/`[]` noise. `board`
+ * stays a flat top-level param, resolved by the HTTP client exactly as
+ * before.
  */
 export async function issueList(client, args) {
     const query = {};
     if (args.filter !== undefined && Object.keys(args.filter).length > 0) {
         query.filter = JSON.stringify(args.filter);
     }
-    if (args.fields !== undefined && args.fields.length > 0) {
-        query.fields = args.fields.join(",");
+    // DX-3427 — a JSON-encoded field tree, mirroring `issue_get` below.
+    if (args.fields !== undefined && Object.keys(args.fields).length > 0) {
+        query.fields = JSON.stringify(args.fields);
     }
     if (args.sort !== undefined && args.sort.length > 0) {
         query.sort = JSON.stringify(args.sort);
@@ -1116,6 +1118,10 @@ export const PLAN_EVENT_KINDS = [
     "session_connected",
     "session_switched_away",
     "idle_nudge_sent",
+    // DX-3519 — plan sign-off.
+    "plan_signed_off",
+    "plan_sign_off_cleared",
+    "plan_auto_sign_off_changed",
 ];
 /**
  * DX-3027 — every origin `plan_get`'s `events_origin` filter accepts.
@@ -1125,14 +1131,14 @@ export const PLAN_EVENT_KINDS = [
  */
 export const PLAN_EVENT_ORIGINS = ["operator", "agent", "machine"];
 /**
- * DX-2834 — the plan-status taxonomy, mirroring `PLAN_FIELD_GROUPS` just
- * above: the ONE copy in this package (the `plan_list` zod enum in
+ * DX-2834 / DX-3519 — the plan-status taxonomy, mirroring `PLAN_FIELD_GROUPS`
+ * just above: the ONE copy in this package (the `plan_list` zod enum in
  * `index.ts` reads this const), duplicated from the server's
  * `src/issues/db/plans.ts#PLAN_STATUS_IDS` 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.
  */
-export const PLAN_STATUSES = ["awaiting-session", "planning", "building", "complete"];
+export const PLAN_STATUSES = ["awaiting-session", "planning", "building", "awaiting-sign-off", "complete"];
 /** Every plan, plus which one THIS session is connected to. */
 export async function planList(client, args = {}) {
     return client.request({

package/dist/index.js

@@ -277,25 +277,6 @@ const EFFORT_VALUES = [
 // still be CREATED through this MCP.
 const ISSUE_TYPES = ["Epic", "Bug", "Feature", "Story", "Chore", "Task"];
 const NON_EPIC_TYPES = ["Bug", "Feature", "Story", "Chore", "Task"];
-// DX-935 / DX-937 — field-group taxonomy for the LIST read envelope,
-// hand-copied from `src/issues/read/field-groups.ts` (`LIST_GROUPS` — this
-// package cannot import server source). Drift surfaces at runtime as a server
-// 400, not silently. DX-3426 moved `issue_get` to the field tree
-// (`field-tree.ts`); DX-3427 moves the list the same way and deletes this.
-const LIST_FIELD_GROUPS = [
-    "description",
-    // DX-2735: replaced the flat "solutions" group (hard cut, no alias).
-    "problems",
-    "ac",
-    "comments",
-    "retro",
-    "dependencies",
-    "triage",
-    "assignment",
-    "quality_gates",
-    "children",
-    "effort",
-];
 const SORT_ORDERS = ["asc", "desc"];
 const sortField = z
     .array(z.object({
@@ -360,7 +341,7 @@ const MARKDOWN_STYLE_DESCRIBE = "Renders as markdown here. Use `##`/`###` header
 strictTool("issue_list", 
 // DX-2735: trimmed to pay for the problem tools inside the work-profile
 // injected-surface budget — same facts, no repeated prose.
-"List cards. Board-scoped; see `board`. `filter`: type, parent_id, dispatchable_derived, status_derived[], self_dispatchable_derived, assigned_agent, include_closed, include_deleted, q (free text over id+title+description). THE DEFAULT ROW IS MINIMAL — scalars only (id, type, title, status, parent_id, priority, created_at, updated_at, assigned_agent, content_hash), no joins; opt into heavy data with `fields` groups: description (+ summary), problems (open_problem_count — a card needs a human exactly when this is > 0), ac, comments, retro, dependencies, triage, assignment, quality_gates, children, effort. `sort`: [{column, order}] over id|priority|repo_name|title|type|status_derived|triage_ice_total|created_at|updated_at (default order: see `sort`'s own field description). `limit`/`offset` page (uncapped by default). `include_closed` defaults to FALSE: a bare call silently excludes every Done/Cancelled card (leaf AND container alike). The response always carries `total` (the full count matching every filter except limit/offset — compare against `issues.length` to tell an exhausted list from a truncated one) and, whenever `include_closed` was not explicitly `true`, `closed_excluded` (how many additional terminal cards the default withheld — re-call with `include_closed: true` to see them). issue_get reads one card in full.", {
+"List cards. Board-scoped; see `board`. `filter`: type, parent_id, dispatchable_derived, status_derived[], self_dispatchable_derived, assigned_agent, include_closed, include_deleted, q (free text over id+title+description). THE DEFAULT ROW IS MINIMAL — scalars only (id, type, title, status, parent_id, priority, created_at, updated_at, assigned_agent, content_hash), no joins; `fields` opts into more — the SAME recursive field-tree JSON `issue_get` takes, against the SAME issue resource (list-row fields like `ac_total`/`comments_count`/`waiting_on`/`quality_gates`/`next_pre_gate` sit alongside every detail field `issue_get` can name). Call `resource_fields({resource:\"issue\"})` for the full, current list of what `fields` may name — never guess a name; unknown → 400 `unknown_field`. `sort`: [{column, order}] over id|priority|repo_name|title|type|status_derived|triage_ice_total|created_at|updated_at (default order: see `sort`'s own field description). `limit`/`offset` page (uncapped by default). `include_closed` defaults to FALSE: a bare call silently excludes every Done/Cancelled card (leaf AND container alike). The response always carries `total` (the full count matching every filter except limit/offset — compare against `issues.length` to tell an exhausted list from a truncated one) and, whenever `include_closed` was not explicitly `true`, `closed_excluded` (how many additional terminal cards the default withheld — re-call with `include_closed: true` to see them). issue_get reads one card in full.", {
     filter: z
         .object({
         q: z.string().optional(),
@@ -381,10 +362,12 @@ strictTool("issue_list",
         // its own `.strict()`.
         .strict()
         .optional(),
-    fields: z
-        .array(z.enum(LIST_FIELD_GROUPS))
+    // DX-3427 — a field TREE, exactly like `issue_get`'s `fields` below
+    // (against the same shared issue resource) — replaces the retired
+    // CSV field-GROUP list.
+    fields: fieldTreeSchema
         .optional()
-        .describe("Field groups to add; absent = minimal scalars."),
+        .describe("A field tree (see tool description); absent/empty = minimal scalars. `resource_fields({resource:\"issue\"})` names every valid key."),
     sort: sortField,
     limit: z.number().int().positive().max(LIST_PAGE_MAX_LIMIT).optional(),
     offset: z.number().int().nonnegative().optional(),
@@ -941,11 +924,11 @@ strictTool("brief_set_page", 'Write one Brief page. Board-scoped; see `board`. B
 // plan id — and it can only ever bind the caller's own session. `plan_create`
 // also takes no plan id, but for a different reason: it MAKES a plan rather
 // than acting on one, so there is no existing plan for an id to name yet.
-strictTool("plan_list", "List every plan, and learn which plan THIS session is connected to. Plans are GLOBAL, not board-scoped — a plan is a named, dated set of cards an operator assembled by hand, from any repo. Returns `{plans: [{id, ref, name, createdAt, cardCount, boards, status}], session, sessionListenerAttached}` — `ref` is the plan's short reference (`PLN-<id>`), cite it rather than the bare id. `status` is computed fresh on every read, never stored: `awaiting-session` (no live session — a session row isn't released just because a session ended), `planning` (no cards, or only Review/Backlog/terminal ones with ≥1 not Done/Cancelled), `building` (a live session AND ≥1 card ToDo/In Progress or stuck-but-active — Blocked/Needs Help), `complete` (≥1 card, all Done/Cancelled — wins even with no session). Pass `status` to filter. `session` is your own registration (`{sessionId, title, planId, planName, firstSeenAt, lastActiveAt}`) or null outside a Claude Code session; `planId: null` means connected to no plan — `plan_get` to browse, `plan_connect` to bind. `sessionListenerAttached` says whether your event stream is attached (the plugin's plan bridge); false for a few seconds right after connect is normal, false after that means events aren't reaching you — tell the operator. Distinct from the board Brief (`brief_list`).", {
+strictTool("plan_list", "List every plan, and learn which plan THIS session is connected to. Plans are GLOBAL, not board-scoped — a plan is a named, dated set of cards an operator assembled by hand, from any repo. Returns `{plans: [{id, ref, name, createdAt, cardCount, boards, status, signedOffAt, signedOffBy, autoSignOff}], session, sessionListenerAttached}` — `ref` is the plan's short reference (`PLN-<id>`), cite it rather than the bare id. `status` is computed fresh on every read, never stored — except the sign-off pair itself: `awaiting-session` (no live session — a session row isn't released just because a session ended), `planning` (no cards, or only Review/Backlog/terminal ones with ≥1 not Done/Cancelled), `building` (a live session AND ≥1 card ToDo/In Progress or stuck-but-active — Blocked/Needs Help), `awaiting-sign-off` (≥1 card, all Done/Cancelled, but nobody has signed the plan off yet — DX-3519), `complete` (≥1 card, all Done/Cancelled, AND signed off — wins even with no session). `signedOffAt`/`signedOffBy` are `null` until a human (`signedOffBy` = their identity) or the `autoSignOff` toggle (`signedOffBy: 'auto'`) signs the plan off; sign-off itself is a human-only write, not exposed through this MCP surface — direct the operator to the dashboard's plan page. Pass `status` to filter. `session` is your own registration (`{sessionId, title, planId, planName, firstSeenAt, lastActiveAt}`) or null outside a Claude Code session; `planId: null` means connected to no plan — `plan_get` to browse, `plan_connect` to bind. `sessionListenerAttached` says whether your event stream is attached (the plugin's plan bridge); false for a few seconds right after connect is normal, false after that means events aren't reaching you — tell the operator. Distinct from the board Brief (`brief_list`).", {
     status: z
         .enum(PLAN_STATUSES)
         .optional()
-        .describe("Filter to one computed status: awaiting-session, planning, building, complete. Omit for every plan."),
+        .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`.", {
     plan_id: z

package/package.json

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

package/dist/entrypoint.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { mkdtempSync, writeFileSync, symlinkSync, rmSync, realpathSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { isEntrypointModule } from "./entrypoint.js";
-describe("isEntrypointModule (DX-1647)", () => {
-    let dir;
-    let real;
-    let link;
-    beforeAll(() => {
-        dir = mkdtempSync(join(tmpdir(), "entrypoint-test-"));
-        real = join(dir, "index.js");
-        writeFileSync(real, "// stub entry\n");
-        link = join(dir, "danx-dashboard-mcp"); // mimics node_modules/.bin symlink
-        symlinkSync(real, link);
-    });
-    afterAll(() => {
-        rmSync(dir, { recursive: true, force: true });
-    });
-    // import.meta.url always reports the module REALPATH — model that here.
-    const moduleUrl = () => pathToFileURL(realpathSync(real)).href;
-    it("true when argv[1] is the real file (direct `node index.js`)", () => {
-        expect(isEntrypointModule(moduleUrl(), real)).toBe(true);
-    });
-    it("true when argv[1] is a SYMLINK to the file (npx / global bin) — the fleet regression", () => {
-        // The symlink path !== the realpath, but the entrypoint MUST still be
-        // detected, or npx imports the module and exits without booting the server.
-        expect(link).not.toBe(realpathSync(link));
-        expect(isEntrypointModule(moduleUrl(), link)).toBe(true);
-    });
-    it("false when argv[1] is undefined (module imported, not run as bin)", () => {
-        expect(isEntrypointModule(moduleUrl(), undefined)).toBe(false);
-    });
-    it("false when argv[1] is an empty string", () => {
-        expect(isEntrypointModule(moduleUrl(), "")).toBe(false);
-    });
-    it("false when argv[1] points at a different real file", () => {
-        const other = join(dir, "other.js");
-        writeFileSync(other, "// other\n");
-        expect(isEntrypointModule(moduleUrl(), other)).toBe(false);
-    });
-});