@thehammer/danx-dashboard-mcp 0.1.187 → 0.1.189

package/README.md

@@ -43,7 +43,7 @@ CLAUDE_CODE_SESSION_ID=<session> npx -y @thehammer/danx-dashboard-mcp@<version>
 - **No client-side reach check (DX-2920).** `bridge` used to prove board reach itself, before ever opening the stream (`GET /api/plans/mine?fields=cards` + a per-board `GET /api/issues/:id/problems`). That check is DELETED. The dashboard briefly enforced the identical requirement server-side (DX-2863: refusing a mint or stream admission with `403 issuer_cannot_read_plan_boards`, and ending a live stream `{"reason":"scope_narrowed","boards":[…]}`), but DX-3468 removed that mechanism too — DX-3409 made every credential team-bound, so a plan session's issuer and every board its connected plan covers are always in the same team, and the check could never fire any more. `bridge` no longer independently verifies board reach at all, client- or server-side. Once a ticket is minted, `bridge` emits, once, `{"type":"ready"}` — no `boards` field, since reach is no longer proven client-side.
 - **Ticket.** `bridge` mints the session's listener ticket (`POST /api/plan-sessions/me/stream-ticket`, 10 s timeout) and keeps it in the process. A ticket authorizes reading that one session's event stream and nothing else, and is only issued while the session is connected to a plan. Minting a new one ends the previous listener.
 - **Output — JSON Lines.** One `{"type":"event","id":<id|null>,"text":"…"}` per event on the connected plan's cards, where `text` is `[DX-8 "Title" repo:board] newms87 answered "Which rollout order?": chose "Pause E2E" — note: "only this week"`, `… answered "…": "<free-form answer>"`, `… commented: "…"`, `… opened a problem: "…"`, `… blocked the card: "…"`, or `… unblocked the card`. An event it cannot read still produces one, with a `could not read event` text. Nothing for keep-alives, reconnects or re-mints. The session's own writes are never echoed back to it.
-- **Stopping.** Last, one `{"type":"stopped","reason":"…","detail":"…","fix":"…"}` and exit, only on a terminal outcome. `fix` is the remedy shown to the session (`STOP_FIXES` in `src/bridge.ts` — never a log-only hint), so a session that hits a stop it cannot otherwise see still knows what to do about it. Terminal reasons: `no_connection_record` / `credential_unavailable` / `credential_mismatch` (the start-time checks above), `not_connected` (a `409 session_not_connected` at mint OR at stream admission, or a live `end("not_connected")` — all three mapped identically), `unauthorized` (401/403), `mint_refused` (any other non-transient mint refusal), `mint_bad_response`, `superseded` / `replaced` (exit 0 — a newer or replacing connection already serves this session, so `fix` says no action is needed), `revoked`, or `refused` (two freshly minted tickets refused in a row with no more specific classification). A transient mint failure (network, timeout, 408, 429, 5xx) backs off and retries; a lapsed ticket lease re-mints.
+- **Stopping.** Last, one `{"type":"stopped","reason":"…","detail":"…","fix":"…"}` and exit, only on a terminal outcome. `fix` is the remedy shown to the session (`STOP_FIXES` in `src/bridge.ts` — never a log-only hint), so a session that hits a stop it cannot otherwise see still knows what to do about it. Terminal reasons: `no_connection_record` / `credential_unavailable` / `credential_mismatch` (the start-time checks above), `not_connected` (a `409 session_not_connected` at mint OR at stream admission, or a live `end("not_connected")` — all three mapped identically), `plan_archived` (DX-3809 — the plan was archived or deleted while the stream was live; the session is disconnected, and reconnects by hand after a restore), `unauthorized` (401/403), `mint_refused` (any other non-transient mint refusal), `mint_bad_response`, `superseded` / `replaced` (exit 0 — a newer or replacing connection already serves this session, so `fix` says no action is needed), `revoked`, or `refused` (two freshly minted tickets refused in a row with no more specific classification). A transient mint failure (network, timeout, 408, 429, 5xx) backs off and retries; a lapsed ticket lease re-mints.
 - **Reconnect and resume.** A read-idle timeout (three missed keep-alives) turns a silently dead connection into a drop. Capped exponential backoff (1s → 30s) that resets only after a healthy connection, with `Last-Event-ID`, so a dashboard restart replays what was missed and nothing is emitted twice. `--resume-ids` carries the same guarantee across a process restart: the ids already delivered seed the duplicate guard, and the highest is the first `Last-Event-ID`. The dashboard floors that replay at the later of the session's first ticket and when it joined its current plan, so a restart loses nothing and a plan move replays nothing from before the move.
 
 ## Build + test

