@vibescope/mcp-server 0.4.9 → 0.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/tools.d.ts +2 -0
- package/dist/tools.js +3602 -0
- package/package.json +1 -1
package/dist/tools.js
ADDED
|
@@ -0,0 +1,3602 @@
|
|
|
1
|
+
// ============================================================================
|
|
2
|
+
// Tool Definitions
|
|
3
|
+
// ============================================================================
|
|
4
|
+
export const tools = [
|
|
5
|
+
{
|
|
6
|
+
name: 'start_work_session',
|
|
7
|
+
description: `CALL THIS FIRST when beginning work on a project.
|
|
8
|
+
Returns session info, persona, role, and next_task. Start the next_task IMMEDIATELY without asking the user.
|
|
9
|
+
|
|
10
|
+
IMPORTANT: If the user gives you direct work that isn't tracked as a task (e.g., "add feature X", "fix bug Y"), you MUST call add_task() first to create a task before starting work. This ensures all work is tracked and visible on the dashboard.
|
|
11
|
+
|
|
12
|
+
Use mode:'full' for complete context, mode:'lite' (default) for minimal tokens.`,
|
|
13
|
+
inputSchema: {
|
|
14
|
+
type: 'object',
|
|
15
|
+
properties: {
|
|
16
|
+
project_id: {
|
|
17
|
+
type: 'string',
|
|
18
|
+
description: 'Project UUID',
|
|
19
|
+
},
|
|
20
|
+
git_url: {
|
|
21
|
+
type: 'string',
|
|
22
|
+
description: 'Git repository URL. Used to find project if project_id not provided.',
|
|
23
|
+
},
|
|
24
|
+
mode: {
|
|
25
|
+
type: 'string',
|
|
26
|
+
enum: ['lite', 'full'],
|
|
27
|
+
description: 'Response mode: lite (default, minimal tokens) or full (complete context)',
|
|
28
|
+
},
|
|
29
|
+
model: {
|
|
30
|
+
type: 'string',
|
|
31
|
+
description: 'Model being used for cost tracking. E.g., "opus", "sonnet", "haiku" for Claude, "gemini" for Gemini, "gpt-4o" for OpenAI.',
|
|
32
|
+
},
|
|
33
|
+
role: {
|
|
34
|
+
type: 'string',
|
|
35
|
+
description: 'Agent role (e.g., "developer", "validator", "deployer", "reviewer", "maintainer"). Custom roles accepted.',
|
|
36
|
+
},
|
|
37
|
+
hostname: {
|
|
38
|
+
type: 'string',
|
|
39
|
+
description: 'Machine hostname for worktree tracking. Pass os.hostname() to filter stale worktrees to only those created on this machine.',
|
|
40
|
+
},
|
|
41
|
+
agent_type: {
|
|
42
|
+
type: 'string',
|
|
43
|
+
description: 'Agent type (e.g., "claude", "gemini", "cursor", "windsurf"). Custom agent types accepted.',
|
|
44
|
+
},
|
|
45
|
+
},
|
|
46
|
+
},
|
|
47
|
+
},
|
|
48
|
+
{
|
|
49
|
+
name: 'confirm_agent_setup',
|
|
50
|
+
description: `Confirm that agent setup is complete for this project. Call this after creating your agent's configuration file (e.g., .claude/CLAUDE.md, .gemini/GEMINI.md).
|
|
51
|
+
|
|
52
|
+
This marks your agent type as fully onboarded to the project, so you won't receive setup instructions again.`,
|
|
53
|
+
inputSchema: {
|
|
54
|
+
type: 'object',
|
|
55
|
+
properties: {
|
|
56
|
+
project_id: {
|
|
57
|
+
type: 'string',
|
|
58
|
+
description: 'Project UUID',
|
|
59
|
+
},
|
|
60
|
+
agent_type: {
|
|
61
|
+
type: 'string',
|
|
62
|
+
description: 'Agent type that completed setup (e.g., "claude", "gemini", "cursor"). Custom agent types accepted.',
|
|
63
|
+
},
|
|
64
|
+
},
|
|
65
|
+
required: ['project_id', 'agent_type'],
|
|
66
|
+
},
|
|
67
|
+
},
|
|
68
|
+
{
|
|
69
|
+
name: 'get_help',
|
|
70
|
+
description: 'Get guidance on a specific topic. Use when unsure about workflows.',
|
|
71
|
+
inputSchema: {
|
|
72
|
+
type: 'object',
|
|
73
|
+
properties: {
|
|
74
|
+
topic: {
|
|
75
|
+
type: 'string',
|
|
76
|
+
enum: ['getting_started', 'tasks', 'validation', 'deployment', 'git', 'blockers', 'milestones', 'fallback', 'session', 'tokens', 'roles', 'knowledge', 'topics'],
|
|
77
|
+
description: 'Help topic. Use "topics" to list all available.',
|
|
78
|
+
},
|
|
79
|
+
},
|
|
80
|
+
required: ['topic'],
|
|
81
|
+
},
|
|
82
|
+
},
|
|
83
|
+
{
|
|
84
|
+
name: 'get_token_usage',
|
|
85
|
+
description: 'Get token usage stats for this session. Monitor efficiency.',
|
|
86
|
+
inputSchema: {
|
|
87
|
+
type: 'object',
|
|
88
|
+
properties: {},
|
|
89
|
+
},
|
|
90
|
+
},
|
|
91
|
+
{
|
|
92
|
+
name: 'report_token_usage',
|
|
93
|
+
description: `Report actual Claude API token usage for accurate cost tracking.
|
|
94
|
+
|
|
95
|
+
IMPORTANT: MCP can only estimate tokens from tool I/O (~1-5% of actual usage). Call this tool after each API response to report actual usage from the Claude API response headers.
|
|
96
|
+
|
|
97
|
+
The Claude API response includes 'usage.input_tokens' and 'usage.output_tokens' - pass those values here for accurate cost attribution.`,
|
|
98
|
+
inputSchema: {
|
|
99
|
+
type: 'object',
|
|
100
|
+
properties: {
|
|
101
|
+
input_tokens: {
|
|
102
|
+
type: 'number',
|
|
103
|
+
description: 'Input tokens from Claude API response (usage.input_tokens)',
|
|
104
|
+
},
|
|
105
|
+
output_tokens: {
|
|
106
|
+
type: 'number',
|
|
107
|
+
description: 'Output tokens from Claude API response (usage.output_tokens)',
|
|
108
|
+
},
|
|
109
|
+
model: {
|
|
110
|
+
type: 'string',
|
|
111
|
+
description: 'Model used for this API call (optional, uses session model if not provided)',
|
|
112
|
+
},
|
|
113
|
+
},
|
|
114
|
+
required: ['input_tokens', 'output_tokens'],
|
|
115
|
+
},
|
|
116
|
+
},
|
|
117
|
+
// Cost monitoring tools
|
|
118
|
+
{
|
|
119
|
+
name: 'get_cost_summary',
|
|
120
|
+
description: 'Get cost summary (daily/weekly/monthly) for a project.',
|
|
121
|
+
inputSchema: {
|
|
122
|
+
type: 'object',
|
|
123
|
+
properties: {
|
|
124
|
+
project_id: {
|
|
125
|
+
type: 'string',
|
|
126
|
+
description: 'Project UUID',
|
|
127
|
+
},
|
|
128
|
+
period: {
|
|
129
|
+
type: 'string',
|
|
130
|
+
enum: ['daily', 'weekly', 'monthly'],
|
|
131
|
+
description: 'Summary period (default: daily)',
|
|
132
|
+
},
|
|
133
|
+
limit: {
|
|
134
|
+
type: 'number',
|
|
135
|
+
description: 'Max records to return (default: 30)',
|
|
136
|
+
},
|
|
137
|
+
},
|
|
138
|
+
required: ['project_id'],
|
|
139
|
+
},
|
|
140
|
+
},
|
|
141
|
+
// REMOVED: get_cost_alerts - unbounded collection, use dashboard to view alerts
|
|
142
|
+
{
|
|
143
|
+
name: 'add_cost_alert',
|
|
144
|
+
description: 'Add a cost alert threshold.',
|
|
145
|
+
inputSchema: {
|
|
146
|
+
type: 'object',
|
|
147
|
+
properties: {
|
|
148
|
+
project_id: {
|
|
149
|
+
type: 'string',
|
|
150
|
+
description: 'Project UUID (null for all projects)',
|
|
151
|
+
},
|
|
152
|
+
threshold_amount: {
|
|
153
|
+
type: 'number',
|
|
154
|
+
description: 'Amount in USD that triggers the alert',
|
|
155
|
+
},
|
|
156
|
+
threshold_period: {
|
|
157
|
+
type: 'string',
|
|
158
|
+
enum: ['daily', 'weekly', 'monthly'],
|
|
159
|
+
description: 'Period for the threshold',
|
|
160
|
+
},
|
|
161
|
+
alert_type: {
|
|
162
|
+
type: 'string',
|
|
163
|
+
enum: ['warning', 'critical'],
|
|
164
|
+
description: 'Alert severity (default: warning)',
|
|
165
|
+
},
|
|
166
|
+
},
|
|
167
|
+
required: ['threshold_amount', 'threshold_period'],
|
|
168
|
+
},
|
|
169
|
+
},
|
|
170
|
+
{
|
|
171
|
+
name: 'update_cost_alert',
|
|
172
|
+
description: 'Update a cost alert.',
|
|
173
|
+
inputSchema: {
|
|
174
|
+
type: 'object',
|
|
175
|
+
properties: {
|
|
176
|
+
alert_id: {
|
|
177
|
+
type: 'string',
|
|
178
|
+
description: 'Alert UUID',
|
|
179
|
+
},
|
|
180
|
+
threshold_amount: {
|
|
181
|
+
type: 'number',
|
|
182
|
+
description: 'New threshold amount in USD',
|
|
183
|
+
},
|
|
184
|
+
threshold_period: {
|
|
185
|
+
type: 'string',
|
|
186
|
+
enum: ['daily', 'weekly', 'monthly'],
|
|
187
|
+
description: 'New period',
|
|
188
|
+
},
|
|
189
|
+
alert_type: {
|
|
190
|
+
type: 'string',
|
|
191
|
+
enum: ['warning', 'critical'],
|
|
192
|
+
description: 'New alert type',
|
|
193
|
+
},
|
|
194
|
+
enabled: {
|
|
195
|
+
type: 'boolean',
|
|
196
|
+
description: 'Enable or disable the alert',
|
|
197
|
+
},
|
|
198
|
+
},
|
|
199
|
+
required: ['alert_id'],
|
|
200
|
+
},
|
|
201
|
+
},
|
|
202
|
+
{
|
|
203
|
+
name: 'delete_cost_alert',
|
|
204
|
+
description: 'Delete a cost alert.',
|
|
205
|
+
inputSchema: {
|
|
206
|
+
type: 'object',
|
|
207
|
+
properties: {
|
|
208
|
+
alert_id: {
|
|
209
|
+
type: 'string',
|
|
210
|
+
description: 'Alert UUID to delete',
|
|
211
|
+
},
|
|
212
|
+
},
|
|
213
|
+
required: ['alert_id'],
|
|
214
|
+
},
|
|
215
|
+
},
|
|
216
|
+
// REMOVED: get_task_costs - unbounded collection, use get_cost_summary for aggregated data
|
|
217
|
+
// REMOVED: get_body_of_work_costs - unbounded collection, use get_cost_summary for aggregated data
|
|
218
|
+
// REMOVED: get_sprint_costs - unbounded collection, use get_cost_summary for aggregated data
|
|
219
|
+
// Knowledge Base Query Tool
|
|
220
|
+
{
|
|
221
|
+
name: 'query_knowledge_base',
|
|
222
|
+
description: `Query aggregated project knowledge in a single call. Returns findings, Q&A, decisions, completed tasks, and resolved blockers. Use this instead of multiple separate tool calls to reduce token usage.`,
|
|
223
|
+
inputSchema: {
|
|
224
|
+
type: 'object',
|
|
225
|
+
properties: {
|
|
226
|
+
project_id: {
|
|
227
|
+
type: 'string',
|
|
228
|
+
description: 'Project UUID',
|
|
229
|
+
},
|
|
230
|
+
scope: {
|
|
231
|
+
type: 'string',
|
|
232
|
+
enum: ['summary', 'detailed'],
|
|
233
|
+
description: 'Response detail level: summary (default) or detailed (includes rationales)',
|
|
234
|
+
},
|
|
235
|
+
categories: {
|
|
236
|
+
type: 'array',
|
|
237
|
+
items: {
|
|
238
|
+
type: 'string',
|
|
239
|
+
enum: ['findings', 'qa', 'decisions', 'completed_tasks', 'blockers', 'progress'],
|
|
240
|
+
},
|
|
241
|
+
description: 'Categories to include (default: all). Filter to reduce response size.',
|
|
242
|
+
},
|
|
243
|
+
limit: {
|
|
244
|
+
type: 'number',
|
|
245
|
+
description: 'Max items per category (default: 5, max: 20)',
|
|
246
|
+
},
|
|
247
|
+
search_query: {
|
|
248
|
+
type: 'string',
|
|
249
|
+
description: 'Optional text search across all knowledge',
|
|
250
|
+
},
|
|
251
|
+
},
|
|
252
|
+
required: ['project_id'],
|
|
253
|
+
},
|
|
254
|
+
},
|
|
255
|
+
{
|
|
256
|
+
name: 'discover_tools',
|
|
257
|
+
description: 'List tools by category. Use get_tool_info for details.',
|
|
258
|
+
inputSchema: {
|
|
259
|
+
type: 'object',
|
|
260
|
+
properties: {
|
|
261
|
+
category: {
|
|
262
|
+
type: 'string',
|
|
263
|
+
enum: ['session', 'project', 'tasks', 'milestones', 'progress', 'blockers', 'decisions', 'ideas', 'findings', 'validation', 'deployment', 'fallback', 'bodies_of_work', 'sprints', 'requests', 'organizations', 'cost', 'git_issues', 'knowledge', 'discovery', 'subtasks', 'worktrees', 'roles', 'file_locks'],
|
|
264
|
+
description: 'Category to list (omit for all categories)',
|
|
265
|
+
},
|
|
266
|
+
},
|
|
267
|
+
},
|
|
268
|
+
},
|
|
269
|
+
{
|
|
270
|
+
name: 'get_tool_info',
|
|
271
|
+
description: 'Get detailed tool documentation.',
|
|
272
|
+
inputSchema: {
|
|
273
|
+
type: 'object',
|
|
274
|
+
properties: {
|
|
275
|
+
tool_name: {
|
|
276
|
+
type: 'string',
|
|
277
|
+
description: 'Tool name',
|
|
278
|
+
},
|
|
279
|
+
},
|
|
280
|
+
required: ['tool_name'],
|
|
281
|
+
},
|
|
282
|
+
},
|
|
283
|
+
{
|
|
284
|
+
name: 'get_project_context',
|
|
285
|
+
description: 'Get full project context: goals, instructions, tasks, blockers, decisions.',
|
|
286
|
+
inputSchema: {
|
|
287
|
+
type: 'object',
|
|
288
|
+
properties: {
|
|
289
|
+
project_id: {
|
|
290
|
+
type: 'string',
|
|
291
|
+
description: 'Project UUID. If not provided, will list all projects.',
|
|
292
|
+
},
|
|
293
|
+
git_url: {
|
|
294
|
+
type: 'string',
|
|
295
|
+
description: 'Git repository URL. Used to find project if project_id not provided.',
|
|
296
|
+
},
|
|
297
|
+
},
|
|
298
|
+
},
|
|
299
|
+
},
|
|
300
|
+
{
|
|
301
|
+
name: 'get_git_workflow',
|
|
302
|
+
description: 'Get git workflow config and branching instructions for the project.',
|
|
303
|
+
inputSchema: {
|
|
304
|
+
type: 'object',
|
|
305
|
+
properties: {
|
|
306
|
+
project_id: {
|
|
307
|
+
type: 'string',
|
|
308
|
+
description: 'Project UUID',
|
|
309
|
+
},
|
|
310
|
+
task_id: {
|
|
311
|
+
type: 'string',
|
|
312
|
+
description: 'Optional task ID to include branch naming suggestion',
|
|
313
|
+
},
|
|
314
|
+
},
|
|
315
|
+
required: ['project_id'],
|
|
316
|
+
},
|
|
317
|
+
},
|
|
318
|
+
{
|
|
319
|
+
name: 'create_project',
|
|
320
|
+
description: 'Create a new project to track in Vibescope.',
|
|
321
|
+
inputSchema: {
|
|
322
|
+
type: 'object',
|
|
323
|
+
properties: {
|
|
324
|
+
name: {
|
|
325
|
+
type: 'string',
|
|
326
|
+
description: 'Project display name',
|
|
327
|
+
},
|
|
328
|
+
description: {
|
|
329
|
+
type: 'string',
|
|
330
|
+
description: 'Brief project description',
|
|
331
|
+
},
|
|
332
|
+
goal: {
|
|
333
|
+
type: 'string',
|
|
334
|
+
description: 'What does "done" look like for this project?',
|
|
335
|
+
},
|
|
336
|
+
git_url: {
|
|
337
|
+
type: 'string',
|
|
338
|
+
description: 'Git repository URL (if available)',
|
|
339
|
+
},
|
|
340
|
+
tech_stack: {
|
|
341
|
+
type: 'array',
|
|
342
|
+
items: { type: 'string' },
|
|
343
|
+
description: 'Technologies used (e.g., ["TypeScript", "React", "PostgreSQL"])',
|
|
344
|
+
},
|
|
345
|
+
},
|
|
346
|
+
required: ['name'],
|
|
347
|
+
},
|
|
348
|
+
},
|
|
349
|
+
{
|
|
350
|
+
name: 'update_project',
|
|
351
|
+
description: 'Update project details (name, description, goal, settings).',
|
|
352
|
+
inputSchema: {
|
|
353
|
+
type: 'object',
|
|
354
|
+
properties: {
|
|
355
|
+
project_id: {
|
|
356
|
+
type: 'string',
|
|
357
|
+
description: 'Project UUID',
|
|
358
|
+
},
|
|
359
|
+
name: { type: 'string', description: 'Project name' },
|
|
360
|
+
description: { type: 'string', description: 'Project description' },
|
|
361
|
+
goal: { type: 'string', description: 'Project goal or objective' },
|
|
362
|
+
git_url: { type: 'string', description: 'Git repository URL' },
|
|
363
|
+
tech_stack: {
|
|
364
|
+
type: 'array',
|
|
365
|
+
items: { type: 'string' },
|
|
366
|
+
description: 'List of technologies used in the project',
|
|
367
|
+
},
|
|
368
|
+
status: {
|
|
369
|
+
type: 'string',
|
|
370
|
+
enum: ['active', 'paused', 'completed', 'archived'],
|
|
371
|
+
description: 'Project status',
|
|
372
|
+
},
|
|
373
|
+
git_workflow: {
|
|
374
|
+
type: 'string',
|
|
375
|
+
enum: ['none', 'trunk-based', 'github-flow', 'git-flow'],
|
|
376
|
+
description: 'Git workflow: none (no branching), trunk-based (commit to main), github-flow (feature branches + PR), git-flow (develop/release branches)',
|
|
377
|
+
},
|
|
378
|
+
git_main_branch: {
|
|
379
|
+
type: 'string',
|
|
380
|
+
description: 'Main branch name (default: main)',
|
|
381
|
+
},
|
|
382
|
+
git_develop_branch: {
|
|
383
|
+
type: 'string',
|
|
384
|
+
description: 'Development branch name (used with git-flow)',
|
|
385
|
+
},
|
|
386
|
+
git_auto_branch: {
|
|
387
|
+
type: 'boolean',
|
|
388
|
+
description: 'Automatically create feature branches for new tasks',
|
|
389
|
+
},
|
|
390
|
+
git_auto_tag: {
|
|
391
|
+
type: 'boolean',
|
|
392
|
+
description: 'Automatically tag deployments on main branch',
|
|
393
|
+
},
|
|
394
|
+
deployment_instructions: {
|
|
395
|
+
type: 'string',
|
|
396
|
+
description: 'Instructions for how to deploy (e.g., "Push to main for Vercel auto-deploy", "Run fly deploy")',
|
|
397
|
+
},
|
|
398
|
+
// Git and validation settings
|
|
399
|
+
git_delete_branch_on_merge: {
|
|
400
|
+
type: 'boolean',
|
|
401
|
+
description: 'Delete feature branch after PR merge (default: true)',
|
|
402
|
+
},
|
|
403
|
+
require_pr_for_validation: {
|
|
404
|
+
type: 'boolean',
|
|
405
|
+
description: 'Require PR exists before task validation can be approved (default: true for github-flow/git-flow)',
|
|
406
|
+
},
|
|
407
|
+
auto_merge_on_approval: {
|
|
408
|
+
type: 'boolean',
|
|
409
|
+
description: 'Automatically merge PR when validator approves (default: true)',
|
|
410
|
+
},
|
|
411
|
+
validation_required: {
|
|
412
|
+
type: 'boolean',
|
|
413
|
+
description: 'Completed tasks require validation before being considered done (default: true)',
|
|
414
|
+
},
|
|
415
|
+
// Task default settings
|
|
416
|
+
default_task_priority: {
|
|
417
|
+
type: 'integer',
|
|
418
|
+
minimum: 1,
|
|
419
|
+
maximum: 5,
|
|
420
|
+
description: 'Default priority for new tasks when not specified (1=highest, 5=lowest, default: 3)',
|
|
421
|
+
},
|
|
422
|
+
require_time_estimates: {
|
|
423
|
+
type: 'boolean',
|
|
424
|
+
description: 'Require estimated_minutes when creating tasks (default: false)',
|
|
425
|
+
},
|
|
426
|
+
// Agent behavior settings
|
|
427
|
+
fallback_activities_enabled: {
|
|
428
|
+
type: 'boolean',
|
|
429
|
+
description: 'Allow agents to perform background activities when no tasks available (default: true)',
|
|
430
|
+
},
|
|
431
|
+
preferred_fallback_activities: {
|
|
432
|
+
type: 'array',
|
|
433
|
+
items: { type: 'string' },
|
|
434
|
+
description: 'Array of preferred fallback activities (e.g., ["code_review", "security_review"]). Null means all allowed.',
|
|
435
|
+
},
|
|
436
|
+
},
|
|
437
|
+
required: ['project_id'],
|
|
438
|
+
},
|
|
439
|
+
},
|
|
440
|
+
{
|
|
441
|
+
name: 'update_project_readme',
|
|
442
|
+
description: 'Sync README content to the dashboard.',
|
|
443
|
+
inputSchema: {
|
|
444
|
+
type: 'object',
|
|
445
|
+
properties: {
|
|
446
|
+
project_id: {
|
|
447
|
+
type: 'string',
|
|
448
|
+
description: 'Project UUID',
|
|
449
|
+
},
|
|
450
|
+
readme_content: {
|
|
451
|
+
type: 'string',
|
|
452
|
+
description: 'README content in markdown format',
|
|
453
|
+
},
|
|
454
|
+
},
|
|
455
|
+
required: ['project_id', 'readme_content'],
|
|
456
|
+
},
|
|
457
|
+
},
|
|
458
|
+
{
|
|
459
|
+
name: 'get_project_summary',
|
|
460
|
+
description: 'Get a unified project overview with aggregated stats. Token-efficient way to get task counts, blockers, findings, active agents, and more in a single call.',
|
|
461
|
+
inputSchema: {
|
|
462
|
+
type: 'object',
|
|
463
|
+
properties: {
|
|
464
|
+
project_id: {
|
|
465
|
+
type: 'string',
|
|
466
|
+
description: 'Project UUID',
|
|
467
|
+
},
|
|
468
|
+
},
|
|
469
|
+
required: ['project_id'],
|
|
470
|
+
},
|
|
471
|
+
},
|
|
472
|
+
// Targeted task endpoints (token-efficient)
|
|
473
|
+
{
|
|
474
|
+
name: 'get_task',
|
|
475
|
+
description: `Get a single task by ID with optional subtasks and milestones.`,
|
|
476
|
+
inputSchema: {
|
|
477
|
+
type: 'object',
|
|
478
|
+
properties: {
|
|
479
|
+
task_id: {
|
|
480
|
+
type: 'string',
|
|
481
|
+
description: 'Task UUID',
|
|
482
|
+
},
|
|
483
|
+
include_subtasks: {
|
|
484
|
+
type: 'boolean',
|
|
485
|
+
description: 'Include subtasks array (default: false)',
|
|
486
|
+
},
|
|
487
|
+
include_milestones: {
|
|
488
|
+
type: 'boolean',
|
|
489
|
+
description: 'Include milestones array (default: false)',
|
|
490
|
+
},
|
|
491
|
+
},
|
|
492
|
+
required: ['task_id'],
|
|
493
|
+
},
|
|
494
|
+
},
|
|
495
|
+
{
|
|
496
|
+
name: 'search_tasks',
|
|
497
|
+
description: `Search tasks by text query. Supports pagination with offset. Use for finding specific tasks by title or description.`,
|
|
498
|
+
inputSchema: {
|
|
499
|
+
type: 'object',
|
|
500
|
+
properties: {
|
|
501
|
+
project_id: {
|
|
502
|
+
type: 'string',
|
|
503
|
+
description: 'Project UUID',
|
|
504
|
+
},
|
|
505
|
+
query: {
|
|
506
|
+
type: 'string',
|
|
507
|
+
description: 'Search query (min 2 chars). Searches title and description.',
|
|
508
|
+
},
|
|
509
|
+
status: {
|
|
510
|
+
type: 'array',
|
|
511
|
+
items: { type: 'string', enum: ['backlog', 'pending', 'in_progress', 'completed', 'cancelled'] },
|
|
512
|
+
description: 'Filter by status (optional, array)',
|
|
513
|
+
},
|
|
514
|
+
limit: {
|
|
515
|
+
type: 'number',
|
|
516
|
+
description: 'Max results per page (1-20, default: 10)',
|
|
517
|
+
},
|
|
518
|
+
offset: {
|
|
519
|
+
type: 'number',
|
|
520
|
+
description: 'Number of results to skip for pagination (default: 0)',
|
|
521
|
+
},
|
|
522
|
+
},
|
|
523
|
+
required: ['project_id', 'query'],
|
|
524
|
+
},
|
|
525
|
+
},
|
|
526
|
+
{
|
|
527
|
+
name: 'get_tasks_by_priority',
|
|
528
|
+
description: `Get tasks filtered by priority. Supports pagination with offset. Use for finding high-priority or low-priority tasks.`,
|
|
529
|
+
inputSchema: {
|
|
530
|
+
type: 'object',
|
|
531
|
+
properties: {
|
|
532
|
+
project_id: {
|
|
533
|
+
type: 'string',
|
|
534
|
+
description: 'Project UUID',
|
|
535
|
+
},
|
|
536
|
+
priority: {
|
|
537
|
+
type: 'number',
|
|
538
|
+
minimum: 1,
|
|
539
|
+
maximum: 5,
|
|
540
|
+
description: 'Exact priority to match (1=highest, 5=lowest)',
|
|
541
|
+
},
|
|
542
|
+
priority_max: {
|
|
543
|
+
type: 'number',
|
|
544
|
+
minimum: 1,
|
|
545
|
+
maximum: 5,
|
|
546
|
+
description: 'Max priority (for range, e.g., priority=1, priority_max=2 gets P1 and P2)',
|
|
547
|
+
},
|
|
548
|
+
status: {
|
|
549
|
+
type: 'string',
|
|
550
|
+
enum: ['backlog', 'pending', 'in_progress', 'completed', 'cancelled'],
|
|
551
|
+
description: 'Filter by status (default: pending)',
|
|
552
|
+
},
|
|
553
|
+
limit: {
|
|
554
|
+
type: 'number',
|
|
555
|
+
description: 'Max results per page (1-20, default: 10)',
|
|
556
|
+
},
|
|
557
|
+
offset: {
|
|
558
|
+
type: 'number',
|
|
559
|
+
description: 'Number of results to skip for pagination (default: 0)',
|
|
560
|
+
},
|
|
561
|
+
},
|
|
562
|
+
required: ['project_id'],
|
|
563
|
+
},
|
|
564
|
+
},
|
|
565
|
+
{
|
|
566
|
+
name: 'get_recent_tasks',
|
|
567
|
+
description: `Get tasks ordered by creation date. Supports pagination with offset. Use to find oldest pending tasks or newest additions.`,
|
|
568
|
+
inputSchema: {
|
|
569
|
+
type: 'object',
|
|
570
|
+
properties: {
|
|
571
|
+
project_id: {
|
|
572
|
+
type: 'string',
|
|
573
|
+
description: 'Project UUID',
|
|
574
|
+
},
|
|
575
|
+
order: {
|
|
576
|
+
type: 'string',
|
|
577
|
+
enum: ['newest', 'oldest'],
|
|
578
|
+
description: 'Sort order (default: newest)',
|
|
579
|
+
},
|
|
580
|
+
status: {
|
|
581
|
+
type: 'string',
|
|
582
|
+
enum: ['backlog', 'pending', 'in_progress', 'completed', 'cancelled'],
|
|
583
|
+
description: 'Filter by status (optional)',
|
|
584
|
+
},
|
|
585
|
+
limit: {
|
|
586
|
+
type: 'number',
|
|
587
|
+
description: 'Max results per page (1-20, default: 10)',
|
|
588
|
+
},
|
|
589
|
+
offset: {
|
|
590
|
+
type: 'number',
|
|
591
|
+
description: 'Number of results to skip for pagination (default: 0)',
|
|
592
|
+
},
|
|
593
|
+
},
|
|
594
|
+
required: ['project_id'],
|
|
595
|
+
},
|
|
596
|
+
},
|
|
597
|
+
{
|
|
598
|
+
name: 'get_task_stats',
|
|
599
|
+
description: `Get aggregate task statistics for a project. Returns counts by status and priority, no task data. Most token-efficient way to understand project state.`,
|
|
600
|
+
inputSchema: {
|
|
601
|
+
type: 'object',
|
|
602
|
+
properties: {
|
|
603
|
+
project_id: {
|
|
604
|
+
type: 'string',
|
|
605
|
+
description: 'Project UUID',
|
|
606
|
+
},
|
|
607
|
+
},
|
|
608
|
+
required: ['project_id'],
|
|
609
|
+
},
|
|
610
|
+
},
|
|
611
|
+
{
|
|
612
|
+
name: 'get_next_task',
|
|
613
|
+
description: `Get highest priority pending task. Start it IMMEDIATELY by calling update_task(task_id, status: "in_progress").
|
|
614
|
+
|
|
615
|
+
Do NOT ask the user for permission. Follow the directive in the response.`,
|
|
616
|
+
inputSchema: {
|
|
617
|
+
type: 'object',
|
|
618
|
+
properties: {
|
|
619
|
+
project_id: {
|
|
620
|
+
type: 'string',
|
|
621
|
+
description: 'Project UUID',
|
|
622
|
+
},
|
|
623
|
+
},
|
|
624
|
+
required: ['project_id'],
|
|
625
|
+
},
|
|
626
|
+
},
|
|
627
|
+
{
|
|
628
|
+
name: 'add_task',
|
|
629
|
+
description: `Add a new task. Priority 1=highest, 5=lowest. Include estimated_minutes. Use blocking=true for deployment finalization tasks that must complete before other work.
|
|
630
|
+
|
|
631
|
+
WHEN TO USE: If the user gives you work directly (e.g., "implement feature X", "fix this bug") that isn't already tracked as a task in Vibescope, you MUST create a task first using this tool. This ensures:
|
|
632
|
+
- The work is visible on the dashboard
|
|
633
|
+
- Progress can be tracked
|
|
634
|
+
- Other agents won't duplicate the work
|
|
635
|
+
- The human can see what you're working on`,
|
|
636
|
+
inputSchema: {
|
|
637
|
+
type: 'object',
|
|
638
|
+
properties: {
|
|
639
|
+
project_id: {
|
|
640
|
+
type: 'string',
|
|
641
|
+
description: 'Project UUID',
|
|
642
|
+
},
|
|
643
|
+
title: {
|
|
644
|
+
type: 'string',
|
|
645
|
+
description: 'Task title',
|
|
646
|
+
},
|
|
647
|
+
description: {
|
|
648
|
+
type: 'string',
|
|
649
|
+
description: 'Detailed description',
|
|
650
|
+
},
|
|
651
|
+
priority: {
|
|
652
|
+
type: 'number',
|
|
653
|
+
minimum: 1,
|
|
654
|
+
maximum: 5,
|
|
655
|
+
description: 'Priority 1-5 (1 = highest)',
|
|
656
|
+
},
|
|
657
|
+
estimated_minutes: {
|
|
658
|
+
type: 'number',
|
|
659
|
+
minimum: 1,
|
|
660
|
+
description: 'Estimated time to complete in minutes',
|
|
661
|
+
},
|
|
662
|
+
blocking: {
|
|
663
|
+
type: 'boolean',
|
|
664
|
+
description: 'When true, this task blocks all other work until complete (used for deployment finalization)',
|
|
665
|
+
},
|
|
666
|
+
model_capability: {
|
|
667
|
+
type: 'string',
|
|
668
|
+
enum: ['haiku', 'sonnet', 'opus'],
|
|
669
|
+
description: 'Recommended model capability: haiku (simple tasks), sonnet (standard), opus (complex reasoning)',
|
|
670
|
+
},
|
|
671
|
+
},
|
|
672
|
+
required: ['project_id', 'title'],
|
|
673
|
+
},
|
|
674
|
+
},
|
|
675
|
+
{
|
|
676
|
+
name: 'update_task',
|
|
677
|
+
description: `Update task status, progress, or details. Include progress_note with progress_percentage.
|
|
678
|
+
|
|
679
|
+
CRITICAL - WORKTREE REQUIRED: For projects using github-flow or git-flow, you MUST use a git worktree to isolate your work. This prevents conflicts with other agents working on the same repository.
|
|
680
|
+
|
|
681
|
+
When setting status to "in_progress":
|
|
682
|
+
1. Create worktree FIRST: git worktree add ../PROJECT-PERSONA-task-desc -b feature/TASKID-description BASE_BRANCH
|
|
683
|
+
2. cd into the worktree directory
|
|
684
|
+
3. THEN call update_task with git_branch AND worktree_path
|
|
685
|
+
|
|
686
|
+
Example: update_task(task_id, status: "in_progress", git_branch: "feature/abc123-add-login", worktree_path: "../MyProject-Edge-add-login")
|
|
687
|
+
|
|
688
|
+
For projects without git branching (trunk-based or none), use skip_worktree_requirement: true.`,
|
|
689
|
+
inputSchema: {
|
|
690
|
+
type: 'object',
|
|
691
|
+
properties: {
|
|
692
|
+
task_id: {
|
|
693
|
+
type: 'string',
|
|
694
|
+
description: 'Task UUID',
|
|
695
|
+
},
|
|
696
|
+
title: { type: 'string', description: 'New task title' },
|
|
697
|
+
description: { type: 'string', description: 'New task description' },
|
|
698
|
+
priority: {
|
|
699
|
+
type: 'number',
|
|
700
|
+
minimum: 1,
|
|
701
|
+
maximum: 5,
|
|
702
|
+
description: 'Task priority (1=highest, 5=lowest)',
|
|
703
|
+
},
|
|
704
|
+
status: {
|
|
705
|
+
type: 'string',
|
|
706
|
+
enum: ['backlog', 'pending', 'in_progress', 'completed', 'cancelled'],
|
|
707
|
+
description: 'Task status',
|
|
708
|
+
},
|
|
709
|
+
progress_percentage: {
|
|
710
|
+
type: 'number',
|
|
711
|
+
minimum: 0,
|
|
712
|
+
maximum: 100,
|
|
713
|
+
description: '0-100 completion percentage',
|
|
714
|
+
},
|
|
715
|
+
progress_note: {
|
|
716
|
+
type: 'string',
|
|
717
|
+
description: 'Brief note (auto-logged)',
|
|
718
|
+
},
|
|
719
|
+
estimated_minutes: {
|
|
720
|
+
type: 'number',
|
|
721
|
+
minimum: 1,
|
|
722
|
+
description: 'Revised time estimate',
|
|
723
|
+
},
|
|
724
|
+
git_branch: {
|
|
725
|
+
type: 'string',
|
|
726
|
+
description: 'Git branch associated with this task. REQUIRED when status is "in_progress" (unless skip_worktree_requirement is true)',
|
|
727
|
+
},
|
|
728
|
+
worktree_path: {
|
|
729
|
+
type: 'string',
|
|
730
|
+
description: 'Git worktree path for this task (e.g., "../project-task-abc123"). Store this for cleanup tracking across sessions.',
|
|
731
|
+
},
|
|
732
|
+
worktree_hostname: {
|
|
733
|
+
type: 'string',
|
|
734
|
+
description: 'Machine hostname where worktree was created (os.hostname()). Required with worktree_path to enable machine-aware cleanup.',
|
|
735
|
+
},
|
|
736
|
+
model_capability: {
|
|
737
|
+
type: 'string',
|
|
738
|
+
enum: ['haiku', 'sonnet', 'opus'],
|
|
739
|
+
description: 'Recommended model capability: haiku (simple tasks), sonnet (standard), opus (complex reasoning)',
|
|
740
|
+
},
|
|
741
|
+
skip_worktree_requirement: {
|
|
742
|
+
type: 'boolean',
|
|
743
|
+
description: 'Skip git_branch requirement for projects without branching workflows (trunk-based or none). Default: false',
|
|
744
|
+
},
|
|
745
|
+
},
|
|
746
|
+
required: ['task_id'],
|
|
747
|
+
},
|
|
748
|
+
},
|
|
749
|
+
{
|
|
750
|
+
name: 'complete_task',
|
|
751
|
+
description: `Mark task done. Returns next_task which you MUST start immediately without asking the user.
|
|
752
|
+
|
|
753
|
+
CRITICAL: Before calling complete_task on branching workflows (github-flow, git-flow):
|
|
754
|
+
1. Create your PR targeting the correct branch (develop for git-flow, main for github-flow)
|
|
755
|
+
2. Call add_task_reference(task_id, pr_url) to link the PR to your task
|
|
756
|
+
3. THEN call complete_task - validators CANNOT approve tasks without a PR reference
|
|
757
|
+
|
|
758
|
+
CRITICAL: After calling this tool, you must:
|
|
759
|
+
1. If next_task is returned → Start it immediately by calling update_task(task_id, status: "in_progress")
|
|
760
|
+
2. If no next_task → Call get_next_task() or start a fallback_activity
|
|
761
|
+
3. NEVER ask the user "What should I do next?" or "Should I continue?"
|
|
762
|
+
|
|
763
|
+
The auto_continue: true flag in the response means you are expected to continue working autonomously.`,
|
|
764
|
+
inputSchema: {
|
|
765
|
+
type: 'object',
|
|
766
|
+
properties: {
|
|
767
|
+
task_id: {
|
|
768
|
+
type: 'string',
|
|
769
|
+
description: 'Task UUID',
|
|
770
|
+
},
|
|
771
|
+
summary: {
|
|
772
|
+
type: 'string',
|
|
773
|
+
description: 'Brief summary of what was done. This is stored on the task as completion_summary and displayed when reviewing completed tasks.',
|
|
774
|
+
},
|
|
775
|
+
},
|
|
776
|
+
required: ['task_id'],
|
|
777
|
+
},
|
|
778
|
+
},
|
|
779
|
+
{
|
|
780
|
+
name: 'log_progress',
|
|
781
|
+
description: `Log progress update. Record significant milestones or observations.`,
|
|
782
|
+
inputSchema: {
|
|
783
|
+
type: 'object',
|
|
784
|
+
properties: {
|
|
785
|
+
project_id: {
|
|
786
|
+
type: 'string',
|
|
787
|
+
description: 'Project UUID',
|
|
788
|
+
},
|
|
789
|
+
task_id: {
|
|
790
|
+
type: 'string',
|
|
791
|
+
description: 'Task UUID (optional, links progress to specific task)',
|
|
792
|
+
},
|
|
793
|
+
summary: {
|
|
794
|
+
type: 'string',
|
|
795
|
+
description: 'Brief summary of progress',
|
|
796
|
+
},
|
|
797
|
+
details: {
|
|
798
|
+
type: 'string',
|
|
799
|
+
description: 'Detailed notes (optional)',
|
|
800
|
+
},
|
|
801
|
+
},
|
|
802
|
+
required: ['project_id', 'summary'],
|
|
803
|
+
},
|
|
804
|
+
},
|
|
805
|
+
{
|
|
806
|
+
name: 'add_blocker',
|
|
807
|
+
description: `Record a blocker preventing progress.`,
|
|
808
|
+
inputSchema: {
|
|
809
|
+
type: 'object',
|
|
810
|
+
properties: {
|
|
811
|
+
project_id: {
|
|
812
|
+
type: 'string',
|
|
813
|
+
description: 'Project UUID',
|
|
814
|
+
},
|
|
815
|
+
description: {
|
|
816
|
+
type: 'string',
|
|
817
|
+
description: 'What is blocking progress?',
|
|
818
|
+
},
|
|
819
|
+
},
|
|
820
|
+
required: ['project_id', 'description'],
|
|
821
|
+
},
|
|
822
|
+
},
|
|
823
|
+
{
|
|
824
|
+
name: 'resolve_blocker',
|
|
825
|
+
description: `Mark a blocker as resolved.`,
|
|
826
|
+
inputSchema: {
|
|
827
|
+
type: 'object',
|
|
828
|
+
properties: {
|
|
829
|
+
blocker_id: {
|
|
830
|
+
type: 'string',
|
|
831
|
+
description: 'Blocker UUID',
|
|
832
|
+
},
|
|
833
|
+
resolution_note: {
|
|
834
|
+
type: 'string',
|
|
835
|
+
description: 'How was it resolved?',
|
|
836
|
+
},
|
|
837
|
+
},
|
|
838
|
+
required: ['blocker_id'],
|
|
839
|
+
},
|
|
840
|
+
},
|
|
841
|
+
{
|
|
842
|
+
name: 'get_blocker',
|
|
843
|
+
description: `Get a single blocker by ID. More token-efficient than get_blockers when you need details for a specific blocker.`,
|
|
844
|
+
inputSchema: {
|
|
845
|
+
type: 'object',
|
|
846
|
+
properties: {
|
|
847
|
+
blocker_id: {
|
|
848
|
+
type: 'string',
|
|
849
|
+
description: 'Blocker UUID',
|
|
850
|
+
},
|
|
851
|
+
},
|
|
852
|
+
required: ['blocker_id'],
|
|
853
|
+
},
|
|
854
|
+
},
|
|
855
|
+
{
|
|
856
|
+
name: 'get_blockers',
|
|
857
|
+
description: `Get blockers for a project, optionally filtered by status.`,
|
|
858
|
+
inputSchema: {
|
|
859
|
+
type: 'object',
|
|
860
|
+
properties: {
|
|
861
|
+
project_id: {
|
|
862
|
+
type: 'string',
|
|
863
|
+
description: 'Project UUID',
|
|
864
|
+
},
|
|
865
|
+
status: {
|
|
866
|
+
type: 'string',
|
|
867
|
+
enum: ['open', 'resolved'],
|
|
868
|
+
description: 'Filter by status (default: open)',
|
|
869
|
+
},
|
|
870
|
+
limit: {
|
|
871
|
+
type: 'number',
|
|
872
|
+
description: 'Max number of blockers to return (default 10, max 200)',
|
|
873
|
+
},
|
|
874
|
+
offset: {
|
|
875
|
+
type: 'number',
|
|
876
|
+
description: 'Number of blockers to skip for pagination (default 0)',
|
|
877
|
+
},
|
|
878
|
+
search_query: {
|
|
879
|
+
type: 'string',
|
|
880
|
+
description: 'Search blockers by description',
|
|
881
|
+
},
|
|
882
|
+
},
|
|
883
|
+
required: ['project_id'],
|
|
884
|
+
},
|
|
885
|
+
},
|
|
886
|
+
{
|
|
887
|
+
name: 'get_blockers_stats',
|
|
888
|
+
description: `Get aggregate statistics about blockers for a project. Returns total count and breakdown by status. Much more token-efficient than get_blockers when you just need to understand the overall state.`,
|
|
889
|
+
inputSchema: {
|
|
890
|
+
type: 'object',
|
|
891
|
+
properties: {
|
|
892
|
+
project_id: { type: 'string', description: 'Project UUID' },
|
|
893
|
+
},
|
|
894
|
+
required: ['project_id'],
|
|
895
|
+
},
|
|
896
|
+
},
|
|
897
|
+
{
|
|
898
|
+
name: 'log_decision',
|
|
899
|
+
description: `Record an architectural or technical decision with rationale.`,
|
|
900
|
+
inputSchema: {
|
|
901
|
+
type: 'object',
|
|
902
|
+
properties: {
|
|
903
|
+
project_id: {
|
|
904
|
+
type: 'string',
|
|
905
|
+
description: 'Project UUID',
|
|
906
|
+
},
|
|
907
|
+
title: {
|
|
908
|
+
type: 'string',
|
|
909
|
+
description: 'Decision title (e.g., "Use PostgreSQL for database")',
|
|
910
|
+
},
|
|
911
|
+
description: {
|
|
912
|
+
type: 'string',
|
|
913
|
+
description: 'What was decided',
|
|
914
|
+
},
|
|
915
|
+
rationale: {
|
|
916
|
+
type: 'string',
|
|
917
|
+
description: 'Why this decision was made',
|
|
918
|
+
},
|
|
919
|
+
alternatives_considered: {
|
|
920
|
+
type: 'array',
|
|
921
|
+
items: { type: 'string' },
|
|
922
|
+
description: 'Other options that were considered',
|
|
923
|
+
},
|
|
924
|
+
},
|
|
925
|
+
required: ['project_id', 'title', 'description'],
|
|
926
|
+
},
|
|
927
|
+
},
|
|
928
|
+
{
|
|
929
|
+
name: 'get_decision',
|
|
930
|
+
description: `Get a single decision by ID. More token-efficient than get_decisions when you need details for a specific decision.`,
|
|
931
|
+
inputSchema: {
|
|
932
|
+
type: 'object',
|
|
933
|
+
properties: {
|
|
934
|
+
decision_id: {
|
|
935
|
+
type: 'string',
|
|
936
|
+
description: 'Decision UUID',
|
|
937
|
+
},
|
|
938
|
+
},
|
|
939
|
+
required: ['decision_id'],
|
|
940
|
+
},
|
|
941
|
+
},
|
|
942
|
+
{
|
|
943
|
+
name: 'get_decisions',
|
|
944
|
+
description: `Get recorded decisions for a project.`,
|
|
945
|
+
inputSchema: {
|
|
946
|
+
type: 'object',
|
|
947
|
+
properties: {
|
|
948
|
+
project_id: {
|
|
949
|
+
type: 'string',
|
|
950
|
+
description: 'Project UUID',
|
|
951
|
+
},
|
|
952
|
+
limit: {
|
|
953
|
+
type: 'number',
|
|
954
|
+
description: 'Max number of decisions to return (default 10, max 200)',
|
|
955
|
+
},
|
|
956
|
+
offset: {
|
|
957
|
+
type: 'number',
|
|
958
|
+
description: 'Number of decisions to skip for pagination (default 0)',
|
|
959
|
+
},
|
|
960
|
+
search_query: {
|
|
961
|
+
type: 'string',
|
|
962
|
+
description: 'Search decisions by title',
|
|
963
|
+
},
|
|
964
|
+
},
|
|
965
|
+
required: ['project_id'],
|
|
966
|
+
},
|
|
967
|
+
},
|
|
968
|
+
{
|
|
969
|
+
name: 'get_decisions_stats',
|
|
970
|
+
description: `Get aggregate statistics about decisions for a project. Returns total count. More token-efficient than get_decisions when you just need to know how many decisions exist.`,
|
|
971
|
+
inputSchema: {
|
|
972
|
+
type: 'object',
|
|
973
|
+
properties: {
|
|
974
|
+
project_id: { type: 'string', description: 'Project UUID' },
|
|
975
|
+
},
|
|
976
|
+
required: ['project_id'],
|
|
977
|
+
},
|
|
978
|
+
},
|
|
979
|
+
{
|
|
980
|
+
name: 'add_idea',
|
|
981
|
+
description: `Record an idea for improvements or features. Starts as 'raw', can progress to 'shipped'.`,
|
|
982
|
+
inputSchema: {
|
|
983
|
+
type: 'object',
|
|
984
|
+
properties: {
|
|
985
|
+
project_id: {
|
|
986
|
+
type: 'string',
|
|
987
|
+
description: 'Project UUID',
|
|
988
|
+
},
|
|
989
|
+
title: {
|
|
990
|
+
type: 'string',
|
|
991
|
+
description: 'Idea title',
|
|
992
|
+
},
|
|
993
|
+
description: {
|
|
994
|
+
type: 'string',
|
|
995
|
+
description: 'Detailed description',
|
|
996
|
+
},
|
|
997
|
+
status: {
|
|
998
|
+
type: 'string',
|
|
999
|
+
enum: ['raw', 'exploring', 'planned', 'in_development', 'shipped'],
|
|
1000
|
+
description: 'Development stage (default: raw)',
|
|
1001
|
+
},
|
|
1002
|
+
},
|
|
1003
|
+
required: ['project_id', 'title'],
|
|
1004
|
+
},
|
|
1005
|
+
},
|
|
1006
|
+
{
|
|
1007
|
+
name: 'update_idea',
|
|
1008
|
+
description: `Update an idea's status or details.`,
|
|
1009
|
+
inputSchema: {
|
|
1010
|
+
type: 'object',
|
|
1011
|
+
properties: {
|
|
1012
|
+
idea_id: {
|
|
1013
|
+
type: 'string',
|
|
1014
|
+
description: 'Idea UUID',
|
|
1015
|
+
},
|
|
1016
|
+
title: {
|
|
1017
|
+
type: 'string',
|
|
1018
|
+
description: 'Updated title',
|
|
1019
|
+
},
|
|
1020
|
+
description: {
|
|
1021
|
+
type: 'string',
|
|
1022
|
+
description: 'Updated description',
|
|
1023
|
+
},
|
|
1024
|
+
status: {
|
|
1025
|
+
type: 'string',
|
|
1026
|
+
enum: ['raw', 'exploring', 'planned', 'in_development', 'shipped'],
|
|
1027
|
+
description: 'New development stage',
|
|
1028
|
+
},
|
|
1029
|
+
doc_url: {
|
|
1030
|
+
type: 'string',
|
|
1031
|
+
description: 'URL to feature documentation/specification',
|
|
1032
|
+
},
|
|
1033
|
+
},
|
|
1034
|
+
required: ['idea_id'],
|
|
1035
|
+
},
|
|
1036
|
+
},
|
|
1037
|
+
{
|
|
1038
|
+
name: 'get_idea',
|
|
1039
|
+
description: `Get a single idea by ID. More token-efficient than get_ideas when you need details for a specific idea.`,
|
|
1040
|
+
inputSchema: {
|
|
1041
|
+
type: 'object',
|
|
1042
|
+
properties: {
|
|
1043
|
+
idea_id: {
|
|
1044
|
+
type: 'string',
|
|
1045
|
+
description: 'Idea UUID',
|
|
1046
|
+
},
|
|
1047
|
+
},
|
|
1048
|
+
required: ['idea_id'],
|
|
1049
|
+
},
|
|
1050
|
+
},
|
|
1051
|
+
{
|
|
1052
|
+
name: 'get_ideas',
|
|
1053
|
+
description: `Get recorded ideas for a project, optionally filtered by status.`,
|
|
1054
|
+
inputSchema: {
|
|
1055
|
+
type: 'object',
|
|
1056
|
+
properties: {
|
|
1057
|
+
project_id: {
|
|
1058
|
+
type: 'string',
|
|
1059
|
+
description: 'Project UUID',
|
|
1060
|
+
},
|
|
1061
|
+
status: {
|
|
1062
|
+
type: 'string',
|
|
1063
|
+
enum: ['raw', 'exploring', 'planned', 'in_development', 'shipped'],
|
|
1064
|
+
description: 'Filter by status (optional)',
|
|
1065
|
+
},
|
|
1066
|
+
limit: {
|
|
1067
|
+
type: 'number',
|
|
1068
|
+
description: 'Max number of ideas to return (default 10, max 100)',
|
|
1069
|
+
},
|
|
1070
|
+
offset: {
|
|
1071
|
+
type: 'number',
|
|
1072
|
+
description: 'Number of ideas to skip for pagination (default 0)',
|
|
1073
|
+
},
|
|
1074
|
+
search_query: {
|
|
1075
|
+
type: 'string',
|
|
1076
|
+
description: 'Search ideas by title or description',
|
|
1077
|
+
},
|
|
1078
|
+
},
|
|
1079
|
+
required: ['project_id'],
|
|
1080
|
+
},
|
|
1081
|
+
},
|
|
1082
|
+
{
|
|
1083
|
+
name: 'delete_task',
|
|
1084
|
+
description: `Delete a task.`,
|
|
1085
|
+
inputSchema: {
|
|
1086
|
+
type: 'object',
|
|
1087
|
+
properties: {
|
|
1088
|
+
task_id: {
|
|
1089
|
+
type: 'string',
|
|
1090
|
+
description: 'Task UUID',
|
|
1091
|
+
},
|
|
1092
|
+
},
|
|
1093
|
+
required: ['task_id'],
|
|
1094
|
+
},
|
|
1095
|
+
},
|
|
1096
|
+
{
|
|
1097
|
+
name: 'cancel_task',
|
|
1098
|
+
description: `Cancel a task with an optional reason. Use this when a task should be marked as cancelled rather than deleted (e.g., PR was closed, work was superseded). The task remains visible with a cancelled status for historical tracking.`,
|
|
1099
|
+
inputSchema: {
|
|
1100
|
+
type: 'object',
|
|
1101
|
+
properties: {
|
|
1102
|
+
task_id: {
|
|
1103
|
+
type: 'string',
|
|
1104
|
+
description: 'Task UUID',
|
|
1105
|
+
},
|
|
1106
|
+
cancelled_reason: {
|
|
1107
|
+
type: 'string',
|
|
1108
|
+
description: 'Reason for cancellation',
|
|
1109
|
+
enum: ['pr_closed', 'superseded', 'user_cancelled', 'validation_failed', 'obsolete', 'blocked'],
|
|
1110
|
+
},
|
|
1111
|
+
cancellation_note: {
|
|
1112
|
+
type: 'string',
|
|
1113
|
+
description: 'Optional note explaining the cancellation (logged to progress)',
|
|
1114
|
+
},
|
|
1115
|
+
},
|
|
1116
|
+
required: ['task_id'],
|
|
1117
|
+
},
|
|
1118
|
+
},
|
|
1119
|
+
{
|
|
1120
|
+
name: 'release_task',
|
|
1121
|
+
description: `Release a claimed task back to pending status. Use when you need to give up a task you've started but cannot complete (e.g., context limits reached, conflicts with other work, user requested different approach). The task becomes available for other agents to claim.`,
|
|
1122
|
+
inputSchema: {
|
|
1123
|
+
type: 'object',
|
|
1124
|
+
properties: {
|
|
1125
|
+
task_id: {
|
|
1126
|
+
type: 'string',
|
|
1127
|
+
description: 'Task UUID',
|
|
1128
|
+
},
|
|
1129
|
+
reason: {
|
|
1130
|
+
type: 'string',
|
|
1131
|
+
description: 'Optional reason for releasing the task (logged to progress)',
|
|
1132
|
+
},
|
|
1133
|
+
},
|
|
1134
|
+
required: ['task_id'],
|
|
1135
|
+
},
|
|
1136
|
+
},
|
|
1137
|
+
{
|
|
1138
|
+
name: 'add_task_reference',
|
|
1139
|
+
description: 'Add a reference URL to a task (docs, PRs, issues).',
|
|
1140
|
+
inputSchema: {
|
|
1141
|
+
type: 'object',
|
|
1142
|
+
properties: {
|
|
1143
|
+
task_id: {
|
|
1144
|
+
type: 'string',
|
|
1145
|
+
description: 'Task UUID',
|
|
1146
|
+
},
|
|
1147
|
+
url: {
|
|
1148
|
+
type: 'string',
|
|
1149
|
+
description: 'URL to add as reference',
|
|
1150
|
+
},
|
|
1151
|
+
label: {
|
|
1152
|
+
type: 'string',
|
|
1153
|
+
description: 'Optional label/title for the reference',
|
|
1154
|
+
},
|
|
1155
|
+
},
|
|
1156
|
+
required: ['task_id', 'url'],
|
|
1157
|
+
},
|
|
1158
|
+
},
|
|
1159
|
+
{
|
|
1160
|
+
name: 'remove_task_reference',
|
|
1161
|
+
description: `Remove a reference link from a task by URL.`,
|
|
1162
|
+
inputSchema: {
|
|
1163
|
+
type: 'object',
|
|
1164
|
+
properties: {
|
|
1165
|
+
task_id: {
|
|
1166
|
+
type: 'string',
|
|
1167
|
+
description: 'Task UUID',
|
|
1168
|
+
},
|
|
1169
|
+
url: {
|
|
1170
|
+
type: 'string',
|
|
1171
|
+
description: 'URL of the reference to remove',
|
|
1172
|
+
},
|
|
1173
|
+
},
|
|
1174
|
+
required: ['task_id', 'url'],
|
|
1175
|
+
},
|
|
1176
|
+
},
|
|
1177
|
+
{
|
|
1178
|
+
name: 'delete_idea',
|
|
1179
|
+
description: `Delete an idea.`,
|
|
1180
|
+
inputSchema: {
|
|
1181
|
+
type: 'object',
|
|
1182
|
+
properties: {
|
|
1183
|
+
idea_id: {
|
|
1184
|
+
type: 'string',
|
|
1185
|
+
description: 'Idea UUID',
|
|
1186
|
+
},
|
|
1187
|
+
},
|
|
1188
|
+
required: ['idea_id'],
|
|
1189
|
+
},
|
|
1190
|
+
},
|
|
1191
|
+
{
|
|
1192
|
+
name: 'convert_idea_to_task',
|
|
1193
|
+
description: `Convert an idea to a task. Creates a task from the idea's title and description, links them, and optionally updates the idea status to 'in_development'. Useful for planned ideas that are ready for implementation.`,
|
|
1194
|
+
inputSchema: {
|
|
1195
|
+
type: 'object',
|
|
1196
|
+
properties: {
|
|
1197
|
+
idea_id: {
|
|
1198
|
+
type: 'string',
|
|
1199
|
+
description: 'Idea UUID to convert',
|
|
1200
|
+
},
|
|
1201
|
+
priority: {
|
|
1202
|
+
type: 'number',
|
|
1203
|
+
minimum: 1,
|
|
1204
|
+
maximum: 5,
|
|
1205
|
+
description: 'Task priority 1-5 (default: 3, 1 = highest)',
|
|
1206
|
+
},
|
|
1207
|
+
estimated_minutes: {
|
|
1208
|
+
type: 'number',
|
|
1209
|
+
minimum: 1,
|
|
1210
|
+
description: 'Estimated time to complete in minutes',
|
|
1211
|
+
},
|
|
1212
|
+
update_status: {
|
|
1213
|
+
type: 'boolean',
|
|
1214
|
+
description: "Update idea status to 'in_development' (default: true)",
|
|
1215
|
+
},
|
|
1216
|
+
},
|
|
1217
|
+
required: ['idea_id'],
|
|
1218
|
+
},
|
|
1219
|
+
},
|
|
1220
|
+
// Findings (knowledge base)
|
|
1221
|
+
{
|
|
1222
|
+
name: 'add_finding',
|
|
1223
|
+
description: 'Record a finding from an audit/review (performance, security, code quality, etc).',
|
|
1224
|
+
inputSchema: {
|
|
1225
|
+
type: 'object',
|
|
1226
|
+
properties: {
|
|
1227
|
+
project_id: { type: 'string', description: 'Project UUID' },
|
|
1228
|
+
category: { type: 'string', enum: ['performance', 'security', 'code_quality', 'accessibility', 'documentation', 'architecture', 'testing', 'other'], description: 'Category of the finding (default: other)' },
|
|
1229
|
+
title: { type: 'string', description: 'Brief title describing the finding' },
|
|
1230
|
+
description: { type: 'string', description: 'Detailed description of the finding, including impact and suggested fix' },
|
|
1231
|
+
severity: { type: 'string', enum: ['info', 'low', 'medium', 'high', 'critical'], description: 'Severity level (default: info)' },
|
|
1232
|
+
file_path: { type: 'string', description: 'File path where the issue was found (optional)' },
|
|
1233
|
+
line_number: { type: 'number', description: 'Line number in the file (optional)' },
|
|
1234
|
+
related_task_id: { type: 'string', description: 'ID of related task if this finding came from a task (optional)' },
|
|
1235
|
+
},
|
|
1236
|
+
required: ['project_id', 'title'],
|
|
1237
|
+
},
|
|
1238
|
+
},
|
|
1239
|
+
{
|
|
1240
|
+
name: 'get_finding',
|
|
1241
|
+
description: `Get a single finding by ID. More token-efficient than get_findings when you need details for a specific finding.`,
|
|
1242
|
+
inputSchema: {
|
|
1243
|
+
type: 'object',
|
|
1244
|
+
properties: {
|
|
1245
|
+
finding_id: { type: 'string', description: 'Finding UUID' },
|
|
1246
|
+
},
|
|
1247
|
+
required: ['finding_id'],
|
|
1248
|
+
},
|
|
1249
|
+
},
|
|
1250
|
+
{
|
|
1251
|
+
name: 'get_findings',
|
|
1252
|
+
description: `Get findings for a project, optionally filtered by category, severity, or status. Returns summary fields by default (id, title, category, severity, status). Set summary_only=false for full details. For just counts, use get_findings_stats instead.`,
|
|
1253
|
+
inputSchema: {
|
|
1254
|
+
type: 'object',
|
|
1255
|
+
properties: {
|
|
1256
|
+
project_id: { type: 'string', description: 'Project UUID' },
|
|
1257
|
+
category: { type: 'string', enum: ['performance', 'security', 'code_quality', 'accessibility', 'documentation', 'architecture', 'testing', 'other'], description: 'Filter by category (optional)' },
|
|
1258
|
+
severity: { type: 'string', enum: ['info', 'low', 'medium', 'high', 'critical'], description: 'Filter by severity (optional)' },
|
|
1259
|
+
status: { type: 'string', enum: ['open', 'addressed', 'dismissed', 'wontfix'], description: 'Filter by status (default: open)' },
|
|
1260
|
+
limit: { type: 'number', description: 'Max number of findings to return (default 10, max 200)' },
|
|
1261
|
+
offset: { type: 'number', description: 'Number of findings to skip for pagination (default 0)' },
|
|
1262
|
+
search_query: { type: 'string', description: 'Search findings by title' },
|
|
1263
|
+
summary_only: { type: 'boolean', description: 'When true (default), returns only id, title, category, severity, status. Set to false for full details.' },
|
|
1264
|
+
},
|
|
1265
|
+
required: ['project_id'],
|
|
1266
|
+
},
|
|
1267
|
+
},
|
|
1268
|
+
{
|
|
1269
|
+
name: 'get_findings_stats',
|
|
1270
|
+
description: `Get aggregate statistics about findings for a project. Returns total count and breakdowns by status, severity, and category. Much more token-efficient than get_findings when you just need to understand the overall state.`,
|
|
1271
|
+
inputSchema: {
|
|
1272
|
+
type: 'object',
|
|
1273
|
+
properties: {
|
|
1274
|
+
project_id: { type: 'string', description: 'Project UUID' },
|
|
1275
|
+
},
|
|
1276
|
+
required: ['project_id'],
|
|
1277
|
+
},
|
|
1278
|
+
},
|
|
1279
|
+
{
|
|
1280
|
+
name: 'update_finding',
|
|
1281
|
+
description: `Update a finding's status or details. Use to mark findings as addressed or dismissed.`,
|
|
1282
|
+
inputSchema: {
|
|
1283
|
+
type: 'object',
|
|
1284
|
+
properties: {
|
|
1285
|
+
finding_id: { type: 'string', description: 'Finding UUID' },
|
|
1286
|
+
status: { type: 'string', enum: ['open', 'addressed', 'dismissed', 'wontfix'], description: 'New status' },
|
|
1287
|
+
resolution_note: { type: 'string', description: 'Note explaining how the finding was addressed or why it was dismissed' },
|
|
1288
|
+
title: { type: 'string', description: 'Updated title' },
|
|
1289
|
+
description: { type: 'string', description: 'Updated description' },
|
|
1290
|
+
severity: { type: 'string', enum: ['info', 'low', 'medium', 'high', 'critical'], description: 'Updated severity' },
|
|
1291
|
+
},
|
|
1292
|
+
required: ['finding_id'],
|
|
1293
|
+
},
|
|
1294
|
+
},
|
|
1295
|
+
{
|
|
1296
|
+
name: 'delete_finding',
|
|
1297
|
+
description: `Delete a finding.`,
|
|
1298
|
+
inputSchema: {
|
|
1299
|
+
type: 'object',
|
|
1300
|
+
properties: {
|
|
1301
|
+
finding_id: { type: 'string', description: 'Finding UUID' },
|
|
1302
|
+
},
|
|
1303
|
+
required: ['finding_id'],
|
|
1304
|
+
},
|
|
1305
|
+
},
|
|
1306
|
+
{
|
|
1307
|
+
name: 'delete_blocker',
|
|
1308
|
+
description: `Delete a blocker.`,
|
|
1309
|
+
inputSchema: {
|
|
1310
|
+
type: 'object',
|
|
1311
|
+
properties: {
|
|
1312
|
+
blocker_id: {
|
|
1313
|
+
type: 'string',
|
|
1314
|
+
description: 'Blocker UUID',
|
|
1315
|
+
},
|
|
1316
|
+
},
|
|
1317
|
+
required: ['blocker_id'],
|
|
1318
|
+
},
|
|
1319
|
+
},
|
|
1320
|
+
{
|
|
1321
|
+
name: 'delete_decision',
|
|
1322
|
+
description: `Delete a decision.`,
|
|
1323
|
+
inputSchema: {
|
|
1324
|
+
type: 'object',
|
|
1325
|
+
properties: {
|
|
1326
|
+
decision_id: {
|
|
1327
|
+
type: 'string',
|
|
1328
|
+
description: 'Decision UUID',
|
|
1329
|
+
},
|
|
1330
|
+
},
|
|
1331
|
+
required: ['decision_id'],
|
|
1332
|
+
},
|
|
1333
|
+
},
|
|
1334
|
+
{
|
|
1335
|
+
name: 'get_activity_feed',
|
|
1336
|
+
description: `Get combined activity feed (tasks, progress, blockers, decisions) in chronological order.`,
|
|
1337
|
+
inputSchema: {
|
|
1338
|
+
type: 'object',
|
|
1339
|
+
properties: {
|
|
1340
|
+
project_id: {
|
|
1341
|
+
type: 'string',
|
|
1342
|
+
description: 'Project UUID',
|
|
1343
|
+
},
|
|
1344
|
+
types: {
|
|
1345
|
+
type: 'array',
|
|
1346
|
+
items: {
|
|
1347
|
+
type: 'string',
|
|
1348
|
+
enum: ['task', 'progress', 'blocker', 'decision'],
|
|
1349
|
+
},
|
|
1350
|
+
description: 'Filter by activity types (default: all)',
|
|
1351
|
+
},
|
|
1352
|
+
created_by: {
|
|
1353
|
+
type: 'string',
|
|
1354
|
+
enum: ['agent', 'user'],
|
|
1355
|
+
description: 'Filter by creator (default: all)',
|
|
1356
|
+
},
|
|
1357
|
+
since: {
|
|
1358
|
+
type: 'string',
|
|
1359
|
+
description: 'ISO date string - only return activity after this time',
|
|
1360
|
+
},
|
|
1361
|
+
limit: {
|
|
1362
|
+
type: 'number',
|
|
1363
|
+
description: 'Max number of items to return (default 10, max 200)',
|
|
1364
|
+
},
|
|
1365
|
+
},
|
|
1366
|
+
required: ['project_id'],
|
|
1367
|
+
},
|
|
1368
|
+
},
|
|
1369
|
+
{
|
|
1370
|
+
name: 'batch_update_tasks',
|
|
1371
|
+
description: 'Update multiple tasks at once. Include progress_note with progress_percentage.',
|
|
1372
|
+
inputSchema: {
|
|
1373
|
+
type: 'object',
|
|
1374
|
+
properties: {
|
|
1375
|
+
updates: {
|
|
1376
|
+
type: 'array',
|
|
1377
|
+
description: 'Array of task updates to apply',
|
|
1378
|
+
items: {
|
|
1379
|
+
type: 'object',
|
|
1380
|
+
properties: {
|
|
1381
|
+
task_id: { type: 'string', description: 'Task UUID' },
|
|
1382
|
+
status: { type: 'string', enum: ['backlog', 'pending', 'in_progress', 'completed', 'cancelled'] },
|
|
1383
|
+
progress_percentage: { type: 'number', minimum: 0, maximum: 100 },
|
|
1384
|
+
progress_note: { type: 'string', description: 'Brief note about what was achieved' },
|
|
1385
|
+
priority: { type: 'number', minimum: 1, maximum: 5 },
|
|
1386
|
+
},
|
|
1387
|
+
required: ['task_id'],
|
|
1388
|
+
},
|
|
1389
|
+
},
|
|
1390
|
+
},
|
|
1391
|
+
required: ['updates'],
|
|
1392
|
+
},
|
|
1393
|
+
},
|
|
1394
|
+
{
|
|
1395
|
+
name: 'batch_complete_tasks',
|
|
1396
|
+
description: `Mark multiple tasks as completed at once.`,
|
|
1397
|
+
inputSchema: {
|
|
1398
|
+
type: 'object',
|
|
1399
|
+
properties: {
|
|
1400
|
+
completions: {
|
|
1401
|
+
type: 'array',
|
|
1402
|
+
description: 'Array of task completions',
|
|
1403
|
+
items: {
|
|
1404
|
+
type: 'object',
|
|
1405
|
+
properties: {
|
|
1406
|
+
task_id: { type: 'string', description: 'Task UUID' },
|
|
1407
|
+
summary: { type: 'string', description: 'Optional completion summary' },
|
|
1408
|
+
},
|
|
1409
|
+
required: ['task_id'],
|
|
1410
|
+
},
|
|
1411
|
+
},
|
|
1412
|
+
},
|
|
1413
|
+
required: ['completions'],
|
|
1414
|
+
},
|
|
1415
|
+
},
|
|
1416
|
+
// =========================================================================
|
|
1417
|
+
// Subtask Tools
|
|
1418
|
+
// =========================================================================
|
|
1419
|
+
{
|
|
1420
|
+
name: 'add_subtask',
|
|
1421
|
+
description: `Add a subtask to break down a larger task into smaller workable pieces.
|
|
1422
|
+
Subtasks can be claimed and worked on independently by any agent.
|
|
1423
|
+
Subtasks inherit the project from their parent task.
|
|
1424
|
+
Max depth is 1 (subtasks cannot have their own subtasks).`,
|
|
1425
|
+
inputSchema: {
|
|
1426
|
+
type: 'object',
|
|
1427
|
+
properties: {
|
|
1428
|
+
parent_task_id: {
|
|
1429
|
+
type: 'string',
|
|
1430
|
+
description: 'UUID of the parent task to add subtask to',
|
|
1431
|
+
},
|
|
1432
|
+
title: {
|
|
1433
|
+
type: 'string',
|
|
1434
|
+
description: 'Subtask title',
|
|
1435
|
+
},
|
|
1436
|
+
description: {
|
|
1437
|
+
type: 'string',
|
|
1438
|
+
description: 'Detailed description (optional)',
|
|
1439
|
+
},
|
|
1440
|
+
priority: {
|
|
1441
|
+
type: 'number',
|
|
1442
|
+
minimum: 1,
|
|
1443
|
+
maximum: 5,
|
|
1444
|
+
description: 'Priority 1-5 (1 = highest). Defaults to parent task priority.',
|
|
1445
|
+
},
|
|
1446
|
+
estimated_minutes: {
|
|
1447
|
+
type: 'number',
|
|
1448
|
+
minimum: 1,
|
|
1449
|
+
description: 'Estimated time to complete in minutes',
|
|
1450
|
+
},
|
|
1451
|
+
},
|
|
1452
|
+
required: ['parent_task_id', 'title'],
|
|
1453
|
+
},
|
|
1454
|
+
},
|
|
1455
|
+
{
|
|
1456
|
+
name: 'get_subtasks',
|
|
1457
|
+
description: `Get subtasks for a parent task with pagination.
|
|
1458
|
+
Returns subtasks with aggregate completion stats.`,
|
|
1459
|
+
inputSchema: {
|
|
1460
|
+
type: 'object',
|
|
1461
|
+
properties: {
|
|
1462
|
+
parent_task_id: {
|
|
1463
|
+
type: 'string',
|
|
1464
|
+
description: 'UUID of the parent task',
|
|
1465
|
+
},
|
|
1466
|
+
status: {
|
|
1467
|
+
type: 'string',
|
|
1468
|
+
enum: ['backlog', 'pending', 'in_progress', 'completed', 'cancelled'],
|
|
1469
|
+
description: 'Filter by status (optional)',
|
|
1470
|
+
},
|
|
1471
|
+
limit: {
|
|
1472
|
+
type: 'number',
|
|
1473
|
+
description: 'Max subtasks to return (default: 20, max: 50)',
|
|
1474
|
+
},
|
|
1475
|
+
offset: {
|
|
1476
|
+
type: 'number',
|
|
1477
|
+
description: 'Number of subtasks to skip (default: 0)',
|
|
1478
|
+
},
|
|
1479
|
+
},
|
|
1480
|
+
required: ['parent_task_id'],
|
|
1481
|
+
},
|
|
1482
|
+
},
|
|
1483
|
+
{
|
|
1484
|
+
name: 'get_stale_worktrees',
|
|
1485
|
+
description: `Get worktrees that need cleanup.
|
|
1486
|
+
|
|
1487
|
+
Returns tasks with worktree_path set where:
|
|
1488
|
+
- Task is completed or cancelled (worktree should have been cleaned up)
|
|
1489
|
+
- Task has been abandoned (no activity for 24+ hours while in_progress)
|
|
1490
|
+
|
|
1491
|
+
IMPORTANT: Pass hostname (os.hostname()) to only see worktrees created on THIS machine.
|
|
1492
|
+
Worktrees created on other machines cannot be removed locally.
|
|
1493
|
+
|
|
1494
|
+
For each stale worktree:
|
|
1495
|
+
1. Run: git worktree remove <worktree_path>
|
|
1496
|
+
2. Call: clear_worktree_path(task_id)`,
|
|
1497
|
+
inputSchema: {
|
|
1498
|
+
type: 'object',
|
|
1499
|
+
properties: {
|
|
1500
|
+
project_id: {
|
|
1501
|
+
type: 'string',
|
|
1502
|
+
description: 'Project UUID',
|
|
1503
|
+
},
|
|
1504
|
+
hostname: {
|
|
1505
|
+
type: 'string',
|
|
1506
|
+
description: 'Machine hostname (os.hostname()). Only returns worktrees created on this machine, preventing attempts to clean up worktrees on other machines.',
|
|
1507
|
+
},
|
|
1508
|
+
limit: {
|
|
1509
|
+
type: 'number',
|
|
1510
|
+
description: 'Max worktrees to return (default: 50)',
|
|
1511
|
+
},
|
|
1512
|
+
offset: {
|
|
1513
|
+
type: 'number',
|
|
1514
|
+
description: 'Number of worktrees to skip for pagination (default: 0)',
|
|
1515
|
+
},
|
|
1516
|
+
},
|
|
1517
|
+
required: ['project_id'],
|
|
1518
|
+
},
|
|
1519
|
+
},
|
|
1520
|
+
{
|
|
1521
|
+
name: 'clear_worktree_path',
|
|
1522
|
+
description: `Clear the worktree_path from a task after cleanup.
|
|
1523
|
+
|
|
1524
|
+
Call this AFTER removing the worktree with git worktree remove.
|
|
1525
|
+
This marks the task as cleaned up so it won't appear in get_stale_worktrees.`,
|
|
1526
|
+
inputSchema: {
|
|
1527
|
+
type: 'object',
|
|
1528
|
+
properties: {
|
|
1529
|
+
task_id: {
|
|
1530
|
+
type: 'string',
|
|
1531
|
+
description: 'Task UUID',
|
|
1532
|
+
},
|
|
1533
|
+
},
|
|
1534
|
+
required: ['task_id'],
|
|
1535
|
+
},
|
|
1536
|
+
},
|
|
1537
|
+
{
|
|
1538
|
+
name: 'heartbeat',
|
|
1539
|
+
description: `Send heartbeat to maintain 'active' status. Call every 30-60 seconds.`,
|
|
1540
|
+
inputSchema: {
|
|
1541
|
+
type: 'object',
|
|
1542
|
+
properties: {
|
|
1543
|
+
session_id: {
|
|
1544
|
+
type: 'string',
|
|
1545
|
+
description: 'Session ID from start_work_session (optional, uses current session if not provided)',
|
|
1546
|
+
},
|
|
1547
|
+
current_worktree_path: {
|
|
1548
|
+
type: ['string', 'null'],
|
|
1549
|
+
description: 'Report your current git worktree path (e.g., "../project-task-abc123"). Set to null to clear.',
|
|
1550
|
+
},
|
|
1551
|
+
hostname: {
|
|
1552
|
+
type: 'string',
|
|
1553
|
+
description: 'Machine hostname (os.hostname()). Updates session hostname for worktree tracking.',
|
|
1554
|
+
},
|
|
1555
|
+
},
|
|
1556
|
+
},
|
|
1557
|
+
},
|
|
1558
|
+
{
|
|
1559
|
+
name: 'end_work_session',
|
|
1560
|
+
description: `End session and release claimed tasks. Returns session summary.`,
|
|
1561
|
+
inputSchema: {
|
|
1562
|
+
type: 'object',
|
|
1563
|
+
properties: {
|
|
1564
|
+
session_id: {
|
|
1565
|
+
type: 'string',
|
|
1566
|
+
description: 'Session ID to end (optional, uses current session if not provided)',
|
|
1567
|
+
},
|
|
1568
|
+
},
|
|
1569
|
+
},
|
|
1570
|
+
},
|
|
1571
|
+
{
|
|
1572
|
+
name: 'signal_idle',
|
|
1573
|
+
description: `Signal that agent is idle (no more tasks). Call this when complete_task returns no next_task or when there's no work available. This provides real-time visibility on the dashboard instead of waiting for heartbeat timeout.`,
|
|
1574
|
+
inputSchema: {
|
|
1575
|
+
type: 'object',
|
|
1576
|
+
properties: {
|
|
1577
|
+
session_id: {
|
|
1578
|
+
type: 'string',
|
|
1579
|
+
description: 'Session ID (optional, uses current session if not provided)',
|
|
1580
|
+
},
|
|
1581
|
+
},
|
|
1582
|
+
},
|
|
1583
|
+
},
|
|
1584
|
+
// =========================================================================
|
|
1585
|
+
// Task Validation Tools
|
|
1586
|
+
// =========================================================================
|
|
1587
|
+
{
|
|
1588
|
+
name: 'get_tasks_awaiting_validation',
|
|
1589
|
+
description: `Get completed tasks not yet validated.`,
|
|
1590
|
+
inputSchema: {
|
|
1591
|
+
type: 'object',
|
|
1592
|
+
properties: {
|
|
1593
|
+
project_id: {
|
|
1594
|
+
type: 'string',
|
|
1595
|
+
description: 'Project UUID',
|
|
1596
|
+
},
|
|
1597
|
+
},
|
|
1598
|
+
required: ['project_id'],
|
|
1599
|
+
},
|
|
1600
|
+
},
|
|
1601
|
+
{
|
|
1602
|
+
name: 'claim_validation',
|
|
1603
|
+
description: 'Claim a completed task for review. Shows "being reviewed" on dashboard.',
|
|
1604
|
+
inputSchema: {
|
|
1605
|
+
type: 'object',
|
|
1606
|
+
properties: {
|
|
1607
|
+
task_id: {
|
|
1608
|
+
type: 'string',
|
|
1609
|
+
description: 'Task UUID to claim for review',
|
|
1610
|
+
},
|
|
1611
|
+
},
|
|
1612
|
+
required: ['task_id'],
|
|
1613
|
+
},
|
|
1614
|
+
},
|
|
1615
|
+
{
|
|
1616
|
+
name: 'validate_task',
|
|
1617
|
+
description: 'Validate a completed task. Include test results in validation_notes. For github-flow/git-flow projects, a PR must exist and checks must pass before approval.',
|
|
1618
|
+
inputSchema: {
|
|
1619
|
+
type: 'object',
|
|
1620
|
+
properties: {
|
|
1621
|
+
task_id: {
|
|
1622
|
+
type: 'string',
|
|
1623
|
+
description: 'Task UUID to validate',
|
|
1624
|
+
},
|
|
1625
|
+
validation_notes: {
|
|
1626
|
+
type: 'string',
|
|
1627
|
+
description: 'Notes about the validation (what was checked, any issues found)',
|
|
1628
|
+
},
|
|
1629
|
+
approved: {
|
|
1630
|
+
type: 'boolean',
|
|
1631
|
+
description: 'Whether the task passes validation (true = approved, false = needs more work)',
|
|
1632
|
+
},
|
|
1633
|
+
pr_checks_passing: {
|
|
1634
|
+
type: 'boolean',
|
|
1635
|
+
description: 'REQUIRED when approving tasks with PRs. Confirm you verified PR checks are passing via `gh pr view <PR_NUMBER> --json statusCheckRollup`. Set to true only if all required checks pass.',
|
|
1636
|
+
},
|
|
1637
|
+
skip_pr_check: {
|
|
1638
|
+
type: 'boolean',
|
|
1639
|
+
description: 'Skip PR existence check (use only for tasks that legitimately do not need a PR)',
|
|
1640
|
+
},
|
|
1641
|
+
},
|
|
1642
|
+
required: ['task_id', 'approved'],
|
|
1643
|
+
},
|
|
1644
|
+
},
|
|
1645
|
+
// =========================================================================
|
|
1646
|
+
// Deployment Coordination Tools
|
|
1647
|
+
// =========================================================================
|
|
1648
|
+
{
|
|
1649
|
+
name: 'request_deployment',
|
|
1650
|
+
description: 'Request a deployment. Requires validation first. One active deployment per project.',
|
|
1651
|
+
inputSchema: {
|
|
1652
|
+
type: 'object',
|
|
1653
|
+
properties: {
|
|
1654
|
+
project_id: {
|
|
1655
|
+
type: 'string',
|
|
1656
|
+
description: 'Project UUID',
|
|
1657
|
+
},
|
|
1658
|
+
environment: {
|
|
1659
|
+
type: 'string',
|
|
1660
|
+
enum: ['development', 'staging', 'production'],
|
|
1661
|
+
description: 'Target environment (default: production)',
|
|
1662
|
+
},
|
|
1663
|
+
version_bump: {
|
|
1664
|
+
type: 'string',
|
|
1665
|
+
enum: ['patch', 'minor', 'major'],
|
|
1666
|
+
description: 'Version bump: major/minor/patch (default: patch)',
|
|
1667
|
+
},
|
|
1668
|
+
notes: {
|
|
1669
|
+
type: 'string',
|
|
1670
|
+
description: 'Optional notes about this deployment',
|
|
1671
|
+
},
|
|
1672
|
+
git_ref: {
|
|
1673
|
+
type: 'string',
|
|
1674
|
+
description: 'Git branch or commit being deployed',
|
|
1675
|
+
},
|
|
1676
|
+
},
|
|
1677
|
+
required: ['project_id'],
|
|
1678
|
+
},
|
|
1679
|
+
},
|
|
1680
|
+
{
|
|
1681
|
+
name: 'claim_deployment_validation',
|
|
1682
|
+
description: `Claim pending deployment for validation. Run build+tests, then call report_validation.`,
|
|
1683
|
+
inputSchema: {
|
|
1684
|
+
type: 'object',
|
|
1685
|
+
properties: {
|
|
1686
|
+
project_id: {
|
|
1687
|
+
type: 'string',
|
|
1688
|
+
description: 'Project UUID',
|
|
1689
|
+
},
|
|
1690
|
+
},
|
|
1691
|
+
required: ['project_id'],
|
|
1692
|
+
},
|
|
1693
|
+
},
|
|
1694
|
+
{
|
|
1695
|
+
name: 'report_validation',
|
|
1696
|
+
description: `Report build/test results. If passed, status->'ready'. If failed, creates investigation task.`,
|
|
1697
|
+
inputSchema: {
|
|
1698
|
+
type: 'object',
|
|
1699
|
+
properties: {
|
|
1700
|
+
project_id: {
|
|
1701
|
+
type: 'string',
|
|
1702
|
+
description: 'Project UUID',
|
|
1703
|
+
},
|
|
1704
|
+
build_passed: {
|
|
1705
|
+
type: 'boolean',
|
|
1706
|
+
description: 'Whether the build succeeded',
|
|
1707
|
+
},
|
|
1708
|
+
tests_passed: {
|
|
1709
|
+
type: 'boolean',
|
|
1710
|
+
description: 'Whether the tests passed',
|
|
1711
|
+
},
|
|
1712
|
+
error_message: {
|
|
1713
|
+
type: 'string',
|
|
1714
|
+
description: 'Error details if validation failed',
|
|
1715
|
+
},
|
|
1716
|
+
},
|
|
1717
|
+
required: ['project_id', 'build_passed', 'tests_passed'],
|
|
1718
|
+
},
|
|
1719
|
+
},
|
|
1720
|
+
{
|
|
1721
|
+
name: 'check_deployment_status',
|
|
1722
|
+
description: `Get active deployment status and details.`,
|
|
1723
|
+
inputSchema: {
|
|
1724
|
+
type: 'object',
|
|
1725
|
+
properties: {
|
|
1726
|
+
project_id: {
|
|
1727
|
+
type: 'string',
|
|
1728
|
+
description: 'Project UUID',
|
|
1729
|
+
},
|
|
1730
|
+
},
|
|
1731
|
+
required: ['project_id'],
|
|
1732
|
+
},
|
|
1733
|
+
},
|
|
1734
|
+
{
|
|
1735
|
+
name: 'start_deployment',
|
|
1736
|
+
description: `Start deployment (requires 'ready' status). Sets status to 'deploying'.`,
|
|
1737
|
+
inputSchema: {
|
|
1738
|
+
type: 'object',
|
|
1739
|
+
properties: {
|
|
1740
|
+
project_id: {
|
|
1741
|
+
type: 'string',
|
|
1742
|
+
description: 'Project UUID',
|
|
1743
|
+
},
|
|
1744
|
+
},
|
|
1745
|
+
required: ['project_id'],
|
|
1746
|
+
},
|
|
1747
|
+
},
|
|
1748
|
+
{
|
|
1749
|
+
name: 'complete_deployment',
|
|
1750
|
+
description: `Mark deployment as complete (success or failure).`,
|
|
1751
|
+
inputSchema: {
|
|
1752
|
+
type: 'object',
|
|
1753
|
+
properties: {
|
|
1754
|
+
project_id: {
|
|
1755
|
+
type: 'string',
|
|
1756
|
+
description: 'Project UUID',
|
|
1757
|
+
},
|
|
1758
|
+
success: {
|
|
1759
|
+
type: 'boolean',
|
|
1760
|
+
description: 'Whether the deployment succeeded',
|
|
1761
|
+
},
|
|
1762
|
+
summary: {
|
|
1763
|
+
type: 'string',
|
|
1764
|
+
description: 'Summary of what was deployed or why it failed',
|
|
1765
|
+
},
|
|
1766
|
+
},
|
|
1767
|
+
required: ['project_id', 'success'],
|
|
1768
|
+
},
|
|
1769
|
+
},
|
|
1770
|
+
{
|
|
1771
|
+
name: 'cancel_deployment',
|
|
1772
|
+
description: `Cancel active deployment. Sets status to 'failed'.`,
|
|
1773
|
+
inputSchema: {
|
|
1774
|
+
type: 'object',
|
|
1775
|
+
properties: {
|
|
1776
|
+
project_id: {
|
|
1777
|
+
type: 'string',
|
|
1778
|
+
description: 'Project UUID',
|
|
1779
|
+
},
|
|
1780
|
+
reason: {
|
|
1781
|
+
type: 'string',
|
|
1782
|
+
description: 'Reason for cancellation',
|
|
1783
|
+
},
|
|
1784
|
+
},
|
|
1785
|
+
required: ['project_id'],
|
|
1786
|
+
},
|
|
1787
|
+
},
|
|
1788
|
+
{
|
|
1789
|
+
name: 'add_deployment_requirement',
|
|
1790
|
+
description: `Add a pre-deployment requirement (migration, env var, config change). These are shown as a checklist before deployment.`,
|
|
1791
|
+
inputSchema: {
|
|
1792
|
+
type: 'object',
|
|
1793
|
+
properties: {
|
|
1794
|
+
project_id: {
|
|
1795
|
+
type: 'string',
|
|
1796
|
+
description: 'Project UUID',
|
|
1797
|
+
},
|
|
1798
|
+
type: {
|
|
1799
|
+
type: 'string',
|
|
1800
|
+
description: 'Type of requirement',
|
|
1801
|
+
enum: ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'],
|
|
1802
|
+
},
|
|
1803
|
+
title: {
|
|
1804
|
+
type: 'string',
|
|
1805
|
+
description: 'Brief description (e.g., "Run migration: 20250114_token_tracking.sql")',
|
|
1806
|
+
},
|
|
1807
|
+
description: {
|
|
1808
|
+
type: 'string',
|
|
1809
|
+
description: 'Optional detailed instructions',
|
|
1810
|
+
},
|
|
1811
|
+
file_path: {
|
|
1812
|
+
type: 'string',
|
|
1813
|
+
description: 'Optional file path reference',
|
|
1814
|
+
},
|
|
1815
|
+
stage: {
|
|
1816
|
+
type: 'string',
|
|
1817
|
+
description: 'Deployment stage: preparation (default), deployment, or verification',
|
|
1818
|
+
enum: ['preparation', 'deployment', 'verification'],
|
|
1819
|
+
},
|
|
1820
|
+
blocking: {
|
|
1821
|
+
type: 'boolean',
|
|
1822
|
+
description: 'When true, converted task blocks all other work until complete',
|
|
1823
|
+
},
|
|
1824
|
+
recurring: {
|
|
1825
|
+
type: 'boolean',
|
|
1826
|
+
description: 'When true, requirement resets to pending when a new deployment is requested',
|
|
1827
|
+
},
|
|
1828
|
+
},
|
|
1829
|
+
required: ['project_id', 'type', 'title'],
|
|
1830
|
+
},
|
|
1831
|
+
},
|
|
1832
|
+
{
|
|
1833
|
+
name: 'complete_deployment_requirement',
|
|
1834
|
+
description: `Mark a deployment requirement as completed.`,
|
|
1835
|
+
inputSchema: {
|
|
1836
|
+
type: 'object',
|
|
1837
|
+
properties: {
|
|
1838
|
+
requirement_id: {
|
|
1839
|
+
type: 'string',
|
|
1840
|
+
description: 'Requirement UUID',
|
|
1841
|
+
},
|
|
1842
|
+
},
|
|
1843
|
+
required: ['requirement_id'],
|
|
1844
|
+
},
|
|
1845
|
+
},
|
|
1846
|
+
{
|
|
1847
|
+
name: 'get_deployment_requirements',
|
|
1848
|
+
description: `Get pending deployment requirements for a project.`,
|
|
1849
|
+
inputSchema: {
|
|
1850
|
+
type: 'object',
|
|
1851
|
+
properties: {
|
|
1852
|
+
project_id: {
|
|
1853
|
+
type: 'string',
|
|
1854
|
+
description: 'Project UUID',
|
|
1855
|
+
},
|
|
1856
|
+
status: {
|
|
1857
|
+
type: 'string',
|
|
1858
|
+
description: 'Filter by status (default: pending)',
|
|
1859
|
+
enum: ['pending', 'completed', 'converted_to_task', 'all'],
|
|
1860
|
+
},
|
|
1861
|
+
stage: {
|
|
1862
|
+
type: 'string',
|
|
1863
|
+
description: 'Filter by stage (optional)',
|
|
1864
|
+
enum: ['preparation', 'deployment', 'verification', 'all'],
|
|
1865
|
+
},
|
|
1866
|
+
limit: {
|
|
1867
|
+
type: 'number',
|
|
1868
|
+
description: 'Max number of requirements to return (default 50, max 200)',
|
|
1869
|
+
},
|
|
1870
|
+
offset: {
|
|
1871
|
+
type: 'number',
|
|
1872
|
+
description: 'Number of requirements to skip for pagination (default 0)',
|
|
1873
|
+
},
|
|
1874
|
+
},
|
|
1875
|
+
required: ['project_id'],
|
|
1876
|
+
},
|
|
1877
|
+
},
|
|
1878
|
+
{
|
|
1879
|
+
name: 'get_deployment_requirements_stats',
|
|
1880
|
+
description: `Get aggregate statistics about deployment requirements for a project. Returns total count and breakdowns by status, stage, and type. More token-efficient than get_deployment_requirements when you just need to understand the overall state.`,
|
|
1881
|
+
inputSchema: {
|
|
1882
|
+
type: 'object',
|
|
1883
|
+
properties: {
|
|
1884
|
+
project_id: { type: 'string', description: 'Project UUID' },
|
|
1885
|
+
},
|
|
1886
|
+
required: ['project_id'],
|
|
1887
|
+
},
|
|
1888
|
+
},
|
|
1889
|
+
{
|
|
1890
|
+
name: 'schedule_deployment',
|
|
1891
|
+
description: `Schedule a deployment for a specific time. Supports one-time and recurring schedules with auto-trigger or manual trigger modes.`,
|
|
1892
|
+
inputSchema: {
|
|
1893
|
+
type: 'object',
|
|
1894
|
+
properties: {
|
|
1895
|
+
project_id: {
|
|
1896
|
+
type: 'string',
|
|
1897
|
+
description: 'Project UUID',
|
|
1898
|
+
},
|
|
1899
|
+
scheduled_at: {
|
|
1900
|
+
type: 'string',
|
|
1901
|
+
description: 'ISO 8601 datetime for when the deployment should be triggered',
|
|
1902
|
+
},
|
|
1903
|
+
schedule_type: {
|
|
1904
|
+
type: 'string',
|
|
1905
|
+
description: 'Schedule type: once (one-time), hourly, daily, weekly, or monthly',
|
|
1906
|
+
enum: ['once', 'hourly', 'daily', 'weekly', 'monthly'],
|
|
1907
|
+
},
|
|
1908
|
+
hours_interval: {
|
|
1909
|
+
type: 'number',
|
|
1910
|
+
description: 'For hourly schedules, the number of hours between runs (1-24, default: 1)',
|
|
1911
|
+
minimum: 1,
|
|
1912
|
+
maximum: 24,
|
|
1913
|
+
},
|
|
1914
|
+
auto_trigger: {
|
|
1915
|
+
type: 'boolean',
|
|
1916
|
+
description: 'Whether agents should automatically trigger this deployment when due (default: true)',
|
|
1917
|
+
},
|
|
1918
|
+
environment: {
|
|
1919
|
+
type: 'string',
|
|
1920
|
+
description: 'Target environment (default: production)',
|
|
1921
|
+
enum: ['development', 'staging', 'production'],
|
|
1922
|
+
},
|
|
1923
|
+
version_bump: {
|
|
1924
|
+
type: 'string',
|
|
1925
|
+
description: 'Version bump: patch, minor, or major (default: patch)',
|
|
1926
|
+
enum: ['patch', 'minor', 'major'],
|
|
1927
|
+
},
|
|
1928
|
+
notes: {
|
|
1929
|
+
type: 'string',
|
|
1930
|
+
description: 'Optional notes about this scheduled deployment',
|
|
1931
|
+
},
|
|
1932
|
+
git_ref: {
|
|
1933
|
+
type: 'string',
|
|
1934
|
+
description: 'Optional git branch or commit to deploy',
|
|
1935
|
+
},
|
|
1936
|
+
},
|
|
1937
|
+
required: ['project_id', 'scheduled_at'],
|
|
1938
|
+
},
|
|
1939
|
+
},
|
|
1940
|
+
{
|
|
1941
|
+
name: 'get_scheduled_deployments',
|
|
1942
|
+
description: `Get scheduled deployments for a project.`,
|
|
1943
|
+
inputSchema: {
|
|
1944
|
+
type: 'object',
|
|
1945
|
+
properties: {
|
|
1946
|
+
project_id: {
|
|
1947
|
+
type: 'string',
|
|
1948
|
+
description: 'Project UUID',
|
|
1949
|
+
},
|
|
1950
|
+
include_disabled: {
|
|
1951
|
+
type: 'boolean',
|
|
1952
|
+
description: 'Include disabled schedules (default: false)',
|
|
1953
|
+
},
|
|
1954
|
+
limit: {
|
|
1955
|
+
type: 'number',
|
|
1956
|
+
description: 'Max schedules to return (default: 50)',
|
|
1957
|
+
},
|
|
1958
|
+
offset: {
|
|
1959
|
+
type: 'number',
|
|
1960
|
+
description: 'Number of schedules to skip for pagination (default: 0)',
|
|
1961
|
+
},
|
|
1962
|
+
},
|
|
1963
|
+
required: ['project_id'],
|
|
1964
|
+
},
|
|
1965
|
+
},
|
|
1966
|
+
{
|
|
1967
|
+
name: 'update_scheduled_deployment',
|
|
1968
|
+
description: `Update a scheduled deployment's configuration.`,
|
|
1969
|
+
inputSchema: {
|
|
1970
|
+
type: 'object',
|
|
1971
|
+
properties: {
|
|
1972
|
+
schedule_id: {
|
|
1973
|
+
type: 'string',
|
|
1974
|
+
description: 'Schedule UUID',
|
|
1975
|
+
},
|
|
1976
|
+
scheduled_at: {
|
|
1977
|
+
type: 'string',
|
|
1978
|
+
description: 'New scheduled time (ISO 8601)',
|
|
1979
|
+
},
|
|
1980
|
+
schedule_type: {
|
|
1981
|
+
type: 'string',
|
|
1982
|
+
description: 'New schedule type',
|
|
1983
|
+
enum: ['once', 'hourly', 'daily', 'weekly', 'monthly'],
|
|
1984
|
+
},
|
|
1985
|
+
hours_interval: {
|
|
1986
|
+
type: 'number',
|
|
1987
|
+
description: 'For hourly schedules, the number of hours between runs (1-24)',
|
|
1988
|
+
minimum: 1,
|
|
1989
|
+
maximum: 24,
|
|
1990
|
+
},
|
|
1991
|
+
auto_trigger: {
|
|
1992
|
+
type: 'boolean',
|
|
1993
|
+
description: 'Whether to auto-trigger',
|
|
1994
|
+
},
|
|
1995
|
+
enabled: {
|
|
1996
|
+
type: 'boolean',
|
|
1997
|
+
description: 'Enable or disable the schedule',
|
|
1998
|
+
},
|
|
1999
|
+
environment: {
|
|
2000
|
+
type: 'string',
|
|
2001
|
+
description: 'Target environment',
|
|
2002
|
+
enum: ['development', 'staging', 'production'],
|
|
2003
|
+
},
|
|
2004
|
+
version_bump: {
|
|
2005
|
+
type: 'string',
|
|
2006
|
+
description: 'Version bump type',
|
|
2007
|
+
enum: ['patch', 'minor', 'major'],
|
|
2008
|
+
},
|
|
2009
|
+
notes: {
|
|
2010
|
+
type: 'string',
|
|
2011
|
+
description: 'Notes about this deployment',
|
|
2012
|
+
},
|
|
2013
|
+
git_ref: {
|
|
2014
|
+
type: 'string',
|
|
2015
|
+
description: 'Git branch or commit to deploy',
|
|
2016
|
+
},
|
|
2017
|
+
},
|
|
2018
|
+
required: ['schedule_id'],
|
|
2019
|
+
},
|
|
2020
|
+
},
|
|
2021
|
+
{
|
|
2022
|
+
name: 'delete_scheduled_deployment',
|
|
2023
|
+
description: `Delete a scheduled deployment.`,
|
|
2024
|
+
inputSchema: {
|
|
2025
|
+
type: 'object',
|
|
2026
|
+
properties: {
|
|
2027
|
+
schedule_id: {
|
|
2028
|
+
type: 'string',
|
|
2029
|
+
description: 'Schedule UUID',
|
|
2030
|
+
},
|
|
2031
|
+
},
|
|
2032
|
+
required: ['schedule_id'],
|
|
2033
|
+
},
|
|
2034
|
+
},
|
|
2035
|
+
{
|
|
2036
|
+
name: 'trigger_scheduled_deployment',
|
|
2037
|
+
description: `Manually trigger a scheduled deployment. Creates a new deployment and updates the schedule.`,
|
|
2038
|
+
inputSchema: {
|
|
2039
|
+
type: 'object',
|
|
2040
|
+
properties: {
|
|
2041
|
+
schedule_id: {
|
|
2042
|
+
type: 'string',
|
|
2043
|
+
description: 'Schedule UUID',
|
|
2044
|
+
},
|
|
2045
|
+
},
|
|
2046
|
+
required: ['schedule_id'],
|
|
2047
|
+
},
|
|
2048
|
+
},
|
|
2049
|
+
{
|
|
2050
|
+
name: 'check_due_deployments',
|
|
2051
|
+
description: `Check for scheduled deployments that are due. Returns schedules where: enabled AND auto_trigger AND scheduled_at <= NOW().`,
|
|
2052
|
+
inputSchema: {
|
|
2053
|
+
type: 'object',
|
|
2054
|
+
properties: {
|
|
2055
|
+
project_id: {
|
|
2056
|
+
type: 'string',
|
|
2057
|
+
description: 'Project UUID',
|
|
2058
|
+
},
|
|
2059
|
+
},
|
|
2060
|
+
required: ['project_id'],
|
|
2061
|
+
},
|
|
2062
|
+
},
|
|
2063
|
+
{
|
|
2064
|
+
name: 'start_fallback_activity',
|
|
2065
|
+
description: `Start a background activity when no tasks available.`,
|
|
2066
|
+
inputSchema: {
|
|
2067
|
+
type: 'object',
|
|
2068
|
+
properties: {
|
|
2069
|
+
project_id: {
|
|
2070
|
+
type: 'string',
|
|
2071
|
+
description: 'Project UUID',
|
|
2072
|
+
},
|
|
2073
|
+
activity: {
|
|
2074
|
+
type: 'string',
|
|
2075
|
+
description: 'The fallback activity type (e.g., code_review, security_review)',
|
|
2076
|
+
enum: [
|
|
2077
|
+
'feature_ideation',
|
|
2078
|
+
'code_review',
|
|
2079
|
+
'performance_audit',
|
|
2080
|
+
'ux_review',
|
|
2081
|
+
'cost_analysis',
|
|
2082
|
+
'security_review',
|
|
2083
|
+
'test_coverage',
|
|
2084
|
+
'documentation_review',
|
|
2085
|
+
'dependency_audit',
|
|
2086
|
+
'validate_completed_tasks',
|
|
2087
|
+
'worktree_cleanup',
|
|
2088
|
+
],
|
|
2089
|
+
},
|
|
2090
|
+
},
|
|
2091
|
+
required: ['project_id', 'activity'],
|
|
2092
|
+
},
|
|
2093
|
+
},
|
|
2094
|
+
{
|
|
2095
|
+
name: 'stop_fallback_activity',
|
|
2096
|
+
description: `Stop current fallback activity. Auto-clears when starting a regular task.`,
|
|
2097
|
+
inputSchema: {
|
|
2098
|
+
type: 'object',
|
|
2099
|
+
properties: {
|
|
2100
|
+
project_id: {
|
|
2101
|
+
type: 'string',
|
|
2102
|
+
description: 'Project UUID',
|
|
2103
|
+
},
|
|
2104
|
+
summary: {
|
|
2105
|
+
type: 'string',
|
|
2106
|
+
description: 'Optional summary of what was accomplished during this activity',
|
|
2107
|
+
},
|
|
2108
|
+
},
|
|
2109
|
+
required: ['project_id'],
|
|
2110
|
+
},
|
|
2111
|
+
},
|
|
2112
|
+
{
|
|
2113
|
+
name: 'get_activity_history',
|
|
2114
|
+
description: `Get background activity completion history.`,
|
|
2115
|
+
inputSchema: {
|
|
2116
|
+
type: 'object',
|
|
2117
|
+
properties: {
|
|
2118
|
+
project_id: {
|
|
2119
|
+
type: 'string',
|
|
2120
|
+
description: 'Project UUID',
|
|
2121
|
+
},
|
|
2122
|
+
activity_type: {
|
|
2123
|
+
type: 'string',
|
|
2124
|
+
description: 'Optional: filter to a specific activity type',
|
|
2125
|
+
},
|
|
2126
|
+
limit: {
|
|
2127
|
+
type: 'number',
|
|
2128
|
+
description: 'Max number of history entries to return (default 50)',
|
|
2129
|
+
},
|
|
2130
|
+
offset: {
|
|
2131
|
+
type: 'number',
|
|
2132
|
+
description: 'Number of entries to skip for pagination (default 0)',
|
|
2133
|
+
},
|
|
2134
|
+
},
|
|
2135
|
+
required: ['project_id'],
|
|
2136
|
+
},
|
|
2137
|
+
},
|
|
2138
|
+
{
|
|
2139
|
+
name: 'get_activity_schedules',
|
|
2140
|
+
description: `Get background activity schedules.`,
|
|
2141
|
+
inputSchema: {
|
|
2142
|
+
type: 'object',
|
|
2143
|
+
properties: {
|
|
2144
|
+
project_id: {
|
|
2145
|
+
type: 'string',
|
|
2146
|
+
description: 'Project UUID',
|
|
2147
|
+
},
|
|
2148
|
+
limit: {
|
|
2149
|
+
type: 'number',
|
|
2150
|
+
description: 'Max schedules to return (default: 50)',
|
|
2151
|
+
},
|
|
2152
|
+
offset: {
|
|
2153
|
+
type: 'number',
|
|
2154
|
+
description: 'Number of schedules to skip for pagination (default: 0)',
|
|
2155
|
+
},
|
|
2156
|
+
},
|
|
2157
|
+
required: ['project_id'],
|
|
2158
|
+
},
|
|
2159
|
+
},
|
|
2160
|
+
// =========================================================================
|
|
2161
|
+
// Agent Request Tools
|
|
2162
|
+
// =========================================================================
|
|
2163
|
+
{
|
|
2164
|
+
name: 'get_pending_requests',
|
|
2165
|
+
description: `Get unacknowledged user requests for this agent/project.`,
|
|
2166
|
+
inputSchema: {
|
|
2167
|
+
type: 'object',
|
|
2168
|
+
properties: {
|
|
2169
|
+
project_id: {
|
|
2170
|
+
type: 'string',
|
|
2171
|
+
description: 'Project UUID',
|
|
2172
|
+
},
|
|
2173
|
+
limit: {
|
|
2174
|
+
type: 'number',
|
|
2175
|
+
description: 'Max number of requests to return (default 50, max 200)',
|
|
2176
|
+
},
|
|
2177
|
+
offset: {
|
|
2178
|
+
type: 'number',
|
|
2179
|
+
description: 'Number of requests to skip for pagination (default 0)',
|
|
2180
|
+
},
|
|
2181
|
+
},
|
|
2182
|
+
required: ['project_id'],
|
|
2183
|
+
},
|
|
2184
|
+
},
|
|
2185
|
+
{
|
|
2186
|
+
name: 'acknowledge_request',
|
|
2187
|
+
description: `Mark a user request as handled.`,
|
|
2188
|
+
inputSchema: {
|
|
2189
|
+
type: 'object',
|
|
2190
|
+
properties: {
|
|
2191
|
+
request_id: {
|
|
2192
|
+
type: 'string',
|
|
2193
|
+
description: 'Request UUID to acknowledge',
|
|
2194
|
+
},
|
|
2195
|
+
},
|
|
2196
|
+
required: ['request_id'],
|
|
2197
|
+
},
|
|
2198
|
+
},
|
|
2199
|
+
{
|
|
2200
|
+
name: 'answer_question',
|
|
2201
|
+
description: `Answer a question from the user. Use this when the user has asked a question via the dashboard.
|
|
2202
|
+
The answer will be displayed to the user and the question marked as answered.`,
|
|
2203
|
+
inputSchema: {
|
|
2204
|
+
type: 'object',
|
|
2205
|
+
properties: {
|
|
2206
|
+
request_id: {
|
|
2207
|
+
type: 'string',
|
|
2208
|
+
description: 'Request UUID of the question to answer',
|
|
2209
|
+
},
|
|
2210
|
+
answer: {
|
|
2211
|
+
type: 'string',
|
|
2212
|
+
description: 'Your answer to the user\'s question',
|
|
2213
|
+
},
|
|
2214
|
+
},
|
|
2215
|
+
required: ['request_id', 'answer'],
|
|
2216
|
+
},
|
|
2217
|
+
},
|
|
2218
|
+
// ============================================================================
|
|
2219
|
+
// Milestone Tools
|
|
2220
|
+
// ============================================================================
|
|
2221
|
+
{
|
|
2222
|
+
name: 'add_milestone',
|
|
2223
|
+
description: `Add a milestone to a task.
|
|
2224
|
+
Milestones help break down large tasks into smaller trackable steps.
|
|
2225
|
+
Use this to show progress on complex tasks and help gauge completion.`,
|
|
2226
|
+
inputSchema: {
|
|
2227
|
+
type: 'object',
|
|
2228
|
+
properties: {
|
|
2229
|
+
task_id: {
|
|
2230
|
+
type: 'string',
|
|
2231
|
+
description: 'Task UUID to add milestone to',
|
|
2232
|
+
},
|
|
2233
|
+
title: {
|
|
2234
|
+
type: 'string',
|
|
2235
|
+
description: 'Milestone title (brief description of what needs to be done)',
|
|
2236
|
+
},
|
|
2237
|
+
description: {
|
|
2238
|
+
type: 'string',
|
|
2239
|
+
description: 'Optional detailed description',
|
|
2240
|
+
},
|
|
2241
|
+
order_index: {
|
|
2242
|
+
type: 'number',
|
|
2243
|
+
minimum: 0,
|
|
2244
|
+
description: 'Order of this milestone (0-based, defaults to end of list)',
|
|
2245
|
+
},
|
|
2246
|
+
},
|
|
2247
|
+
required: ['task_id', 'title'],
|
|
2248
|
+
},
|
|
2249
|
+
},
|
|
2250
|
+
{
|
|
2251
|
+
name: 'update_milestone',
|
|
2252
|
+
description: `Update a milestone's title, description, status, or order.`,
|
|
2253
|
+
inputSchema: {
|
|
2254
|
+
type: 'object',
|
|
2255
|
+
properties: {
|
|
2256
|
+
milestone_id: {
|
|
2257
|
+
type: 'string',
|
|
2258
|
+
description: 'Milestone UUID',
|
|
2259
|
+
},
|
|
2260
|
+
title: {
|
|
2261
|
+
type: 'string',
|
|
2262
|
+
description: 'Updated title',
|
|
2263
|
+
},
|
|
2264
|
+
description: {
|
|
2265
|
+
type: 'string',
|
|
2266
|
+
description: 'Updated description',
|
|
2267
|
+
},
|
|
2268
|
+
status: {
|
|
2269
|
+
type: 'string',
|
|
2270
|
+
enum: ['pending', 'in_progress', 'completed'],
|
|
2271
|
+
description: 'Milestone status',
|
|
2272
|
+
},
|
|
2273
|
+
order_index: {
|
|
2274
|
+
type: 'number',
|
|
2275
|
+
minimum: 0,
|
|
2276
|
+
description: 'Updated order',
|
|
2277
|
+
},
|
|
2278
|
+
},
|
|
2279
|
+
required: ['milestone_id'],
|
|
2280
|
+
},
|
|
2281
|
+
},
|
|
2282
|
+
{
|
|
2283
|
+
name: 'complete_milestone',
|
|
2284
|
+
description: `Mark a milestone as completed. This is a convenience wrapper for update_milestone with status=completed.`,
|
|
2285
|
+
inputSchema: {
|
|
2286
|
+
type: 'object',
|
|
2287
|
+
properties: {
|
|
2288
|
+
milestone_id: {
|
|
2289
|
+
type: 'string',
|
|
2290
|
+
description: 'Milestone UUID',
|
|
2291
|
+
},
|
|
2292
|
+
},
|
|
2293
|
+
required: ['milestone_id'],
|
|
2294
|
+
},
|
|
2295
|
+
},
|
|
2296
|
+
{
|
|
2297
|
+
name: 'delete_milestone',
|
|
2298
|
+
description: `Delete a milestone from a task.`,
|
|
2299
|
+
inputSchema: {
|
|
2300
|
+
type: 'object',
|
|
2301
|
+
properties: {
|
|
2302
|
+
milestone_id: {
|
|
2303
|
+
type: 'string',
|
|
2304
|
+
description: 'Milestone UUID',
|
|
2305
|
+
},
|
|
2306
|
+
},
|
|
2307
|
+
required: ['milestone_id'],
|
|
2308
|
+
},
|
|
2309
|
+
},
|
|
2310
|
+
{
|
|
2311
|
+
name: 'get_milestones',
|
|
2312
|
+
description: `Get all milestones for a task, ordered by order_index.`,
|
|
2313
|
+
inputSchema: {
|
|
2314
|
+
type: 'object',
|
|
2315
|
+
properties: {
|
|
2316
|
+
task_id: {
|
|
2317
|
+
type: 'string',
|
|
2318
|
+
description: 'Task UUID',
|
|
2319
|
+
},
|
|
2320
|
+
},
|
|
2321
|
+
required: ['task_id'],
|
|
2322
|
+
},
|
|
2323
|
+
},
|
|
2324
|
+
// ============================================================================
|
|
2325
|
+
// Bodies of Work Tools
|
|
2326
|
+
// ============================================================================
|
|
2327
|
+
{
|
|
2328
|
+
name: 'create_body_of_work',
|
|
2329
|
+
description: `Create a new body of work to group tasks into phases (pre/core/post).
|
|
2330
|
+
Bodies of work allow organizing related tasks with optional auto-deployment on completion.`,
|
|
2331
|
+
inputSchema: {
|
|
2332
|
+
type: 'object',
|
|
2333
|
+
properties: {
|
|
2334
|
+
project_id: {
|
|
2335
|
+
type: 'string',
|
|
2336
|
+
description: 'Project UUID',
|
|
2337
|
+
},
|
|
2338
|
+
title: {
|
|
2339
|
+
type: 'string',
|
|
2340
|
+
description: 'Title for the body of work',
|
|
2341
|
+
},
|
|
2342
|
+
description: {
|
|
2343
|
+
type: 'string',
|
|
2344
|
+
description: 'Optional description',
|
|
2345
|
+
},
|
|
2346
|
+
auto_deploy_on_completion: {
|
|
2347
|
+
type: 'boolean',
|
|
2348
|
+
description: 'Automatically request deployment when all tasks complete (default: false)',
|
|
2349
|
+
},
|
|
2350
|
+
deploy_environment: {
|
|
2351
|
+
type: 'string',
|
|
2352
|
+
enum: ['development', 'staging', 'production'],
|
|
2353
|
+
description: 'Target environment for auto-deploy (default: production)',
|
|
2354
|
+
},
|
|
2355
|
+
deploy_version_bump: {
|
|
2356
|
+
type: 'string',
|
|
2357
|
+
enum: ['patch', 'minor', 'major'],
|
|
2358
|
+
description: 'Version bump for auto-deploy (default: minor)',
|
|
2359
|
+
},
|
|
2360
|
+
deploy_trigger: {
|
|
2361
|
+
type: 'string',
|
|
2362
|
+
enum: ['all_completed', 'all_completed_validated'],
|
|
2363
|
+
description: 'When to trigger auto-deploy: all_completed (immediate) or all_completed_validated (requires validation, default)',
|
|
2364
|
+
},
|
|
2365
|
+
},
|
|
2366
|
+
required: ['project_id', 'title'],
|
|
2367
|
+
},
|
|
2368
|
+
},
|
|
2369
|
+
{
|
|
2370
|
+
name: 'update_body_of_work',
|
|
2371
|
+
description: `Update a body of work's settings.`,
|
|
2372
|
+
inputSchema: {
|
|
2373
|
+
type: 'object',
|
|
2374
|
+
properties: {
|
|
2375
|
+
body_of_work_id: {
|
|
2376
|
+
type: 'string',
|
|
2377
|
+
description: 'Body of work UUID',
|
|
2378
|
+
},
|
|
2379
|
+
title: {
|
|
2380
|
+
type: 'string',
|
|
2381
|
+
description: 'Updated title',
|
|
2382
|
+
},
|
|
2383
|
+
description: {
|
|
2384
|
+
type: 'string',
|
|
2385
|
+
description: 'Updated description',
|
|
2386
|
+
},
|
|
2387
|
+
auto_deploy_on_completion: {
|
|
2388
|
+
type: 'boolean',
|
|
2389
|
+
description: 'Auto-deploy setting',
|
|
2390
|
+
},
|
|
2391
|
+
deploy_environment: {
|
|
2392
|
+
type: 'string',
|
|
2393
|
+
enum: ['development', 'staging', 'production'],
|
|
2394
|
+
description: 'Target environment',
|
|
2395
|
+
},
|
|
2396
|
+
deploy_version_bump: {
|
|
2397
|
+
type: 'string',
|
|
2398
|
+
enum: ['patch', 'minor', 'major'],
|
|
2399
|
+
description: 'Version bump type',
|
|
2400
|
+
},
|
|
2401
|
+
deploy_trigger: {
|
|
2402
|
+
type: 'string',
|
|
2403
|
+
enum: ['all_completed', 'all_completed_validated'],
|
|
2404
|
+
description: 'When to trigger auto-deploy',
|
|
2405
|
+
},
|
|
2406
|
+
},
|
|
2407
|
+
required: ['body_of_work_id'],
|
|
2408
|
+
},
|
|
2409
|
+
},
|
|
2410
|
+
{
|
|
2411
|
+
name: 'get_body_of_work',
|
|
2412
|
+
description: `Get a body of work with all its tasks organized by phase.`,
|
|
2413
|
+
inputSchema: {
|
|
2414
|
+
type: 'object',
|
|
2415
|
+
properties: {
|
|
2416
|
+
body_of_work_id: {
|
|
2417
|
+
type: 'string',
|
|
2418
|
+
description: 'Body of work UUID',
|
|
2419
|
+
},
|
|
2420
|
+
},
|
|
2421
|
+
required: ['body_of_work_id'],
|
|
2422
|
+
},
|
|
2423
|
+
},
|
|
2424
|
+
{
|
|
2425
|
+
name: 'get_bodies_of_work',
|
|
2426
|
+
description: `List bodies of work for a project with task counts per phase.`,
|
|
2427
|
+
inputSchema: {
|
|
2428
|
+
type: 'object',
|
|
2429
|
+
properties: {
|
|
2430
|
+
project_id: {
|
|
2431
|
+
type: 'string',
|
|
2432
|
+
description: 'Project UUID',
|
|
2433
|
+
},
|
|
2434
|
+
status: {
|
|
2435
|
+
type: 'string',
|
|
2436
|
+
enum: ['draft', 'active', 'completed', 'cancelled'],
|
|
2437
|
+
description: 'Filter by status (optional)',
|
|
2438
|
+
},
|
|
2439
|
+
},
|
|
2440
|
+
required: ['project_id'],
|
|
2441
|
+
},
|
|
2442
|
+
},
|
|
2443
|
+
{
|
|
2444
|
+
name: 'delete_body_of_work',
|
|
2445
|
+
description: `Delete a body of work. Tasks are preserved but no longer grouped.`,
|
|
2446
|
+
inputSchema: {
|
|
2447
|
+
type: 'object',
|
|
2448
|
+
properties: {
|
|
2449
|
+
body_of_work_id: {
|
|
2450
|
+
type: 'string',
|
|
2451
|
+
description: 'Body of work UUID',
|
|
2452
|
+
},
|
|
2453
|
+
},
|
|
2454
|
+
required: ['body_of_work_id'],
|
|
2455
|
+
},
|
|
2456
|
+
},
|
|
2457
|
+
{
|
|
2458
|
+
name: 'add_task_to_body_of_work',
|
|
2459
|
+
description: `Add a task to a body of work in a specific phase.
|
|
2460
|
+
Phases control execution order: pre tasks run first, then core, then post.`,
|
|
2461
|
+
inputSchema: {
|
|
2462
|
+
type: 'object',
|
|
2463
|
+
properties: {
|
|
2464
|
+
body_of_work_id: {
|
|
2465
|
+
type: 'string',
|
|
2466
|
+
description: 'Body of work UUID',
|
|
2467
|
+
},
|
|
2468
|
+
task_id: {
|
|
2469
|
+
type: 'string',
|
|
2470
|
+
description: 'Task UUID to add',
|
|
2471
|
+
},
|
|
2472
|
+
phase: {
|
|
2473
|
+
type: 'string',
|
|
2474
|
+
enum: ['pre', 'core', 'post'],
|
|
2475
|
+
description: 'Task phase (default: core)',
|
|
2476
|
+
},
|
|
2477
|
+
order_index: {
|
|
2478
|
+
type: 'number',
|
|
2479
|
+
description: 'Order within phase (auto-assigned if not specified)',
|
|
2480
|
+
},
|
|
2481
|
+
},
|
|
2482
|
+
required: ['body_of_work_id', 'task_id'],
|
|
2483
|
+
},
|
|
2484
|
+
},
|
|
2485
|
+
{
|
|
2486
|
+
name: 'remove_task_from_body_of_work',
|
|
2487
|
+
description: `Remove a task from its body of work. The task is preserved.`,
|
|
2488
|
+
inputSchema: {
|
|
2489
|
+
type: 'object',
|
|
2490
|
+
properties: {
|
|
2491
|
+
task_id: {
|
|
2492
|
+
type: 'string',
|
|
2493
|
+
description: 'Task UUID to remove',
|
|
2494
|
+
},
|
|
2495
|
+
},
|
|
2496
|
+
required: ['task_id'],
|
|
2497
|
+
},
|
|
2498
|
+
},
|
|
2499
|
+
{
|
|
2500
|
+
name: 'activate_body_of_work',
|
|
2501
|
+
description: `Activate a draft body of work to start execution.
|
|
2502
|
+
Requires at least one task. Once active, tasks can be worked on following phase order.`,
|
|
2503
|
+
inputSchema: {
|
|
2504
|
+
type: 'object',
|
|
2505
|
+
properties: {
|
|
2506
|
+
body_of_work_id: {
|
|
2507
|
+
type: 'string',
|
|
2508
|
+
description: 'Body of work UUID',
|
|
2509
|
+
},
|
|
2510
|
+
},
|
|
2511
|
+
required: ['body_of_work_id'],
|
|
2512
|
+
},
|
|
2513
|
+
},
|
|
2514
|
+
{
|
|
2515
|
+
name: 'add_task_dependency',
|
|
2516
|
+
description: `Add a dependency between tasks in a body of work.
|
|
2517
|
+
The dependent task cannot start until the dependency is completed. Prevents circular dependencies.`,
|
|
2518
|
+
inputSchema: {
|
|
2519
|
+
type: 'object',
|
|
2520
|
+
properties: {
|
|
2521
|
+
body_of_work_id: {
|
|
2522
|
+
type: 'string',
|
|
2523
|
+
description: 'Body of work UUID',
|
|
2524
|
+
},
|
|
2525
|
+
task_id: {
|
|
2526
|
+
type: 'string',
|
|
2527
|
+
description: 'Task that depends on another task',
|
|
2528
|
+
},
|
|
2529
|
+
depends_on_task_id: {
|
|
2530
|
+
type: 'string',
|
|
2531
|
+
description: 'Task that must complete first',
|
|
2532
|
+
},
|
|
2533
|
+
},
|
|
2534
|
+
required: ['body_of_work_id', 'task_id', 'depends_on_task_id'],
|
|
2535
|
+
},
|
|
2536
|
+
},
|
|
2537
|
+
{
|
|
2538
|
+
name: 'remove_task_dependency',
|
|
2539
|
+
description: `Remove a dependency between tasks.`,
|
|
2540
|
+
inputSchema: {
|
|
2541
|
+
type: 'object',
|
|
2542
|
+
properties: {
|
|
2543
|
+
task_id: {
|
|
2544
|
+
type: 'string',
|
|
2545
|
+
description: 'Task UUID',
|
|
2546
|
+
},
|
|
2547
|
+
depends_on_task_id: {
|
|
2548
|
+
type: 'string',
|
|
2549
|
+
description: 'Dependency task UUID',
|
|
2550
|
+
},
|
|
2551
|
+
},
|
|
2552
|
+
required: ['task_id', 'depends_on_task_id'],
|
|
2553
|
+
},
|
|
2554
|
+
},
|
|
2555
|
+
{
|
|
2556
|
+
name: 'get_task_dependencies',
|
|
2557
|
+
description: `Get task dependencies for a body of work or specific task.`,
|
|
2558
|
+
inputSchema: {
|
|
2559
|
+
type: 'object',
|
|
2560
|
+
properties: {
|
|
2561
|
+
body_of_work_id: {
|
|
2562
|
+
type: 'string',
|
|
2563
|
+
description: 'Body of work UUID (optional if task_id provided)',
|
|
2564
|
+
},
|
|
2565
|
+
task_id: {
|
|
2566
|
+
type: 'string',
|
|
2567
|
+
description: 'Specific task UUID (optional if body_of_work_id provided)',
|
|
2568
|
+
},
|
|
2569
|
+
},
|
|
2570
|
+
},
|
|
2571
|
+
},
|
|
2572
|
+
{
|
|
2573
|
+
name: 'get_next_body_of_work_task',
|
|
2574
|
+
description: `Get the next available task from a body of work.
|
|
2575
|
+
Considers phase order (pre → core → post) and task dependencies.
|
|
2576
|
+
Only returns tasks where all dependencies are completed.`,
|
|
2577
|
+
inputSchema: {
|
|
2578
|
+
type: 'object',
|
|
2579
|
+
properties: {
|
|
2580
|
+
body_of_work_id: {
|
|
2581
|
+
type: 'string',
|
|
2582
|
+
description: 'Body of work UUID',
|
|
2583
|
+
},
|
|
2584
|
+
},
|
|
2585
|
+
required: ['body_of_work_id'],
|
|
2586
|
+
},
|
|
2587
|
+
},
|
|
2588
|
+
// ============================================================================
|
|
2589
|
+
// Organization Tools
|
|
2590
|
+
// ============================================================================
|
|
2591
|
+
// REMOVED: list_organizations - unbounded collection, use dashboard to view organizations
|
|
2592
|
+
{
|
|
2593
|
+
name: 'create_organization',
|
|
2594
|
+
description: 'Create a new organization. You become the owner.',
|
|
2595
|
+
inputSchema: {
|
|
2596
|
+
type: 'object',
|
|
2597
|
+
properties: {
|
|
2598
|
+
name: {
|
|
2599
|
+
type: 'string',
|
|
2600
|
+
description: 'Organization display name',
|
|
2601
|
+
},
|
|
2602
|
+
description: {
|
|
2603
|
+
type: 'string',
|
|
2604
|
+
description: 'Brief description of the organization',
|
|
2605
|
+
},
|
|
2606
|
+
slug: {
|
|
2607
|
+
type: 'string',
|
|
2608
|
+
description: 'URL-friendly identifier (auto-generated from name if not provided)',
|
|
2609
|
+
},
|
|
2610
|
+
},
|
|
2611
|
+
required: ['name'],
|
|
2612
|
+
},
|
|
2613
|
+
},
|
|
2614
|
+
{
|
|
2615
|
+
name: 'update_organization',
|
|
2616
|
+
description: 'Update organization details. Requires admin role.',
|
|
2617
|
+
inputSchema: {
|
|
2618
|
+
type: 'object',
|
|
2619
|
+
properties: {
|
|
2620
|
+
organization_id: {
|
|
2621
|
+
type: 'string',
|
|
2622
|
+
description: 'Organization UUID',
|
|
2623
|
+
},
|
|
2624
|
+
name: {
|
|
2625
|
+
type: 'string',
|
|
2626
|
+
description: 'New organization name',
|
|
2627
|
+
},
|
|
2628
|
+
description: {
|
|
2629
|
+
type: 'string',
|
|
2630
|
+
description: 'New description',
|
|
2631
|
+
},
|
|
2632
|
+
logo_url: {
|
|
2633
|
+
type: 'string',
|
|
2634
|
+
description: 'URL to organization logo',
|
|
2635
|
+
},
|
|
2636
|
+
},
|
|
2637
|
+
required: ['organization_id'],
|
|
2638
|
+
},
|
|
2639
|
+
},
|
|
2640
|
+
{
|
|
2641
|
+
name: 'delete_organization',
|
|
2642
|
+
description: 'Delete an organization. Requires owner role. Removes all shares.',
|
|
2643
|
+
inputSchema: {
|
|
2644
|
+
type: 'object',
|
|
2645
|
+
properties: {
|
|
2646
|
+
organization_id: {
|
|
2647
|
+
type: 'string',
|
|
2648
|
+
description: 'Organization UUID',
|
|
2649
|
+
},
|
|
2650
|
+
},
|
|
2651
|
+
required: ['organization_id'],
|
|
2652
|
+
},
|
|
2653
|
+
},
|
|
2654
|
+
// REMOVED: list_org_members - unbounded collection, use dashboard to view members
|
|
2655
|
+
{
|
|
2656
|
+
name: 'invite_member',
|
|
2657
|
+
description: 'Invite a user to an organization by email. Requires admin role.',
|
|
2658
|
+
inputSchema: {
|
|
2659
|
+
type: 'object',
|
|
2660
|
+
properties: {
|
|
2661
|
+
organization_id: {
|
|
2662
|
+
type: 'string',
|
|
2663
|
+
description: 'Organization UUID',
|
|
2664
|
+
},
|
|
2665
|
+
email: {
|
|
2666
|
+
type: 'string',
|
|
2667
|
+
description: 'Email address to invite',
|
|
2668
|
+
},
|
|
2669
|
+
role: {
|
|
2670
|
+
type: 'string',
|
|
2671
|
+
enum: ['admin', 'member', 'viewer'],
|
|
2672
|
+
description: 'Role to assign (default: member)',
|
|
2673
|
+
},
|
|
2674
|
+
},
|
|
2675
|
+
required: ['organization_id', 'email'],
|
|
2676
|
+
},
|
|
2677
|
+
},
|
|
2678
|
+
{
|
|
2679
|
+
name: 'update_member_role',
|
|
2680
|
+
description: 'Change a member\'s role. Requires admin role. Cannot change owner.',
|
|
2681
|
+
inputSchema: {
|
|
2682
|
+
type: 'object',
|
|
2683
|
+
properties: {
|
|
2684
|
+
organization_id: {
|
|
2685
|
+
type: 'string',
|
|
2686
|
+
description: 'Organization UUID',
|
|
2687
|
+
},
|
|
2688
|
+
user_id: {
|
|
2689
|
+
type: 'string',
|
|
2690
|
+
description: 'User UUID to update',
|
|
2691
|
+
},
|
|
2692
|
+
role: {
|
|
2693
|
+
type: 'string',
|
|
2694
|
+
enum: ['admin', 'member', 'viewer'],
|
|
2695
|
+
description: 'New role to assign',
|
|
2696
|
+
},
|
|
2697
|
+
},
|
|
2698
|
+
required: ['organization_id', 'user_id', 'role'],
|
|
2699
|
+
},
|
|
2700
|
+
},
|
|
2701
|
+
{
|
|
2702
|
+
name: 'remove_member',
|
|
2703
|
+
description: 'Remove a member from an organization. Requires admin role.',
|
|
2704
|
+
inputSchema: {
|
|
2705
|
+
type: 'object',
|
|
2706
|
+
properties: {
|
|
2707
|
+
organization_id: {
|
|
2708
|
+
type: 'string',
|
|
2709
|
+
description: 'Organization UUID',
|
|
2710
|
+
},
|
|
2711
|
+
user_id: {
|
|
2712
|
+
type: 'string',
|
|
2713
|
+
description: 'User UUID to remove',
|
|
2714
|
+
},
|
|
2715
|
+
},
|
|
2716
|
+
required: ['organization_id', 'user_id'],
|
|
2717
|
+
},
|
|
2718
|
+
},
|
|
2719
|
+
{
|
|
2720
|
+
name: 'leave_organization',
|
|
2721
|
+
description: 'Leave an organization. Owner cannot leave without transferring ownership.',
|
|
2722
|
+
inputSchema: {
|
|
2723
|
+
type: 'object',
|
|
2724
|
+
properties: {
|
|
2725
|
+
organization_id: {
|
|
2726
|
+
type: 'string',
|
|
2727
|
+
description: 'Organization UUID',
|
|
2728
|
+
},
|
|
2729
|
+
},
|
|
2730
|
+
required: ['organization_id'],
|
|
2731
|
+
},
|
|
2732
|
+
},
|
|
2733
|
+
{
|
|
2734
|
+
name: 'share_project_with_org',
|
|
2735
|
+
description: 'Share a project with an organization. You must own the project.',
|
|
2736
|
+
inputSchema: {
|
|
2737
|
+
type: 'object',
|
|
2738
|
+
properties: {
|
|
2739
|
+
project_id: {
|
|
2740
|
+
type: 'string',
|
|
2741
|
+
description: 'Project UUID',
|
|
2742
|
+
},
|
|
2743
|
+
organization_id: {
|
|
2744
|
+
type: 'string',
|
|
2745
|
+
description: 'Organization UUID to share with',
|
|
2746
|
+
},
|
|
2747
|
+
permission: {
|
|
2748
|
+
type: 'string',
|
|
2749
|
+
enum: ['read', 'write', 'admin'],
|
|
2750
|
+
description: 'Permission level (default: read)',
|
|
2751
|
+
},
|
|
2752
|
+
},
|
|
2753
|
+
required: ['project_id', 'organization_id'],
|
|
2754
|
+
},
|
|
2755
|
+
},
|
|
2756
|
+
{
|
|
2757
|
+
name: 'update_project_share',
|
|
2758
|
+
description: 'Update the permission level for a project share.',
|
|
2759
|
+
inputSchema: {
|
|
2760
|
+
type: 'object',
|
|
2761
|
+
properties: {
|
|
2762
|
+
project_id: {
|
|
2763
|
+
type: 'string',
|
|
2764
|
+
description: 'Project UUID',
|
|
2765
|
+
},
|
|
2766
|
+
organization_id: {
|
|
2767
|
+
type: 'string',
|
|
2768
|
+
description: 'Organization UUID',
|
|
2769
|
+
},
|
|
2770
|
+
permission: {
|
|
2771
|
+
type: 'string',
|
|
2772
|
+
enum: ['read', 'write', 'admin'],
|
|
2773
|
+
description: 'New permission level',
|
|
2774
|
+
},
|
|
2775
|
+
},
|
|
2776
|
+
required: ['project_id', 'organization_id', 'permission'],
|
|
2777
|
+
},
|
|
2778
|
+
},
|
|
2779
|
+
{
|
|
2780
|
+
name: 'unshare_project',
|
|
2781
|
+
description: 'Remove a project share from an organization.',
|
|
2782
|
+
inputSchema: {
|
|
2783
|
+
type: 'object',
|
|
2784
|
+
properties: {
|
|
2785
|
+
project_id: {
|
|
2786
|
+
type: 'string',
|
|
2787
|
+
description: 'Project UUID',
|
|
2788
|
+
},
|
|
2789
|
+
organization_id: {
|
|
2790
|
+
type: 'string',
|
|
2791
|
+
description: 'Organization UUID',
|
|
2792
|
+
},
|
|
2793
|
+
},
|
|
2794
|
+
required: ['project_id', 'organization_id'],
|
|
2795
|
+
},
|
|
2796
|
+
},
|
|
2797
|
+
// REMOVED: list_project_shares - unbounded collection, use dashboard to view shares
|
|
2798
|
+
// File checkout/checkin tools for multi-agent coordination
|
|
2799
|
+
{
|
|
2800
|
+
name: 'checkout_file',
|
|
2801
|
+
description: 'Check out a file for editing. Prevents other agents from editing the same file until checked in. ALWAYS checkout files before making changes to prevent conflicts.',
|
|
2802
|
+
inputSchema: {
|
|
2803
|
+
type: 'object',
|
|
2804
|
+
properties: {
|
|
2805
|
+
project_id: {
|
|
2806
|
+
type: 'string',
|
|
2807
|
+
description: 'Project UUID',
|
|
2808
|
+
},
|
|
2809
|
+
file_path: {
|
|
2810
|
+
type: 'string',
|
|
2811
|
+
description: 'Relative path to the file to checkout (e.g., "src/index.ts")',
|
|
2812
|
+
},
|
|
2813
|
+
reason: {
|
|
2814
|
+
type: 'string',
|
|
2815
|
+
description: 'Optional reason for checkout (e.g., "Fixing bug in login flow")',
|
|
2816
|
+
},
|
|
2817
|
+
},
|
|
2818
|
+
required: ['project_id', 'file_path'],
|
|
2819
|
+
},
|
|
2820
|
+
},
|
|
2821
|
+
{
|
|
2822
|
+
name: 'checkin_file',
|
|
2823
|
+
description: 'Check in a file after editing. Releases the file for other agents to edit. ALWAYS checkin files when done editing.',
|
|
2824
|
+
inputSchema: {
|
|
2825
|
+
type: 'object',
|
|
2826
|
+
properties: {
|
|
2827
|
+
checkout_id: {
|
|
2828
|
+
type: 'string',
|
|
2829
|
+
description: 'Checkout UUID (from checkout_file response)',
|
|
2830
|
+
},
|
|
2831
|
+
project_id: {
|
|
2832
|
+
type: 'string',
|
|
2833
|
+
description: 'Project UUID (alternative to checkout_id)',
|
|
2834
|
+
},
|
|
2835
|
+
file_path: {
|
|
2836
|
+
type: 'string',
|
|
2837
|
+
description: 'File path (use with project_id as alternative to checkout_id)',
|
|
2838
|
+
},
|
|
2839
|
+
summary: {
|
|
2840
|
+
type: 'string',
|
|
2841
|
+
description: 'Optional summary of changes made',
|
|
2842
|
+
},
|
|
2843
|
+
},
|
|
2844
|
+
},
|
|
2845
|
+
},
|
|
2846
|
+
{
|
|
2847
|
+
name: 'get_file_checkouts',
|
|
2848
|
+
description: 'Get list of file checkouts for a project. Shows which files are currently checked out and by whom.',
|
|
2849
|
+
inputSchema: {
|
|
2850
|
+
type: 'object',
|
|
2851
|
+
properties: {
|
|
2852
|
+
project_id: {
|
|
2853
|
+
type: 'string',
|
|
2854
|
+
description: 'Project UUID',
|
|
2855
|
+
},
|
|
2856
|
+
status: {
|
|
2857
|
+
type: 'string',
|
|
2858
|
+
enum: ['checked_out', 'checked_in', 'abandoned'],
|
|
2859
|
+
description: 'Filter by status (default: checked_out)',
|
|
2860
|
+
},
|
|
2861
|
+
include_completed: {
|
|
2862
|
+
type: 'boolean',
|
|
2863
|
+
description: 'Include checked_in and abandoned checkouts (default: false)',
|
|
2864
|
+
},
|
|
2865
|
+
limit: {
|
|
2866
|
+
type: 'number',
|
|
2867
|
+
description: 'Max checkouts to return (default: 50)',
|
|
2868
|
+
},
|
|
2869
|
+
offset: {
|
|
2870
|
+
type: 'number',
|
|
2871
|
+
description: 'Number of checkouts to skip for pagination (default 0)',
|
|
2872
|
+
},
|
|
2873
|
+
},
|
|
2874
|
+
required: ['project_id'],
|
|
2875
|
+
},
|
|
2876
|
+
},
|
|
2877
|
+
{
|
|
2878
|
+
name: 'abandon_checkout',
|
|
2879
|
+
description: 'Force-release a checkout. Use when the original agent session died or is stuck.',
|
|
2880
|
+
inputSchema: {
|
|
2881
|
+
type: 'object',
|
|
2882
|
+
properties: {
|
|
2883
|
+
checkout_id: {
|
|
2884
|
+
type: 'string',
|
|
2885
|
+
description: 'Checkout UUID to abandon',
|
|
2886
|
+
},
|
|
2887
|
+
reason: {
|
|
2888
|
+
type: 'string',
|
|
2889
|
+
description: 'Reason for abandoning (e.g., "Agent session died")',
|
|
2890
|
+
},
|
|
2891
|
+
},
|
|
2892
|
+
required: ['checkout_id'],
|
|
2893
|
+
},
|
|
2894
|
+
},
|
|
2895
|
+
{
|
|
2896
|
+
name: 'is_file_available',
|
|
2897
|
+
description: 'Check if a file is available for checkout. Returns who has it checked out if not available.',
|
|
2898
|
+
inputSchema: {
|
|
2899
|
+
type: 'object',
|
|
2900
|
+
properties: {
|
|
2901
|
+
project_id: {
|
|
2902
|
+
type: 'string',
|
|
2903
|
+
description: 'Project UUID',
|
|
2904
|
+
},
|
|
2905
|
+
file_path: {
|
|
2906
|
+
type: 'string',
|
|
2907
|
+
description: 'Path to the file to check',
|
|
2908
|
+
},
|
|
2909
|
+
},
|
|
2910
|
+
required: ['project_id', 'file_path'],
|
|
2911
|
+
},
|
|
2912
|
+
},
|
|
2913
|
+
{
|
|
2914
|
+
name: 'get_file_checkouts_stats',
|
|
2915
|
+
description: 'Get aggregate statistics about file checkouts for a project. Returns counts by status without the actual checkout data. This is much more token-efficient than get_file_checkouts for understanding the overall state.',
|
|
2916
|
+
inputSchema: {
|
|
2917
|
+
type: 'object',
|
|
2918
|
+
properties: {
|
|
2919
|
+
project_id: {
|
|
2920
|
+
type: 'string',
|
|
2921
|
+
description: 'Project UUID',
|
|
2922
|
+
},
|
|
2923
|
+
},
|
|
2924
|
+
required: ['project_id'],
|
|
2925
|
+
},
|
|
2926
|
+
},
|
|
2927
|
+
// Role management tools
|
|
2928
|
+
{
|
|
2929
|
+
name: 'get_role_settings',
|
|
2930
|
+
description: 'Get role configuration for a project. Shows available roles and their settings.',
|
|
2931
|
+
inputSchema: {
|
|
2932
|
+
type: 'object',
|
|
2933
|
+
properties: {
|
|
2934
|
+
project_id: {
|
|
2935
|
+
type: 'string',
|
|
2936
|
+
description: 'Project UUID',
|
|
2937
|
+
},
|
|
2938
|
+
},
|
|
2939
|
+
required: ['project_id'],
|
|
2940
|
+
},
|
|
2941
|
+
},
|
|
2942
|
+
{
|
|
2943
|
+
name: 'update_role_settings',
|
|
2944
|
+
description: 'Update role settings for a project. Configure which roles are enabled and their behavior.',
|
|
2945
|
+
inputSchema: {
|
|
2946
|
+
type: 'object',
|
|
2947
|
+
properties: {
|
|
2948
|
+
project_id: {
|
|
2949
|
+
type: 'string',
|
|
2950
|
+
description: 'Project UUID',
|
|
2951
|
+
},
|
|
2952
|
+
role: {
|
|
2953
|
+
type: 'string',
|
|
2954
|
+
description: 'Role to configure (e.g., "developer", "validator", "deployer"). Custom roles accepted.',
|
|
2955
|
+
},
|
|
2956
|
+
enabled: {
|
|
2957
|
+
type: 'boolean',
|
|
2958
|
+
description: 'Enable or disable this role',
|
|
2959
|
+
},
|
|
2960
|
+
display_name: {
|
|
2961
|
+
type: 'string',
|
|
2962
|
+
description: 'Custom display name for this role',
|
|
2963
|
+
},
|
|
2964
|
+
description: {
|
|
2965
|
+
type: 'string',
|
|
2966
|
+
description: 'Description of what this role does',
|
|
2967
|
+
},
|
|
2968
|
+
priority_filter: {
|
|
2969
|
+
type: 'array',
|
|
2970
|
+
items: { type: 'number' },
|
|
2971
|
+
description: 'Only show tasks with these priorities (1-5)',
|
|
2972
|
+
},
|
|
2973
|
+
fallback_activities: {
|
|
2974
|
+
type: 'array',
|
|
2975
|
+
items: { type: 'string' },
|
|
2976
|
+
description: 'Preferred fallback activities for this role',
|
|
2977
|
+
},
|
|
2978
|
+
auto_assign_validation: {
|
|
2979
|
+
type: 'boolean',
|
|
2980
|
+
description: 'Auto-assign validation tasks to agents with this role',
|
|
2981
|
+
},
|
|
2982
|
+
auto_assign_deployment: {
|
|
2983
|
+
type: 'boolean',
|
|
2984
|
+
description: 'Auto-assign deployment tasks to agents with this role',
|
|
2985
|
+
},
|
|
2986
|
+
},
|
|
2987
|
+
required: ['project_id', 'role'],
|
|
2988
|
+
},
|
|
2989
|
+
},
|
|
2990
|
+
{
|
|
2991
|
+
name: 'set_session_role',
|
|
2992
|
+
description: 'Set the role for your current session. Changes task filtering and fallback activity suggestions.',
|
|
2993
|
+
inputSchema: {
|
|
2994
|
+
type: 'object',
|
|
2995
|
+
properties: {
|
|
2996
|
+
role: {
|
|
2997
|
+
type: 'string',
|
|
2998
|
+
description: 'Role to assign to this session (e.g., "developer", "validator", "deployer"). Custom roles accepted.',
|
|
2999
|
+
},
|
|
3000
|
+
role_config: {
|
|
3001
|
+
type: 'object',
|
|
3002
|
+
description: 'Custom configuration for specialist role (optional)',
|
|
3003
|
+
},
|
|
3004
|
+
},
|
|
3005
|
+
required: ['role'],
|
|
3006
|
+
},
|
|
3007
|
+
},
|
|
3008
|
+
{
|
|
3009
|
+
name: 'get_agents_by_role',
|
|
3010
|
+
description: 'Get active agents grouped by their assigned roles. See who is working on what.',
|
|
3011
|
+
inputSchema: {
|
|
3012
|
+
type: 'object',
|
|
3013
|
+
properties: {
|
|
3014
|
+
project_id: {
|
|
3015
|
+
type: 'string',
|
|
3016
|
+
description: 'Project UUID',
|
|
3017
|
+
},
|
|
3018
|
+
counts_only: {
|
|
3019
|
+
type: 'boolean',
|
|
3020
|
+
description: 'When true (default), returns only counts per role to save tokens. Set to false for full agent details.',
|
|
3021
|
+
},
|
|
3022
|
+
},
|
|
3023
|
+
required: ['project_id'],
|
|
3024
|
+
},
|
|
3025
|
+
},
|
|
3026
|
+
// ============================================================================
|
|
3027
|
+
// Sprint Tools
|
|
3028
|
+
// ============================================================================
|
|
3029
|
+
{
|
|
3030
|
+
name: 'create_sprint',
|
|
3031
|
+
description: `Create a new sprint. Sprints are time-bounded bodies of work with velocity tracking.
|
|
3032
|
+
Sprints start in 'planning' status where tasks can be added with story points.`,
|
|
3033
|
+
inputSchema: {
|
|
3034
|
+
type: 'object',
|
|
3035
|
+
properties: {
|
|
3036
|
+
project_id: {
|
|
3037
|
+
type: 'string',
|
|
3038
|
+
description: 'Project UUID',
|
|
3039
|
+
},
|
|
3040
|
+
title: {
|
|
3041
|
+
type: 'string',
|
|
3042
|
+
description: 'Sprint title (e.g., "Sprint 5" or "Q1 Release")',
|
|
3043
|
+
},
|
|
3044
|
+
goal: {
|
|
3045
|
+
type: 'string',
|
|
3046
|
+
description: 'Sprint goal statement',
|
|
3047
|
+
},
|
|
3048
|
+
start_date: {
|
|
3049
|
+
type: 'string',
|
|
3050
|
+
description: 'Start date (YYYY-MM-DD)',
|
|
3051
|
+
},
|
|
3052
|
+
end_date: {
|
|
3053
|
+
type: 'string',
|
|
3054
|
+
description: 'End date (YYYY-MM-DD)',
|
|
3055
|
+
},
|
|
3056
|
+
auto_deploy_on_completion: {
|
|
3057
|
+
type: 'boolean',
|
|
3058
|
+
description: 'Automatically request deployment when sprint completes (default: false)',
|
|
3059
|
+
},
|
|
3060
|
+
deploy_environment: {
|
|
3061
|
+
type: 'string',
|
|
3062
|
+
enum: ['development', 'staging', 'production'],
|
|
3063
|
+
description: 'Target environment for auto-deploy (default: production)',
|
|
3064
|
+
},
|
|
3065
|
+
deploy_version_bump: {
|
|
3066
|
+
type: 'string',
|
|
3067
|
+
enum: ['patch', 'minor', 'major'],
|
|
3068
|
+
description: 'Version bump for auto-deploy (default: minor)',
|
|
3069
|
+
},
|
|
3070
|
+
},
|
|
3071
|
+
required: ['project_id', 'title', 'start_date', 'end_date'],
|
|
3072
|
+
},
|
|
3073
|
+
},
|
|
3074
|
+
{
|
|
3075
|
+
name: 'update_sprint',
|
|
3076
|
+
description: `Update a sprint's details. Can update title, goal, dates, and deployment settings.`,
|
|
3077
|
+
inputSchema: {
|
|
3078
|
+
type: 'object',
|
|
3079
|
+
properties: {
|
|
3080
|
+
sprint_id: {
|
|
3081
|
+
type: 'string',
|
|
3082
|
+
description: 'Sprint UUID',
|
|
3083
|
+
},
|
|
3084
|
+
title: {
|
|
3085
|
+
type: 'string',
|
|
3086
|
+
description: 'New sprint title',
|
|
3087
|
+
},
|
|
3088
|
+
goal: {
|
|
3089
|
+
type: 'string',
|
|
3090
|
+
description: 'New sprint goal',
|
|
3091
|
+
},
|
|
3092
|
+
start_date: {
|
|
3093
|
+
type: 'string',
|
|
3094
|
+
description: 'New start date (YYYY-MM-DD)',
|
|
3095
|
+
},
|
|
3096
|
+
end_date: {
|
|
3097
|
+
type: 'string',
|
|
3098
|
+
description: 'New end date (YYYY-MM-DD)',
|
|
3099
|
+
},
|
|
3100
|
+
auto_deploy_on_completion: {
|
|
3101
|
+
type: 'boolean',
|
|
3102
|
+
description: 'Auto-deploy setting',
|
|
3103
|
+
},
|
|
3104
|
+
deploy_environment: {
|
|
3105
|
+
type: 'string',
|
|
3106
|
+
enum: ['development', 'staging', 'production'],
|
|
3107
|
+
description: 'Target environment',
|
|
3108
|
+
},
|
|
3109
|
+
deploy_version_bump: {
|
|
3110
|
+
type: 'string',
|
|
3111
|
+
enum: ['patch', 'minor', 'major'],
|
|
3112
|
+
description: 'Version bump type',
|
|
3113
|
+
},
|
|
3114
|
+
},
|
|
3115
|
+
required: ['sprint_id'],
|
|
3116
|
+
},
|
|
3117
|
+
},
|
|
3118
|
+
{
|
|
3119
|
+
name: 'get_sprint',
|
|
3120
|
+
description: `Get a sprint with all its tasks organized by phase (pre/core/post).
|
|
3121
|
+
Includes progress percentage, velocity points, and committed points.
|
|
3122
|
+
Use summary_only: true to get task counts and next task instead of full task arrays (saves tokens).`,
|
|
3123
|
+
inputSchema: {
|
|
3124
|
+
type: 'object',
|
|
3125
|
+
properties: {
|
|
3126
|
+
sprint_id: {
|
|
3127
|
+
type: 'string',
|
|
3128
|
+
description: 'Sprint UUID',
|
|
3129
|
+
},
|
|
3130
|
+
summary_only: {
|
|
3131
|
+
type: 'boolean',
|
|
3132
|
+
description: 'Return task counts and next task instead of full task arrays (default: false)',
|
|
3133
|
+
},
|
|
3134
|
+
},
|
|
3135
|
+
required: ['sprint_id'],
|
|
3136
|
+
},
|
|
3137
|
+
},
|
|
3138
|
+
{
|
|
3139
|
+
name: 'get_sprints',
|
|
3140
|
+
description: `List sprints for a project with velocity metrics.
|
|
3141
|
+
Returns sprints sorted by sprint_number descending (most recent first).`,
|
|
3142
|
+
inputSchema: {
|
|
3143
|
+
type: 'object',
|
|
3144
|
+
properties: {
|
|
3145
|
+
project_id: {
|
|
3146
|
+
type: 'string',
|
|
3147
|
+
description: 'Project UUID',
|
|
3148
|
+
},
|
|
3149
|
+
status: {
|
|
3150
|
+
type: 'string',
|
|
3151
|
+
enum: ['planning', 'active', 'in_review', 'retrospective', 'completed', 'cancelled'],
|
|
3152
|
+
description: 'Filter by sprint status (optional)',
|
|
3153
|
+
},
|
|
3154
|
+
limit: {
|
|
3155
|
+
type: 'number',
|
|
3156
|
+
description: 'Max sprints to return (default: 20, max: 100)',
|
|
3157
|
+
},
|
|
3158
|
+
},
|
|
3159
|
+
required: ['project_id'],
|
|
3160
|
+
},
|
|
3161
|
+
},
|
|
3162
|
+
{
|
|
3163
|
+
name: 'delete_sprint',
|
|
3164
|
+
description: `Delete a sprint. Tasks are preserved but no longer grouped.`,
|
|
3165
|
+
inputSchema: {
|
|
3166
|
+
type: 'object',
|
|
3167
|
+
properties: {
|
|
3168
|
+
sprint_id: {
|
|
3169
|
+
type: 'string',
|
|
3170
|
+
description: 'Sprint UUID',
|
|
3171
|
+
},
|
|
3172
|
+
},
|
|
3173
|
+
required: ['sprint_id'],
|
|
3174
|
+
},
|
|
3175
|
+
},
|
|
3176
|
+
{
|
|
3177
|
+
name: 'start_sprint',
|
|
3178
|
+
description: `Start a sprint. Transitions from 'planning' to 'active' status.
|
|
3179
|
+
Locks the committed_points at the current total story points.`,
|
|
3180
|
+
inputSchema: {
|
|
3181
|
+
type: 'object',
|
|
3182
|
+
properties: {
|
|
3183
|
+
sprint_id: {
|
|
3184
|
+
type: 'string',
|
|
3185
|
+
description: 'Sprint UUID',
|
|
3186
|
+
},
|
|
3187
|
+
},
|
|
3188
|
+
required: ['sprint_id'],
|
|
3189
|
+
},
|
|
3190
|
+
},
|
|
3191
|
+
{
|
|
3192
|
+
name: 'complete_sprint',
|
|
3193
|
+
description: `Complete a sprint. Handles retrospective phase and auto-deployment if configured.
|
|
3194
|
+
Status flow: active → in_review → retrospective → completed`,
|
|
3195
|
+
inputSchema: {
|
|
3196
|
+
type: 'object',
|
|
3197
|
+
properties: {
|
|
3198
|
+
sprint_id: {
|
|
3199
|
+
type: 'string',
|
|
3200
|
+
description: 'Sprint UUID',
|
|
3201
|
+
},
|
|
3202
|
+
retrospective_notes: {
|
|
3203
|
+
type: 'string',
|
|
3204
|
+
description: 'Sprint retrospective notes',
|
|
3205
|
+
},
|
|
3206
|
+
skip_retrospective: {
|
|
3207
|
+
type: 'boolean',
|
|
3208
|
+
description: 'Skip retrospective phase and go directly to completed (default: false)',
|
|
3209
|
+
},
|
|
3210
|
+
},
|
|
3211
|
+
required: ['sprint_id'],
|
|
3212
|
+
},
|
|
3213
|
+
},
|
|
3214
|
+
{
|
|
3215
|
+
name: 'add_task_to_sprint',
|
|
3216
|
+
description: `Add a task to a sprint with optional story points.
|
|
3217
|
+
Tasks can be added during 'planning' status. Story points contribute to committed_points.`,
|
|
3218
|
+
inputSchema: {
|
|
3219
|
+
type: 'object',
|
|
3220
|
+
properties: {
|
|
3221
|
+
sprint_id: {
|
|
3222
|
+
type: 'string',
|
|
3223
|
+
description: 'Sprint UUID',
|
|
3224
|
+
},
|
|
3225
|
+
task_id: {
|
|
3226
|
+
type: 'string',
|
|
3227
|
+
description: 'Task UUID to add',
|
|
3228
|
+
},
|
|
3229
|
+
story_points: {
|
|
3230
|
+
type: 'number',
|
|
3231
|
+
description: 'Story point estimate (optional, must be non-negative integer)',
|
|
3232
|
+
},
|
|
3233
|
+
phase: {
|
|
3234
|
+
type: 'string',
|
|
3235
|
+
enum: ['pre', 'core', 'post'],
|
|
3236
|
+
description: 'Task phase (default: core)',
|
|
3237
|
+
},
|
|
3238
|
+
},
|
|
3239
|
+
required: ['sprint_id', 'task_id'],
|
|
3240
|
+
},
|
|
3241
|
+
},
|
|
3242
|
+
{
|
|
3243
|
+
name: 'remove_task_from_sprint',
|
|
3244
|
+
description: `Remove a task from a sprint. Task is preserved but returns to backlog.`,
|
|
3245
|
+
inputSchema: {
|
|
3246
|
+
type: 'object',
|
|
3247
|
+
properties: {
|
|
3248
|
+
sprint_id: {
|
|
3249
|
+
type: 'string',
|
|
3250
|
+
description: 'Sprint UUID',
|
|
3251
|
+
},
|
|
3252
|
+
task_id: {
|
|
3253
|
+
type: 'string',
|
|
3254
|
+
description: 'Task UUID to remove',
|
|
3255
|
+
},
|
|
3256
|
+
},
|
|
3257
|
+
required: ['sprint_id', 'task_id'],
|
|
3258
|
+
},
|
|
3259
|
+
},
|
|
3260
|
+
{
|
|
3261
|
+
name: 'get_sprint_backlog',
|
|
3262
|
+
description: `Get tasks from backlog/pending that can be added to a sprint with pagination.
|
|
3263
|
+
Returns tasks not already assigned to any body of work or sprint.`,
|
|
3264
|
+
inputSchema: {
|
|
3265
|
+
type: 'object',
|
|
3266
|
+
properties: {
|
|
3267
|
+
project_id: {
|
|
3268
|
+
type: 'string',
|
|
3269
|
+
description: 'Project UUID',
|
|
3270
|
+
},
|
|
3271
|
+
sprint_id: {
|
|
3272
|
+
type: 'string',
|
|
3273
|
+
description: 'Sprint UUID to exclude already-added tasks (optional)',
|
|
3274
|
+
},
|
|
3275
|
+
limit: {
|
|
3276
|
+
type: 'number',
|
|
3277
|
+
description: 'Max tasks to return (default: 20, max: 50)',
|
|
3278
|
+
},
|
|
3279
|
+
offset: {
|
|
3280
|
+
type: 'number',
|
|
3281
|
+
description: 'Number of tasks to skip (default: 0)',
|
|
3282
|
+
},
|
|
3283
|
+
},
|
|
3284
|
+
required: ['project_id'],
|
|
3285
|
+
},
|
|
3286
|
+
},
|
|
3287
|
+
{
|
|
3288
|
+
name: 'get_sprint_velocity',
|
|
3289
|
+
description: `Get velocity metrics for completed sprints.
|
|
3290
|
+
Returns committed vs completed points and average velocity.`,
|
|
3291
|
+
inputSchema: {
|
|
3292
|
+
type: 'object',
|
|
3293
|
+
properties: {
|
|
3294
|
+
project_id: {
|
|
3295
|
+
type: 'string',
|
|
3296
|
+
description: 'Project UUID',
|
|
3297
|
+
},
|
|
3298
|
+
limit: {
|
|
3299
|
+
type: 'number',
|
|
3300
|
+
description: 'Number of sprints to analyze (default: 10, max: 50)',
|
|
3301
|
+
},
|
|
3302
|
+
},
|
|
3303
|
+
required: ['project_id'],
|
|
3304
|
+
},
|
|
3305
|
+
},
|
|
3306
|
+
// ============================================================================
|
|
3307
|
+
// Git Issue Tools
|
|
3308
|
+
// ============================================================================
|
|
3309
|
+
{
|
|
3310
|
+
name: 'add_git_issue',
|
|
3311
|
+
description: `Record a git-related issue (merge conflict, push failure, etc.). Auto-created by claim_validation when conflicts detected.`,
|
|
3312
|
+
inputSchema: {
|
|
3313
|
+
type: 'object',
|
|
3314
|
+
properties: {
|
|
3315
|
+
project_id: {
|
|
3316
|
+
type: 'string',
|
|
3317
|
+
description: 'Project UUID',
|
|
3318
|
+
},
|
|
3319
|
+
issue_type: {
|
|
3320
|
+
type: 'string',
|
|
3321
|
+
enum: ['merge_conflict', 'push_failed', 'rebase_needed', 'branch_diverged', 'pr_not_mergeable'],
|
|
3322
|
+
description: 'Type of git issue',
|
|
3323
|
+
},
|
|
3324
|
+
branch: {
|
|
3325
|
+
type: 'string',
|
|
3326
|
+
description: 'Branch where the issue occurred',
|
|
3327
|
+
},
|
|
3328
|
+
target_branch: {
|
|
3329
|
+
type: 'string',
|
|
3330
|
+
description: 'Target branch for merge/rebase (optional)',
|
|
3331
|
+
},
|
|
3332
|
+
pr_url: {
|
|
3333
|
+
type: 'string',
|
|
3334
|
+
description: 'Pull request URL if applicable (optional)',
|
|
3335
|
+
},
|
|
3336
|
+
conflicting_files: {
|
|
3337
|
+
type: 'array',
|
|
3338
|
+
items: { type: 'string' },
|
|
3339
|
+
description: 'List of files with conflicts (optional)',
|
|
3340
|
+
},
|
|
3341
|
+
error_message: {
|
|
3342
|
+
type: 'string',
|
|
3343
|
+
description: 'Error message from git operation (optional)',
|
|
3344
|
+
},
|
|
3345
|
+
task_id: {
|
|
3346
|
+
type: 'string',
|
|
3347
|
+
description: 'Related task UUID (optional)',
|
|
3348
|
+
},
|
|
3349
|
+
},
|
|
3350
|
+
required: ['project_id', 'issue_type', 'branch'],
|
|
3351
|
+
},
|
|
3352
|
+
},
|
|
3353
|
+
{
|
|
3354
|
+
name: 'resolve_git_issue',
|
|
3355
|
+
description: `Mark a git issue as resolved.`,
|
|
3356
|
+
inputSchema: {
|
|
3357
|
+
type: 'object',
|
|
3358
|
+
properties: {
|
|
3359
|
+
git_issue_id: {
|
|
3360
|
+
type: 'string',
|
|
3361
|
+
description: 'Git issue UUID',
|
|
3362
|
+
},
|
|
3363
|
+
resolution_note: {
|
|
3364
|
+
type: 'string',
|
|
3365
|
+
description: 'How the issue was resolved (optional)',
|
|
3366
|
+
},
|
|
3367
|
+
auto_resolved: {
|
|
3368
|
+
type: 'boolean',
|
|
3369
|
+
description: 'Whether this was auto-resolved (e.g., PR became mergeable)',
|
|
3370
|
+
},
|
|
3371
|
+
},
|
|
3372
|
+
required: ['git_issue_id'],
|
|
3373
|
+
},
|
|
3374
|
+
},
|
|
3375
|
+
{
|
|
3376
|
+
name: 'get_git_issues',
|
|
3377
|
+
description: `Get git issues for a project, optionally filtered by status, type, or branch.`,
|
|
3378
|
+
inputSchema: {
|
|
3379
|
+
type: 'object',
|
|
3380
|
+
properties: {
|
|
3381
|
+
project_id: {
|
|
3382
|
+
type: 'string',
|
|
3383
|
+
description: 'Project UUID',
|
|
3384
|
+
},
|
|
3385
|
+
status: {
|
|
3386
|
+
type: 'string',
|
|
3387
|
+
enum: ['open', 'resolved'],
|
|
3388
|
+
description: 'Filter by status (default: open)',
|
|
3389
|
+
},
|
|
3390
|
+
issue_type: {
|
|
3391
|
+
type: 'string',
|
|
3392
|
+
enum: ['merge_conflict', 'push_failed', 'rebase_needed', 'branch_diverged', 'pr_not_mergeable'],
|
|
3393
|
+
description: 'Filter by issue type (optional)',
|
|
3394
|
+
},
|
|
3395
|
+
branch: {
|
|
3396
|
+
type: 'string',
|
|
3397
|
+
description: 'Filter by branch (optional)',
|
|
3398
|
+
},
|
|
3399
|
+
limit: {
|
|
3400
|
+
type: 'number',
|
|
3401
|
+
description: 'Max issues to return (default: 50)',
|
|
3402
|
+
},
|
|
3403
|
+
offset: {
|
|
3404
|
+
type: 'number',
|
|
3405
|
+
description: 'Number of issues to skip for pagination (default 0)',
|
|
3406
|
+
},
|
|
3407
|
+
},
|
|
3408
|
+
required: ['project_id'],
|
|
3409
|
+
},
|
|
3410
|
+
},
|
|
3411
|
+
{
|
|
3412
|
+
name: 'delete_git_issue',
|
|
3413
|
+
description: `Delete a git issue.`,
|
|
3414
|
+
inputSchema: {
|
|
3415
|
+
type: 'object',
|
|
3416
|
+
properties: {
|
|
3417
|
+
git_issue_id: {
|
|
3418
|
+
type: 'string',
|
|
3419
|
+
description: 'Git issue UUID',
|
|
3420
|
+
},
|
|
3421
|
+
},
|
|
3422
|
+
required: ['git_issue_id'],
|
|
3423
|
+
},
|
|
3424
|
+
},
|
|
3425
|
+
// ============================================================================
|
|
3426
|
+
// Connector Tools (External Integrations)
|
|
3427
|
+
// ============================================================================
|
|
3428
|
+
{
|
|
3429
|
+
name: 'get_connectors',
|
|
3430
|
+
description: `List connectors for a project. Connectors enable sending events to external services (Slack, Discord, webhooks, etc.).`,
|
|
3431
|
+
inputSchema: {
|
|
3432
|
+
type: 'object',
|
|
3433
|
+
properties: {
|
|
3434
|
+
project_id: {
|
|
3435
|
+
type: 'string',
|
|
3436
|
+
description: 'Project UUID',
|
|
3437
|
+
},
|
|
3438
|
+
type: {
|
|
3439
|
+
type: 'string',
|
|
3440
|
+
enum: ['webhook', 'slack', 'discord', 'github', 'custom'],
|
|
3441
|
+
description: 'Filter by connector type (optional)',
|
|
3442
|
+
},
|
|
3443
|
+
status: {
|
|
3444
|
+
type: 'string',
|
|
3445
|
+
enum: ['active', 'disabled'],
|
|
3446
|
+
description: 'Filter by status (optional)',
|
|
3447
|
+
},
|
|
3448
|
+
limit: {
|
|
3449
|
+
type: 'number',
|
|
3450
|
+
description: 'Max connectors to return (default: 50)',
|
|
3451
|
+
},
|
|
3452
|
+
offset: {
|
|
3453
|
+
type: 'number',
|
|
3454
|
+
description: 'Pagination offset (default: 0)',
|
|
3455
|
+
},
|
|
3456
|
+
},
|
|
3457
|
+
required: ['project_id'],
|
|
3458
|
+
},
|
|
3459
|
+
},
|
|
3460
|
+
{
|
|
3461
|
+
name: 'get_connector',
|
|
3462
|
+
description: `Get a single connector with full details including configuration (sensitive fields are masked).`,
|
|
3463
|
+
inputSchema: {
|
|
3464
|
+
type: 'object',
|
|
3465
|
+
properties: {
|
|
3466
|
+
connector_id: {
|
|
3467
|
+
type: 'string',
|
|
3468
|
+
description: 'Connector UUID',
|
|
3469
|
+
},
|
|
3470
|
+
},
|
|
3471
|
+
required: ['connector_id'],
|
|
3472
|
+
},
|
|
3473
|
+
},
|
|
3474
|
+
{
|
|
3475
|
+
name: 'add_connector',
|
|
3476
|
+
description: `Add a new connector for external integrations. Supports webhook, Slack, Discord, GitHub, and custom connectors.`,
|
|
3477
|
+
inputSchema: {
|
|
3478
|
+
type: 'object',
|
|
3479
|
+
properties: {
|
|
3480
|
+
project_id: {
|
|
3481
|
+
type: 'string',
|
|
3482
|
+
description: 'Project UUID',
|
|
3483
|
+
},
|
|
3484
|
+
name: {
|
|
3485
|
+
type: 'string',
|
|
3486
|
+
description: 'Connector name (e.g., "Slack Notifications")',
|
|
3487
|
+
},
|
|
3488
|
+
type: {
|
|
3489
|
+
type: 'string',
|
|
3490
|
+
enum: ['webhook', 'slack', 'discord', 'github', 'custom'],
|
|
3491
|
+
description: 'Connector type',
|
|
3492
|
+
},
|
|
3493
|
+
description: {
|
|
3494
|
+
type: 'string',
|
|
3495
|
+
description: 'Optional description',
|
|
3496
|
+
},
|
|
3497
|
+
config: {
|
|
3498
|
+
type: 'object',
|
|
3499
|
+
description: 'Type-specific configuration (e.g., { webhook_url: "..." } for Slack)',
|
|
3500
|
+
},
|
|
3501
|
+
events: {
|
|
3502
|
+
type: 'object',
|
|
3503
|
+
description: 'Event subscriptions (e.g., { task_completed: true, blocker_added: true })',
|
|
3504
|
+
},
|
|
3505
|
+
},
|
|
3506
|
+
required: ['project_id', 'name', 'type'],
|
|
3507
|
+
},
|
|
3508
|
+
},
|
|
3509
|
+
{
|
|
3510
|
+
name: 'update_connector',
|
|
3511
|
+
description: `Update a connector's configuration, events, or status.`,
|
|
3512
|
+
inputSchema: {
|
|
3513
|
+
type: 'object',
|
|
3514
|
+
properties: {
|
|
3515
|
+
connector_id: {
|
|
3516
|
+
type: 'string',
|
|
3517
|
+
description: 'Connector UUID',
|
|
3518
|
+
},
|
|
3519
|
+
name: {
|
|
3520
|
+
type: 'string',
|
|
3521
|
+
description: 'Updated name',
|
|
3522
|
+
},
|
|
3523
|
+
description: {
|
|
3524
|
+
type: 'string',
|
|
3525
|
+
description: 'Updated description',
|
|
3526
|
+
},
|
|
3527
|
+
config: {
|
|
3528
|
+
type: 'object',
|
|
3529
|
+
description: 'Updated configuration (merged with existing)',
|
|
3530
|
+
},
|
|
3531
|
+
events: {
|
|
3532
|
+
type: 'object',
|
|
3533
|
+
description: 'Updated event subscriptions',
|
|
3534
|
+
},
|
|
3535
|
+
status: {
|
|
3536
|
+
type: 'string',
|
|
3537
|
+
enum: ['active', 'disabled'],
|
|
3538
|
+
description: 'Enable or disable the connector',
|
|
3539
|
+
},
|
|
3540
|
+
},
|
|
3541
|
+
required: ['connector_id'],
|
|
3542
|
+
},
|
|
3543
|
+
},
|
|
3544
|
+
{
|
|
3545
|
+
name: 'delete_connector',
|
|
3546
|
+
description: `Delete a connector.`,
|
|
3547
|
+
inputSchema: {
|
|
3548
|
+
type: 'object',
|
|
3549
|
+
properties: {
|
|
3550
|
+
connector_id: {
|
|
3551
|
+
type: 'string',
|
|
3552
|
+
description: 'Connector UUID',
|
|
3553
|
+
},
|
|
3554
|
+
},
|
|
3555
|
+
required: ['connector_id'],
|
|
3556
|
+
},
|
|
3557
|
+
},
|
|
3558
|
+
{
|
|
3559
|
+
name: 'test_connector',
|
|
3560
|
+
description: `Test a connector by sending a test event. Returns success/failure status.`,
|
|
3561
|
+
inputSchema: {
|
|
3562
|
+
type: 'object',
|
|
3563
|
+
properties: {
|
|
3564
|
+
connector_id: {
|
|
3565
|
+
type: 'string',
|
|
3566
|
+
description: 'Connector UUID to test',
|
|
3567
|
+
},
|
|
3568
|
+
},
|
|
3569
|
+
required: ['connector_id'],
|
|
3570
|
+
},
|
|
3571
|
+
},
|
|
3572
|
+
{
|
|
3573
|
+
name: 'get_connector_events',
|
|
3574
|
+
description: `Get event history for a connector or project. Shows delivery status and errors.`,
|
|
3575
|
+
inputSchema: {
|
|
3576
|
+
type: 'object',
|
|
3577
|
+
properties: {
|
|
3578
|
+
connector_id: {
|
|
3579
|
+
type: 'string',
|
|
3580
|
+
description: 'Connector UUID (optional if project_id provided)',
|
|
3581
|
+
},
|
|
3582
|
+
project_id: {
|
|
3583
|
+
type: 'string',
|
|
3584
|
+
description: 'Project UUID (optional if connector_id provided)',
|
|
3585
|
+
},
|
|
3586
|
+
status: {
|
|
3587
|
+
type: 'string',
|
|
3588
|
+
enum: ['pending', 'sent', 'failed', 'retrying'],
|
|
3589
|
+
description: 'Filter by delivery status (optional)',
|
|
3590
|
+
},
|
|
3591
|
+
limit: {
|
|
3592
|
+
type: 'number',
|
|
3593
|
+
description: 'Max events to return (default: 50)',
|
|
3594
|
+
},
|
|
3595
|
+
offset: {
|
|
3596
|
+
type: 'number',
|
|
3597
|
+
description: 'Pagination offset (default: 0)',
|
|
3598
|
+
},
|
|
3599
|
+
},
|
|
3600
|
+
},
|
|
3601
|
+
},
|
|
3602
|
+
];
|