@recursiv/mcp 0.1.1

package/dist/tools/dispatcher.js

@@ -0,0 +1,647 @@
+import { z } from 'zod';
+import { Scopes } from '../scopes.js';
+import { fmtErr } from './utils.js';
+// Env-based default so users don't need to pass org every call
+const defaultOrgId = process.env.RECURSIV_ORGANIZATION_ID;
+export function registerDispatcherTools(registry, client) {
+    registry.tool('list_tasks', 'List tasks from the dispatcher with optional filters. Automatically scoped to the configured organization.', [Scopes.COMMANDS_READ], {
+        status: z.string().optional().describe('Filter by status (pending, in_progress, claimed, done). "claimed" returns in_progress tasks with an active claim.'),
+        milestone: z.string().optional().describe('Filter by milestone'),
+        layer: z.string().optional().describe('Filter by layer (core, plugin, ops)'),
+        owner: z.string().optional().describe('Filter by owner'),
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+        limit: z.number().optional().describe('Max results (default 20)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.tasks({
+                ...params,
+                organization_id: params.organization_id || defaultOrgId,
+            });
+            const allTasks = result.data;
+            const limit = params.limit ?? 20;
+            const tasks = allTasks.slice(0, limit);
+            if (tasks.length === 0) {
+                return { content: [{ type: 'text', text: 'No tasks found matching filters.' }] };
+            }
+            const lines = tasks.map((t) => `[${t.status}] ${t.id} — ${t.title} (score: ${t.score ?? 'N/A'}, effort: ${t.effort ?? 'N/A'}${t.owner ? `, owner: ${t.owner}` : ''})`);
+            const header = `Showing ${tasks.length} of ${allTasks.length} tasks${allTasks.length > limit ? ` (use limit param to see more)` : ''}:`;
+            return { content: [{ type: 'text', text: `${header}\n${lines.join('\n')}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error listing tasks', e);
+        }
+    });
+    registry.tool('claim_next_task', 'Atomically claim the highest-priority available task. Scoped to the configured organization.', [Scopes.COMMANDS_WRITE], {
+        agent: z.string().describe('Agent identifier (e.g., "claude-terminal-1")'),
+        owner: z.string().optional().describe('Owner filter (e.g., "bill")'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.claimNext(params);
+            const claim = result.data;
+            return {
+                content: [{ type: 'text', text: `Claimed task: ${claim.task.title}\nTask ID: ${claim.task_id}\nClaim ID: ${claim.claim_id}\nAgent: ${claim.agent}\n\nRemember to send heartbeats every 5 minutes.` }],
+            };
+        }
+        catch (e) {
+            if (e.status === 409) {
+                return { content: [{ type: 'text', text: 'No available tasks to claim. All tasks are either claimed, blocked, or done.' }] };
+            }
+            return fmtErr('Error claiming task', e);
+        }
+    });
+    registry.tool('claim_task', 'Claim a specific task by ID', [Scopes.COMMANDS_WRITE], {
+        task_id: z.string().describe('Task ID to claim'),
+        agent: z.string().describe('Agent identifier'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.claim(params.task_id, { agent: params.agent });
+            return {
+                content: [{ type: 'text', text: `Claimed task: ${result.data.task.title}\nTask ID: ${result.data.task_id}\nClaim ID: ${result.data.claim_id}` }],
+            };
+        }
+        catch (e) {
+            if (e.status === 409) {
+                return { content: [{ type: 'text', text: `Task ${params.task_id} is already claimed by another agent.` }] };
+            }
+            return fmtErr('Error claiming task', e);
+        }
+    });
+    registry.tool('heartbeat_task', 'Send heartbeat for an active task claim. Must be called every 5 minutes to keep the claim alive.', [Scopes.COMMANDS_WRITE], {
+        task_id: z.string().describe('Task ID'),
+        agent: z.string().describe('Agent identifier'),
+    }, async (params) => {
+        try {
+            await client.dispatcher.heartbeat(params.task_id, { agent: params.agent });
+            return { content: [{ type: 'text', text: `Heartbeat sent for task ${params.task_id}.` }] };
+        }
+        catch (e) {
+            return fmtErr('Error sending heartbeat', e);
+        }
+    });
+    registry.tool('complete_task', 'Mark a task as done', [Scopes.COMMANDS_WRITE], {
+        task_id: z.string().describe('Task ID to complete'),
+        notes: z.string().optional().describe('Completion notes'),
+    }, async (params) => {
+        try {
+            await client.dispatcher.complete(params.task_id, { notes: params.notes });
+            return { content: [{ type: 'text', text: `Task ${params.task_id} marked as done.` }] };
+        }
+        catch (e) {
+            return fmtErr('Error completing task', e);
+        }
+    });
+    registry.tool('release_task', 'Release a claim on a task, making it available for other agents', [Scopes.COMMANDS_WRITE], {
+        task_id: z.string().describe('Task ID to release'),
+        agent: z.string().optional().describe('Agent identifier'),
+        notes: z.string().optional().describe('Reason for release'),
+        release_reason: z.string().optional().describe('Structured reason: completed, blocked, timeout, reassigned, out_of_scope, needs_human, audit_failed'),
+        context_handoff: z.string().optional().describe('What you learned, where you left off, what the next agent needs to know'),
+        pr_urls: z.array(z.string()).optional().describe('PR URLs produced during this claim'),
+        commits: z.array(z.string()).optional().describe('Commit SHAs touched during this claim'),
+    }, async (params) => {
+        try {
+            await client.dispatcher.release(params.task_id, {
+                agent: params.agent,
+                notes: params.notes,
+                release_reason: params.release_reason,
+                context_handoff: params.context_handoff,
+                pr_urls: params.pr_urls,
+                commits: params.commits,
+            });
+            return { content: [{ type: 'text', text: `Released claim on task ${params.task_id}.` }] };
+        }
+        catch (e) {
+            return fmtErr('Error releasing task', e);
+        }
+    });
+    registry.tool('create_task', 'Create a new task in the dispatcher. Automatically scoped to the configured organization.', [Scopes.COMMANDS_WRITE], {
+        title: z.string().describe('Task title'),
+        description: z.string().optional().describe('Task description'),
+        milestone: z.string().optional().describe('Milestone (e.g., "v1-launch")'),
+        effort: z.number().optional().describe('Effort estimate (1-10)'),
+        layer: z.string().optional().describe('Layer (core, plugin, ops)'),
+        owner: z.string().optional().describe('Assigned owner'),
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+        project_id: z.string().optional().describe('Project UUID to scope the task to a specific project'),
+        severity: z.number().min(0).max(5).optional().describe('Bug/security severity 0-5 (5 = critical). Drives priority scoring.'),
+        urgency: z.number().min(0).max(5).optional().describe('Time urgency 0-5 (5 = immediate). Drives priority scoring.'),
+        signal: z.number().min(0).max(5).optional().describe('User/market signal strength 0-5. Drives priority scoring.'),
+        ui_impact: z.number().min(0).max(5).optional().describe('UI/UX impact 0-5 (5 = core user-facing experience). Drives priority scoring.'),
+        created_by: z.string().optional().describe('Agent name or user who created this task'),
+        created_via: z.string().optional().describe('How this task was created: mcp, api, sync, auto-audit, manual'),
+    }, async (params) => {
+        try {
+            // Generate a slug-based ID (REST endpoint requires it)
+            const slug = params.title
+                .toLowerCase()
+                .replace(/[^a-z0-9]+/g, '-')
+                .replace(/^-|-$/g, '')
+                .slice(0, 80);
+            const suffix = Math.random().toString(36).slice(2, 10);
+            const id = `proj-${slug}-${suffix}`;
+            const result = await client.dispatcher.create({
+                id,
+                title: params.title,
+                notes: params.description,
+                effort: params.effort,
+                layer: params.layer,
+                owner: params.owner,
+                milestone: params.milestone,
+                organization_id: params.organization_id || defaultOrgId,
+                project_id: params.project_id,
+                severity: params.severity,
+                urgency_score: params.urgency,
+                signal_score: params.signal,
+                ui_impact: params.ui_impact,
+                created_by: params.created_by,
+                created_via: params.created_via || 'mcp',
+            });
+            const task = result.data;
+            return {
+                content: [{ type: 'text', text: `Created task: ${task.title}\nID: ${task.id}\nScore: ${task.score ?? 'N/A'}` }],
+            };
+        }
+        catch (e) {
+            return fmtErr('Error creating task', e);
+        }
+    });
+    registry.tool('update_task', 'Update an existing task in the dispatcher. Can modify title, status, scoring fields, and more.', [Scopes.COMMANDS_WRITE], {
+        task_id: z.string().describe('Task ID to update'),
+        title: z.string().optional().describe('New task title'),
+        notes: z.string().optional().describe('Task notes'),
+        status: z.string().optional().describe('Task status (pending, in_progress, blocked, done, archived)'),
+        milestone: z.string().optional().describe('Milestone (e.g., "R1", "v1-launch")'),
+        effort: z.number().optional().describe('Effort estimate (1-10)'),
+        layer: z.string().optional().describe('Layer (core, plugin, ops)'),
+        owner: z.string().optional().describe('Assigned owner'),
+        proximity: z.number().min(1).max(10).optional().describe('How close to shippable (1-10). Drives priority scoring.'),
+        severity: z.number().min(0).max(5).optional().describe('Bug/security severity 0-5 (5 = critical). Drives priority scoring.'),
+        urgency: z.number().min(0).max(5).optional().describe('Time urgency 0-5 (5 = immediate). Drives priority scoring.'),
+        signal: z.number().min(0).max(5).optional().describe('User/market signal strength 0-5. Drives priority scoring.'),
+        ui_impact: z.number().min(0).max(5).optional().describe('UI/UX impact 0-5 (5 = core user-facing experience). Drives priority scoring.'),
+        score_override: z.number().optional().describe('Manual score override (bypasses formula calculation)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.update(params.task_id, {
+                title: params.title,
+                notes: params.notes,
+                status: params.status,
+                milestone: params.milestone,
+                effort: params.effort,
+                layer: params.layer,
+                owner: params.owner,
+                proximity: params.proximity,
+                severity: params.severity,
+                urgency_score: params.urgency,
+                signal_score: params.signal,
+                ui_impact: params.ui_impact,
+                score_override: params.score_override,
+            });
+            const task = result.data;
+            return {
+                content: [{ type: 'text', text: `Updated task: ${task.title}\nID: ${task.id}\nStatus: ${task.status}\nScore: ${task.score ?? 'N/A'}` }],
+            };
+        }
+        catch (e) {
+            return fmtErr('Error updating task', e);
+        }
+    });
+    registry.tool('get_dispatcher_stats', 'Get dispatcher statistics: task counts by status, owner, layer, and active claims. Scoped to the configured organization.', [Scopes.COMMANDS_READ], {}, async () => {
+        try {
+            const result = await client.dispatcher.stats();
+            const { tasks, byOwner, byLayer, activeClaims } = result.data;
+            const lines = [
+                `Total tasks: ${tasks.total}`,
+                `Pending: ${tasks.pending}`,
+                `In progress: ${tasks.in_progress}`,
+                `Done: ${tasks.done}`,
+                `Blocked: ${tasks.blocked}`,
+                `Archived: ${tasks.archived}`,
+                `Stale: ${tasks.stale}`,
+                `Active claims: ${activeClaims}`,
+                '',
+                'By layer:',
+                ...byLayer.map((r) => `  ${r.layer}: ${r.count} (${r.done} done)`),
+                '',
+                'By owner:',
+                ...byOwner.map((r) => `  ${r.owner}: ${r.count} (${r.done} done)`),
+            ];
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
+        catch (e) {
+            return fmtErr('Error getting stats', e);
+        }
+    });
+    registry.tool('list_active_claims', 'List all active task claims — shows which agents are working on which tasks, with heartbeat status.', [Scopes.COMMANDS_READ], {}, async () => {
+        try {
+            const result = await client.dispatcher.activeClaims();
+            const claims = result.data;
+            if (!claims || claims.length === 0) {
+                return { content: [{ type: 'text', text: 'No active claims.' }] };
+            }
+            const lines = claims.map((c) => {
+                const heartbeatAge = c.lastHeartbeat || c.last_heartbeat
+                    ? Math.round((Date.now() - new Date(c.lastHeartbeat || c.last_heartbeat).getTime()) / 60000)
+                    : null;
+                const staleWarning = heartbeatAge != null && heartbeatAge > 10 ? ' [STALE]' : '';
+                return `${c.agent} → ${c.taskId || c.task_id} (claimed ${c.claimedAt || c.claimed_at}, heartbeat ${heartbeatAge ?? '?'}m ago${staleWarning})`;
+            });
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
+        catch (e) {
+            return fmtErr('Error listing claims', e);
+        }
+    });
+    registry.tool('list_signals', 'List signals from the dispatcher signal log. Shows what external data (PostHog, Stripe, GitHub, social) has been collected for tasks.', [Scopes.COMMANDS_READ], {
+        task_id: z.string().optional().describe('Filter signals for a specific task'),
+        source: z.string().optional().describe('Filter by signal source (posthog, stripe, github, social, human)'),
+        limit: z.number().optional().describe('Max results (default 100)'),
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.signals({
+                ...params,
+                organization_id: params.organization_id || defaultOrgId,
+            });
+            const signals = result.data;
+            if (!signals || signals.length === 0) {
+                return { content: [{ type: 'text', text: 'No signals found.' }] };
+            }
+            const lines = signals.map((s) => `[${s.signal_source}] ${s.signal_type}: ${s.signal_value} → task ${s.task_id} (${s.created_at})`);
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
+        catch (e) {
+            return fmtErr('Error listing signals', e);
+        }
+    });
+    registry.tool('list_outcomes', 'List outcome checks — measured results for completed tasks (before/after metrics).', [Scopes.COMMANDS_READ], {
+        task_id: z.string().optional().describe('Filter outcomes for a specific task'),
+        limit: z.number().optional().describe('Max results (default 100)'),
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.outcomes({
+                ...params,
+                organization_id: params.organization_id || defaultOrgId,
+            });
+            const outcomes = result.data;
+            if (!outcomes || outcomes.length === 0) {
+                return { content: [{ type: 'text', text: 'No outcomes found.' }] };
+            }
+            const lines = outcomes.map((o) => `[${o.status}] ${o.metric_name}: ${o.before_value ?? '?'} → ${o.after_value} (task ${o.task_id}, ${o.created_at})`);
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
+        catch (e) {
+            return fmtErr('Error listing outcomes', e);
+        }
+    });
+    registry.tool('list_discoveries', 'List tasks in the discovery queue — agent-discovered work items needing human review.', [Scopes.COMMANDS_READ], {
+        max_confidence: z.number().optional().describe('Max confidence threshold (1-10, default 5)'),
+        limit: z.number().optional().describe('Max results (default 50)'),
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.discoveries({
+                maxConfidence: params.max_confidence,
+                limit: params.limit,
+                organization_id: params.organization_id || defaultOrgId,
+            });
+            const tasks = result.data;
+            if (!tasks || tasks.length === 0) {
+                return { content: [{ type: 'text', text: 'No discoveries in queue.' }] };
+            }
+            const lines = tasks.map((t) => `${t.id} — ${t.title} (score: ${t.score ?? 'N/A'}, effort: ${t.effort ?? 'N/A'})`);
+            return { content: [{ type: 'text', text: `Discovery queue (${tasks.length} items):\n${lines.join('\n')}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error listing discoveries', e);
+        }
+    });
+    registry.tool('get_pause_state', 'Check if dispatcher claiming is currently paused.', [Scopes.COMMANDS_READ], {
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.pauseState({
+                organization_id: params.organization_id || defaultOrgId,
+            });
+            const state = result.data;
+            if (!state.pausedUntil) {
+                return { content: [{ type: 'text', text: 'Dispatcher is NOT paused. Claiming is active.' }] };
+            }
+            return { content: [{ type: 'text', text: `Dispatcher is PAUSED until ${state.pausedUntil}${state.reason ? ` — Reason: ${state.reason}` : ''}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error getting pause state', e);
+        }
+    });
+    registry.tool('pause_dispatcher', 'Pause dispatcher claiming for a duration. No agents can claim tasks while paused.', [Scopes.COMMANDS_WRITE], {
+        pause_minutes: z.number().optional().describe('Pause duration in minutes (default: 60)'),
+        until: z.string().optional().describe('ISO 8601 datetime to pause until (alternative to pause_minutes)'),
+        reason: z.string().optional().describe('Reason for pausing'),
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.pause({
+                pauseMs: params.until ? undefined : (params.pause_minutes || 60) * 60_000,
+                until: params.until,
+                reason: params.reason,
+                organization_id: params.organization_id || defaultOrgId,
+            });
+            const state = result.data;
+            return { content: [{ type: 'text', text: `Dispatcher paused until ${state.pausedUntil}${state.reason ? ` — ${state.reason}` : ''}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error pausing dispatcher', e);
+        }
+    });
+    registry.tool('resume_dispatcher', 'Resume dispatcher claiming (clear pause). Agents can claim tasks again.', [Scopes.COMMANDS_WRITE], {
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+    }, async (params) => {
+        try {
+            await client.dispatcher.resume({
+                organization_id: params.organization_id || defaultOrgId,
+            });
+            return { content: [{ type: 'text', text: 'Dispatcher resumed. Claiming is active.' }] };
+        }
+        catch (e) {
+            return fmtErr('Error resuming dispatcher', e);
+        }
+    });
+    registry.tool('list_stale_tasks', 'List tasks with no updates in N days. Helps identify abandoned or forgotten work.', [Scopes.COMMANDS_READ], {
+        days: z.number().optional().describe('Days threshold (default 60)'),
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.staleItems({
+                days: params.days,
+                organization_id: params.organization_id || defaultOrgId,
+            });
+            const tasks = result.data;
+            if (!tasks || tasks.length === 0) {
+                return { content: [{ type: 'text', text: `No stale tasks (>${params.days || 60} days without update).` }] };
+            }
+            const lines = tasks.map((t) => `[${t.status}] ${t.id} — ${t.title} (last updated: ${t.updated_at})`);
+            return { content: [{ type: 'text', text: `Stale tasks (${tasks.length}):\n${lines.join('\n')}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error listing stale tasks', e);
+        }
+    });
+    registry.tool('list_stuck_tasks', 'List in-progress tasks stuck for N days — claimed but no heartbeat or completion.', [Scopes.COMMANDS_READ], {
+        days: z.number().optional().describe('Days threshold (default 7)'),
+        organization_id: z.string().optional().describe('Organization UUID (defaults to RECURSIV_ORGANIZATION_ID env var)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.stuckItems({
+                days: params.days,
+                organization_id: params.organization_id || defaultOrgId,
+            });
+            const tasks = result.data;
+            if (!tasks || tasks.length === 0) {
+                return { content: [{ type: 'text', text: `No stuck tasks (>${params.days || 7} days in progress).` }] };
+            }
+            const lines = tasks.map((t) => `[${t.status}] ${t.id} — ${t.title} (owner: ${t.owner ?? 'unassigned'}, updated: ${t.updated_at})`);
+            return { content: [{ type: 'text', text: `Stuck tasks (${tasks.length}):\n${lines.join('\n')}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error listing stuck tasks', e);
+        }
+    });
+    registry.tool('get_claim', 'Get the claim status for a specific task — shows if it is claimed, by whom, and heartbeat age.', [Scopes.COMMANDS_READ], {
+        task_id: z.string().describe('Task ID to check'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.getClaim(params.task_id);
+            const claim = result.data;
+            if (!claim) {
+                return { content: [{ type: 'text', text: `Task ${params.task_id} has no active or historical claims.` }] };
+            }
+            const c = claim;
+            const status = c.status;
+            const heartbeatAge = c.lastHeartbeat || c.last_heartbeat
+                ? Math.round((Date.now() - new Date(c.lastHeartbeat || c.last_heartbeat).getTime()) / 60000)
+                : null;
+            const lines = [
+                `Task: ${c.taskId || c.task_id}`,
+                `Status: ${status}`,
+                `Agent: ${c.agent}`,
+                `Claimed at: ${c.claimedAt || c.claimed_at}`,
+                heartbeatAge != null ? `Last heartbeat: ${heartbeatAge}m ago` : null,
+                c.releasedAt || c.released_at ? `Released at: ${c.releasedAt || c.released_at}` : null,
+                c.completedAt || c.completed_at ? `Completed at: ${c.completedAt || c.completed_at}` : null,
+                c.notes ? `Notes: ${c.notes}` : null,
+            ].filter(Boolean);
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
+        catch (e) {
+            return fmtErr('Error getting claim', e);
+        }
+    });
+    registry.tool('get_task', 'Get a single task by ID — full details including score, status, owner, description.', [Scopes.COMMANDS_READ], {
+        task_id: z.string().describe('Task ID to retrieve'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.getTask(params.task_id);
+            const t = result.data;
+            const lines = [
+                `ID: ${t.id}`,
+                `Title: ${t.title}`,
+                `Status: ${t.status}`,
+                `Score: ${t.score ?? 'N/A'}`,
+                `Effort: ${t.effort ?? 'N/A'}`,
+                `Layer: ${t.layer ?? 'N/A'}`,
+                `Owner: ${t.owner ?? 'unassigned'}`,
+                `Milestone: ${t.milestone ?? 'N/A'}`,
+                t.description ? `Description: ${t.description}` : null,
+                `Created: ${t.created_at}`,
+                `Updated: ${t.updated_at}`,
+            ].filter(Boolean);
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
+        catch (e) {
+            if (e.status === 404) {
+                return { content: [{ type: 'text', text: `Task ${params.task_id} not found.` }] };
+            }
+            return fmtErr('Error getting task', e);
+        }
+    });
+    registry.tool('list_task_activity', 'Get the activity log for a task — shows claim/release/complete events with timestamps and agents.', [Scopes.COMMANDS_READ], {
+        task_id: z.string().describe('Task ID to get activity for'),
+        limit: z.number().optional().describe('Max results (default 50, max 200)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.activity(params.task_id, {
+                limit: params.limit,
+            });
+            const entries = result.data;
+            if (!entries || entries.length === 0) {
+                return { content: [{ type: 'text', text: `No activity recorded for task ${params.task_id}.` }] };
+            }
+            const lines = entries.map((e) => `[${e.created_at}] ${e.event_type}${e.agent ? ` by ${e.agent}` : ''}${e.detail ? ` — ${e.detail}` : ''}`);
+            return { content: [{ type: 'text', text: `Activity for ${params.task_id} (${entries.length} events):\n${lines.join('\n')}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error getting task activity', e);
+        }
+    });
+    registry.tool('archive_task', 'Archive (soft-delete) a task. Sets status to archived. Cannot be undone easily.', [Scopes.COMMANDS_WRITE], {
+        task_id: z.string().describe('Task ID to archive'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.archive(params.task_id);
+            return { content: [{ type: 'text', text: `Archived task: ${result.data.title} (${params.task_id})` }] };
+        }
+        catch (e) {
+            if (e.status === 404) {
+                return { content: [{ type: 'text', text: `Task ${params.task_id} not found.` }] };
+            }
+            return fmtErr('Error archiving task', e);
+        }
+    });
+    registry.tool('discover_task', 'Submit a discovered task for human review. Use when an agent finds work that needs to be done but should be triaged first.', [Scopes.COMMANDS_WRITE], {
+        title: z.string().describe('Task title (min 3 chars)'),
+        discovered_by: z.string().describe('Agent name or task ID that discovered this work'),
+        notes: z.string().optional().describe('Details about what was discovered and why it matters'),
+        layer: z.string().optional().describe('Layer (core, plugin, ops)'),
+        effort: z.number().optional().describe('Estimated effort (1-10)'),
+        task_type: z.string().optional().describe('Task type (bug, feature, refactor, content, infra)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.discover({
+                ...params,
+                organization_id: defaultOrgId,
+            });
+            const task = result.data;
+            return {
+                content: [{ type: 'text', text: `Discovery submitted: ${task.title}\nID: ${task.id}\nScore: ${task.score ?? 'N/A'}\n\nTask is in the discovery queue for human review.` }],
+            };
+        }
+        catch (e) {
+            return fmtErr('Error submitting discovery', e);
+        }
+    });
+    registry.tool('record_outcome', 'Record a measured outcome for a completed task — before/after metrics to track impact.', [Scopes.COMMANDS_WRITE], {
+        task_id: z.string().describe('Task ID to record outcome for'),
+        metric_name: z.string().describe('Metric being measured (e.g., "page_load_ms", "error_rate", "signup_conversion")'),
+        after_value: z.string().describe('Measured value after the task was completed'),
+        before_value: z.string().optional().describe('Measured value before the task (if known)'),
+        notes: z.string().optional().describe('Additional context about the measurement'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.recordOutcome(params.task_id, {
+                metric_name: params.metric_name,
+                after_value: params.after_value,
+                before_value: params.before_value,
+                notes: params.notes,
+            });
+            const o = result.data;
+            return {
+                content: [{ type: 'text', text: `Outcome recorded for task ${params.task_id}:\n${o.metric_name}: ${o.before_value ?? '?'} → ${o.after_value}${o.notes ? `\nNotes: ${o.notes}` : ''}` }],
+            };
+        }
+        catch (e) {
+            return fmtErr('Error recording outcome', e);
+        }
+    });
+    registry.tool('register_webhook', 'Register a webhook URL to receive dispatcher events (task_claimed, task_done, task_released, etc.). Returns the signing secret — save it, it is only shown once.', [Scopes.COMMANDS_WRITE], {
+        url: z.string().url().refine((u) => u.startsWith('https://'), { message: 'URL must use HTTPS' }).describe('HTTPS URL to receive POST events'),
+        event_types: z.array(z.string()).optional().describe('Event types to subscribe to (empty = all). Options: task_claimed, task_released, task_done, task_created, task_updated, task_archived, heartbeat'),
+        description: z.string().optional().describe('Human-readable label for this webhook'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.createWebhook({
+                url: params.url,
+                event_types: params.event_types,
+                description: params.description,
+            });
+            const sub = result.data;
+            return {
+                content: [{ type: 'text', text: `Webhook registered!\nID: ${sub.id}\nURL: ${sub.url}\nEvents: ${sub.event_types.length > 0 ? sub.event_types.join(', ') : 'all'}\n\nSAVE THIS SECRET (shown only once):\n${sub.secret}\n\nUse it to verify X-Recursiv-Signature header (HMAC-SHA256).` }],
+            };
+        }
+        catch (e) {
+            return fmtErr('Error registering webhook', e);
+        }
+    });
+    registry.tool('list_webhooks', 'List registered webhook subscriptions. Secrets are redacted.', [Scopes.COMMANDS_READ], {}, async () => {
+        try {
+            const result = await client.dispatcher.listWebhooks();
+            const subs = result.data;
+            if (!subs || subs.length === 0) {
+                return { content: [{ type: 'text', text: 'No webhooks registered.' }] };
+            }
+            const lines = subs.map((s) => `${s.id} → ${s.url} (events: ${s.event_types?.length > 0 ? s.event_types.join(', ') : 'all'}, active: ${s.active}${s.description ? `, ${s.description}` : ''})`);
+            return { content: [{ type: 'text', text: `Webhooks (${subs.length}):\n${lines.join('\n')}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error listing webhooks', e);
+        }
+    });
+    registry.tool('update_webhook', 'Update a webhook subscription (URL, event types, description, or active status).', [Scopes.COMMANDS_WRITE], {
+        webhook_id: z.string().describe('Webhook subscription ID to update'),
+        url: z.string().url().optional().describe('New HTTPS URL'),
+        event_types: z.array(z.string()).optional().describe('New event types filter (empty array = all events)'),
+        description: z.string().optional().describe('Updated description'),
+        active: z.boolean().optional().describe('Enable or disable the webhook'),
+    }, async (params) => {
+        try {
+            const { webhook_id, ...input } = params;
+            const result = await client.dispatcher.updateWebhook(webhook_id, input);
+            const sub = result.data;
+            return {
+                content: [{ type: 'text', text: `Webhook ${sub.id} updated.\nURL: ${sub.url}\nActive: ${sub.active}\nEvents: ${sub.event_types.length > 0 ? sub.event_types.join(', ') : 'all'}` }],
+            };
+        }
+        catch (e) {
+            return fmtErr('Error updating webhook', e);
+        }
+    });
+    registry.tool('delete_webhook', 'Delete a webhook subscription. Stops all future event deliveries to this URL.', [Scopes.COMMANDS_WRITE], {
+        webhook_id: z.string().describe('Webhook subscription ID to delete'),
+    }, async (params) => {
+        try {
+            await client.dispatcher.deleteWebhook(params.webhook_id);
+            return { content: [{ type: 'text', text: `Webhook ${params.webhook_id} deleted.` }] };
+        }
+        catch (e) {
+            if (e.status === 404) {
+                return { content: [{ type: 'text', text: `Webhook ${params.webhook_id} not found.` }] };
+            }
+            return fmtErr('Error deleting webhook', e);
+        }
+    });
+    registry.tool('test_webhook', 'Send a test event to a webhook subscription to verify it is reachable and properly configured.', [Scopes.COMMANDS_WRITE], {
+        webhook_id: z.string().describe('Webhook subscription ID to test'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.testWebhook(params.webhook_id);
+            const test = result.data;
+            if (test.success) {
+                return { content: [{ type: 'text', text: `Webhook test successful! HTTP ${test.status}` }] };
+            }
+            return { content: [{ type: 'text', text: `Webhook test failed. ${test.error || `HTTP ${test.status}`}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error testing webhook', e);
+        }
+    });
+    // ── Webhook Delivery Log ──
+    registry.tool('webhook_deliveries', 'Get recent delivery log for a webhook subscription. Shows status, HTTP response, attempts, and errors.', [Scopes.COMMANDS_READ], {
+        webhook_id: z.string().describe('Webhook subscription ID'),
+        limit: z.number().optional().default(20).describe('Max deliveries to return (default 20, max 200)'),
+    }, async (params) => {
+        try {
+            const result = await client.dispatcher.webhookDeliveries(params.webhook_id, { limit: params.limit });
+            const deliveries = result.data;
+            if (!deliveries || deliveries.length === 0) {
+                return { content: [{ type: 'text', text: 'No deliveries found for this webhook.' }] };
+            }
+            const lines = deliveries.map((d) => `${d.event_type} — ${d.status} (HTTP ${d.response_status || '?'}) — ${d.attempts}/${d.max_attempts} attempts — ${d.created_at}${d.error ? ` — Error: ${d.error}` : ''}`);
+            return { content: [{ type: 'text', text: `Deliveries (${deliveries.length}):\n${lines.join('\n')}` }] };
+        }
+        catch (e) {
+            return fmtErr('Error fetching webhook deliveries', e);
+        }
+    });
+}
+//# sourceMappingURL=dispatcher.js.map