@nonbot/mcp 0.2.3 → 0.3.0

package/dist/core/toolsets/build.js

@@ -1,8 +1,11 @@
 import { z } from 'zod';
 import { api, expectJson } from '../http.js';
 import { validateGraph } from '../validate.js';
-import { LEVELS, applyLayout, layoutTimeline, scheduleFields, todayColumn, columnOf, isItem, PX_PER_WEEK } from '../layout.js';
+import { LEVELS, applyLayout, layoutTimeline, layoutMapDetailed, applyMapLayout, scheduleFields, todayColumn, columnOf, isItem, PX_PER_WEEK } from '../layout.js';
 import { emptyIp, IP_KINDS, IP_NODE_SIZE } from '../ipShape.js';
+import { withMapHeaders } from '../mapHeaders.js';
+import { renderPreviewSvg } from '../preview.js';
+import { applyStyleRules, CARD_STYLES, TITLE_SIZES, ACCENTS, SHOW_KEYS, STATES as STYLE_STATES } from '../style.js';
 const STATES = ['funnel', 'reviewing', 'analyzing', 'ready', 'implementing', 'done'];
 const OKR_STATUSES = ['on-track', 'at-risk', 'behind'];
 const RESERVED = new Set(['hierarchyLevel', 'parentItemId', 'linkedEpicIds', 'id', '__proto__', 'constructor', 'prototype']);