package/dist/bridge.js

@@ -51,6 +51,8 @@
  *   - `not_connected`         the mint, or the stream's admission / keep-alive,
  *                              answered `session_not_connected` (409 at mint and
  *                              at admission; `end("not_connected")` once live);
+ *   - `plan_archived`         DX-3809 — the plan was archived or deleted while the
+ *                              stream was live (`end("plan_archived")`);
  *   - `unauthorized`          the mint answered 401 / 403;
  *   - `mint_refused`          any other non-transient mint refusal (400, 404, …);
  *   - `mint_bad_response`     a 2xx mint whose body is not a ticket;
@@ -209,6 +211,7 @@ export const STOP_FIXES = {
     credential_unavailable: "fix the credential this session's danx-dashboard MCP server declares, then call plan_connect again",
     credential_mismatch: "restart this Claude Code session so its MCP server and its bridge pick up the same credential, then call plan_connect again",
     not_connected: "call plan_connect to connect this session to a plan",
+    plan_archived: "the plan was archived or deleted, so this session was disconnected; ask the operator to restore it, then call plan_connect again",
     unauthorized: "give this session's danx-dashboard MCP server a dashboard credential that is accepted, then call plan_connect again",
     mint_refused: "check that this session is connected to a plan on the dashboard its MCP server points at, then call plan_connect again",
     mint_bad_response: "check that DANXBOT_DASHBOARD_URL for this session's MCP server points at a danxbot dashboard",
@@ -516,6 +519,7 @@ function classifyAdmissionRefusal(refusal) {
 const EXIT_NEVER_RESTART_LIST = [
     "no_connection_record",
     "not_connected",
+    "plan_archived",
     "superseded",
     "replaced",
     "session_is_worker",

package/dist/index.js

@@ -422,7 +422,7 @@ strictTool("attach_file", "Attach a LOCAL file to a card: `card_id` + `path` (an
 // no existing plan for an id to name yet.
 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 read + 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 a `danxbot_api` call to a `/api/plans/mine/...` route (there is no dedicated 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 the plan list/get routes 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. The response's `reminders[]` (when present) carries the mantra — read and follow it.", {
+"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 read + 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 a `danxbot_api` call to a `/api/plans/mine/...` route (there is no dedicated 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 the plan list/get routes 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\"`. An action the operator DECLINES arrives as `... rejected the action \"<title>\" for \"<statement>\" — reason: \"<note>\". Do not perform it; re-plan from the reason` (a decision with `outcome: \"rejected\"` — never treat it as work done). 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. The response's `reminders[]` (when present) carries the mantra — read and follow it.", {
     plan_id: z.number().int().positive().describe("The plan id, from the plans list (`danxbot_api` `GET /api/plans`)."),
     title: z
         .string()

package/dist/listen.js

@@ -78,6 +78,27 @@ function isRecord(value) {
 function isCappedText(value) {
     return isRecord(value) && typeof value.text === "string" && typeof value.truncated === "boolean";
 }
+/**
+ * DX-3880 — the part `solution_answered` and `problem_answer_changed` share: the
+ * decision's `outcome` and the either/or body it implies. A rejection (the
+ * operator DECLINED an action) always names the solution and carries its reason
+ * as `solution.note`; an answer is a solution (optional note) or free-form text.
+ */
+function invalidDecisionBody(d) {
+    if (d.outcome !== "answered" && d.outcome !== "rejected")
+        return 'detail.outcome is not "answered" or "rejected"';
+    if (d.solution === null) {
+        if (d.outcome === "rejected")
+            return "detail.solution is null on a rejection";
+        return isCappedText(d.freeform) ? null : "detail.freeform is not capped text";
+    }
+    if (!isRecord(d.solution) || typeof d.solution.title !== "string")
+        return "detail.solution is not {title, note}";
+    if (d.outcome === "rejected") {
+        return isCappedText(d.solution.note) ? null : "detail.solution.note (the rejection reason) is not capped text";
+    }
+    return d.solution.note === null || isCappedText(d.solution.note) ? null : "detail.solution.note is not capped text";
+}
 /**
  * DX-2735 — why an event cannot be described, or `null` when it can.
  *
@@ -122,11 +143,7 @@ export function invalidEventReason(value) {
             if (!isRecord(problem) || typeof problem.id !== "number" || !isCappedText(problem.statement)) {
                 return "detail.problem is not {id, statement}";
             }
-            if (d.solution === null)
-                return isCappedText(d.freeform) ? null : "detail.freeform is not capped text";
-            if (!isRecord(d.solution) || typeof d.solution.title !== "string")
-                return "detail.solution is not {title, note}";
-            return d.solution.note === null || isCappedText(d.solution.note) ? null : "detail.solution.note is not capped text";
+            return invalidDecisionBody(d);
         }
         case "problem_added": {
             const problem = d.problem;
@@ -155,11 +172,7 @@ export function invalidEventReason(value) {
                 return "detail.retracted_decision_id is not a number";
             if (typeof d.decision_id !== "number")
                 return "detail.decision_id is not a number";
-            if (d.solution === null)
-                return isCappedText(d.freeform) ? null : "detail.freeform is not capped text";
-            if (!isRecord(d.solution) || typeof d.solution.title !== "string")
-                return "detail.solution is not {title, note}";
-            return d.solution.note === null || isCappedText(d.solution.note) ? null : "detail.solution.note is not capped text";
+            return invalidDecisionBody(d);
         }
         case "blocked":
             return isCappedText(d.reason) ? null : "detail.reason is not capped text";
@@ -196,8 +209,13 @@ function describe(event) {
             // so the line names the problem — otherwise the agent cannot tell which of its
             // questions just closed.
             const problem = d.problem;
-            const answered = `${who} answered ${quoted(problem.statement)}:`;
             const solution = d.solution;
+            // DX-3880 — a REJECTION is the opposite of work done: the operator declined
+            // the action, so the line says so and names the reason; the agent must not
+            // perform it and re-plans from the note.
+            if (d.outcome === "rejected")
+                return `${who} rejected the action "${solution.title}" for ${quoted(problem.statement)} — reason: ${quoted(solution.note)}. Do not perform it; re-plan from the reason`;
+            const answered = `${who} answered ${quoted(problem.statement)}:`;
             if (solution === null)
                 return `${answered} ${quoted(d.freeform)}`;
             const note = solution.note === null ? "" : ` — note: ${quoted(solution.note)}`;
@@ -222,6 +240,8 @@ function describe(event) {
             // open questions knows which one just moved.
             const problem = d.problem;
             const solution = d.solution;
+            if (d.outcome === "rejected")
+                return `${who} changed the answer to ${quoted(problem.statement)}: now REJECTED the action "${solution.title}" — reason: ${quoted(solution.note)}. Do not perform it; re-plan from the reason`;
             const now = solution === null ? quoted(d.freeform) : `"${solution.title}"`;
             return `${who} changed the answer to ${quoted(problem.statement)}: now ${now}`;
         }
@@ -353,7 +373,7 @@ function parseBlock(block) {
  * than passing the raw string through, which is what lets `Outcome`'s
  * `reason` field below be a closed union instead of `string`.
  */
-const KNOWN_WIRE_END_REASONS = new Set(["superseded", "replaced", "revoked", "not_connected"]);
+const KNOWN_WIRE_END_REASONS = new Set(["superseded", "replaced", "revoked", "not_connected", "plan_archived"]);
 function isKnownWireEndReason(reason) {
     return KNOWN_WIRE_END_REASONS.has(reason);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-dashboard-mcp",
-  "version": "0.1.187",
+  "version": "0.1.189",
   "description": "Stdio MCP server fronting danxbot's dashboard API for agents (operator sessions and dispatched workers alike): the generic danxbot_api/danxbot_api_list/danxbot_api_spec tools reach any route the caller's credential may call, plus dedicated agent-specific tools (plan_connect, danxbot_complete, and other per-dispatch lifecycle callbacks) (DX-3465, PLN-11 R-25).",
   "license": "MIT",
   "type": "module",