@orboto/mcp 0.178.0

package/dist/prompts.js

@@ -0,0 +1,219 @@
+/**
+ * ORB-244 Phase D - MCP prompts.
+ *
+ * Prompts are reusable instruction templates an MCP-aware client
+ * (Claude Desktop, Cursor) surfaces in its UI as a one-click action.
+ * Each handler returns `messages[]` that become the start of the
+ * conversation; the user's model then drives the work, typically
+ * by calling orboto MCP tools.
+ *
+ * Five v1 templates - each a thin wrapper that hands the model a
+ * focused goal + a tool sequence to execute:
+ * - plan-sprint(projectKey) - draft a sprint plan from open work
+ * - triage-my-tickets() - sort caller's open assignments
+ * - summarize-project(projectKey) - quick project briefing
+ * - estimate-ticket(ticketKey) - rough effort guess via similar work
+ * - find-duplicates(ticketKey) - search for overlapping tickets
+ *
+ * No backend AI calls - the prompts steer the model, the model
+ * uses tools. Keeps the surface stateless and the AI provider
+ * irrelevant (works with any MCP client).
+ */
+import { z } from 'zod';
+export function registerOrbotoPrompts(server) {
+    // -------------------------------------------------------------------------
+    // plan-sprint
+    // -------------------------------------------------------------------------
+    server.registerPrompt('plan-sprint', {
+        title: 'Draft a sprint plan',
+        description: 'Build a 2-week sprint plan from a project\'s open backlog and the team\'s recent velocity.',
+        argsSchema: { projectKey: z.string().min(1).describe('Project key, e.g. "ACME".') },
+    }, ({ projectKey }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Plan a 2-week sprint for project ${projectKey}.`,
+                        '',
+                        'Steps:',
+                        `1. Use \`orboto_get_project\` on "${projectKey}" to see milestones, members, and overall status.`,
+                        `2. Use \`orboto_list_tickets\` with statusCategory="todo" to fetch the open backlog.`,
+                        `3. Use \`orboto_list_milestones\` and pick the next not-yet-completed milestone as the sprint target.`,
+                        '4. Sort the backlog by priority (blocker > high > normal > low > trivial), then by ticket age (older first), and propose 8-12 tickets that:',
+                        '   - Together fit roughly the team\'s capacity (estimate via past closed tickets if visible)',
+                        '   - Cover all the blockers and high-priority items',
+                        '   - Have at most 1-2 epics so the sprint stays achievable',
+                        '5. For each picked ticket, name the recommended assignee from the project members and a 1-line "why this person".',
+                        '6. Output the plan as a Markdown table: ticket key, title, assignee, rough days. Then a 2-3 sentence summary on what this sprint aims to deliver.',
+                        '',
+                        'If a step blocks (e.g. no milestones, empty backlog), say so plainly and stop instead of inventing data.',
+                    ].join('\n'),
+                },
+            }],
+    }));
+    // -------------------------------------------------------------------------
+    // triage-my-tickets
+    // -------------------------------------------------------------------------
+    server.registerPrompt('triage-my-tickets', {
+        title: 'Triage my open tickets',
+        description: 'Sort the caller\'s open assignments and recommend the next 3 to focus on.',
+        argsSchema: {},
+    }, () => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        'Triage my open tickets.',
+                        '',
+                        'Steps:',
+                        '1. Use `orboto_my_tickets` (no statusCategory filter - defaults to open work) to fetch what I\'m assigned to.',
+                        '2. For each ticket, fetch full context with `orboto_get_ticket` to see description, latest comment, blocking sub-tickets, and linked git activity.',
+                        '3. Rank by:',
+                        '   - Priority (blocker > high > normal > low)',
+                        '   - Due date (overdue + soon-due first)',
+                        '   - Whether something/someone is waiting (open PR comment, assignee comment asking a question)',
+                        '4. Pick the top 3 and explain - for each - what the next concrete action is (write code? respond to a comment? close as won\'t fix?).',
+                        '5. Surface anything that should be DELEGATED (assigned to someone else) or DROPPED (closed as won\'t fix), if anything fits.',
+                        '',
+                        'Be terse. One paragraph per ticket. The point is to start working, not to read a thesis.',
+                    ].join('\n'),
+                },
+            }],
+    }));
+    // -------------------------------------------------------------------------
+    // summarize-project
+    // -------------------------------------------------------------------------
+    server.registerPrompt('summarize-project', {
+        title: 'Summarise a project',
+        description: 'A 3-sentence briefing on a project - what it is, where it stands, what\'s next.',
+        argsSchema: { projectKey: z.string().min(1).describe('Project key, e.g. "ACME".') },
+    }, ({ projectKey }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Give me a 3-sentence summary of project ${projectKey}.`,
+                        '',
+                        'Steps:',
+                        `1. Use \`orboto_get_project\` on "${projectKey}" to see metadata, milestones, members.`,
+                        `2. Use \`orboto_list_tickets\` with statusCategory="in_progress" to see what's actively being worked.`,
+                        `3. Use \`orboto_list_milestones\` to see what's nearest the deadline.`,
+                        '',
+                        'Then write exactly 3 sentences: (a) what the project is, (b) where it currently stands, (c) what\'s next on the milestone path.',
+                        'No bullet lists, no headings. Just the three sentences.',
+                    ].join('\n'),
+                },
+            }],
+    }));
+    // -------------------------------------------------------------------------
+    // estimate-ticket
+    // -------------------------------------------------------------------------
+    server.registerPrompt('estimate-ticket', {
+        title: 'Estimate a ticket\'s effort',
+        description: 'Rough effort guess for a ticket based on its description and similar past work.',
+        argsSchema: { ticketKey: z.string().min(3).describe('Ticket key, e.g. "ACME-42".') },
+    }, ({ ticketKey }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Estimate the effort needed for ${ticketKey}.`,
+                        '',
+                        'Steps:',
+                        `1. Use \`orboto_get_ticket\` on "${ticketKey}" to read the description, type, priority, and any sub-tickets.`,
+                        `2. Use \`orboto_search\` with the ticket's title and description to find 3-5 similar past tickets, ideally already closed.`,
+                        '3. For each similar ticket found, use `orboto_get_ticket` to look up its loggedMinutes and check if the work seems comparable.',
+                        '4. Compute a median + range from the comparable past efforts.',
+                        '5. Output: estimated minutes, a confidence rating (low/medium/high), and one line per comparable ticket with its actual logged time.',
+                        '',
+                        'If you can\'t find comparable past work, say so - don\'t guess from thin air.',
+                    ].join('\n'),
+                },
+            }],
+    }));
+    // -------------------------------------------------------------------------
+    // find-duplicates
+    // -------------------------------------------------------------------------
+    server.registerPrompt('find-duplicates', {
+        title: 'Find duplicate tickets',
+        description: 'Look for tickets that overlap with the given one - likely duplicates or competing work.',
+        argsSchema: { ticketKey: z.string().min(3).describe('Ticket key, e.g. "ACME-42".') },
+    }, ({ ticketKey }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Find tickets that might overlap with ${ticketKey}.`,
+                        '',
+                        'Steps:',
+                        `1. Use \`orboto_get_ticket\` on "${ticketKey}" to read its title and description.`,
+                        '2. Pull 3-5 keyword phrases from the description.',
+                        `3. Use \`orboto_search\` with each phrase to find candidate matches (limit each search to 5).`,
+                        '4. Use `orboto_get_ticket` on the top 3 candidates to verify the actual overlap.',
+                        '5. Output:',
+                        ' - Likely duplicates (same intent, same scope) - list these first',
+                        ' - Related but distinct (overlapping topic, different scope) - list these second',
+                        ' - "Probably nothing" - only mention if all candidates were unrelated',
+                        '',
+                        'Be honest: if the original ticket has too little detail to compare, say so and stop. False positives waste more time than they save.',
+                    ].join('\n'),
+                },
+            }],
+    }));
+    // -------------------------------------------------------------------------
+    // ORB-855 - wiki-ingest: guided URL ingest flow.
+    // -------------------------------------------------------------------------
+    server.registerPrompt('wiki-ingest', {
+        title: 'Ingest a URL into the wiki',
+        description: 'Guided flow: import a URL into an LLM-Wiki space and confirm what the curation produced.',
+        argsSchema: { spaceId: z.string().min(1).describe('Target wiki space id.'), url: z.string().min(1).describe('Public URL to import.') },
+    }, ({ spaceId, url }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Ingest ${url} into wiki space ${spaceId}.`,
+                        '',
+                        'Steps:',
+                        `1. Call \`orboto_wiki_ingest_url\` with spaceId="${spaceId}" and url="${url}".`,
+                        '2. If the space runs review-gate, the curation lands as a pending plan - tell the operator to review it in the space (sidebar). If auto-apply, the pages were written directly.',
+                        '3. Read `orboto://wiki/' + spaceId + '/log` to confirm what changed and summarise the new / updated pages in 2-3 sentences.',
+                        '',
+                        'If ingest fails (bad URL, space not wiki-enabled), report the error plainly and stop.',
+                    ].join('\n'),
+                },
+            }],
+    }));
+    // -------------------------------------------------------------------------
+    // ORB-855 - wiki-maintain: guided lint + fix flow.
+    // -------------------------------------------------------------------------
+    server.registerPrompt('wiki-maintain', {
+        title: 'Maintain a wiki (lint + fix)',
+        description: 'Run the lint pass on an LLM-Wiki space and propose fixes for the open issues.',
+        argsSchema: { spaceId: z.string().min(1).describe('Wiki space id to maintain.') },
+    }, ({ spaceId }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Maintain wiki space ${spaceId}.`,
+                        '',
+                        'Steps:',
+                        `1. Call \`orboto_wiki_lint\` with spaceId="${spaceId}" to get the open issues.`,
+                        '2. Group them by kind (orphans, missing cross-references, stale, contradictions, undocumented, unprocessed sources).',
+                        '3. For each issue with a clear fix, propose the concrete change. For a fix the operator approves, use `orboto_wiki_plan_update` to draft it and `orboto_wiki_apply_plan` to commit - never apply destructive rewrites without confirmation.',
+                        '4. Summarise what you fixed and what still needs a human decision.',
+                        '',
+                        'If there are no open issues, say the wiki is clean and stop.',
+                    ].join('\n'),
+                },
+            }],
+    }));
+}

