@thehammer/danx-dashboard-mcp 0.1.87 → 0.1.88

package/dist/listen.js

@@ -11,31 +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 — 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
- *     admitted), `bad_end_payload` (a `scope_narrowed` end whose `boards` array
- *     was missing/invalid — a protocol error, never silently downgraded), or
- *     `lease_expired` (no healthy connection for the lease). DX-2920 —
- *     `refusal` is populated ONLY for `reason === "refused"`: `{status,
- *     errorCode, body}`, the admission response parsed ONCE here, so a
- *     consumer can recognize a SPECIFIC refusal (the dashboard's own
- *     `409 session_not_connected`, the same shape the mint route uses) by
- *     status + error code rather than re-deriving it from the flattened
- *     `detail` string. `boards` is REQUIRED (round 4 — a discriminated union,
- *     not an optional field: see `ListenStopped` / `ListenStopReason`) for
- *     `reason === "scope_narrowed"` and absent for every other reason, parsed
- *     from the dashboard's `end` payload the SAME way `reason` itself is
- *     parsed — never re-derived from `detail`. A wire `reason` value this
- *     build does not recognize (a newer dashboard's reason an older bridge
- *     hasn't shipped yet) normalizes to `"unknown"` rather than passing the
- *     raw string through, so the closed set stays closed — `fixForStop`'s
- *     generic `DEFAULT_STOP_FIX` handles it exactly as it already handled a
- *     verbatim unrecognized string.
+ *     that carried no usable id.
+ *   - `{type:"stopped", reason, detail}` — once, last. `reason` is the dashboard's
+ *     own end reason (`superseded`, `replaced`, `revoked`), `refused` (the ticket
+ *     was not admitted), or `lease_expired` (no healthy connection for the lease).
  *   - nothing for keep-alives, the connect marker, or a successful reconnect.
  *
  * RECONNECT AND RESUME. The stream drops whenever the dashboard restarts, and can
@@ -53,7 +32,6 @@
  * (`src/issues/db/issue-activity.ts`); this published package cannot import
  * danxbot source.
  */
-import { errorCodeOf } from "./json-body.js";
 import { oneLine } from "./one-line.js";
 export const INITIAL_BACKOFF_MS = 1_000;
 export const MAX_BACKOFF_MS = 30_000;
@@ -64,7 +42,6 @@ export const HEALTHY_CONNECTION_MS = 20_000;
 /** How many delivered event ids the duplicate guard remembers — well past the replay overlap. */
 export const DELIVERED_ID_MEMORY = 1_000;
 const LINE_PREFIX = "[danx-dashboard listen]";
-const ACTIVITY_ORIGINS = new Set(["operator", "agent", "machine"]);
 function quoted(value) {
     return `"${value.text}${value.truncated ? "…" : ""}"`;
 }
@@ -92,27 +69,12 @@ export function invalidEventReason(value) {
         if (typeof value[field] !== "string")
             return `${field} is not a string`;
     }
-    // DX-2730 D4 — checked with the rest of the envelope, before any kind-specific
-    // detail check, exactly like every other envelope field above.
-    if (typeof value.origin !== "string" || !ACTIVITY_ORIGINS.has(value.origin)) {
-        return "origin is not one of operator, agent, machine";
-    }
     const d = value.detail;
     if (!isRecord(d))
         return "detail is not an object";
     switch (value.kind) {
-        case "comment_added": {
-            if (!isCappedText(d.excerpt))
-                return "detail.excerpt is not capped text";
-            // DX-2906 — `problem` is OPTIONAL (only present when the comment named
-            // one); absent is valid, but a present-and-malformed one is not.
-            if (d.problem === undefined)
-                return null;
-            const problem = d.problem;
-            return isRecord(problem) && typeof problem.id === "number" && isCappedText(problem.statement)
-                ? null
-                : "detail.problem is not {id, statement}";
-        }
+        case "comment_added":
+            return isCappedText(d.excerpt) ? null : "detail.excerpt is not capped text";
         case "solution_answered": {
             const problem = d.problem;
             if (!isRecord(problem) || typeof problem.id !== "number" || !isCappedText(problem.statement)) {
@@ -131,68 +93,24 @@ 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:
             return null;
     }
 }
-/**
- * DX-2730 D4 — `actor` alone cannot distinguish an `agent` event from a
- * `machine` one (both stamp `actor: "danxbot"` today), so every line names
- * the origin next to the actor rather than leaving it to a separate field a
- * reader would have to cross-reference.
- */
-function actorLabel(event) {
-    return `${event.actor} (${event.origin})`;
-}
 /** Only ever called on an event `invalidEventReason` accepted, so its casts are checked. */
 function describe(event) {
     const d = event.detail;
-    const who = actorLabel(event);
     switch (event.kind) {
-        case "comment_added": {
-            // DX-2906 — a comment naming a problem (a follow-up question, without
-            // answering it) relays distinctly from a plain comment, so an agent
-            // listening to the stream can tell which of its open problems just
-            // got a reply.
-            const problem = d.problem;
-            if (problem === undefined)
-                return `${who} commented: ${quoted(d.excerpt)}`;
-            return `${who} commented on problem ${quoted(problem.statement)}: ${quoted(d.excerpt)}`;
-        }
+        case "comment_added":
+            return `${event.actor} commented: ${quoted(d.excerpt)}`;
         case "solution_answered": {
             // DX-2735: every answer answers ONE problem on a card that may carry several,
             // 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 answered = `${event.actor} answered ${quoted(problem.statement)}:`;
             const solution = d.solution;
             if (solution === null)
                 return `${answered} ${quoted(d.freeform)}`;
@@ -203,32 +121,16 @@ function describe(event) {
             // DX-2830 — this IS the "needs a human" signal now: a card needs one
             // exactly when it has an open problem, and this is one being opened.
             const problem = d.problem;
-            return `${who} 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 `${who} 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 `${who} changed the answer to ${quoted(problem.statement)}: now ${now}`;
+            return `${event.actor} opened a problem: ${quoted(problem.statement)}`;
         }
         case "blocked":
-            return `${who} blocked the card: ${quoted(d.reason)}`;
+            return `${event.actor} blocked the card: ${quoted(d.reason)}`;
         case "unblocked":
-            return `${who} unblocked the card`;
+            return `${event.actor} unblocked the card`;
         default:
             // A kind newer than this listener still produces a line: an event the
             // agent is never told about is exactly the failure this reader prevents.
-            return `${who}: ${event.kind}`;
+            return `${event.actor}: ${event.kind}`;
     }
 }
 /** The one readable line for an event. Always a single line; throws, naming the fault, on a malformed event. */
@@ -238,46 +140,6 @@ 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.
@@ -319,23 +181,6 @@ function parseBlock(block) {
     }
     return sawField ? { id, event, data: data.join("\n") } : null;
 }
-/**
- * DX-2920 (round 4) — the dashboard's own `StreamEndReason` values this
- * client recognizes on the wire, EXCLUDING `scope_narrowed` (parsed by its own
- * dedicated branch in `handle()` below, since it alone carries `boards`).
- * Hand-copied from `StreamEndReason` in `src/issues/plan-session-listeners.ts`
- * — this published package cannot import danxbot source. A wire `reason` this
- * set does not contain (a newer dashboard's reason this build predates)
- * normalizes to `"unknown"` rather than passing the raw string through, which
- * is what lets `Outcome`'s `reason` field below be a closed union instead of
- * `string` — see `ListenStopReason`'s docblock for why that closure is what
- * makes the `scope_narrowed`-requires-`boards` invariant an actual compile
- * error rather than a comment's promise.
- */
-const KNOWN_WIRE_END_REASONS = new Set(["superseded", "replaced", "revoked", "not_connected"]);
-function isKnownWireEndReason(reason) {
-    return KNOWN_WIRE_END_REASONS.has(reason);
-}
 /** Statuses that describe the moment, not the ticket — retry them. */
 const RETRYABLE_CLIENT_STATUSES = new Set([408, 429]);
 /**
@@ -356,89 +201,14 @@ export async function runListener(options, deps) {
     };
     for (const id of options.resumeIds.slice(-DELIVERED_ID_MEMORY))
         remember(id);
-    function stop(reason, detail, code, extra) {
-        if (reason === "scope_narrowed") {
-            if (extra?.boards === undefined) {
-                throw new Error('stop("scope_narrowed", ...) requires boards — unreachable through the exported overloads above');
-            }
-            deps.write({ type: "stopped", reason, detail, boards: extra.boards });
-            return code;
-        }
-        deps.write({ type: "stopped", reason, detail, refusal: extra?.refusal });
+    const stop = (reason, detail, code) => {
+        deps.write({ type: "stopped", reason, detail });
         return code;
-    }
+    };
     const handle = (message) => {
         if (message.event === "end") {
-            // DX-2920 (round 3) — a JSON.parse failure here falls through to the
-            // pre-existing "unknown" reason below via `isRecord(null)`, unchanged
-            // from before this round. Only a `scope_narrowed` reason additionally
-            // REQUIRES a valid `boards` string array (matching the server's `end`
-            // overload, which cannot emit `scope_narrowed` without one) — a
-            // `scope_narrowed` frame that fails that check is a PROTOCOL error
-            // (a server too old to have sent boards, or a corrupted frame), never
-            // silently downgraded to the generic "the dashboard ended this
-            // listener" message the caller cannot act on.
-            let parsed;
-            try {
-                parsed = JSON.parse(message.data);
-            }
-            catch {
-                parsed = null;
-            }
-            const reasonRaw = isRecord(parsed) ? parsed.reason : undefined;
-            const reason = typeof reasonRaw === "string" ? reasonRaw : "unknown";
-            if (reason === "scope_narrowed") {
-                const boardsRaw = isRecord(parsed) ? parsed.boards : undefined;
-                const boards = Array.isArray(boardsRaw) && boardsRaw.length > 0 && boardsRaw.every((b) => typeof b === "string")
-                    ? boardsRaw
-                    : null;
-                if (boards === null) {
-                    return { kind: "ended", reason: "bad_end_payload" };
-                }
-                return { kind: "ended", reason, boards };
-            }
-            // DX-2920 (round 4) — a wire reason this build does not recognize (a
-            // newer dashboard's reason an older bridge hasn't shipped yet)
-            // normalizes to "unknown" rather than passing the raw string through:
-            // `Outcome`'s "ended" reason is now a closed set (`EndedReason`), and an
-            // open passthrough here would be exactly the hole that lets a
-            // missing-`boards` "scope_narrowed" construction slip past the compiler
-            // 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)}`;
-            // 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;
+            const reason = JSON.parse(message.data).reason;
+            return { kind: "ended", reason: typeof reason === "string" ? reason : "unknown" };
         }
         if (message.event !== "activity")
             return null;
@@ -467,13 +237,7 @@ export async function runListener(options, deps) {
                 // DX-2735: oneLine caps by code point, so a bad event carrying an emoji
                 // at the cut can never leave a lone surrogate in the line.
                 oneLine(message.data, 300);
-        // DX-2730 D4 — an event this listener could not parse carries `origin: null`
-        // (emit immediately) rather than the unreadable payload's own claimed
-        // origin: a fault worth surfacing at all must never be hidden behind a
-        // 10-minute digest wait just because it happened to come from an agent or
-        // a machine writer.
-        const origin = invalid === null ? parsed.origin : null;
-        deps.write({ type: "event", id: knownId ? id : null, text, origin });
+        deps.write({ type: "event", id: knownId ? id : null, text });
         if (knownId)
             remember(id);
         return null;
@@ -498,25 +262,7 @@ export async function runListener(options, deps) {
             armIdle();
             const response = await deps.fetch(options.streamUrl, { headers, signal: controller.signal });
             if (response.status >= 400 && response.status < 500 && !RETRYABLE_CLIENT_STATUSES.has(response.status)) {
-                const text = await response.text();
-                // DX-2920 — parsed ONCE, here, into a structured outcome a consumer can
-                // classify by status + error code (`bridge.ts` does, matching a specific
-                // admission refusal such as the dashboard's own `409 session_not_connected`)
-                // rather than re-deriving it from the flattened `detail` string below.
-                let body = null;
-                try {
-                    body = text === "" ? null : JSON.parse(text);
-                }
-                catch {
-                    body = null;
-                }
-                return {
-                    kind: "refused",
-                    status: response.status,
-                    errorCode: errorCodeOf(body),
-                    body,
-                    detail: `HTTP ${response.status} ${oneLine(text, 300)}`,
-                };
+                return { kind: "refused", detail: `HTTP ${response.status} ${oneLine(await response.text(), 300)}` };
             }
             if (!response.ok || response.body === null) {
                 await response.body?.cancel();
@@ -550,23 +296,10 @@ export async function runListener(options, deps) {
             if (outcome.reason === "superseded" || outcome.reason === "replaced") {
                 return stop(outcome.reason, "another listener for this session took over", 0);
             }
-            if (outcome.reason === "bad_end_payload") {
-                return stop("bad_end_payload", "the dashboard's scope_narrowed end event carried no valid boards array — this is a protocol error, not an ordinary end", 1);
-            }
-            // DX-2920 (round 4) — split explicitly rather than the old conditional
-            // `outcome.boards === undefined ? undefined : {boards}` pass-through:
-            // `Outcome`'s "ended" kind is now itself discriminated on `reason`, so
-            // `outcome.boards` is GUARANTEED present here (no `?? []`, no optional
-            // check needed) once narrowed to `"scope_narrowed"`.
-            if (outcome.reason === "scope_narrowed") {
-                return stop("scope_narrowed", "the dashboard ended this listener", 1, { boards: outcome.boards });
-            }
             return stop(outcome.reason, "the dashboard ended this listener", 1);
         }
         if (outcome.kind === "refused") {
-            return stop("refused", `the dashboard refused the listener ticket: ${outcome.detail}`, 1, {
-                refusal: { status: outcome.status, errorCode: outcome.errorCode, body: outcome.body },
-            });
+            return stop("refused", `the dashboard refused the listener ticket: ${outcome.detail}`, 1);
         }
         if (outcome.healthy) {
             unhealthySince = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-dashboard-mcp",
-  "version": "0.1.87",
+  "version": "0.1.88",
   "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/json-body.js

@@ -1,23 +0,0 @@
-/**
- * DX-2920 — the ONE place that reads a JSON body's top-level `.error` string.
- *
- * WHY THIS EXISTS. `bridge.ts` (classifying a mint refusal) and `listen.ts`
- * (classifying a stream admission refusal) both need to answer "what error
- * code did this JSON body carry", and before this card each answered it a
- * different way: `bridge.ts` parsed the body directly, `listen.ts` never
- * looked past a flattened, human-readable detail string at all — a caller
- * that wanted to react to a SPECIFIC refusal (the admission-time 409 the
- * mint route also uses) had to regex-scrape that flattened string back apart,
- * a second, fragile source of truth for the same fact. This module is generic
- * — it knows nothing about "session_not_connected" or "issuer_cannot_read_plan_boards",
- * only that a JSON object may carry a top-level string field named `error` —
- * so it can live in BOTH the domain-aware `bridge.ts` and the deliberately
- * generic `listen.ts` (whose own docblock states it carries no domain
- * knowledge of the dashboard's specific error shapes) without either one
- * importing the other.
- */
-export function errorCodeOf(body) {
-    return typeof body === "object" && body !== null && typeof body.error === "string"
-        ? body.error
-        : null;
-}

package/dist/plan-state.js

@@ -1,194 +0,0 @@
-/**
- * `danx-dashboard-mcp plan-state` — the ONE-SHOT client of
- * `GET /api/plan-sessions/me/turn-state` (DX-2921).
- *
- * WHO RUNS IT. The danxbot Claude Code plugin's DX-2888 turn-start /
- * turn-end hooks, via the plugin's existing `bridgeCommand()` npx path — the
- * SAME package pin, no separate install, no deep import of this package's
- * `dist/` internals (that was DX-2921's whole reason to exist: the DX-2888
- * architecture review found the first build of this logic vendored a private
- * copy of the MCP package and hardcoded the dashboard HTTP contract inside
- * the PLUGIN). The plugin decides what to DO with the answer (inject plan
- * numbers at turn start, refuse to let a turn end while the session could
- * legally start work and has nothing running); this module only fetches it.
- *
- * THE CONTRACT (agreed with the DX-2888 plugin side, issue comment 4245 on
- * DX-2921 — binding, because the plugin is already built against it):
- *   - print EXACTLY ONE JSON line on stdout, and ALWAYS exit 0 — success or
- *     failure alike, because the hook must stay silent rather than spam the
- *     session's own turn with a stack trace;
- *   - a session that is not connected to a plan prints
- *     `{"ok":false,"reason":"session_not_connected"}` — that EXACT literal,
- *     because the plugin keys its no-log-spam rule on it (it is also the
- *     dashboard's own 409 error code for this case — see
- *     `requireConnectedPlanId`, `plan-session-context.ts`);
- *   - on success, every count is a finite number, `plan` carries `id` +
- *     `name`, and every `startable` / `held` entry carries a string `id` +
- *     `title` — the plugin rejects anything else as `bad_response`, so this
- *     module validates the server's response BEFORE printing it, rather than
- *     trusting a 200 status to mean a well-shaped body;
- *   - human-readable diagnostics go to stderr only, never stdout.
- *
- * THE CREDENTIAL — the SAME resolver `bridge` uses (DX-2862 / DX-2921 AC),
- * via `resolveBridgeOptions` (`bridge.ts`): the dashboard URL, credential
- * source and credential all come from the connection record this session's
- * OWN danx-dashboard MCP server wrote on its last successful `plan_connect`
- * (`session-connection.ts`), never from this process's own ambient env. That
- * is deliberate here for the identical reason it is deliberate for `bridge`:
- * a hook process trusting whatever `DANXBOT_DISPATCH_TOKEN` happens to be in
- * its environment is precisely the DX-2862 bug (a hook's ambient credential
- * silently pointed at a different dashboard from the one the session's tools
- * actually use).
- *
- * A HARD TIMEOUT (AC 30672) — `PLAN_STATE_REQUEST_TIMEOUT_MS`. This call
- * blocks a turn boundary the plugin is holding open, so it must never hang:
- * a slow or wedged dashboard is `{ok:false, reason:"timeout"}`, not a stuck
- * hook.
- */
-import { SESSION_ID_HEADER, resolveBridgeOptions } from "./bridge.js";
-export const PLAN_STATE_SUBCOMMAND = "plan-state";
-export const TURN_STATE_PATH = "/api/plan-sessions/me/turn-state";
-/** How long this one-shot call may take before it counts as a timeout. */
-export const PLAN_STATE_REQUEST_TIMEOUT_MS = 5_000;
-const USAGE = `usage: CLAUDE_CODE_SESSION_ID=<session-id> danx-dashboard-mcp ${PLAN_STATE_SUBCOMMAND}`;
-function errorCodeOf(body) {
-    return typeof body === "object" && body !== null && typeof body.error === "string"
-        ? body.error
-        : null;
-}
-function isFiniteNumber(v) {
-    return typeof v === "number" && Number.isFinite(v);
-}
-function isCardRef(v) {
-    return (typeof v === "object" &&
-        v !== null &&
-        typeof v.id === "string" &&
-        typeof v.title === "string");
-}
-/**
- * The strict shape check the contract pins (comment 4245): finite counts, a
- * `plan` with `id` + `name`, and a string `id` + `title` on every
- * `startable` / `held` entry. `null` on anything short of that — a 200 whose
- * body does not match is `bad_response`, exactly like a non-2xx.
- */
-export function parseTurnStateBody(body) {
-    if (typeof body !== "object" || body === null)
-        return null;
-    const b = body;
-    const plan = b.plan;
-    if (typeof plan !== "object" || plan === null)
-        return null;
-    const p = plan;
-    if (!isFiniteNumber(p.id) || typeof p.name !== "string")
-        return null;
-    const counts = b.counts;
-    if (typeof counts !== "object" || counts === null)
-        return null;
-    const c = counts;
-    if (!isFiniteNumber(c.open) || !isFiniteNumber(c.inProgress) || !isFiniteNumber(c.needsYou))
-        return null;
-    if (!Array.isArray(b.startable) || !b.startable.every(isCardRef))
-        return null;
-    if (!Array.isArray(b.held) || !b.held.every(isCardRef))
-        return null;
-    return {
-        plan: { id: p.id, name: p.name },
-        counts: { open: c.open, inProgress: c.inProgress, needsYou: c.needsYou },
-        startable: b.startable,
-        held: b.held,
-    };
-}
-/**
- * One authenticated GET, with a hard timeout, classified into the output
- * shape this subcommand always prints — never a throw, never a non-2xx
- * bubbling past this function.
- */
-export async function fetchTurnState(options, deps) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), deps.requestTimeoutMs);
-    let status;
-    let text;
-    try {
-        try {
-            const response = await deps.fetch(`${options.dashboardUrl}${TURN_STATE_PATH}`, {
-                method: "GET",
-                headers: {
-                    Authorization: `Bearer ${options.token}`,
-                    Accept: "application/json",
-                    [SESSION_ID_HEADER]: options.sessionId,
-                },
-                signal: controller.signal,
-            });
-            status = response.status;
-            text = await response.text();
-        }
-        catch (err) {
-            return { ok: false, reason: controller.signal.aborted ? "timeout" : "request_failed" };
-        }
-    }
-    finally {
-        clearTimeout(timer);
-    }
-    let body = null;
-    try {
-        body = text === "" ? null : JSON.parse(text);
-    }
-    catch {
-        return { ok: false, reason: "bad_response" };
-    }
-    // The exact literal the plugin's no-log-spam rule keys on (AC 30672 /
-    // comment 4245) — the dashboard's own 409 error code for an unconnected
-    // session, passed through verbatim rather than renamed.
-    if (status === 409 && errorCodeOf(body) === "session_not_connected") {
-        return { ok: false, reason: "session_not_connected" };
-    }
-    if (status === 401 || status === 403) {
-        return { ok: false, reason: "unauthorized" };
-    }
-    if (status < 200 || status >= 300) {
-        return { ok: false, reason: "http_error" };
-    }
-    const parsed = parseTurnStateBody(body);
-    if (parsed === null) {
-        return { ok: false, reason: "bad_response" };
-    }
-    return { ok: true, ...parsed };
-}
-/** The bin's `plan-state` subcommand, wired to the real process. Always resolves to exit code 0. */
-export async function runPlanStateCommand(argv, env = process.env, 
-/** Test seam: the home the session's connection record is read from. */
-resolveFrom = {}) {
-    const write = (output) => {
-        process.stdout.write(`${JSON.stringify(output)}\n`);
-    };
-    if (argv.length !== 0) {
-        // A malformed invocation is still a "the hook must stay silent" failure,
-        // not a crash — same ok:false/exit-0 contract as every other failure
-        // path here, with the usage line reserved for a human reading stderr.
-        write({ ok: false, reason: "usage" });
-        process.stderr.write(`${USAGE}\n`);
-        return 0;
-    }
-    const sessionId = env.CLAUDE_CODE_SESSION_ID;
-    if (!sessionId) {
-        write({ ok: false, reason: "no_session_id" });
-        process.stderr.write(`${USAGE}\n`);
-        return 0;
-    }
-    let options;
-    try {
-        options = resolveBridgeOptions({ sessionId, resumeIds: [] }, env, resolveFrom);
-    }
-    catch (err) {
-        const start = err;
-        write({ ok: false, reason: start.reason });
-        process.stderr.write(`${start.reason}: ${start.message}. Fix: ${start.fix}.\n`);
-        return 0;
-    }
-    const output = await fetchTurnState(options, {
-        fetch: (input, init) => fetch(input, init),
-        requestTimeoutMs: PLAN_STATE_REQUEST_TIMEOUT_MS,
-    });
-    write(output);
-    return 0;
-}