borgmcp 0.2.0-beta.9 → 0.4.0

package/dist/index.js

@@ -6,16 +6,101 @@
  * 1. Connects to Claude Code via stdio transport
  * 2. Authenticates via Google OAuth device flow
  * 3. Proxies MCP tools to remote server at api.borgmcp.ai
- * 4. Provides borg:regen tool for centralized context retrieval
+ * 4. Provides the borg: cube tool surface (assimilate / cube / role /
+ *    roster / read-log) so Claude can act as a Drone in a hive of
+ *    collaborating sessions.
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { regenerateContext, checkSubscriptionStatus, createSubscription, } from './remote-client.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { assimilate, getCubeInfo, getRoleInfo, getRoster, readLog, appendLog, regen, listCubes, createCube, updateCube, deleteCube, createRole, updateRole, deleteRole, reassignDrone, getCube, checkSubscriptionStatus, createSubscription, API_URL, } from './remote-client.js';
+import { getTemplate, listTemplateNames } from './templates.js';
+import { getActiveCube, setActiveCube } from './cubes.js';
+import { addSessionStartHook, addUserPromptSubmitHook } from './config-utils.js';
+import { humanAgo, formatRegenMarkdown, getDronePlaybook, getDroneMode } from './regen-format.js';
+import { startInboxPoller } from './inbox.js';
+import open from 'open';
+/**
+ * Apply a template's roles to a cube. Roles are merged by name:
+ *   - existing role with same name → updateRole with the template's fields
+ *   - no existing role with that name → createRole
+ * Returns counts for the caller to report.
+ */
+async function applyTemplateToCube(cubeId, templateRoles) {
+    const { roles: existing } = await getCube(cubeId);
+    const byName = new Map(existing.map((r) => [r.name, r]));
+    let created = 0;
+    let updated = 0;
+    for (const tr of templateRoles) {
+        const match = byName.get(tr.name);
+        if (match) {
+            await updateRole(match.id, {
+                short_description: tr.short_description,
+                detailed_description: tr.detailed_description,
+                is_default: tr.is_default === true,
+                is_coordinator: tr.is_coordinator === true,
+            });
+            updated += 1;
+        }
+        else {
+            await createRole(cubeId, {
+                name: tr.name,
+                short_description: tr.short_description,
+                detailed_description: tr.detailed_description,
+                is_default: tr.is_default === true,
+                is_coordinator: tr.is_coordinator === true,
+            });
+            created += 1;
+        }
+    }
+    return { created, updated };
+}
+/**
+ * Throw a friendly error if the client has not been assimilated to a cube.
+ */
+async function requireActiveCube() {
+    const active = await getActiveCube();
+    if (!active) {
+        throw new Error('Not assimilated to a cube. Use borg:assimilate <cube-name> first.');
+    }
+    return active;
+}
 /**
  * Main entry point - MCP stdio server
  */
 async function main() {
+    // Auto-register the SessionStart hook so existing users get borg-regen
+    // auto-orientation on session start without re-running borg setup. Idempotent.
+    try {
+        addSessionStartHook();
+    }
+    catch (err) {
+        // Silent on failure — never break the MCP server because of hook registration.
+    }
+    // Auto-register the UserPromptSubmit audit hook so the drone gets a
+    // nudge if the previous assistant span used state-changing tools
+    // without calling borg:log. Domain-agnostic — knows nothing about git
+    // or any specific convention. Idempotent.
+    try {
+        addUserPromptSubmitHook();
+    }
+    catch (err) {
+        // Silent on failure — same rationale as above.
+    }
+    // Spawn the long-poll background poller. This gives drones real-time
+    // wakeup: when another drone posts to the cube, a line gets appended
+    // to the per-cube inbox file (see inboxPathForCube in cubes.ts) and
+    // the launcher's Monitor wakes the active /loop iteration immediately.
+    // No truncation needed — the launcher's Monitor uses `tail -n 0 -F`,
+    // which starts at end-of-file and only emits new appends. Failure
+    // here is non-fatal — the launcher's fallback heartbeat still keeps
+    // things moving.
+    try {
+        startInboxPoller();
+    }
+    catch {
+        // Silent — never break the MCP server because of inbox setup.
+    }
     // Create MCP server
     const server = new Server({
         name: 'borg-mcp-client',
@@ -23,6 +108,7 @@ async function main() {
     }, {
         capabilities: {
             tools: {},
+            prompts: {},
         },
     });
     // Register tool listing
@@ -31,7 +117,25 @@ async function main() {
             tools: [
                 {
                     name: 'subscribe',
-                    description: 'Create Stripe checkout session ($2/month, 7-day trial)',
+                    description: 'Create Stripe checkout session ($1/month, 7-day trial)',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        required: [],
+                    },
+                },
+                {
+                    name: 'subscription_status',
+                    description: 'Check subscription status',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        required: [],
+                    },
+                },
+                {
+                    name: 'open_dashboard',
+                    description: 'Open Borg MCP dashboard in browser to manage cubes, roles, and drones',
                     inputSchema: {
                         type: 'object',
                         properties: {},
@@ -40,30 +144,232 @@ async function main() {
                 },
                 {
                     name: 'borg:regen',
-                    description: 'Regenerate centralized context from your active context entries (requires subscription). Returns markdown-formatted hive mind context.',
+                    description: "Refresh your context as a Drone. Returns the active cube's ground rules, " +
+                        "your role's detailed playbook, the drone roster, and recent activity log entries — " +
+                        'everything you need to be oriented. Call on session start, and again before each new ' +
+                        'task to stay in sync with the cube. Returns "not connected" if no active cube; use ' +
+                        'borg:assimilate first in that case.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        required: [],
+                    },
+                },
+                {
+                    name: 'borg:assimilate',
+                    description: "Connect this Claude session as a Drone to a Cube. Provide the cube's name. " +
+                        "Returns the cube's ground rules, your assigned role's detailed instructions, " +
+                        'and persists a session token locally so subsequent borg: tools work for this cube.',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            categories: {
-                                type: 'array',
-                                items: {
-                                    type: 'string',
-                                },
-                                description: 'Optional: Filter by specific categories (e.g., ["code-style", "commit-rules"])',
+                            cube_name: {
+                                type: 'string',
+                                description: 'The cube to connect to',
                             },
                         },
+                        required: ['cube_name'],
+                    },
+                },
+                {
+                    name: 'borg:cube',
+                    description: "Read the active Cube's ground rules and the registry of all roles in it " +
+                        "(each role's name + short description). Use to remind yourself of cube-wide context.",
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
                         required: [],
                     },
                 },
                 {
-                    name: 'subscription_status',
-                    description: 'Check subscription status',
+                    name: 'borg:role',
+                    description: "Read your assigned role's detailed description (your playbook). " +
+                        'Other drones cannot see this — only you (drones in this role).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        required: [],
+                    },
+                },
+                {
+                    name: 'borg:roster',
+                    description: "List all currently connected drones in your cube, with each drone's label, role, and last-seen time.",
                     inputSchema: {
                         type: 'object',
                         properties: {},
                         required: [],
                     },
                 },