package/dist/prompts.test.js

@@ -0,0 +1,79 @@
+/**
+ * ORB-244 Phase D - prompt template unit tests.
+ *
+ * Prompts are stateless: handler returns a `messages[]` shape based
+ * purely on input args. We register against a real McpServer and
+ * read back via the SDK's internal registry, then assert the
+ * returned message text mentions (a) the goal, (b) the tools the
+ * model is supposed to call.
+ */
+import { describe, expect, it } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerOrbotoPrompts } from './prompts.js';
+function buildServerWithPrompts() {
+    const server = new McpServer({ name: 'test', version: '0.0.0' });
+    registerOrbotoPrompts(server);
+    return server;
+}
+function getPromptHandler(server, name) {
+    const prompts = server._registeredPrompts;
+    const entry = prompts[name];
+    if (!entry)
+        throw new Error(`No prompt "${name}" - known: ${Object.keys(prompts).join(', ')}`);
+    return entry.callback;
+}
+describe('plan-sprint prompt', () => {
+    it('emits a single user message that names the project + tool sequence', () => {
+        const server = buildServerWithPrompts();
+        const handler = getPromptHandler(server, 'plan-sprint');
+        const out = handler({ projectKey: 'ACME' });
+        expect(out.messages).toHaveLength(1);
+        expect(out.messages[0].role).toBe('user');
+        const text = out.messages[0].content.text;
+        expect(text).toContain('project ACME');
+        expect(text).toContain('orboto_get_project');
+        expect(text).toContain('orboto_list_tickets');
+        expect(text).toContain('orboto_list_milestones');
+    });
+});
+describe('triage-my-tickets prompt', () => {
+    it('takes no args and instructs to call orboto_my_tickets', () => {
+        const server = buildServerWithPrompts();
+        const handler = getPromptHandler(server, 'triage-my-tickets');
+        const out = handler({});
+        const text = out.messages[0].content.text;
+        expect(text).toContain('orboto_my_tickets');
+        expect(text).toContain('top 3');
+    });
+});
+describe('summarize-project prompt', () => {
+    it('embeds the project key + asks for exactly 3 sentences', () => {
+        const server = buildServerWithPrompts();
+        const handler = getPromptHandler(server, 'summarize-project');
+        const out = handler({ projectKey: 'ACME' });
+        const text = out.messages[0].content.text;
+        expect(text).toContain('project ACME');
+        expect(text).toContain('exactly 3 sentences');
+    });
+});
+describe('estimate-ticket prompt', () => {
+    it('embeds the ticket key + asks for similar past tickets', () => {
+        const server = buildServerWithPrompts();
+        const handler = getPromptHandler(server, 'estimate-ticket');
+        const out = handler({ ticketKey: 'ACME-42' });
+        const text = out.messages[0].content.text;
+        expect(text).toContain('ACME-42');
+        expect(text).toContain('orboto_search');
+        expect(text).toContain('loggedMinutes');
+    });
+});
+describe('find-duplicates prompt', () => {
+    it('warns explicitly against false positives', () => {
+        const server = buildServerWithPrompts();
+        const handler = getPromptHandler(server, 'find-duplicates');
+        const out = handler({ ticketKey: 'ACME-7' });
+        const text = out.messages[0].content.text;
+        expect(text).toContain('ACME-7');
+        expect(text).toContain('False positives');
+    });
+});

