@thehammer/danx-dashboard-mcp 0.1.162 → 0.1.164

package/dist/lifecycle.js

@@ -0,0 +1,447 @@
+/**
+ * DX-3465 (PLN-11 R-25 / plan rule R-25) — the "lifecycle" tool set: agent-
+ * specific dispatch callbacks, merged from danxbot's own `src/mcp/danxbot-server.ts`
+ * (DX-3459 problem 1754, decision: one server, named tool sets, switched on
+ * per profile). These are NOT dashboard CRUD — they are the agent's own
+ * self-report channel to the worker/dashboard that spawned it: "I'm done"
+ * (`danxbot_complete`), Slack reply/update/recovery, quality-gate sign-off,
+ * template-app load/save, and the evaluator summary. Every dashboard CRUD
+ * operation these tools used to sit beside (issue_*, plan_* etc.) goes
+ * through `danxbot_api` instead (R-25) — see `index.ts`.
+ *
+ * Registered UNCONDITIONALLY at module load (so the DX-1606 tool-defs
+ * generator — which never calls `boot()` — still introspects every one of
+ * them for token-cost accounting), then individually `.disable()`d inside
+ * `boot()` (`index.ts`) based on which per-dispatch callback URL env vars
+ * are actually present — the same visibility contract
+ * `buildActiveTools`/`callTool` used to enforce in the old standalone
+ * server: a tool whose URL wasn't injected for this dispatch is not just
+ * inert, it is invisible to `tools/list`.
+ *
+ * DX-3394 problem 1682 cleanup folded into this merge:
+ *  - `danxbot_restart_worker` — already removed on `main` before this card
+ *    (DX-3231 host-mode removal); never carried over.
+ *  - `quality_gate_skip` folded into `quality_gate_complete` as
+ *    `status: "skipped"` (reason ≥20 chars, same server-side bar).
+ *  - `slack_replace_message` + `slack_purge_message` merged into
+ *    `slack_recovery_message({action: "replace" | "purge", ts, text?})`.
+ *  - `ready` / `archive` / `review` removed from `AGENT_COMPLETE_STATUSES`
+ *    (Core Principle 1 — no legacy aliases). The `danx-flesh-out` plugin
+ *    skill instructed the old aliases; that is Part B (plugin-side prose),
+ *    not reachable from this repo.
+ *  - `danxbot_update_router_prompt` DELETED OUTRIGHT (DX-3459 problem 1755,
+ *    decision 251: the router prompt becomes an ordinary board setting,
+ *    reached through `danxbot_api` with a scoped permission — no dedicated
+ *    tool). The slack-agent profile documents the route (Part B).
+ *  - Descriptions trimmed of DX-card historical narration where cheap to do
+ *    without re-deriving the byte-for-byte target DX-3394 measured.
+ */
+import { z } from "zod";
+/**
+ * The six canonical agent-visible `danxbot_complete` statuses. DX-3394
+ * problem 1682 / Core Principle 1 — the pre-DX-770 deprecated aliases
+ * (`completed`, `agent_blocked`) were already gone; this merge additionally
+ * drops the `ready` / `archive` / `review` backward-compat aliases that
+ * Core Principle 1 forbids as standing legacy tolerance. A dispatch that
+ * needs one of those non-terminal lifecycle stamps transitions the card
+ * FIRST through `danxbot_api` ({method:'POST', path:'/api/issues/:id/transition',
+ * body:{action:'ready'|'archive'}}), then calls
+ * `danxbot_complete({status:'complete'})`.
+ */
+export const AGENT_COMPLETE_STATUSES = [
+    "complete",
+    "cancelled",
+    "failed",
+    "critical_failure",
+    "waiting_on_dependency",
+];
+/** DX-722 — minimum `summary` length for `failed` to count as a legitimate self-block. */
+export const ADEQUATE_SUMMARY_MIN_CHARS = 30;
+/** DX-1369 — minimum reason length for a `quality_gate_complete` "skipped" verdict. */
+export const QUALITY_GATE_SKIP_REASON_MIN_CHARS = 20;
+export function hasAdequateBlockSummary(summary) {
+    return typeof summary === "string" && summary.trim().length >= ADEQUATE_SUMMARY_MIN_CHARS;
+}
+/** Read the lifecycle callback URLs straight from `process.env`. */
+export function readLifecycleUrlsFromEnv() {
+    const opt = (name) => {
+        const v = process.env[name];
+        return typeof v === "string" && v !== "" ? v : undefined;
+    };
+    return {
+        stop: opt("DANXBOT_STOP_URL"),
+        slackReply: opt("DANXBOT_SLACK_REPLY_URL"),
+        slackUpdate: opt("DANXBOT_SLACK_UPDATE_URL"),
+        linkThreadToIssue: opt("DANXBOT_LINK_THREAD_TO_ISSUE_URL"),
+        slackRecoveryList: opt("DANXBOT_SLACK_RECOVERY_LIST_URL"),
+        slackRecoveryMessage: opt("DANXBOT_SLACK_RECOVERY_MESSAGE_URL"),
+        slackRecoveryCreateOrLink: opt("DANXBOT_SLACK_RECOVERY_CREATE_OR_LINK_URL"),
+        qualityGate: opt("DANXBOT_QUALITY_GATE_URL"),
+        evaluatorSummary: opt("DANXBOT_EVALUATOR_SUMMARY_URL"),
+        saveTemplateApp: opt("DANXBOT_TEMPLATE_APP_SAVE_URL"),
+        loadTemplateApp: opt("DANXBOT_TEMPLATE_APP_LOAD_URL"),
+    };
+}
+async function postJson(url, body, bearer) {
+    return fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...(bearer ? { Authorization: `Bearer ${bearer}` } : {}),
+        },
+        body: JSON.stringify(body),
+    });
+}
+/** DX-925 — bearer for dispatch-internal WORKER routes (stop, quality-gate, template-app, ...). */
+function agentBearer() {
+    return process.env.DANX_AGENT_TOKEN;
+}
+/** DX-2246 — bearer for the callbacks that target the DASHBOARD (slack reply/update, link-thread, slack-recovery). */
+function dashboardBearer() {
+    return process.env.DANXBOT_DASHBOARD_TOKEN;
+}
+async function postWorkerRoute(url, body, toolName, bearer) {
+    const response = await postJson(url, body, bearer);
+    const text = await response.text();
+    if (!response.ok) {
+        throw new Error(`${toolName} worker endpoint returned HTTP ${response.status}: ${text}`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { raw: text };
+    }
+}
+function parseOptionalAbsolutePathArray(field, value) {
+    if (value === undefined)
+        return [];
+    return value.map((entry, idx) => {
+        if (!entry.startsWith("/")) {
+            throw new Error(`field "${field}"[${idx}] must be an absolute path (got "${entry}")`);
+        }
+        return entry;
+    });
+}
+/**
+ * Registers every lifecycle tool on `server` via the caller's `strictTool`
+ * wrapper (so every tool here gets the same DX-3238 strict-shape guard the
+ * rest of this package's tools use) and returns the `RegisteredTool` handles
+ * for the ones that are conditionally visible — `boot()` disables each based
+ * on `readLifecycleUrlsFromEnv()`.
+ */
+export function registerLifecycleTools(strictTool) {
+    // ---------------- danxbot_complete ----------------
+    // Always visible — every dispatch, of every kind, ends with this call.
+    strictTool("danxbot_complete", "Finalize the current dispatch. Releases the worker's per-dispatch scope and ends the dispatch row. " +
+        "Does NOT move any card — if you're working an issue-bound dispatch and want the card to move " +
+        "(Done / Blocked / Cancelled / etc.), transition the card FIRST through danxbot_api " +
+        "({method:'POST', path:'/api/issues/:id/transition', body:{action:...}}), then call this tool. " +
+        "Always call this when done instead of simply stopping output.", {
+        status: z.enum(AGENT_COMPLETE_STATUSES).describe("complete = work shipped, ends the dispatch row (does NOT move the card — transition it first); " +
+            "failed = the dispatch could not finish its job; ends the dispatch row failed + a strike; see " +
+            `summary for its ≥${ADEQUATE_SUMMARY_MIN_CHARS}-char requirement. Does NOT block the card — if the ` +
+            "cause is card-specific, first transition the card with action 'block' and a reason through " +
+            "danxbot_api ({method:'POST', path:'/api/issues/:id/transition', body:{action:'block', reason}}). " +
+            "Waiting on other work is a depends_on edge, not a block; when a human is 100% required, add a " +
+            "problem with solutions instead; " +
+            "cancelled = agent voluntarily abandons the dispatch (does NOT cancel the card — transition it first); " +
+            "critical_failure = environment broken in a way that affects every dispatch (MCP tools not loading, " +
+            "Bash unavailable, Claude auth missing) — halts the poller until a human clears it; " +
+            "waiting_on_dependency = genuinely blocked on a card that must land on another board/repo — file that " +
+            "change as a card on the right board, add a depends_on edge from yours to it, commit your own WIP, " +
+            "transition yours rollback_pickup, then end with this status (never complete/ready/archive/review, " +
+            "which delete your branch)."),
+        summary: z
+            .string()
+            .describe("Brief summary of what happened. For failed, the dispatch-environment failure reason, " +
+            `≥${ADEQUATE_SUMMARY_MIN_CHARS} chars or the call downgrades to cancelled + a strike. For ` +
+            "critical_failure, the specific environment issue. For complete, a one-line summary of what shipped. " +
+            "Card-side context belongs on the transition call (through danxbot_api), not here."),
+    }, async (args) => {
+        const stopUrl = readLifecycleUrlsFromEnv().stop;
+        if (!stopUrl) {
+            throw new Error("danxbot_complete: DANXBOT_STOP_URL not configured for this dispatch");
+        }
+        let response;
+        try {
+            response = await postJson(stopUrl, { status: args.status, summary: args.summary }, agentBearer());
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            throw new Error(`danxbot_complete: POST to worker stop endpoint failed (${detail}) — terminal transition NOT applied.`);
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`danxbot_complete: worker stop endpoint returned HTTP ${response.status}: ${text} — terminal transition NOT applied.`);
+        }
+        return {
+            content: [{ type: "text", text: `Agent signaled ${args.status}: ${args.summary}` }],
+        };
+    });
+    // ---------------- danxbot_slack_reply ----------------
+    const slackReply = strictTool("danxbot_slack_reply", "Post the FINAL user-facing reply to the originating Slack thread. Call exactly once per dispatch, " +
+        "immediately before danxbot_complete. Optionally attach result files via files[] (absolute local paths " +
+        "on the shared filesystem) — text + attachments land as ONE atomic thread post. For intermediate " +
+        "progress use danxbot_slack_post_update instead.", {
+        text: z.string().describe("The final reply text to post to the Slack thread."),
+        files: z
+            .array(z.string())
+            .optional()
+            .describe("Optional absolute local paths to files to attach to the reply."),
+    }, async (args) => {
+        const url = readLifecycleUrlsFromEnv().slackReply;
+        if (!url)
+            throw new Error("danxbot_slack_reply called outside a Slack dispatch");
+        const files = parseOptionalAbsolutePathArray("files", args.files);
+        const body = { text: args.text };
+        if (files.length > 0)
+            body.files = files;
+        const response = await postJson(url, body, dashboardBearer());
+        if (!response.ok)
+            throw new Error(`Slack reply API returned HTTP ${response.status}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: files.length > 0
+                        ? `Reply posted to Slack thread with ${files.length} file(s)`
+                        : "Reply posted to Slack thread",
+                },
+            ],
+        };
+    });
+    // ---------------- danxbot_slack_post_update ----------------
+    const slackPostUpdate = strictTool("danxbot_slack_post_update", "Post an intermediate progress update to the originating Slack thread. Use SPARINGLY — only for " +
+        "meaningful status the user cares about. Do NOT post for every file read or trivial step.", { text: z.string().describe("The intermediate status update text.") }, async (args) => {
+        const url = readLifecycleUrlsFromEnv().slackUpdate;
+        if (!url)
+            throw new Error("danxbot_slack_post_update called outside a Slack dispatch");
+        const response = await postJson(url, { text: args.text }, dashboardBearer());
+        if (!response.ok)
+            throw new Error(`Slack update API returned HTTP ${response.status}`);
+        return { content: [{ type: "text", text: "Update posted to Slack thread" }] };
+    });
+    // ---------------- link_thread_to_issue ----------------
+    const linkThreadToIssue = strictTool("link_thread_to_issue", "Upgrade THIS Slack thread into a tracked card: bind the thread to ONE issue (immutable 1:1) and " +
+        "register the Slack mirror so future card updates re-render the thread's card-view message. Thread " +
+        "scope is IMPLICIT (channel + thread_ts come from the dispatch) — pass only the issue id. Call this " +
+        "AFTER posting your substantive answer with danxbot_slack_reply (that reply becomes the card-view " +
+        '"message #1"). A second call on an already-linked thread fails loud with a 409 — never a silent re-link.', { issue_id: z.string().describe('The card id to bind this thread to (e.g. "DX-1086").') }, async (args) => {
+        const url = readLifecycleUrlsFromEnv().linkThreadToIssue;
+        if (!url)
+            throw new Error("link_thread_to_issue called outside a Slack dispatch");
+        const result = await postWorkerRoute(url, { issue_id: args.issue_id }, "link_thread_to_issue", dashboardBearer());
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ---------------- slack_recovery_list ----------------
+    const slackRecoveryList = strictTool("slack_recovery_list", "Read-only. Returns the Slack thread's full stored message history plus failures[], the recorded " +
+        "router failures projected out of those same messages, so you can reason about what happened before " +
+        "mutating anything. Only available on a slack-recovery dispatch.", {}, async () => {
+        const url = readLifecycleUrlsFromEnv().slackRecoveryList;
+        if (!url)
+            throw new Error("slack_recovery_list called outside a slack-recovery dispatch");
+        const result = await postWorkerRoute(url, {}, "slack_recovery_list", dashboardBearer());
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ---------------- slack_recovery_message (merged replace+purge, DX-3394 problem 1682) ----------------
+    const slackRecoveryMessage = strictTool("slack_recovery_message", "Replace or delete ONE message you posted in this thread. `action: 'replace'` (`chat.update`) rewrites " +
+        "the message text — the replaced message becomes this thread's card-view anchor ('message #1'): a " +
+        "later link_thread_to_issue registers THIS ts, and danxbot re-renders the real card view into this " +
+        "exact slot, so write a short human line, never a hand-written card view, in `text`. `action: 'purge'` " +
+        "(`chat.delete` + prunes the matching thread-history entry in ONE call — never post-and-hope these " +
+        "happen separately). Both REFUSE any ts you did not author (server-side) and are idempotent: replacing " +
+        "or purging an already-gone ts succeeds as a no-op.", {
+        action: z.enum(["replace", "purge"]),
+        ts: z
+            .string()
+            .describe("The Slack message timestamp to act on. Must be a message this bot authored (from " +
+            "slack_recovery_list's messages[] with isBot:true — every failures[] postedTs is one)."),
+        text: z
+            .string()
+            .optional()
+            .describe("Required for action:'replace' — the new message text. Ignored for 'purge'."),
+    }, async (args) => {
+        const url = readLifecycleUrlsFromEnv().slackRecoveryMessage;
+        if (!url)
+            throw new Error("slack_recovery_message called outside a slack-recovery dispatch");
+        if (args.action === "replace" && args.text === undefined) {
+            throw new Error("slack_recovery_message: text is required for action:'replace'");
+        }
+        const body = { action: args.action, ts: args.ts };
+        if (args.text !== undefined)
+            body.text = args.text;
+        const result = await postWorkerRoute(url, body, "slack_recovery_message", dashboardBearer());
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ---------------- slack_recovery_create_or_link ----------------
+    const slackRecoveryCreateOrLink = strictTool("slack_recovery_create_or_link", "The ONLY way to get a card id for this thread on a slack-recovery dispatch (danxbot_api's card-create " +
+        "route, POST /api/issues, is not available here). Resolves SERVER-SIDE whether the thread already " +
+        "resolves to a card before creating " +
+        "anything: a hit returns that existing card's id (created:false) and creates NOTHING; a miss creates a " +
+        "fresh card with the fields you pass (created:true) — a duplicate card is structurally impossible. " +
+        "Either way, follow up with link_thread_to_issue({issue_id}) using the returned id.", {
+        type: z
+            .enum(["Bug", "Story", "Chore"])
+            .describe("The card type. Never Epic/Feature — a single Slack request never warrants a container card."),
+        title: z.string().describe("Card title."),
+        description: z
+            .string()
+            .describe("Card description — sourced from the triggering human message's content."),
+        ac: z
+            .array(z.object({ title: z.string() }).strict())
+            .optional()
+            .describe("Optional acceptance-criteria items."),
+        effort_level: z.string().optional().describe("Optional effort level."),
+        priority: z.number().optional().describe("Optional priority in [0, 6)."),
+        triage_enabled: z.boolean().optional().describe("Optional auto-triage opt-in; absent → false."),
+    }, async (args) => {
+        const url = readLifecycleUrlsFromEnv().slackRecoveryCreateOrLink;
+        if (!url)
+            throw new Error("slack_recovery_create_or_link called outside a slack-recovery dispatch");
+        const body = {
+            type: args.type,
+            title: args.title,
+            description: args.description,
+        };
+        if (args.ac !== undefined)
+            body.ac = args.ac;
+        if (args.effort_level !== undefined)
+            body.effort_level = args.effort_level;
+        if (args.priority !== undefined)
+            body.priority = args.priority;
+        if (args.triage_enabled !== undefined)
+            body.triage_enabled = args.triage_enabled;
+        const result = await postWorkerRoute(url, body, "slack_recovery_create_or_link", dashboardBearer());
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ---------------- quality_gate_complete (absorbs quality_gate_skip, DX-3394 problem 1682) ----------------
+    const qualityGateComplete = strictTool("quality_gate_complete", "Sign off a registered quality gate. Two flavors by the gate's PHASE: (PLAN, e.g. plan-architecture) — " +
+        "runs as its own dispatch; this call is that dispatch's TERMINAL call: status='pass' releases the " +
+        "dispatch (the picker launches the next gate or the work agent); status='fail' BLOCKS the card (your " +
+        "message becomes the reason) and stops the dispatch (do NOT follow up with danxbot_complete); " +
+        "status='retry' — the fixer loop: you edited the card into a sounder plan and want a fresh pass. " +
+        "(CODE, e.g. code-quality) — runs INLINE in your WORK session: stamps the gate + stores findings and " +
+        "does NOTHING else. You CONTINUE: fix any blocking findings, re-run to a pass, then finalize and " +
+        "complete the card normally. status='skipped' — the gate is OBVIOUSLY UNNECESSARY for this diff " +
+        "(a single-line / docs-only change, or nothing in this gate's lane): use `message` as the mandatory " +
+        `justification (≥${QUALITY_GATE_SKIP_REASON_MIN_CHARS} chars, the permanent accountability record a ` +
+        "reviewer will read) — never skip to dodge a real review. A skipped required gate does not block " +
+        "transitioning the card to complete (through danxbot_api) and does not re-dispatch a PRE gate.", {
+        gate: z.string().describe("Registered gate name, e.g. 'plan-architecture' or 'code-quality'."),
+        status: z.enum(["pass", "fail", "retry", "skipped"]),
+        message: z
+            .string()
+            .describe("Sign-off rationale / verdict summary. On a plan-gate fail this becomes the card's block reason. " +
+            `On 'skipped' this is the mandatory ≥${QUALITY_GATE_SKIP_REASON_MIN_CHARS}-char justification.`),
+        findings: z
+            .array(z
+            .object({
+            title: z.string(),
+            description: z.string().optional(),
+            status: z.string().optional(),
+            reasoning: z.string().optional(),
+        })
+            .strict())
+            .optional()
+            .describe("Code gates only — structured findings, one object per finding. Omit for plan gates."),
+    }, async (args) => {
+        const url = readLifecycleUrlsFromEnv().qualityGate;
+        if (!url)
+            throw new Error("quality_gate_complete called outside a quality-gate-capable dispatch");
+        if (args.status === "skipped" &&
+            args.message.trim().length < QUALITY_GATE_SKIP_REASON_MIN_CHARS) {
+            throw new Error(`quality_gate_complete: message must be at least ${QUALITY_GATE_SKIP_REASON_MIN_CHARS} characters ` +
+                `for status:'skipped' — it is the accountability record for skipping the "${args.gate}" gate`);
+        }
+        const body = { gate: args.gate, status: args.status, message: args.message };
+        if (args.findings !== undefined)
+            body.findings = args.findings;
+        const result = await postWorkerRoute(url, body, "quality_gate_complete", agentBearer());
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ---------------- danxbot_set_evaluator_summary ----------------
+    const evaluatorSummary = strictTool("danxbot_set_evaluator_summary", "Write the root-cause summary for a 3-strike broken agent. ONLY the system-evaluator dispatch sees this " +
+        "tool. Call exactly once at the END of the dispatch, immediately before danxbot_complete. A dispatch " +
+        "that exits without calling this tool is treated as evaluator failure.", {
+        reason: z
+            .string()
+            .describe("Markdown body the dashboard banner renders: ## Root cause(s) (1-3 bullets), ## Per-strike detail " +
+            "(one bullet per strike), ## Recommended human action (one paragraph)."),
+        suggested_steps: z
+            .array(z.string())
+            .optional()
+            .describe("Ordered list of concrete operator actions. Empty/absent is allowed."),
+    }, async (args) => {
+        const url = readLifecycleUrlsFromEnv().evaluatorSummary;
+        if (!url)
+            throw new Error("danxbot_set_evaluator_summary called without an evaluator dispatch");
+        const result = await postWorkerRoute(url, { reason: args.reason, suggested_steps: args.suggested_steps ?? [] }, "danxbot_set_evaluator_summary", agentBearer());
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ---------------- save_template_app ----------------
+    const saveTemplateApp = strictTool("save_template_app", "Build and ship ONE template app, keyed by template id. Walks <cwd>/templates/<template_id>/source/, " +
+        "builds, packs the bundle, then on success fires an async callback to the repo's configured save_url. " +
+        "Returns the synchronous build verdict. Call once per app after its edits are complete.", {
+        template_id: z
+            .string()
+            .describe("Receiver-side template id — selects the source location and keys the output bundle."),
+    }, async (args) => {
+        const url = readLifecycleUrlsFromEnv().saveTemplateApp;
+        if (!url)
+            throw new Error("save_template_app called without a template_app-configured dispatch");
+        const result = await postWorkerRoute(url, { template_id: args.template_id }, "save_template_app", agentBearer());
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ---------------- load_template_app ----------------
+    const loadTemplateApp = strictTool("load_template_app", "Set up ONE template app on demand and bring its live HMR preview up. On a FRESH dispatch this WHOLESALE-" +
+        "RESETS <cwd>/templates/<template_id>/source/ (pulling the consumer's source or scaffolding a default) " +
+        "— call this BEFORE you start editing, never after. On a RESUMED dispatch it touches nothing. Returns " +
+        "{template_id, hmr_url, source_dir} — source_dir is the ONLY path to edit; the build reads it directly.", {
+        template_id: z
+            .string()
+            .describe("Receiver-side template id — defines the source location and is echoed to consumer callbacks."),
+    }, async (args) => {
+        const url = readLifecycleUrlsFromEnv().loadTemplateApp;
+        if (!url)
+            throw new Error("load_template_app called without a template_app-configured dispatch");
+        const result = await postWorkerRoute(url, { template_id: args.template_id }, "load_template_app", agentBearer());
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    return {
+        slackReply,
+        slackPostUpdate,
+        linkThreadToIssue,
+        slackRecoveryList,
+        slackRecoveryMessage,
+        slackRecoveryCreateOrLink,
+        qualityGateComplete,
+        evaluatorSummary,
+        saveTemplateApp,
+        loadTemplateApp,
+    };
+}
+/**
+ * Disable every conditionally-visible lifecycle tool whose URL is absent
+ * from `urls` — the same advertise-filter contract `buildActiveTools` used
+ * to enforce in the old standalone server. `danxbot_complete` is never in
+ * this map — it is unconditionally visible (every dispatch ends with it).
+ */
+export function applyLifecycleVisibility(tools, urls) {
+    const setVisible = (tool, visible) => {
+        if (visible)
+            tool.enable();
+        else
+            tool.disable();
+    };
+    setVisible(tools.slackReply, !!urls.slackReply);
+    setVisible(tools.slackPostUpdate, !!urls.slackUpdate);
+    setVisible(tools.linkThreadToIssue, !!urls.linkThreadToIssue);
+    setVisible(tools.slackRecoveryList, !!urls.slackRecoveryList);
+    setVisible(tools.slackRecoveryMessage, !!urls.slackRecoveryMessage);
+    setVisible(tools.slackRecoveryCreateOrLink, !!urls.slackRecoveryCreateOrLink);
+    setVisible(tools.qualityGateComplete, !!urls.qualityGate);
+    setVisible(tools.evaluatorSummary, !!urls.evaluatorSummary);
+    setVisible(tools.saveTemplateApp, !!urls.saveTemplateApp);
+    setVisible(tools.loadTemplateApp, !!urls.loadTemplateApp);
+}

package/dist/priority.js

@@ -1,13 +1,13 @@
 /**
- * Tier-word → numeric priority resolution for the MCP `issue_edit` tool
- * (DX-1532).
+ * Tier-word → numeric priority resolution for `danxbot_api`'s
+ * `PATCH /api/issues/:id/edit` route (DX-1532).
  *
  * Priority is a STRUCTURED numeric column `issues.priority` (float in `[0,6)`).
  * Both the Trello "priority" label and the dashboard priority badge read it via
  * `priorityTier(issue.priority)` — description PROSE ("Priority: Low") is read
  * by neither. So an agent that "sets priority" by editing description text
  * produces a silent false-positive: nothing downstream changes. The fix is to
- * let the agent write the numeric column through `issue_edit`.
+ * let the agent write the numeric column through the issue-edit route.
  *
  * Agents (and operators) speak in tier WORDS ("low" / "high"), so the tool
  * accepts a tier word and resolves it to the tier's MIDPOINT here — the inverse
@@ -64,7 +64,7 @@ export function resolvePriority(input) {
         return input;
     const midpoint = PRIORITY_TIER_MIDPOINTS[input];
     if (midpoint === undefined) {
-        throw new Error(`issue_edit: unknown priority tier word "${input}" (expected one of ${PRIORITY_TIER_WORDS.join(", ")} or a number in [0,6))`);
+        throw new Error(`issue-edit: unknown priority tier word "${input}" (expected one of ${PRIORITY_TIER_WORDS.join(", ")} or a number in [0,6))`);
     }
     return midpoint;
 }

package/package.json

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