+                {
+                    name: 'borg:read-log',
+                    description: "Read recent entries from the cube's shared activity log. Each entry is tagged " +
+                        "with the drone that wrote it and that drone's role. Optional: since (ISO-8601 " +
+                        'timestamp, returns entries strictly after) and limit (1–500, default 50).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            since: {
+                                type: 'string',
+                                description: 'ISO-8601 timestamp',
+                            },
+                            limit: {
+                                type: 'number',
+                                description: 'max entries to return (1-500)',
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'borg:log',
+                    description: 'Append a message to the cube\'s shared activity log. All connected drones will see your entry, tagged with your drone label and role name. Use this to coordinate work, post review-ready signals, share findings, or anything else the cube\'s ground rules and your role description direct you to communicate.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            message: { type: 'string', description: 'The log message (max 10KB).' },
+                        },
+                        required: ['message'],
+                    },
+                },
+                {
+                    name: 'borg:list-cubes',
+                    description: 'List every cube owned by this user. Returns id, name, ground_rules, and timestamps for each. Useful before assimilate to see what\'s available, or as a starting point for any management action.',
+                    inputSchema: { type: 'object', properties: {} },
+                },
+                {
+                    name: 'borg:create-cube',
+                    description: 'Create a new cube. The server seeds a default "Drone" role atomically so the cube is assimilatable immediately. ' +
+                        'Pass an optional `template` name to apply a richer role set instead (see borg:list-templates / borg:apply-template).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                type: 'string',
+                                description: 'Cube name (lowercase letters, digits, hyphens; max 64 chars).',
+                                pattern: '^[a-z0-9-]+$',
+                                maxLength: 64,
+                            },
+                            ground_rules: { type: 'string', description: 'Markdown text every drone in this cube will see in regen. Anything project-specific.' },
+                            template: {
+                                type: 'string',
+                                description: 'Optional template name to apply after cube creation (e.g. "software-dev"). Roles are merged by name; the default Drone role gets overwritten by the template if a same-named role is in the template.',
+                            },
+                        },
+                        required: ['name', 'ground_rules'],
+                    },
+                },
+                {
+                    name: 'borg:update-cube',
+                    description: 'Update a cube\'s name and/or ground_rules. Pass only what changes.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cube_id: { type: 'string', description: 'UUID of the cube to update.' },
+                            name: {
+                                type: 'string',
+                                description: 'New name (optional). Lowercase letters, digits, hyphens; max 64 chars.',
+                                pattern: '^[a-z0-9-]+$',
+                                maxLength: 64,
+                            },
+                            ground_rules: { type: 'string', description: 'New ground rules markdown (optional).' },
+                        },
+                        required: ['cube_id'],
+                    },
+                },
+                {
+                    name: 'borg:delete-cube',
+                    description: 'Delete a cube and all its roles, drones, and log entries. Irreversible — confirm with the user before invoking unless the cube is clearly disposable.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cube_id: { type: 'string', description: 'UUID of the cube to delete.' },
+                        },
+                        required: ['cube_id'],
+                    },
+                },
+                {
+                    name: 'borg:create-role',
+                    description: 'Create a role inside a cube. The detailed_description is the role\'s playbook — only drones assigned to this role see it. Setting is_default=true demotes any existing default; a cube has exactly one default role at a time.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cube_id: { type: 'string', description: 'UUID of the cube this role belongs to.' },
+                            name: { type: 'string', description: 'Role name (e.g. "Builder", "Reviewer").' },
+                            short_description: { type: 'string', description: 'One-line summary, shown to every drone in the cube.' },
+                            detailed_description: { type: 'string', description: 'Full playbook for drones in this role — workflow, conventions, log signals to post.' },
+                            is_default: { type: 'boolean', description: 'If true, new drones assimilating into this cube are assigned this role (when the Coordinator seat is taken or there is no Coordinator role). Demotes the previous default.' },
+                            is_coordinator: { type: 'boolean', description: 'If true, this role becomes the cube\'s Coordinator (Queen seat, supervised mode). At most one Coordinator role per cube — promoting demotes the previous one.' },
+                        },
+                        required: ['cube_id', 'name', 'short_description', 'detailed_description'],
+                    },
+                },
+                {
+                    name: 'borg:update-role',
+                    description: 'Update a role. Pass only the fields that change. Promoting to is_default demotes the previous default in the same cube.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            role_id: { type: 'string', description: 'UUID of the role to update.' },
+                            name: { type: 'string', description: 'New role name (optional).' },
+                            short_description: { type: 'string', description: 'New short description (optional).' },
+                            detailed_description: { type: 'string', description: 'New detailed playbook (optional).' },
+                            is_default: { type: 'boolean', description: 'Set true to make this the cube\'s default role (optional).' },
+                            is_coordinator: { type: 'boolean', description: 'Set true to promote this role to Coordinator (singleton per cube; demotes the previous one). Setting false on the current Coordinator role demotes it.' },
+                        },
+                        required: ['role_id'],
+                    },
+                },
+                {
+                    name: 'borg:delete-role',
+                    description: 'Delete a role. Refuses if any drone is still assigned — reassign or evict those drones from the dashboard first.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            role_id: { type: 'string', description: 'UUID of the role to delete.' },
+                        },
+                        required: ['role_id'],
+                    },
+                },
+                {
+                    name: 'borg:reassign-drone',
+                    description: 'Reassign a drone to a different role in the same cube. Coordinator-shaped: the cube\'s Coordinator drone is the one expected to call this when dispatching new drones to specific work. ' +
+                        'Server refuses if you try to assign to the Coordinator role when another drone already holds it (evict or reassign that drone first).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            drone_id: { type: 'string', description: 'UUID of the drone to reassign.' },
+                            role_id: { type: 'string', description: 'UUID of the target role. Must belong to the same cube as the drone.' },
+                        },
+                        required: ['drone_id', 'role_id'],
+                    },
+                },
+                {
+                    name: 'borg:list-drones',
+                    description: 'List every drone in a cube (owner-scoped). Returns id, label, role_id, last_seen for each — gives the Coordinator a roster they can act on with borg:reassign-drone.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cube_id: { type: 'string', description: 'UUID of the cube whose drones to list.' },
+                        },
+                        required: ['cube_id'],
+                    },
+                },
+                {
+                    name: 'borg:list-templates',
+                    description: 'List available cube templates that can be applied via borg:apply-template or passed to borg:create-cube.',
+                    inputSchema: { type: 'object', properties: {} },
+                },
+                {
+                    name: 'borg:apply-template',
+                    description: 'Apply a named template to an existing cube. Roles are merged by name: existing roles with the same name get their fields overwritten; new ones are created. Use this to retrofit an existing cube with a richer role set (e.g. add Coordinator/Reviewer/UX Expert to a cube that started bare).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cube_id: { type: 'string', description: 'UUID of the cube to apply the template to.' },
+                            template_name: { type: 'string', description: 'Template to apply (see borg:list-templates).' },
+                        },
+                        required: ['cube_id', 'template_name'],
+                    },
+                },
             ],
         };
     });