package/dist/protect-text-usage.test.js

@@ -0,0 +1,38 @@
+/**
+ * ORB-1818 - `PROTECT_TEXT_META` is a protection, not an escape hatch.
+ *
+ * A handler that sets it keeps its text half out of the shrinker, so a
+ * tool could use it to opt out of the central response budget - the one
+ * thing ORB-1697 exists to prevent. It is sanctioned for exactly one
+ * payload: the complete binding workspace rules, which must never be cut
+ * for either client class (Claude Code keeps the structured half,
+ * text-only clients keep the Markdown one).
+ *
+ * This ratchet fails the build when any other source file sets it, the
+ * same way the dark-mode / i18n / audit checks fail on a new violation.
+ */
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+const SRC = fileURLToPath(new URL('.', import.meta.url));
+/** The files allowed to SET the flag (response-budget.ts defines and
+ *  consumes it; the session-start tool is the sanctioned setter). */
+const ALLOWED = new Set(['response-budget.ts', 'tools/session-start.ts']);
+function walk(dir, prefix = '') {
+    return readdirSync(dir).flatMap((entry) => {
+        const full = join(dir, entry);
+        const rel = prefix ? `${prefix}/${entry}` : entry;
+        if (statSync(full).isDirectory())
+            return entry === 'node_modules' ? [] : walk(full, rel);
+        return rel.endsWith('.ts') ? [rel] : [];
+    });
+}
+describe('PROTECT_TEXT_META usage (ORB-1818)', () => {
+    it('is set by the session-start tool only', () => {
+        const offenders = walk(SRC)
+            .filter((rel) => !rel.endsWith('.test.ts') && !ALLOWED.has(rel))
+            .filter((rel) => readFileSync(join(SRC, rel), 'utf8').includes('PROTECT_TEXT_META'));
+        expect(offenders).toEqual([]);
+    });
+});

