@thehammer/danx-dashboard-mcp 0.1.84 → 0.1.86

package/dist/listen.js

@@ -11,7 +11,10 @@
  *   - `{type:"event", id, text}` — exactly one per event, the moment it arrives.
  *     `text` is what the session reads; an event it cannot read still produces one
  *     (`could not read event …`), never silence. `id` is `null` only for a frame
- *     that carried no usable id.
+ *     that carried no usable id — which includes DX-2885's `nudge` frame
+ *     (`formatNudgeLine`): it is advisory, re-derived fresh every tick by the
+ *     dashboard's own keep-alive tick, and never replayed, so it rides this
+ *     same shape with `id: null` rather than growing a THIRD output variant.
  *   - `{type:"stopped", reason, detail, refusal?, boards?}` — once, last. `reason`
  *     is the dashboard's own end reason (`superseded`, `replaced`, `revoked`,
  *     `scope_narrowed`, `not_connected`), `refused` (the ticket was not
@@ -122,6 +125,32 @@ export function invalidEventReason(value) {
             }
             return null;
         }
+        // DX-2935 — the operator retracted a problem's answer with no new one yet.
+        case "problem_unanswered": {
+            const problem = d.problem;
+            if (!isRecord(problem) || typeof problem.id !== "number" || !isCappedText(problem.statement)) {
+                return "detail.problem is not {id, statement}";
+            }
+            return typeof d.decision_id === "number" ? null : "detail.decision_id is not a number";
+        }
+        // DX-2935 — the operator retracted a problem's answer AND recorded a new
+        // one, in one transaction — same either/or solution/freeform shape
+        // `solution_answered` carries, plus which decision was retracted.
+        case "problem_answer_changed": {
+            const problem = d.problem;
+            if (!isRecord(problem) || typeof problem.id !== "number" || !isCappedText(problem.statement)) {
+                return "detail.problem is not {id, statement}";
+            }
+            if (typeof d.retracted_decision_id !== "number")
+                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";
+        }
         case "blocked":
             return isCappedText(d.reason) ? null : "detail.reason is not capped text";
         default:
@@ -160,6 +189,22 @@ function describe(event) {
             const problem = d.problem;
             return `${event.actor} opened a problem: ${quoted(problem.statement)}`;
         }
+        case "problem_unanswered": {
+            // DX-2935 — MUST read as "a previous answer was withdrawn", never as a
+            // brand-new problem: a connected session that already acted on the
+            // retracted answer has to stop, not treat this as fresh work to start.
+            const problem = d.problem;
+            return `${event.actor} retracted the answer to ${quoted(problem.statement)}`;
+        }
+        case "problem_answer_changed": {
+            // DX-2935 — ONE line for the whole retract-and-reanswer (never two
+            // separate events), naming the statement so a listener with several
+            // open questions knows which one just moved.
+            const problem = d.problem;
+            const solution = d.solution;
+            const now = solution === null ? quoted(d.freeform) : `"${solution.title}"`;
+            return `${event.actor} changed the answer to ${quoted(problem.statement)}: now ${now}`;
+        }
         case "blocked":
             return `${event.actor} blocked the card: ${quoted(d.reason)}`;
         case "unblocked":
@@ -177,6 +222,46 @@ export function formatActivityLine(event) {
         throw new Error(`malformed activity event: ${invalid}`);
     return oneLine(`[${event.cardId} "${event.cardTitle}" ${event.boardId}] ${describe(event)}`);
 }
+function isNudgeCardRef(value) {
+    return isRecord(value) && typeof value.id === "string" && typeof value.title === "string";
+}
+function isNudgeCardRefArray(value) {
+    return Array.isArray(value) && value.every(isNudgeCardRef);
+}
+/** Why a nudge cannot be read, or `null` when it can — same checked-before-describing shape as `invalidEventReason`. */
+export function invalidNudgeReason(value) {
+    if (!isRecord(value))
+        return "the nudge is not an object";
+    if (typeof value.idleMinutes !== "number" || !Number.isFinite(value.idleMinutes)) {
+        return "idleMinutes is not a number";
+    }
+    if (!isNudgeCardRefArray(value.startable))
+        return "startable is not a {id,title}[] array";
+    if (!isNudgeCardRefArray(value.held))
+        return "held is not a {id,title}[] array";
+    return null;
+}
+function cardList(cards) {
+    return cards.map((c) => `${c.id} "${c.title}"`).join(", ");
+}
+/**
+ * The one readable line for a nudge (DX-2885). Always names the actual
+ * waiting cards — never a generic "keep going" — because that is the whole
+ * point of the feature: a session that only sees "you're idle" learns
+ * nothing a bare timer couldn't have told it. Always a single line; throws,
+ * naming the fault, on a malformed nudge.
+ */
+export function formatNudgeLine(event) {
+    const invalid = invalidNudgeReason(event);
+    if (invalid !== null)
+        throw new Error(`malformed nudge event: ${invalid}`);
+    const parts = [];
+    if (event.startable.length > 0)
+        parts.push(`startable: ${cardList(event.startable)}`);
+    if (event.held.length > 0)
+        parts.push(`held: ${cardList(event.held)}`);
+    return oneLine(`${LINE_PREFIX} this session has been idle ${event.idleMinutes}m with work waiting — ${parts.join("; ")}`);
+}
 /**
  * Incremental SSE parser. Comment lines (keep-alives, the connect marker) and
  * field-less blocks produce no message, which is what keeps them out of the output.
@@ -305,6 +390,36 @@ export async function runListener(options, deps) {
             // elsewhere — see `ListenStopReason`'s docblock.
             return { kind: "ended", reason: isKnownWireEndReason(reason) ? reason : "unknown" };
         }
+        if (message.event === "nudge") {
+            // DX-2885 — a nudge carries no usable id (it is advisory, re-derived
+            // fresh every tick, never replayed — see `plan-session-stream.ts`'s
+            // module doc), so it rides the SAME `{type:"event", id:null, text}`
+            // shape an ordinary activity line uses (`id` is `null` only for a frame
+            // that carried no usable id — a nudge is exactly that case). That is
+            // what lets `bridge.ts` and the plugin's relay
+            // (`danxbot/scripts/plan-event-bridge.mjs`, outside this repo) forward
+            // it with NO changes at all: both already forward any `{type:"event",
+            // id, text}` line generically, keyed only on `type`.
+            //
+            // DX-2885 — this frame must stay exempt from DX-2730 D4's digest-
+            // batching when that lands (see DX-2730 AC 29939, and the matching note
+            // at the dashboard's own emit site): it must keep delivering
+            // immediately, never held for a later digest flush.
+            let parsed;
+            let invalid;
+            try {
+                parsed = JSON.parse(message.data);
+                invalid = invalidNudgeReason(parsed);
+            }
+            catch (err) {
+                invalid = `not JSON: ${err.message}`;
+            }
+            const text = invalid === null
+                ? formatNudgeLine(parsed)
+                : `${LINE_PREFIX} could not read nudge (${invalid}): ${oneLine(message.data, 300)}`;
+            deps.write({ type: "event", id: null, text });
+            return null;
+        }
         if (message.event !== "activity")
             return null;
         // `Number(null)` is 0, so a frame with no id must never be read as event 0: that id

package/package.json

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