@@ -72,6 +378,22 @@ async function main() {
         const { name, arguments: args } = request.params;
         try {
             switch (name) {
+                case 'borg:regen': {
+                    const active = await getActiveCube();
+                    if (!active) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: 'Not connected to a cube. Use `borg:assimilate cube_name="<name>"` to join one.',
+                                },
+                            ],
+                        };
+                    }
+                    const result = await regen(active.sessionToken, active.apiUrl);
+                    const mode = getDroneMode(result.role?.is_coordinator === true);
+                    return { content: [{ type: 'text', text: formatRegenMarkdown(result, mode) }] };
+                }
                 case 'subscribe': {
                     const checkoutUrl = await createSubscription();
                     return {
@@ -83,29 +405,334 @@ async function main() {
                         ],
                     };
                 }
-                case 'borg:regen': {
-                    const categories = Array.isArray(args?.categories) ? args.categories : undefined;
-                    const context = await regenerateContext(categories);
+                case 'subscription_status': {
+                    const status = await checkSubscriptionStatus();
                     return {
                         content: [
                             {
                                 type: 'text',
-                                text: context,
+                                text: JSON.stringify(status, null, 2),
                             },
                         ],
                     };
                 }
-                case 'subscription_status': {
-                    const status = await checkSubscriptionStatus();
+                case 'open_dashboard': {
+                    const dashboardUrl = 'https://borgmcp.ai/dashboard';
+                    await open(dashboardUrl);
                     return {
                         content: [
                             {
                                 type: 'text',
-                                text: JSON.stringify(status, null, 2),
+                                text: `◼ Opened dashboard in browser: ${dashboardUrl}`,
                             },
                         ],
                     };
                 }
+                case 'borg:assimilate': {
+                    const cubeName = args?.cube_name;
+                    if (!cubeName)
+                        throw new Error('cube_name is required');
+                    // First-call assimilate uses the env-or-prod default; we then
+                    // persist that same URL so all subsequent drone calls hit the
+                    // worker that issued the session token.
+                    const apiUrl = API_URL;
+                    const result = await assimilate(cubeName, apiUrl);
+                    await setActiveCube({
+                        cubeId: result.cube.id,
+                        droneId: result.drone.id,
+                        name: result.cube.name,
+                        sessionToken: result.sessionToken,
+                        droneLabel: result.drone.label,
+                        apiUrl,
+                    });
+                    const text = [
+                        `# Assimilated to cube: ${result.cube.name}`,
+                        ``,
+                        `**Drone label:** ${result.drone.label}`,
+                        `**Assigned role:** ${result.role.name}`,
+                        `**Mode:** ${getDroneMode(result.role.is_coordinator === true)}`,
+                        ``,
+                        `## Ground rules`,
+                        result.cube.ground_rules || '_(none)_',
+                        ``,
+                        `## Your role: ${result.role.name}`,
+                        result.role.detailed_description || '_(no detailed description set)_',
+                        ``,
+                        getDronePlaybook(getDroneMode(result.role.is_coordinator === true)),
+                    ].join('\n');
+                    return { content: [{ type: 'text', text }] };
+                }
+                case 'borg:cube': {
+                    const active = await requireActiveCube();
+                    const [{ cube, roles }, { role: ownRole }] = await Promise.all([
+                        getCubeInfo(active.sessionToken, active.apiUrl),
+                        getRoleInfo(active.sessionToken, active.apiUrl),
+                    ]);
+                    // Mode is derived from this drone's own current role —
+                    // Coordinator → supervised, anything else → autonomous.
+                    const mode = getDroneMode(ownRole?.is_coordinator === true);
+                    const lines = [];
+                    lines.push(`# Cube: ${cube.name}`);
+                    lines.push(`**Mode:** ${mode}`);
+                    lines.push('');
+                    lines.push('## Ground rules');
+                    lines.push(cube.ground_rules || '_(none)_');
+                    lines.push('');
+                    lines.push('## Roles in this cube');
+                    if (!roles.length) {
+                        lines.push('_(no roles defined)_');
+                    }
+                    else {
+                        for (const r of roles) {
+                            const tags = [
+                                r.is_coordinator ? 'Coordinator' : null,
+                                r.is_default ? 'default' : null,
+                            ].filter(Boolean).join(', ');
+                            const marker = tags ? ` (${tags})` : '';
+                            const desc = r.short_description || '_(no description)_';
+                            lines.push(`- **${r.name}**${marker} — ${desc}`);
+                        }
+                    }
+                    lines.push('');
+                    lines.push(getDronePlaybook(mode));
+                    return { content: [{ type: 'text', text: lines.join('\n') }] };
+                }
+                case 'borg:role': {
+                    const active = await requireActiveCube();
+                    const { role } = await getRoleInfo(active.sessionToken, active.apiUrl);
+                    const text = [
+                        `# Your role: ${role.name}`,
+                        ``,
+                        role.detailed_description || '_(no detailed description set)_',
+                    ].join('\n');
+                    return { content: [{ type: 'text', text }] };
+                }
+                case 'borg:roster': {
+                    const active = await requireActiveCube();
+                    const { drones, roles } = await getRoster(active.sessionToken, active.apiUrl);
+                    const roleById = new Map();
+                    for (const r of roles)
+                        roleById.set(r.id, r);
+                    const lines = [];
+                    lines.push(`# Drones in cube: ${active.name}`);
+                    lines.push('');
+                    if (!drones.length) {
+                        lines.push('_(no drones connected)_');
+                    }
+                    else {
+                        for (const d of drones) {
+                            const role = roleById.get(d.role_id);
+                            const roleName = role?.name ?? 'unknown';
+                            lines.push(`- **${d.label}** (${roleName}) — last seen ${humanAgo(d.last_seen)}`);
+                        }
+                    }
+                    return { content: [{ type: 'text', text: lines.join('\n') }] };
+                }
+                case 'borg:read-log': {
+                    const active = await requireActiveCube();
+                    const since = typeof args?.since === 'string' ? args.since : undefined;
+                    const limit = typeof args?.limit === 'number' ? args.limit : undefined;
+                    const { entries, drones, roles } = await readLog(active.sessionToken, active.apiUrl, {
+                        since,
+                        limit,
+                    });
+                    const droneById = new Map();
+                    for (const d of drones)
+                        droneById.set(d.id, d);
+                    const roleById = new Map();
+                    for (const r of roles)
+                        roleById.set(r.id, r);
+                    const lines = [];
+                    lines.push(`# Activity log: ${active.name}`);
+                    lines.push('');
+                    if (!entries.length) {
+                        lines.push('_(no entries)_');
+                    }
+                    else {
+                        for (const e of entries) {
+                            const drone = droneById.get(e.drone_id);
+                            const droneLabel = drone?.label ?? 'unknown-drone';
+                            const roleName = drone ? roleById.get(drone.role_id)?.name ?? 'unknown' : 'unknown';
+                            const ts = typeof e.created_at === 'string'
+                                ? e.created_at
+                                : new Date(e.created_at).toISOString();
+                            lines.push(`**[${ts}]** ${droneLabel} (${roleName}): ${e.message}`);
+                        }
+                    }
+                    return { content: [{ type: 'text', text: lines.join('\n') }] };
+                }
+                case 'borg:log': {
+                    const message = args?.message;
+                    if (!message || typeof message !== 'string')
+                        throw new Error('message is required');
+                    const active = await getActiveCube();
+                    if (!active)
+                        throw new Error('Not assimilated to a cube. Use borg:assimilate <cube-name> first.');
+                    const result = await appendLog(active.sessionToken, active.apiUrl, message);
+                    const text = `Logged to cube "${active.name}" as ${active.droneLabel}. (entry id: ${result.entry.id})`;
+                    return { content: [{ type: 'text', text }] };
+                }
+                case 'borg:list-cubes': {
+                    const { cubes } = await listCubes();
+                    if (!cubes.length) {
+                        return { content: [{ type: 'text', text: 'No cubes yet. Use borg:create-cube to make your first one.' }] };
+                    }
+                    const lines = cubes.map((c) => `- **${c.name}** (id: ${c.id})\n  ${(c.ground_rules || '_(no ground rules)_').split('\n')[0].slice(0, 120)}`);
+                    return { content: [{ type: 'text', text: `Your cubes (${cubes.length}):\n\n${lines.join('\n\n')}` }] };
+                }
+                case 'borg:create-cube': {
+                    const name = args?.name;
+                    const groundRules = args?.ground_rules;
+                    const templateName = args?.template;
+                    if (!name)
+                        throw new Error('name is required');
+                    if (groundRules === undefined)
+                        throw new Error('ground_rules is required (pass empty string if none)');
+                    const { cube } = await createCube(name, groundRules);
+                    // Apply template if requested. Merges by name: any role the
+                    // server auto-seeded (e.g. "Drone") that the template doesn't
+                    // also include stays put; templated roles upsert.
+                    if (templateName) {
+                        const template = getTemplate(templateName);
+                        if (!template) {
+                            throw new Error(`Unknown template "${templateName}". Available: ${listTemplateNames().join(', ')}`);
+                        }
+                        const summary = await applyTemplateToCube(cube.id, template.roles);
+                        const text = `Created cube **${cube.name}** (id: ${cube.id}) with template **${templateName}** applied — ${summary.created} role(s) created, ${summary.updated} updated. Use borg:assimilate ${cube.name} to join as a drone.`;
+                        return { content: [{ type: 'text', text }] };
+                    }
+                    const text = `Created cube **${cube.name}** (id: ${cube.id}). A default "Drone" role was seeded — rename or replace it via borg:update-role / borg:create-role / borg:delete-role. Use borg:assimilate ${cube.name} to join as a drone.`;
+                    return { content: [{ type: 'text', text }] };
+                }
+                case 'borg:update-cube': {
+                    const cubeId = args?.cube_id;
+                    if (!cubeId)
+                        throw new Error('cube_id is required');
+                    const updates = {};
+                    if (typeof args?.name === 'string')
+                        updates.name = args.name;
+                    if (typeof args?.ground_rules === 'string')
+                        updates.ground_rules = args.ground_rules;
+                    if (Object.keys(updates).length === 0)
+                        throw new Error('Pass at least one of: name, ground_rules.');
+                    const { cube } = await updateCube(cubeId, updates);
+                    return { content: [{ type: 'text', text: `Updated cube **${cube.name}** (id: ${cube.id}).` }] };
+                }
+                case 'borg:delete-cube': {
+                    const cubeId = args?.cube_id;
+                    if (!cubeId)
+                        throw new Error('cube_id is required');
+                    await deleteCube(cubeId);
+                    return { content: [{ type: 'text', text: `Deleted cube ${cubeId} (and all its roles, drones, log entries).` }] };
+                }
+                case 'borg:create-role': {
+                    const cubeId = args?.cube_id;
+                    const name = args?.name;
+                    const shortDesc = args?.short_description;
+                    const detailedDesc = args?.detailed_description;
+                    if (!cubeId)
+                        throw new Error('cube_id is required');
+                    if (!name)
+                        throw new Error('name is required');
+                    if (shortDesc === undefined)
+                        throw new Error('short_description is required (pass empty string if none)');
+                    if (detailedDesc === undefined)
+                        throw new Error('detailed_description is required (pass empty string if none)');
+                    const isDefault = args?.is_default === true;
+                    const isCoordinator = args?.is_coordinator === true;
+                    const { role } = await createRole(cubeId, {
+                        name,
+                        short_description: shortDesc,
+                        detailed_description: detailedDesc,
+                        is_default: isDefault,
+                        is_coordinator: isCoordinator,
+                    });
+                    const tags = [
+                        role.is_coordinator ? 'Coordinator' : null,
+                        role.is_default ? 'default' : null,
+                    ].filter(Boolean).join(', ');
+                    const tag = tags ? ` (${tags})` : '';
+                    return { content: [{ type: 'text', text: `Created role **${role.name}**${tag} (id: ${role.id}) in cube ${cubeId}.` }] };
+                }
+                case 'borg:update-role': {
+                    const roleId = args?.role_id;
+                    if (!roleId)
+                        throw new Error('role_id is required');
+                    const updates = {};
+                    if (typeof args?.name === 'string')
+                        updates.name = args.name;
+                    if (typeof args?.short_description === 'string')
+                        updates.short_description = args.short_description;
+                    if (typeof args?.detailed_description === 'string')
+                        updates.detailed_description = args.detailed_description;
+                    if (typeof args?.is_default === 'boolean')
+                        updates.is_default = args.is_default;
+                    if (typeof args?.is_coordinator === 'boolean')
+                        updates.is_coordinator = args.is_coordinator;
+                    if (Object.keys(updates).length === 0)
+                        throw new Error('Pass at least one of: name, short_description, detailed_description, is_default, is_coordinator.');
+                    const { role } = await updateRole(roleId, updates);
+                    const tags = [
+                        role.is_coordinator ? 'Coordinator' : null,
+                        role.is_default ? 'default' : null,
+                    ].filter(Boolean).join(', ');
+                    const tag = tags ? ` (${tags})` : '';
+                    return { content: [{ type: 'text', text: `Updated role **${role.name}**${tag} (id: ${role.id}).` }] };
+                }
+                case 'borg:delete-role': {
+                    const roleId = args?.role_id;
+                    if (!roleId)
+                        throw new Error('role_id is required');
+                    await deleteRole(roleId);
+                    return { content: [{ type: 'text', text: `Deleted role ${roleId}.` }] };
+                }
+                case 'borg:reassign-drone': {
+                    const droneId = args?.drone_id;
+                    const roleId = args?.role_id;
+                    if (!droneId)
+                        throw new Error('drone_id is required');
+                    if (!roleId)
+                        throw new Error('role_id is required');
+                    const { drone } = await reassignDrone(droneId, roleId);
+                    return { content: [{ type: 'text', text: `Reassigned drone ${drone.label} (${drone.id}) to role ${drone.role_id}.` }] };
+                }
+                case 'borg:list-drones': {
+                    const cubeId = args?.cube_id;
+                    if (!cubeId)
+                        throw new Error('cube_id is required');
+                    const { drones, roles } = await getCube(cubeId);
+                    if (!drones.length) {
+                        return { content: [{ type: 'text', text: 'No drones in this cube yet.' }] };
+                    }
+                    const rolesById = new Map(roles.map((r) => [r.id, r]));
+                    const lines = drones.map((d) => {
+                        const r = rolesById.get(d.role_id);
+                        return `- **${d.label}** (id: ${d.id}) — role: ${r?.name ?? '?'} (${d.role_id}) — last seen ${d.last_seen}`;
+                    });
+                    return { content: [{ type: 'text', text: `Drones in cube ${cubeId} (${drones.length}):\n\n${lines.join('\n')}` }] };
+                }
+                case 'borg:list-templates': {
+                    const names = listTemplateNames();
+                    const lines = names.map((n) => {
+                        const t = getTemplate(n);
+                        return `- **${n}**: ${t.description}`;
+                    });
+                    return { content: [{ type: 'text', text: `Available templates:\n\n${lines.join('\n')}` }] };
+                }
+                case 'borg:apply-template': {
+                    const cubeId = args?.cube_id;
+                    const templateName = args?.template_name;
+                    if (!cubeId)
+                        throw new Error('cube_id is required');
+                    if (!templateName)
+                        throw new Error('template_name is required');
+                    const template = getTemplate(templateName);
+                    if (!template) {
+                        throw new Error(`Unknown template "${templateName}". Available: ${listTemplateNames().join(', ')}`);
+                    }
+                    const summary = await applyTemplateToCube(cubeId, template.roles);
+                    return { content: [{ type: 'text', text: `Applied template **${templateName}** to cube ${cubeId} — ${summary.created} role(s) created, ${summary.updated} updated.` }] };
+                }
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }
@@ -113,12 +740,13 @@ async function main() {
         catch (error) {
             // Better error messages for auth/subscription issues
             if (error.message?.includes('Authentication required') ||
+                error.message?.includes('Authentication expired') ||
                 error.message?.includes('Failed to refresh')) {
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: '🔐 Authentication expired. Run: borg setup',
+                            text: '◼ Authentication expired. Run: borg setup',
                         },
                     ],
                     isError: true,
@@ -135,15 +763,63 @@ async function main() {
             };
         }
     });