@@ -13,7 +16,7 @@ const fail = (msg) => ({ content: [{ type: 'text', text: msg }], isError: true }
 const escHtml = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 export const toHtml = (s) => /^\s*</.test(s) ? s : s.split(/\n{2,}/).map(p => `<p>${escHtml(p.trim()).replace(/\n/g, '<br>')}</p>`).join('');
 export function newItemId(now = Date.now()) { return `pf-${now}-${Math.random().toString(36).slice(2, 11)}`; }
-async function loadGraph(ctx, id) {
+export async function loadGraph(ctx, id) {
     const data = await expectJson(await api(ctx, `/api/portfolio/graph?id=${encodeURIComponent(id)}`), 'load portfolio');
     const g = (data.graph ?? data);
     return {
@@ -25,7 +28,7 @@ async function loadGraph(ctx, id) {
         version: typeof g.version === 'number' ? g.version : undefined,
     };
 }
-async function saveGraph(ctx, id, before, after, expectedVersion) {
+export async function saveGraph(ctx, id, before, after, expectedVersion) {
     const problems = validateGraph(after.nodes, after.edges);
     if (problems.length)
         return { ok: false, message: `Refusing to write — ${problems.length} problem(s):\n` + problems.map(p => `  - ${p}`).join('\n') };
@@ -63,7 +66,7 @@ const itemSpec = z.object({
     duration_weeks: z.number().min(0).max(156).optional().describe('Default: epic 8, feature 4, story 1, enabler 2, milestone 0, objective / key-result 12.'),
     tags: z.array(z.string().max(40)).max(20).optional(),
     wsjf: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional().describe('[business value, time criticality, risk reduction, job size].'),
-    owner: z.string().max(80).optional(),
+    owner: z.string().max(80).optional().describe(`Who does this item — the Program view's lanes group by it. Set it on every feature / story / enabler / milestone: the human's name (as they appear in the portfolio, e.g. "Conrad") for work only a person can do — review or approve a plan, decide, buy, sign up, sign in, hand over a key, test on a real device, talk to a customer; "AI" for work an agent delivers — code, tests, migrations, docs, research, drafts. Spell it exactly "AI" so all agent work shares one lane.`),
     kr_target: z.string().max(200).optional(),
     kr_current: z.string().max(200).optional(),
     okr_status: z.enum(OKR_STATUSES).optional(),
@@ -74,6 +77,20 @@ const DEFAULT_WEEKS = { epic: 8, feature: 4, story: 1, enabler: 2, milestone: 0,
 const LEGAL_PARENT = {
     epic: [], objective: [], 'key-result': ['objective'], feature: ['epic'], story: ['feature', 'epic'], enabler: ['epic', 'feature'], milestone: ['epic', 'feature'],
 };
+export const AI_OWNER = 'AI';
+const WORK_LEVELS = new Set(['feature', 'story', 'enabler', 'milestone']);
+export function ownerReport(specs) {
+    const owners = {};
+    const unassigned = [];
+    for (const s of specs) {
+        const who = s.owner?.trim();
+        if (who)
+            owners[who] = (owners[who] ?? 0) + 1;
+        else if (WORK_LEVELS.has(s.level))
+            unassigned.push(s.key ?? s.title);
+    }
+    return { owners, unassigned };
+}
 export function buildItems(g, specs, now = new Date()) {
     const errors = [];
     const ids = {};
@@ -112,8 +129,8 @@ export function buildItems(g, specs, now = new Date()) {
             d.hypothesisStatement = s.hypothesis;
         if (s.tags)
             d.tags = s.tags;
-        if (s.owner)
-            d.owner = s.owner;
+        if (s.owner?.trim())
+            d.owner = s.owner.trim();
         if (s.wsjf)
             Object.assign(d, { wsjfBusinessValue: s.wsjf[0], wsjfTimeCriticality: s.wsjf[1], wsjfRiskReduction: s.wsjf[2], wsjfJobSize: s.wsjf[3] });
         if (s.kr_target)
@@ -166,6 +183,21 @@ export function buildItems(g, specs, now = new Date()) {
     return { nodes, edges, ids, errors, patched };
 }
 export function registerBuildTools(server, ctx) {
+    server.registerTool('portfolio_preview', {
+        title: 'Picture a portfolio layout',
+        description: 'Draw the portfolio as an SVG schematic — every card at its stored Map (default) or Timeline position and size, with its level, state and title (done cards pale green), section-header notes as headings — so you can LOOK at a layout before calling it done. Returns the SVG text plus the card count and extent. `sizes` (px per id) overrides the stored / estimated card sizes; `width` sets the output width.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            view: z.enum(['map', 'timeline']).optional(),
+            sizes: z.record(z.string(), z.object({ width: z.number().min(1).max(8000), height: z.number().min(1).max(8000) })).optional(),
+            width: z.number().int().min(200).max(8000).optional(),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (a) => {
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const r = renderPreviewSvg(g.nodes, { view: a.view, sizes: a.sizes, width: a.width });
+        return { content: [{ type: 'text', text: JSON.stringify({ cards: r.cards, extent: r.extent }) }, { type: 'text', text: r.svg }] };
+    });
     if (ctx.readonly)
         return;
     server.registerTool('portfolio_create', {
@@ -216,12 +248,16 @@ export function registerBuildTools(server, ctx) {
         const r = await saveGraph(ctx, a.portfolio_id, g, after, a.expected_version);
         if (!r.ok)
             return fail(r.message);
-        const structured = { ok: true, added: built.nodes.length, edges: built.edges.length, ids: built.ids, ...(r.version !== undefined ? { version: r.version } : {}) };
-        return { content: [text(structured)], structuredContent: structured };
+        const who = ownerReport(a.items);
+        const structured = { ok: true, added: built.nodes.length, edges: built.edges.length, ids: built.ids, owners: who.owners, unassigned: who.unassigned, ...(r.version !== undefined ? { version: r.version } : {}) };
+        const content = [text(structured)];
+        if (who.unassigned.length)
+            content.push({ type: 'text', text: `${who.unassigned.length} work item(s) have no owner: ${who.unassigned.join(', ')}. Give each one with portfolio_patch_item (set: { owner }) — the human's name for work only a person can do (review, approve, decide, buy, sign in, test on a device), "${AI_OWNER}" for work an agent delivers — so the human can see at a glance what is theirs.` });
+        return { content, structuredContent: structured };
     });
     server.registerTool('portfolio_patch_item', {
         title: 'Patch one item',
-        description: 'Change fields of ONE portfolio item without rewriting the graph (PATCH /api/portfolio/graph/node): `set` writes allowlisted PortfolioItemData fields (title, description, bluf, acceptanceCriteria, hypothesisStatement, state, tags, wsjf*, krTarget, pastedImages, durationWeeks, startDate, …), `unset` deletes them. Rich text is stored as given (pass HTML, or plain text which is wrapped in <p>). A stale version answers 409 — nothing is written.',
+        description: 'Change fields of ONE portfolio item without rewriting the graph (PATCH /api/portfolio/graph/node): `set` writes allowlisted PortfolioItemData fields (title, description, bluf, acceptanceCriteria, hypothesisStatement, state, owner — the human\'s name or "AI", tags, wsjf*, krTarget, pastedImages, durationWeeks, startDate, …), `unset` deletes them. Rich text is stored as given (pass HTML, or plain text which is wrapped in <p>). A stale version answers 409 — nothing is written.',
         inputSchema: {
             portfolio_id: z.string(),
             item_id: z.string(),
@@ -248,22 +284,92 @@ export function registerBuildTools(server, ctx) {
     });
     server.registerTool('portfolio_layout', {
         title: 'Lay out a portfolio on the Timeline',
-        description: 'Re-position every item so the Timeline reads cleanly: x from each item\'s start date (the canvas reads dates off x), y top-down — objectives, key results, then one block per epic (epic, features, stories + enablers, milestones), each row lane-packed so overlapping items stack, IP nodes directly above their first source. Short items get a minimum painted width so titles fit. Content is untouched. `heights` overrides the estimated card height per id (px) when a card measures taller on screen.',
+        description: 'Re-position every item so the Timeline reads cleanly: x from each item\'s start date (the canvas reads dates off x), y top-down — objectives, key results, then one block per epic (epic, features, stories + enablers, milestones), each row lane-packed so overlapping items stack, IP nodes directly above their first source. Short items get a minimum painted width so titles fit. Content is untouched. `heights` overrides the estimated card height per id (px) when a card measures taller on screen. `group: "objective"` reads top-down by goal instead: each objective, its key results, then the blocks of the epics those key results link to, before the next objective (`objective_order` lists objective ids to put first); unlinked epics follow. Grouping changes rows only, never x or dates. `view: "map"` lays out the Map instead (the free layout, `freePosition` only — the Timeline positions and dates are untouched): one band per objective (`objective_order` first), the objective + key results leading it, then one column per linked epic with its features and a 3-wide grid of stories; unlinked epics, loose items and modules follow.',
         inputSchema: {
             portfolio_id: z.string(),
             heights: z.record(z.string(), z.number().min(20).max(2000)).optional(),
+            sizes: z.record(z.string(), z.object({ width: z.number().min(1).max(8000), height: z.number().min(1).max(8000) })).optional().describe('With view "map": measured card sizes (px) per id — Map cards are as wide as their content.'),
+            column_height: z.number().min(400).max(20000).optional().describe('With view "map": an epic column taller than this (px) wraps into another column beside it, at feature boundaries.'),
+            pack: z.enum(['stack', 'grid']).optional().describe('With view "map": "grid" packs the objective bands into rows shaped like a screen (default "stack": top to bottom).'),
+            headers: z.boolean().optional().describe('With view "map": a section-header note above each objective band (title + epics + % done). Re-running updates the same notes; notes you wrote are never touched.'),
+            view: z.enum(['timeline', 'map']).optional().describe('Default timeline. "map": write the Map (free) positions only, grouped by objective.'),
+            group: z.enum(['objective']).optional().describe('"objective": group epic blocks under the objective whose key results link to them.'),
+            objective_order: z.array(z.string()).max(100).optional().describe('With group "objective": objective ids to place first, in this order.'),
             expected_version: z.number().int().optional(),
         },
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (a) => {
         const g = await loadGraph(ctx, a.portfolio_id);
-        const res = layoutTimeline(g.nodes, { heights: a.heights });
+        if (a.view === 'map') {
+            const HEADER_H = 220;
+            const cards = g.nodes.filter(n => !(n.type === 'rad-module' && n.data?.moduleData?.__layoutHeader));
+            const d = layoutMapDetailed(cards, { edges: g.edges, objectiveOrder: a.objective_order, heights: a.heights, sizes: a.sizes, pack: a.pack, columnHeight: a.column_height, headerHeight: a.headers ? HEADER_H : 0 });
+            let nodes = applyMapLayout(g.nodes, d.positions);
+            let headers = { added: 0, updated: 0, removed: 0 };
+            if (a.headers !== undefined) {
+                const h = withMapHeaders(nodes, a.headers ? d.bands : [], HEADER_H);
+                nodes = h.nodes;
+                headers = { added: h.added, updated: h.updated, removed: h.removed };
+            }
+            const r = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes }, a.expected_version);
+            if (!r.ok)
+                return fail(r.message);
+            const structured = { ok: true, view: 'map', positioned: d.positions.size, bands: d.bands.length, headers, ...(r.version !== undefined ? { version: r.version } : {}) };
+            return { content: [text(structured)], structuredContent: structured };
+        }
+        const res = layoutTimeline(g.nodes, { heights: a.heights, ...(a.group ? { group: a.group, edges: g.edges, objectiveOrder: a.objective_order } : {}) });
         const r = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes: applyLayout(g.nodes, res) }, a.expected_version);
         if (!r.ok)
             return fail(r.message);
         const structured = { ok: true, positioned: res.positions.size, ...(r.version !== undefined ? { version: r.version } : {}) };
         return { content: [text(structured)], structuredContent: structured };
     });
+    server.registerTool('portfolio_style', {
+        title: 'Restyle many cards at once',
+        description: 'Give a portfolio one consistent look in ONE versioned write: rules, applied in order, each matching cards by levels / states / ids / hasImage and setting how they are drawn — display (card_style plain|poster|split|image-top|cover|grid-2|grid-4, title_size sm|md|lg, accent tint|bar|plain, show {bluf, description, acceptanceCriteria, tags, dates, wsjf}), size (Map width × height, or "auto" to size to content) and satellites "close" (fold the card\'s inner-loop panels). Content is untouched. Artifact child cards (hypothesis, NFR…) are skipped unless a rule sets artifacts: true.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            rules: z.array(z.object({
+                levels: z.array(z.enum(LEVELS)).optional(),
+                states: z.array(z.enum(STYLE_STATES)).optional(),
+                ids: z.array(z.string()).max(1000).optional(),
+                has_image: z.boolean().optional(),
+                artifacts: z.boolean().optional(),
+                display: z.object({
+                    card_style: z.enum(CARD_STYLES).optional(),
+                    title_size: z.enum(TITLE_SIZES).optional(),
+                    accent: z.enum(ACCENTS).optional(),
+                    show: z.object(Object.fromEntries(SHOW_KEYS.map(k => [k, z.boolean().optional()]))).optional(),
+                }).optional(),
+                size: z.union([z.object({ width: z.number().min(60).max(4000), height: z.number().min(40).max(4000) }), z.literal('auto')]).optional(),
+                satellites: z.literal('close').optional(),
+            })).min(1).max(40),
+            expected_version: z.number().int().optional(),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (a) => {
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const rules = a.rules.map(r => ({
+            ...(r.levels ? { levels: r.levels } : {}),
+            ...(r.states ? { states: r.states } : {}),
+            ...(r.ids ? { ids: r.ids } : {}),
+            ...(r.has_image !== undefined ? { hasImage: r.has_image } : {}),
+            ...(r.artifacts ? { artifacts: true } : {}),
+            ...(r.display ? { display: { cardStyle: r.display.card_style, titleSize: r.display.title_size, accent: r.display.accent, show: r.display.show } } : {}),
+            ...(r.size ? { size: r.size } : {}),
+            ...(r.satellites ? { satellites: r.satellites } : {}),
+        }));
+        const res = applyStyleRules(g.nodes, rules);
+        if (res.changed === 0) {
+            const structured = { ok: true, matched: res.matched, changed: 0, perRule: res.perRule };
+            return { content: [text(structured)], structuredContent: structured };
+        }
+        const r = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes: res.nodes }, a.expected_version);
+        if (!r.ok)
+            return fail(r.message);
+        const structured = { ok: true, matched: res.matched, changed: res.changed, perRule: res.perRule, ...(r.version !== undefined ? { version: r.version } : {}) };
+        return { content: [text(structured)], structuredContent: structured };
+    });
     server.registerTool('portfolio_set_meta', {
         title: 'Set portfolio settings',
         description: 'Graph-level settings that travel with the portfolio (the `__graph_meta__` record): `context_text` (the portfolio\'s context notes — what a newcomer reads first), `palette` ({ id, name, swatches: [{hex, label?}] ≤ 10, roles?: {epic, feature, story, …: hex | "p:N"} }), `canvas_style`, `sprint_settings`. Only the keys you pass change; everything else in the record is kept.',

package/dist/core/toolsets/portfolio.js

@@ -208,6 +208,15 @@ export function registerPortfolioTools(server, ctx) {
         const structured = { count: characters.length, characters };
         return { content: [text(structured)], structuredContent: structured };
     });
+    server.registerTool('portfolio_comments_list', {
+        title: 'List comments on an item',
+        description: 'List the threaded comments on one portfolio item (author, content, resolved flag, parent comment).',
+        inputSchema: { portfolio_id: z.string(), item_id: z.string() },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (a) => {
+        const res = await api(ctx, `/api/portfolio/comments?portfolioId=${encodeURIComponent(a.portfolio_id)}&itemId=${encodeURIComponent(a.item_id)}`);
+        return { content: [text(await expectJson(res, 'portfolio_comments_list'))] };
+    });
     if (ctx.readonly)
         return;
     async function gatedReq(method, path, body, label) {
@@ -518,4 +527,65 @@ export function registerPortfolioTools(server, ctx) {
         const structured = { ok: true, ...(versionId ? { versionId } : {}), ...(a.label ? { label: a.label } : {}) };
         return { content: [text(structured)], structuredContent: structured };
     });
+    async function currentVersion(portfolioId, label) {
+        const res = await api(ctx, `/api/portfolio/graph?id=${encodeURIComponent(portfolioId)}`);
+        const g = await expectJson(res, label);
+        const graph = (g.graph ?? g);
+        const v = Number(graph.version);
+        if (!Number.isFinite(v))
+            throw new Error(`${label}: portfolio ${portfolioId} returned no version`);
+        return v;
+    }
+    server.registerTool('portfolio_move_subtree', {
+        title: 'Move an item and its descendants to another portfolio',
+        description: 'Move one item AND every descendant (by parentItemId) out of a portfolio into another one — an existing portfolio (target_portfolio_id) or a brand-new one (new_portfolio_name). Atomic: both portfolios are written together or not at all. Hierarchy edges that cross the boundary are severed (the moved root becomes a root); dependency edges are kept as cross-portfolio links. Versions are read automatically when omitted.',
+        inputSchema: {
+            portfolio_id: z.string().describe('Source portfolio.'),
+            root_item_id: z.string().describe('The item to move; its whole subtree travels with it.'),
+            target_portfolio_id: z.string().optional().describe('Existing destination portfolio.'),
+            new_portfolio_name: z.string().optional().describe('Create a new destination portfolio with this name instead.'),
+            expected_version: z.number().int().optional().describe('Source version (OCC). Read automatically when omitted.'),
+            target_expected_version: z.number().int().optional().describe('Target version (OCC). Read automatically when omitted.'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+    }, async (a) => {
+        if (!!a.target_portfolio_id === !!a.new_portfolio_name) {
+            return { content: [{ type: 'text', text: 'Provide exactly one of target_portfolio_id or new_portfolio_name.' }], isError: true };
+        }
+        const expectedVersion = a.expected_version ?? await currentVersion(a.portfolio_id, 'portfolio_move_subtree (source)');
+        const target = a.target_portfolio_id
+            ? {
+                kind: 'existing',
+                portfolioId: a.target_portfolio_id,
+                expectedVersion: a.target_expected_version ?? await currentVersion(a.target_portfolio_id, 'portfolio_move_subtree (target)'),
+            }
+            : { kind: 'new', name: a.new_portfolio_name };
+        const res = await api(ctx, `/api/portfolio/${encodeURIComponent(a.portfolio_id)}/move-subtree`, {
+            method: 'POST',
+            body: JSON.stringify({ rootNodeId: a.root_item_id, expectedVersion, target }),
+        });
+        return { content: [text(await expectJson(res, 'portfolio_move_subtree'))] };
+    });
+    server.registerTool('portfolio_comment_post', {
+        title: 'Comment on an item',
+        description: 'Post a comment on one portfolio item (optionally as a reply via parent_comment_id). Max 10 KB; the server allows 20 comments per minute.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            item_id: z.string(),
+            content: z.string().min(1).max(10240),
+            parent_comment_id: z.string().optional(),
+        },
+        annotations: { readOnlyHint: false, openWorldHint: true },
+    }, async (a) => {
+        const res = await api(ctx, '/api/portfolio/comments', {
+            method: 'POST',
+            body: JSON.stringify({
+                portfolioId: a.portfolio_id,
+                itemId: a.item_id,
+                content: a.content,
+                ...(a.parent_comment_id ? { parentCommentId: a.parent_comment_id } : {}),
+            }),
+        });
+        return { content: [text(await expectJson(res, 'portfolio_comment_post'))] };
+    });
 }

package/dist/core/toolsets/radbugs.d.ts

@@ -1,3 +1,30 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ApiContext } from '../config.js';
+declare const LIST_STATUSES: readonly ["open", "done", "wontfix", "ai_flagged"];
+type ListStatus = (typeof LIST_STATUSES)[number];
+export interface RadbugNote {
+    id: string;
+    status: string;
+    priority: string | null;
+    area: string | null;
+    pageUrl: string | null;
+    description: string;
+    createdAt: number | null;
+    updatedAt: number | null;
+    hasScreenshot: boolean;
+    rawMessage?: string | null;
+}
+export declare function fetchRadbugs(ctx: ApiContext, opts?: {
+    status?: ListStatus;
+    area?: string;
+    priority?: 'low' | 'med' | 'high';
+    limit?: number;
+}): Promise<{
+    forbidden: true;
+    reason: string;
+} | {
+    forbidden: false;
+    notes: RadbugNote[];
+}>;
 export declare function registerRadbugsTools(server: McpServer, ctx: ApiContext): void;
+export {};

package/dist/core/toolsets/radbugs.js

@@ -16,7 +16,62 @@ async function forbiddenText(res) {
 function textResult(data) {
     return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
 }
+const LIST_STATUSES = ['open', 'done', 'wontfix', 'ai_flagged'];
+const LIST_FORBIDDEN = 'radbug_list is owner-only: it needs the site owner\'s account and a token with the radbugs:read scope (or an unscoped token).';
+const ms = (v) => { const n = Number(v); return Number.isFinite(n) && n > 0 ? n : null; };
+export async function fetchRadbugs(ctx, opts = {}) {
+    const limit = Math.min(Math.max(opts.limit ?? 200, 1), 500);
+    const q = [`limit=${encodeURIComponent(String(opts.status === 'done' ? 500 : limit))}`];
+    if (opts.status && opts.status !== 'done')
+        q.push(`status=${encodeURIComponent(opts.status)}`);
+    if (opts.area)
+        q.push(`area=${encodeURIComponent(opts.area)}`);
+    if (opts.priority)
+        q.push(`priority=${encodeURIComponent(opts.priority)}`);
+    const res = await api(ctx, `/api/admin/radbugs?${q.join('&')}`);
+    if (res.status === 403 || res.status === 401)
+        return { forbidden: true, reason: LIST_FORBIDDEN };
+    const body = await expectJson(res, 'GET /api/admin/radbugs');
+    const raw = Array.isArray(body.notes) ? body.notes : [];
+    const notes = [];
+    for (const r of raw) {
+        if (!r || typeof r.id !== 'string')
+            continue;
+        const status = String(r.status ?? '');
+        if (opts.status && status !== opts.status)
+            continue;
+        notes.push({
+            id: r.id, status,
+            priority: typeof r.priority === 'string' ? r.priority : null,
+            area: typeof r.area === 'string' ? r.area : null,
+            pageUrl: typeof r.pageUrl === 'string' ? r.pageUrl.slice(0, 2048) : null,
+            description: String(r.description ?? '').slice(0, 2000),
+            createdAt: ms(r.createdAt), updatedAt: ms(r.updatedAt),
+            hasScreenshot: !!(r.screenshot || (Array.isArray(r.screenshots) && r.screenshots.length)),
+            rawMessage: typeof r.rawMessage === 'string' ? r.rawMessage.slice(0, 500) : null,
+        });
+        if (notes.length >= limit)
+            break;
+    }
+    return { forbidden: false, notes };
+}
 export function registerRadbugsTools(server, ctx) {
+    server.registerTool('radbug_list', {
+        title: 'List radBUGS',
+        description: 'List radBUGS from the non.bot inbox, newest first (open ones lead): id (ti_…), status (open | ai_flagged | done | wontfix), priority, area, page URL, description (clipped to 2 000 chars), created / updated time (epoch ms). `done` includes bugs closed from the inbox. Screenshots are left out. Owner-only: the site owner\'s account with a radbugs:read (or unscoped) token.',
+        inputSchema: {
+            status: z.enum(LIST_STATUSES).optional().describe('Only this status; "done" = closed.'),
+            area: z.string().max(80).optional(),
+            priority: z.enum(['low', 'med', 'high']).optional(),
+            limit: z.number().int().min(1).max(500).optional().describe('Default 200.'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (a) => {
+        const r = await fetchRadbugs(ctx, a);
+        if (r.forbidden)
+            return { content: [{ type: 'text', text: r.reason }], isError: true };
+        return textResult({ count: r.notes.length, notes: r.notes });
+    });
     if (ctx.readonly)
         return;
     server.registerTool('radbug_file', {

package/dist/core/toolsets/release.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type ApiContext } from '../config.js';
+export declare function registerReleaseTools(server: McpServer, ctx: ApiContext): void;