package/dist/resources.js

@@ -0,0 +1,260 @@
+/**
+ * ORB-244 Phase D - MCP resources.
+ *
+ * Resources let MCP-aware clients (Claude Desktop, Cursor) read
+ * orboto content as static blobs without explicitly invoking a tool.
+ * Where tools are RPCs ("do this thing"), resources are URIs ("here
+ * is content at this address").
+ *
+ * Four URI templates exposed:
+ *   orboto://ticket/{ticketKey} - rendered Markdown of the ticket
+ *   orboto://doc/{docId} - doc body (Markdown)
+ *   orboto://project/{projectKey} - project summary
+ *   orboto://search/{query} - search results as Markdown
+ *
+ * No `list` callback for tickets/docs because the candidate set is
+ * unbounded (every ticket, every doc) - the URI templates are
+ * sufficient. Clients discover content via tools first, then read a
+ * specific resource. The required `list: undefined` pattern keeps
+ * the SDK happy.
+ *
+ * Implementation note: each resource handler delegates to the same
+ * REST endpoints the tools use; the only difference is response
+ * shape (Markdown text vs. structured tool result). Sharing logic
+ * with tools/*.ts would couple the two surfaces too tightly - for
+ * now the resources are independent thin renderers.
+ */
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { OrbotoApiError } from './orboto-client.js';
+import { resolveProjectByKey, resolveTicketByKey } from './tools/shared.js';
+export function registerOrbotoResources(server, client) {
+    // -------------------------------------------------------------------------
+    // orboto://rules
+    //
+    // ORB-1177 - the COMPLETE assembled binding rules, cap-independent. The
+    // MCP `instructions` block is budgeted + may be truncated by the client
+    // (ORB-1168); this resource is never truncated, so a client can fetch
+    // the full rule set on demand. Same source orboto_session_start reads.
+    // -------------------------------------------------------------------------
+    server.registerResource('rules', new ResourceTemplate('orboto://rules', { list: undefined }), {
+        title: 'Workspace agent rules (complete)',
+        description: 'The complete, assembled binding rules you must follow as an agent in this workspace - cap-independent (the MCP instructions block may be truncated; this resource is not). orboto_session_start returns the same rules plus your in-progress work.',
+        mimeType: 'text/markdown',
+    }, async (uri) => {
+        const res = await client.get('/agent-instructions').catch(() => ({ instructions: '' }));
+        const rules = res?.instructions?.trim() || '(no workspace rules configured)';
+        return {
+            contents: [{ uri: uri.href, mimeType: 'text/markdown', text: `# orboto workspace agent rules\n\n${rules}` }],
+        };
+    });
+    // -------------------------------------------------------------------------
+    // orboto://ticket/{ticketKey}
+    // -------------------------------------------------------------------------
+    server.registerResource('ticket', new ResourceTemplate('orboto://ticket/{ticketKey}', { list: undefined }), {
+        title: 'orboto ticket',
+        description: 'A single ticket with description, assignees, comments, and labels - rendered as Markdown.',
+        mimeType: 'text/markdown',
+    }, async (uri, vars) => {
+        const ticketKey = String(vars.ticketKey);
+        const ticket = await resolveTicketByKey(client, ticketKey);
+        const commentsPage = await client.get(`/tickets/${ticket.id}/comments?limit=50`).catch((err) => {
+            if (err instanceof OrbotoApiError && err.status === 404) {
+                return { items: [], nextCursor: null };
+            }
+            throw err;
+        });
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: 'text/markdown',
+                    text: renderTicketMarkdown(ticket, commentsPage.items),
+                }],
+        };
+    });
+    // -------------------------------------------------------------------------
+    // orboto://doc/{docId}
+    // -------------------------------------------------------------------------
+    server.registerResource('doc', new ResourceTemplate('orboto://doc/{docId}', { list: undefined }), {
+        title: 'orboto doc',
+        description: 'A wiki page from a doc space - Markdown body.',
+        mimeType: 'text/markdown',
+    }, async (uri, vars) => {
+        const docId = String(vars.docId);
+        const doc = await client.get(`/docs/${docId}`);
+        const lines = [
+            `# ${doc.title}`,
+            `_Visibility: ${doc.visibility} · Updated: ${doc.updatedAt}_`,
+            '',
+            doc.content || '_(empty)_',
+        ];
+        return {
+            contents: [{ uri: uri.href, mimeType: 'text/markdown', text: lines.join('\n') }],
+        };
+    });
+    // -------------------------------------------------------------------------
+    // orboto://project/{projectKey}
+    // -------------------------------------------------------------------------
+    server.registerResource('project', new ResourceTemplate('orboto://project/{projectKey}', { list: undefined }), {
+        title: 'orboto project',
+        description: 'Project metadata, milestones, members.',
+        mimeType: 'text/markdown',
+    }, async (uri, vars) => {
+        const projectKey = String(vars.projectKey);
+        const project = await resolveProjectByKey(client, projectKey);
+        const [milestones, members] = await Promise.all([
+            client.get(`/projects/${project.id}/milestones`),
+            client.get(`/projects/${project.id}/members`),
+        ]);
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: 'text/markdown',
+                    text: renderProjectMarkdown(project, milestones, members),
+                }],
+        };
+    });
+    // -------------------------------------------------------------------------
+    // orboto://search/{query}
+    //
+    // Note: clients URL-encode `query` automatically. Special chars in
+    // a natural-language query are fine; the URI template handles
+    // unescaping.
+    // -------------------------------------------------------------------------
+    server.registerResource('search', new ResourceTemplate('orboto://search/{query}', { list: undefined }), {
+        title: 'orboto search',
+        description: 'Full-text search across tickets, comments, docs - visibility-filtered.',
+        mimeType: 'text/markdown',
+    }, async (uri, vars) => {
+        const query = String(vars.query);
+        const qs = new URLSearchParams({ q: query, limit: '15' });
+        const res = await client.get(`/search?${qs}`);
+        const lines = res.items.length === 0
+            ? [`# Search: ${query}`, '', '_No hits._']
+            : [
+                `# Search: ${query}`,
+                `_${res.total} total hit(s) - top ${res.items.length} shown._`,
+                '',
+                ...res.items.map((h) => {
+                    const tag = h.type.toUpperCase();
+                    const ident = h.ticketKey ?? h.url;
+                    const project = h.projectName ? ` (${h.projectName})` : '';
+                    return `- **${tag} ${ident}**${project}: ${h.title}\n  ${h.excerpt}`;
+                }),
+            ];
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: 'text/markdown',
+                    text: lines.join('\n'),
+                }],
+        };
+    });
+    // -------------------------------------------------------------------------
+    // orboto://user/me/notifications
+    //
+    // ORB-706 - read the calling user's recent notifications.
+    // Subscribable: every `notification:new` event for this user
+    // fires a `resources/updated` push. Used by agents that want to
+    // react to mentions / agent_message / status-change pings in
+    // real time.
+    // -------------------------------------------------------------------------
+    server.registerResource('user-notifications', new ResourceTemplate('orboto://user/me/notifications', { list: undefined }), {
+        title: 'My notifications',
+        description: 'Calling user\'s recent notifications. Subscribable - every new notification fires resources/updated. Use this to react to mentions, agent_message (ORB-705), and status-change pings in real time.',
+        mimeType: 'text/markdown',
+    }, async (uri) => {
+        const page = await client.get('/notifications?limit=20');
+        const lines = [];
+        lines.push(`# My notifications`);
+        lines.push(`_${page.unreadCount} unread of ${page.items.length} shown._`);
+        lines.push('');
+        if (page.items.length === 0) {
+            lines.push('_No notifications._');
+        }
+        else {
+            for (const n of page.items) {
+                const unread = n.readAt ? '' : ' **unread**';
+                const subject = typeof n.payload.subject === 'string'
+                    ? n.payload.subject
+                    : typeof n.payload.message === 'string' ? n.payload.message : n.type;
+                lines.push(`- [${n.type}]${unread} - ${subject} _(${n.createdAt})_`);
+            }
+        }
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: 'text/markdown',
+                    text: lines.join('\n'),
+                }],
+        };
+    });
+    // -------------------------------------------------------------------------
+    // ORB-855 - LLM-Wiki resources. The index + log are the space's singleton
+    // kind='index'/'log' docs; a page is any doc by id (namespaced under the
+    // space). A `page/` discriminator keeps the page template from colliding
+    // with the static index/log segments.
+    // -------------------------------------------------------------------------
+    const layerDoc = async (spaceId, kind) => {
+        const list = await client.get(`/spaces/${spaceId}/docs`);
+        return list.find((d) => d.kind === kind) ?? null;
+    };
+    server.registerResource('wiki-index', new ResourceTemplate('orboto://wiki/{spaceId}/index', { list: undefined }), { title: 'LLM-Wiki index', description: 'The auto-maintained navigation index of an LLM-Wiki space.', mimeType: 'text/markdown' }, async (uri, vars) => {
+        const doc = await layerDoc(String(vars.spaceId), 'index');
+        return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text: doc?.content || '_(no index)_' }] };
+    });
+    server.registerResource('wiki-log', new ResourceTemplate('orboto://wiki/{spaceId}/log', { list: undefined }), { title: 'LLM-Wiki activity log', description: 'The append-only activity log of an LLM-Wiki space.', mimeType: 'text/markdown' }, async (uri, vars) => {
+        const doc = await layerDoc(String(vars.spaceId), 'log');
+        return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text: doc?.content || '_(no log)_' }] };
+    });
+    server.registerResource('wiki-page', new ResourceTemplate('orboto://wiki/{spaceId}/page/{docId}', { list: undefined }), { title: 'LLM-Wiki page', description: 'A single wiki page by id within an LLM-Wiki space.', mimeType: 'text/markdown' }, async (uri, vars) => {
+        const doc = await client.get(`/docs/${String(vars.docId)}`);
+        return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text: `# ${doc.title}\n\n${doc.content || '_(empty)_'}` }] };
+    });
+}
+function renderTicketMarkdown(ticket, comments) {
+    const lines = [];
+    lines.push(`# [${ticket.ticketKey}] ${ticket.title}`);
+    lines.push(`_Status: ${ticket.statusName ?? ticket.status} · Priority: ${ticket.priority} · Type: ${ticket.type}_`);
+    if (ticket.dueDate)
+        lines.push(`_Due: ${ticket.dueDate}_`);
+    if (ticket.assignees && ticket.assignees.length > 0) {
+        lines.push(`_Assignees: ${ticket.assignees.map((a) => a.fullName || a.email).join(', ')}_`);
+    }
+    if (ticket.labels && ticket.labels.length > 0) {
+        lines.push(`_Labels: ${ticket.labels.map((l) => l.name).join(', ')}_`);
+    }
+    if (ticket.description) {
+        lines.push('', '## Description', ticket.description);
+    }
+    if (comments.length > 0) {
+        lines.push('', `## Comments (${comments.length})`);
+        for (const c of comments) {
+            lines.push('', `**${c.userName ?? '(unknown)'}** - ${c.createdAt}${c.isInternal ? ' [internal]' : ''}`);
+            lines.push(c.content);
+        }
+    }
+    return lines.join('\n');
+}
+function renderProjectMarkdown(project, milestones, members) {
+    const lines = [
+        `# ${project.key} - ${project.name}`,
+        `_Status: ${project.status}_`,
+    ];
+    if (project.description)
+        lines.push('', project.description);
+    if (milestones.length > 0) {
+        lines.push('', '## Milestones');
+        for (const m of milestones) {
+            const range = [m.startDate, m.endDate].filter(Boolean).join(' → ') || 'no dates';
+            lines.push(`- **${m.name}** [${m.status}] (${range})`);
+        }
+    }
+    if (members.length > 0) {
+        lines.push('', '## Members');
+        for (const m of members) {
+            const name = m.user.fullName || m.user.email;
+            lines.push(`- ${name} <${m.user.email}> - ${m.role.name}`);
+        }
+    }
+    return lines.join('\n');
+}