+    // Register prompts listing
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return {
+            prompts: [
+                {
+                    name: 'subscribe',
+                    description: 'Set up Borg MCP subscription ($1/month, 7-day trial)',
+                },
+                {
+                    name: 'dashboard',
+                    description: 'Open Borg MCP dashboard to manage cubes',
+                },
+            ],
+        };
+    });
+    // Register prompt getter
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const { name } = request.params;
+        switch (name) {
+            case 'subscribe':
+                return {
+                    description: 'Set up Borg MCP subscription ($1/month, 7-day trial)',
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: 'Please help me set up a Borg MCP subscription using the subscribe tool.',
+                            },
+                        },
+                    ],
+                };
+            case 'dashboard':
+                return {
+                    description: 'Open Borg MCP dashboard to manage cubes',
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: 'Please open the Borg MCP dashboard using the open_dashboard tool.',
+                            },
+                        },
+                    ],
+                };
+            default:
+                throw new Error(`Unknown prompt: ${name}`);
+        }
+    });
     // Create stdio transport
     const transport = new StdioServerTransport();
     // Connect server to transport
     await server.connect(transport);
-    console.error('🚀 Borg MCP Client started');
-    console.error('💡 Use borg:regen to fetch centralized context from the hive mind');
-    console.error('🌐 Manage your context entries at https://borgmcp.ai/dashboard');
+    console.error('◼ Borg MCP Client started');
+    console.error('◼ Use borg:assimilate <cube-name> to join a cube as a drone');
+    console.error('◼ Manage your cubes at https://borgmcp.ai/dashboard');
 }
-// Start the server
 main().catch((error) => {
     console.error('Fatal error:', error);
     process.exit(1);