@thehammer/danx-dashboard-mcp 0.1.254 → 0.1.258

package/dist/listen.js

@@ -12,9 +12,10 @@
  *     `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 — 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.
+ *     (`formatNudgeLine`) and DX-4340's `pacing` frame (`formatPacingLine`):
+ *     both are advisory, written fresh by the dashboard's own keep-alive tick,
+ *     and never replayed, so they ride this same shape with `id: null` rather
+ *     than growing a THIRD output variant.
  *   - `{type:"stopped", reason, detail, refusal?}` — once, last. `reason`
  *     is the dashboard's own end reason (`superseded`, `replaced`, `revoked`,
  *     `not_connected`), `refused` (the ticket was not admitted), or
@@ -48,7 +49,8 @@
  * danxbot source.
  */
 import { errorCodeOf } from "./json-body.js";
-import { oneLine } from "./one-line.js";
+import { LINE_PREFIX, oneLine } from "./one-line.js";
+import { pacingRelayLine } from "./pacing-relay.js";
 export const INITIAL_BACKOFF_MS = 1_000;
 export const MAX_BACKOFF_MS = 30_000;
 /** Three of the dashboard's 15 s keep-alives without a byte means the connection is dead. */
@@ -67,7 +69,6 @@ export const DELIVERED_ID_MEMORY = 1_000;
 export function capResumeIds(ids) {
     return ids.slice(-DELIVERED_ID_MEMORY);
 }
-const LINE_PREFIX = "[danx-dashboard stream]";
 const ACTIVITY_ORIGINS = new Set(["operator", "agent", "machine"]);
 function quoted(value) {
     return `"${value.text}${value.truncated ? "…" : ""}"`;
@@ -329,6 +330,28 @@ export function formatNudgeLine(event) {
         "Work these cards; any you cannot work, update to its true state: open a problem, add depends_on or " +
         "conflict_on, block it with the real reason, or rollback_pickup.");
 }
+const PACING_LEVELS = ["on_pace", "over_pace", "critical"];
+/** Why a pacing message cannot be read, or `null` when it can. */
+export function invalidPacingReason(value) {
+    if (!isRecord(value))
+        return "the pacing message is not an object";
+    if (!PACING_LEVELS.includes(value.level))
+        return "level is not on_pace, over_pace or critical";
+    if (value.budget !== null && !(typeof value.budget === "number" && Number.isInteger(value.budget) && value.budget >= 0))
+        return "budget is not a count or null";
+    if (typeof value.resets_at !== "string" || Number.isNaN(Date.parse(value.resets_at)))
+        return "resets_at is not a timestamp";
+    if (typeof value.text !== "string" || value.text.trim() === "")
+        return "text is empty";
+    return null;
+}
+/** The one readable line for a pacing message: the dashboard's text, on one line. Throws, naming the fault, on a malformed message. */
+export function formatPacingLine(event) {
+    const invalid = invalidPacingReason(event);
+    if (invalid !== null)
+        throw new Error(`malformed pacing message: ${invalid}`);
+    return pacingRelayLine(event.text);
+}
 /**
  * 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.
@@ -416,6 +439,30 @@ export async function runListener(options, deps) {
         deps.write({ type: "stopped", reason, detail, refusal: extra?.refusal });
         return code;
     }
+    /**
+     * The shared path of an ADVISORY frame (DX-2885 `nudge`, DX-4340 `pacing`): it carries no usable id (re-derived or written fresh by the
+     * dashboard's keep-alive 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. 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: both forward any `{type:"event", id, text}` line keyed only on `type`.
+     *
+     * `origin: null` is DX-2730 D4's exemption: the frame is delivered at once, never held for a digest flush (a nudge exists to interrupt a quiet
+     * session; a pacing change is an instruction to act now). A frame that is not JSON or not the right shape is reported from an explicit check
+     * naming the fault, and the next frame still emits.
+     */
+    const emitAdvisory = (message, what, invalidReason, format) => {
+        let parsed;
+        let invalid;
+        try {
+            parsed = JSON.parse(message.data);
+            invalid = invalidReason(parsed);
+        }
+        catch (err) {
+            invalid = `not JSON: ${err.message}`;
+        }
+        const text = invalid === null ? format(parsed) : `${LINE_PREFIX} could not read ${what} (${invalid}): ${oneLine(message.data, 300)}`;
+        deps.write({ type: "event", id: null, text, origin: null });
+        return null;
+    };
     const handle = (message) => {
         if (message.event === "end") {
             // DX-2920 (round 3) — a JSON.parse failure here falls through to the
@@ -435,40 +482,11 @@ export async function runListener(options, deps) {
             // `Outcome`'s "ended" reason is a closed set (`EndedReason`).
             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)}`;
-            // DX-2730 D4 — `origin: null` here, not the parsed event's own origin
-            // (a nudge has none): this is the exemption the module doc above
-            // describes, letting `bridge.ts` treat it exactly like an operator
-            // event (immediate) without needing a fourth vocabulary member.
-            deps.write({ type: "event", id: null, text, origin: null });
-            return null;
-        }
+        if (message.event === "nudge")
+            return emitAdvisory(message, "nudge", invalidNudgeReason, (p) => formatNudgeLine(p));
+        // DX-4340 - the pacing tick's one message for this session's Claude account (level or budget changed): advisory like a nudge.
+        if (message.event === "pacing")
+            return emitAdvisory(message, "pacing message", invalidPacingReason, (p) => formatPacingLine(p));
         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/dist/one-line.js

@@ -17,3 +17,9 @@ export function oneLine(text, maxCodePoints) {
     const points = Array.from(collapsed);
     return points.length > maxCodePoints ? `${points.slice(0, maxCodePoints).join("")}…` : collapsed;
 }
+/** The prefix of every line the stream listener emits for the session to read. */
+export const LINE_PREFIX = "[danx-dashboard stream]";
+/** `text` as one prefixed listener line, optionally cut (the one template of a listener line, shared with whoever must know its length). */
+export function prefixedLine(text, maxCodePoints) {
+    return oneLine(`${LINE_PREFIX} ${text}`, maxCodePoints);
+}

package/dist/pacing-relay.js

@@ -0,0 +1,16 @@
+import { prefixedLine } from "./one-line.js";
+/**
+ * DX-4341 - the longest pacing line the stream listener relays whole. `formatPacingLine` (`listen.ts`) cuts a pacing line, PREFIX INCLUDED and
+ * after whitespace collapses, to this many code points and ends it with an ellipsis, which would drop the tail of a message first (an
+ * orchestrator's duties, the end of the pause note format). The dashboard renders the message and refuses one that would be cut
+ * (`pacingRelayLength`, used by `src/team-pacing/pacing-message.ts`), so the cut and the refusal measure the very same line.
+ */
+export const PACING_RELAY_MAX_CODE_POINTS = 1000;
+/** The line the listener emits for pacing text `text`: prefixed, on one line, cut at the relay maximum. */
+export function pacingRelayLine(text) {
+    return prefixedLine(text, PACING_RELAY_MAX_CODE_POINTS);
+}
+/** How many code points the listener's line for `text` has before the cut. */
+export function pacingRelayLength(text) {
+    return Array.from(prefixedLine(text)).length;
+}

package/package.json

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