feat(claude/mcp): optional capability filter for genesis-tools MCP

README.md

@@ -160,6 +160,16 @@ Answer a question, then preserve the Q→A to the local question store so it can
 
 Captured via the `question_answer` MCP tool, falling back to the `tools question record` CLI.
 
+#### genesis-tools MCP server (`tools claude mcp`)
+
+The plugin's own MCP server (stdio) exposes two capabilities: `question_answer` (the Q&A capture tool above) and `boards` (dev-dashboard annotation boards — `boards_list_boards`, `boards_wait_for_work`, `boards_compose_board`, etc.). Both are enabled by default. To restrict which capabilities are registered, set `GENESIS_TOOLS_MCP_CAPABILITIES` to a comma-delimited list of capability names in the server's environment (e.g. in `~/.claude.json`'s `mcpServers.genesis-tools.env`):
+
+```bash
+GENESIS_TOOLS_MCP_CAPABILITIES=question_answer,boards   # both (default when unset)
+GENESIS_TOOLS_MCP_CAPABILITIES=question_answer          # only the Q&A tool
+GENESIS_TOOLS_MCP_CAPABILITIES=boards                   # only boards tools
+```
+
 ---
 
 ### Skill Details

plugins/genesis-tools/skills/agents-talk/SKILL.md

@@ -122,7 +122,7 @@ Each event is a JSON line. The most important `type` values:
 
 | | `--stream` (default, CC) | `--once` (any host) |
 |---|---|---|
-| Lifetime | Long-running, ~1h sanity cap | Returns when a message arrives or harness kills it |
+| Lifetime | Long-running, ~8h sanity cap | Returns when a message arrives or harness kills it |
 | Harness tool | `Monitor` follows stdout | Caller re-invokes in a loop |
 | Resume after exit | Continues where it left off | Continues where it left off |
 | Cost | One held process per agent | One short-lived call per receive |

src/agents/commands/login.ts

@@ -17,7 +17,7 @@ import { resolveSession } from "../lib/session-resolve";
 import { readSlotPayload, releaseSlot, runStaleSweep, slotLockPath, tryAcquireSlot } from "../lib/slot-lock";
 import type { AgentRecord, FeedEvent, SessionPaths, SlotLockPayload } from "../lib/types";
 
-const ONE_HOUR_MS = 60 * 60 * 1000;
+const LISTEN_CAP_MS = 8 * 60 * 60 * 1000;
 
 const log = logger.child({ component: "agents:login" });
 
@@ -426,6 +426,12 @@ async function runLoginImpl(opts: LoginOpts): Promise<void> {
     onShutdown(async (reason) => {
         exitReason = reason;
 
+        // Release the PID lock BEFORE any feed I/O: if the process dies
+        // mid-drain (force-kill, lock timeout), the slot must not stay
+        // orphaned. Worst case of the reversed order is a same-agent relogin
+        // racing the final cursor write — duplicate delivery, never loss.
+        releaseSlot(lockPath);
+
         try {
             await drainPending(active);
         } catch (err) {
@@ -438,7 +444,6 @@ async function runLoginImpl(opts: LoginOpts): Promise<void> {
             log.warn({ err }, "logged_out emit failed during shutdown");
         }
 
-        releaseSlot(lockPath);
         emitResumeHint(active.record, mode);
     });
 
@@ -451,23 +456,29 @@ async function runLoginImpl(opts: LoginOpts): Promise<void> {
             const initialEmitted = await drainPending(active);
 
             if (initialEmitted === 0) {
-                const deadline = Date.now() + ONE_HOUR_MS;
+                const deadline = Date.now() + LISTEN_CAP_MS;
                 await watchUntilDeadline(active, deadline, true);
             }
         } else {
-            const deadline = Date.now() + ONE_HOUR_MS;
+            const deadline = Date.now() + LISTEN_CAP_MS;
             await watchUntilDeadline(active, deadline, false);
             exitReason = "cap";
         }
     } finally {
+        releaseSlot(lockPath);
+
         try {
             await drainPending(active);
         } catch (err) {
             log.warn({ err }, "final drain failed");
         }
 
-        await emitLoggedOut({ paths, record: active.record, reason: exitReason, mode });
-        releaseSlot(lockPath);
+        try {
+            await emitLoggedOut({ paths, record: active.record, reason: exitReason, mode });
+        } catch (err) {
+            log.warn({ err }, "logged_out emit failed on exit");
+        }
+
         emitResumeHint(active.record, mode);
     }
 }

src/agents/lib/lifecycle.ts

@@ -8,23 +8,29 @@ export type ShutdownHandler = (reason: ShutdownReason) => Promise<void> | void;
 
 const handlers: ShutdownHandler[] = [];
 let signalsInstalled = false;
-let shuttingDown = false;
-
-async function runHandlers(reason: ShutdownReason): Promise<void> {
-    if (shuttingDown) {
-        return;
+let shutdownRun: Promise<void> | null = null;
+
+// A single shared promise (not a boolean guard) so a second signal delivered
+// mid-shutdown awaits the in-flight handlers instead of returning immediately
+// and calling process.exit() while they're still running — that killed the
+// process before releaseSlot(), orphaning the PID lock until an unrelated
+// agent's stale-lock sweep reaped it.
+function runHandlers(reason: ShutdownReason): Promise<void> {
+    if (!shutdownRun) {
+        shutdownRun = (async () => {
+            const ordered = [...handlers].reverse();
+
+            for (const handler of ordered) {
+                try {
+                    await handler(reason);
+                } catch (err) {
+                    log.warn({ err }, "shutdown handler threw");
+                }
+            }
+        })();
     }
 
-    shuttingDown = true;
-    const ordered = [...handlers].reverse();
-
-    for (const handler of ordered) {
-        try {
-            await handler(reason);
-        } catch (err) {
-            log.warn({ err }, "shutdown handler threw");
-        }
-    }
+    return shutdownRun;
 }
 
 function installSignals(): void {

src/claude/commands/mcp.ts

@@ -8,7 +8,10 @@ const log = logger.child({ component: "claude:mcp-cmd" });
 export function registerMcpCommand(program: Command): void {
     const mcp = program
         .command("mcp")
-        .description("Run the genesis-tools MCP server (stdio) — exposes question_answer")
+        .description(
+            "Run the genesis-tools MCP server (stdio) — exposes question_answer + boards. " +
+                "Set GENESIS_TOOLS_MCP_CAPABILITIES (comma-delimited, e.g. question_answer,boards) to restrict."
+        )
         .action(async () => {
             log.info("starting MCP server");
             await startMcpServer();

src/claude/mcp/server.ts

@@ -1,4 +1,5 @@
 import { logger } from "@app/logger";
+import { env } from "@app/utils/env/envVariables";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -351,8 +352,37 @@ function buildToolRegistry(): Record<string, ToolEntry> {
     };
 }
 
+/** Known capability names, keyed to the tool-name prefix that identifies membership. */
+const CAPABILITY_PREFIXES: Record<string, string> = {
+    question_answer: "question_answer",
+    boards: "boards_",
+};
+
+/**
+ * Filters the tool registry by GENESIS_TOOLS_MCP_CAPABILITIES (comma-delimited, e.g.
+ * "question_answer,boards"). Unset or empty -> every capability enabled (unchanged default).
+ */
+function filterRegistryByCapabilities(registry: Record<string, ToolEntry>): Record<string, ToolEntry> {
+    const capabilities = env.tools.getMcpCapabilities();
+    if (capabilities === undefined) {
+        return registry;
+    }
+
+    const enabledPrefixes = capabilities
+        .map((capability) => CAPABILITY_PREFIXES[capability])
+        .filter((prefix): prefix is string => prefix !== undefined);
+
+    return Object.fromEntries(
+        Object.entries(registry).filter(([name]) => enabledPrefixes.some((prefix) => name.startsWith(prefix)))
+    );
+}
+
 export async function startMcpServer(): Promise<void> {
-    const registry = buildToolRegistry();
+    const registry = filterRegistryByCapabilities(buildToolRegistry());
+    log.info(
+        { capabilities: env.tools.getMcpCapabilities() ?? "all", tools: Object.keys(registry) },
+        "genesis-tools MCP tool registry resolved"
+    );
     const server = new Server(
         { name: "genesis-tools", version: "1.0.0" },
         { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS }

src/jenkins-mcp/lib/blue-ocean.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "bun:test";
+import {
+    type BlueOceanNode,
+    blueOceanNodesUrls,
+    buildContextMap,
+    contextFromBlueOcean,
+    dedupeConsecutive,
+} from "./blue-ocean";
+
+describe("blueOceanNodesUrls", () => {
+    it("prefers multibranch branch URL then full pipeline fallback", () => {
+        const urls = blueOceanNodesUrls("job/Digi22/job/col/job/FE/job/col-fe-multibranch-build/job/develop", "7180");
+        expect(urls).toHaveLength(2);
+        expect(urls[0]).toContain("/pipelines/Digi22/pipelines/col/pipelines/FE/pipelines/col-fe-multibranch-build/");
+        expect(urls[0]).toContain("/branches/develop/runs/7180/nodes/");
+        expect(urls[1]).toContain("/pipelines/develop/runs/7180/nodes/");
+        expect(urls[1]).not.toContain("/branches/");
+    });
+
+    it("percent-encodes branch segments (Jenkins stores feature/foo as one segment)", () => {
+        // Classic URL already has one path segment for the branch; % must be re-encoded for Blue Ocean.
+        const urls = blueOceanNodesUrls("job/pipe/job/feature%2Ffoo", "3");
+        expect(urls[0]).toContain("/branches/feature%252Ffoo/");
+    });
+});
+
+describe("dedupeConsecutive", () => {
+    it("collapses PARALLEL+STAGE duplicate names", () => {
+        expect(dedupeConsecutive(["Build affected apps", "fee-web", "fee-web", "Tests"])).toEqual([
+            "Build affected apps",
+            "fee-web",
+            "Tests",
+        ]);
+    });
+});
+
+describe("contextFromBlueOcean", () => {
+    const nodes: BlueOceanNode[] = [
+        { id: "12", displayName: "Clone", type: "STAGE", firstParent: null },
+        { id: "58", displayName: "Repo QA", type: "STAGE", firstParent: "12" },
+        { id: "62", displayName: "Type check", type: "PARALLEL", firstParent: "58" },
+        { id: "75", displayName: "Build affected apps", type: "STAGE", firstParent: null },
+        { id: "82", displayName: "fee-web", type: "PARALLEL", firstParent: "75" },
+        { id: "91", displayName: "fee-web", type: "STAGE", firstParent: "82" },
+        { id: "110", displayName: "Tests", type: "STAGE", firstParent: "91" },
+        { id: "166", displayName: "Build", type: "STAGE", firstParent: "110" },
+        { id: "499", displayName: "SonarQube", type: "STAGE", firstParent: "480" },
+        { id: "480", displayName: "deploy", type: "STAGE", firstParent: "346" },
+        { id: "346", displayName: "Build image", type: "STAGE", firstParent: "166" },
+    ];
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+
+    it("labels Tests with fee-web context", () => {
+        const ctx = contextFromBlueOcean("110", byId)!;
+        expect(ctx.context).toBe("fee-web");
+        expect(ctx.label).toBe("fee-web · Tests");
+        expect(ctx.path).toEqual(["Build affected apps", "fee-web", "Tests"]);
+    });
+
+    it("labels nested Build under fee-web", () => {
+        const ctx = contextFromBlueOcean("166", byId)!;
+        expect(ctx.context).toBe("fee-web");
+        expect(ctx.label).toBe("fee-web · Build");
+    });
+
+    it("labels SonarQube with fee-web (not deploy)", () => {
+        const ctx = contextFromBlueOcean("499", byId)!;
+        expect(ctx.context).toBe("fee-web");
+        expect(ctx.label).toBe("fee-web · SonarQube");
+        expect(ctx.path).toContain("fee-web");
+        expect(ctx.path[ctx.path.length - 1]).toBe("SonarQube");
+    });
+
+    it("labels parallel QA under Repo QA", () => {
+        const ctx = contextFromBlueOcean("62", byId)!;
+        expect(ctx.context).toBe("Repo QA");
+        expect(ctx.label).toBe("Repo QA · Type check");
+    });
+
+    it("keeps top-level Clone plain", () => {
+        const ctx = contextFromBlueOcean("12", byId)!;
+        expect(ctx.context).toBeUndefined();
+        expect(ctx.label).toBe("Clone");
+        expect(ctx.path).toEqual(["Clone"]);
+    });
+
+    it("keeps fee-web shell label plain (no fee-web · fee-web)", () => {
+        const ctx = contextFromBlueOcean("91", byId)!;
+        expect(ctx.label).toBe("fee-web");
+    });
+});
+
+describe("buildContextMap", () => {
+    it("indexes every node id", () => {
+        const map = buildContextMap([
+            { id: "1", displayName: "A", type: "STAGE", firstParent: null },
+            { id: "2", displayName: "B", type: "STAGE", firstParent: "1" },
+        ]);
+        expect(map.get("2")?.label).toBe("A · B");
+    });
+});