@vibescope/mcp-server 0.2.2 → 0.2.4

package/dist/handlers/session.js

@@ -8,11 +8,16 @@
  * - get_help
  * - get_token_usage
  */
+import os from 'os';
 import { parseArgs, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+import { getAgentGuidelinesTemplate, getAgentGuidelinesSummary } from '../templates/agent-guidelines.js';
+// Auto-detect machine hostname for worktree tracking
+const MACHINE_HOSTNAME = os.hostname();
 const VALID_MODES = ['lite', 'full'];
 const VALID_MODELS = ['opus', 'sonnet', 'haiku'];
 const VALID_ROLES = ['developer', 'validator', 'deployer', 'reviewer', 'maintainer'];
+const VALID_AGENT_TYPES = ['claude', 'gemini', 'cursor', 'windsurf', 'other'];
 // Argument schemas for type-safe parsing
 const startWorkSessionSchema = {
     project_id: { type: 'string' },
@@ -20,10 +25,13 @@ const startWorkSessionSchema = {
     mode: { type: 'string', default: 'lite', validate: createEnumValidator(VALID_MODES) },
     model: { type: 'string', validate: createEnumValidator(VALID_MODELS) },
     role: { type: 'string', default: 'developer', validate: createEnumValidator(VALID_ROLES) },
+    hostname: { type: 'string' }, // Machine hostname for worktree tracking
+    agent_type: { type: 'string', validate: createEnumValidator(VALID_AGENT_TYPES) }, // Agent type for onboarding
 };
 const heartbeatSchema = {
     session_id: { type: 'string' },
     current_worktree_path: { type: 'string' },
+    hostname: { type: 'string' }, // Machine hostname for worktree tracking
 };
 const endWorkSessionSchema = {
     session_id: { type: 'string' },
@@ -32,7 +40,9 @@ const getHelpSchema = {
     topic: { type: 'string', required: true },
 };
 export const startWorkSession = async (args, ctx) => {
-    const { project_id, git_url, mode, model, role } = parseArgs(args, startWorkSessionSchema);
+    const { project_id, git_url, mode, model, role, hostname: providedHostname, agent_type } = parseArgs(args, startWorkSessionSchema);
+    // Use auto-detected hostname if not provided - enables machine-aware worktree filtering
+    const hostname = providedHostname || MACHINE_HOSTNAME;
     const { session, updateSession } = ctx;
     // Reset token tracking for new session with model info
     const normalizedModel = model ? model.toLowerCase().replace(/^claude[- ]*/i, '') : null;
@@ -53,6 +63,9 @@ export const startWorkSession = async (args, ctx) => {
         return {
             result: {
                 error: 'Please provide project_id or git_url to start a session',
+                session_termination_required: true,
+                reason: 'Cannot start work without identifying a project',
+                action: 'END_SESSION_NOW - Do not proceed with any work until MCP is properly configured.',
             },
         };
     }
@@ -62,18 +75,53 @@ export const startWorkSession = async (args, ctx) => {
         git_url,
         mode: mode,
         model: model,
-        role: role
+        role: role,
+        hostname, // Machine hostname for worktree tracking
+        agent_type: agent_type, // Agent type for onboarding
     });
     if (!response.ok) {
+        // Include additional error details if available
+        const errorData = response.data;
         return {
             result: {
                 error: response.error || 'Failed to start session',
+                ...(errorData?.detail && { detail: errorData.detail }),
+                ...(errorData?.code && { code: errorData.code }),
+                session_termination_required: true,
+                reason: 'MCP server connection failed - cannot track work',
+                action: 'END_SESSION_NOW - Do not proceed with any work.',
+                troubleshooting: [
+                    '1. Check if MCP server is configured: claude mcp list',
+                    '2. Verify VIBESCOPE_API_KEY is set correctly',
+                    '3. Check network connectivity to vibescope.dev',
+                    '4. Restart Claude Code after fixing configuration',
+                ],
+                user_message: 'MCP connection to Vibescope failed. I cannot proceed without task tracking. Please fix the configuration and restart.',
             },
         };
     }
     const data = response.data;
-    // Handle project not found
+    // Handle project not found - include agent guidelines for new project setup
     if (!data?.session_started) {
+        // If project_not_found, include agent guidelines template for CLAUDE.md setup
+        if (data?.project_not_found) {
+            return {
+                result: {
+                    ...data,
+                    agent_guidelines: {
+                        message: 'IMPORTANT: After creating the project, add these guidelines to your .claude/CLAUDE.md file.',
+                        summary: getAgentGuidelinesSummary(),
+                        full_template: getAgentGuidelinesTemplate(),
+                        setup_instructions: [
+                            '1. Create the project using create_project()',
+                            '2. Create .claude/CLAUDE.md in your project root',
+                            '3. Copy the full_template content into CLAUDE.md',
+                            '4. Call start_work_session again to begin work',
+                        ],
+                    },
+                },
+            };
+        }
         return { result: data };
     }
     // Store session ID and persona in local state
@@ -121,12 +169,28 @@ export const startWorkSession = async (args, ctx) => {
     if (data.blockers_count !== undefined && data.blockers_count > 0) {
         result.blockers_count = data.blockers_count;
     }
-    // Add validation count
+    // Add validation tasks when present - agents should validate before starting new work
     if (data.validation_count !== undefined && data.validation_count > 0) {
         result.validation_count = data.validation_count;
     }
+    if (data.awaiting_validation && data.awaiting_validation.length > 0) {
+        result.awaiting_validation = data.awaiting_validation;
+        result.validation_priority = data.validation_priority;
+    }
+    // Add stale worktrees warning if any exist
+    if (data.stale_worktrees && data.stale_worktrees.length > 0) {
+        result.stale_worktrees = data.stale_worktrees;
+        result.stale_worktrees_count = data.stale_worktrees_count;
+        result.cleanup_action = data.cleanup_action;
+    }
     // Add git workflow info if available in project
     if (data.project?.git_workflow && data.project.git_workflow !== 'none') {
+        // Branching workflows (git-flow, github-flow) require worktrees
+        // Trunk-based development commits directly to main, no worktree needed
+        const isBranchingWorkflow = data.project.git_workflow === 'git-flow' || data.project.git_workflow === 'github-flow';
+        const baseBranch = data.project.git_workflow === 'git-flow'
+            ? (data.project.git_develop_branch || 'develop')
+            : (data.project.git_main_branch || 'main');
         result.git_workflow = {
             workflow: data.project.git_workflow,
             auto_branch: data.project.git_auto_branch ?? false,
@@ -134,17 +198,38 @@ export const startWorkSession = async (args, ctx) => {
             ...(data.project.git_workflow === 'git-flow' && data.project.git_develop_branch
                 ? { develop_branch: data.project.git_develop_branch }
                 : {}),
-            worktree_required: true,
-            worktree_hint: 'CRITICAL: Create a git worktree before starting work. Run get_help("git") for instructions.',
+            worktree_required: isBranchingWorkflow,
         };
+        // Only show worktree reminder for branching workflows (git-flow, github-flow)
+        if (isBranchingWorkflow) {
+            result.WORKTREE_REMINDER = {
+                message: 'CRITICAL: Create worktree BEFORE making ANY file edits',
+                wrong_order: 'DO NOT: Edit files → stash → create worktree → pop stash',
+                right_order: 'DO: Create worktree → cd into it → THEN edit files',
+                command: `git worktree add ../<project>-<persona>-<task> -b feature/<task-id> ${baseBranch}`,
+                help: 'Run get_help("git") for full instructions',
+            };
+        }
     }
-    // Add next action at end - pending requests take priority over tasks
+    // Add agent setup instructions if this is a new agent type for the project
+    if (data.agent_setup) {
+        result.agent_setup = data.agent_setup;
+        // If setup is required, update directive to prioritize setup
+        if (data.agent_setup.setup_required) {
+            result.directive = `SETUP REQUIRED: This is your first time connecting as a ${data.agent_setup.agent_type} agent. Follow the agent_setup instructions before starting work.`;
+        }
+    }
+    // Add next action at end - pending requests take priority over validation, then regular tasks
     if (hasUrgentQuestions) {
         const firstQuestion = data.URGENT_QUESTIONS?.requests?.[0] || data.pending_requests?.[0];
         result.next_action = firstQuestion
             ? `answer_question(request_id: "${firstQuestion.id}", answer: "...")`
             : 'Check pending_requests and respond using answer_question(request_id, answer)';
     }
+    else if (data.awaiting_validation && data.awaiting_validation.length > 0) {
+        // Validation tasks take priority over new work - use next_action from API if available
+        result.next_action = data.next_action || `claim_validation(task_id: "${data.awaiting_validation[0].id}")`;
+    }
     else if (data.next_task) {
         result.next_action = `update_task(task_id: "${data.next_task.id}", status: "in_progress")`;
     }
@@ -154,9 +239,11 @@ export const startWorkSession = async (args, ctx) => {
     return { result };
 };
 export const heartbeat = async (args, ctx) => {
-    const { session_id, current_worktree_path } = parseArgs(args, heartbeatSchema);
+    const { session_id, current_worktree_path, hostname: providedHostname } = parseArgs(args, heartbeatSchema);
     const { session } = ctx;
     const targetSession = session_id || session.currentSessionId;
+    // Use auto-detected hostname if not provided
+    const hostname = providedHostname || MACHINE_HOSTNAME;
     if (!targetSession) {
         return {
             result: {
@@ -165,9 +252,10 @@ export const heartbeat = async (args, ctx) => {
         };
     }
     const apiClient = getApiClient();
-    // Send heartbeat with optional worktree path
+    // Send heartbeat with optional worktree path and hostname
     const heartbeatResponse = await apiClient.heartbeat(targetSession, {
         current_worktree_path,
+        hostname,
     });
     if (!heartbeatResponse.ok) {
         return {
@@ -272,17 +360,38 @@ export const getHelp = async (args, _ctx) => {
     }
     return { result: { topic, content: response.data.content } };
 };
-// Model pricing rates (USD per 1M tokens)
 const MODEL_PRICING = {
-    opus: { input: 15.0, output: 75.0 },
-    sonnet: { input: 3.0, output: 15.0 },
-    haiku: { input: 0.25, output: 1.25 },
+    standard: {
+        // Claude models
+        opus: { input: 15.0, output: 75.0, description: 'Claude Opus 4.5' },
+        sonnet: { input: 3.0, output: 15.0, description: 'Claude Sonnet 4' },
+        haiku: { input: 0.25, output: 1.25, description: 'Claude Haiku 3.5' },
+        // Gemini models (as of Jan 2025)
+        gemini: { input: 0.10, output: 0.40, description: 'Gemini 2.0 Flash' },
+        'gemini-2.0-flash': { input: 0.10, output: 0.40, description: 'Gemini 2.0 Flash' },
+        'gemini-1.5-pro': { input: 1.25, output: 5.00, description: 'Gemini 1.5 Pro' },
+        'gemini-1.5-flash': { input: 0.075, output: 0.30, description: 'Gemini 1.5 Flash' },
+    },
+    extra_usage: {
+        // Claude models - extra usage/overage rates (same as standard for now)
+        opus: { input: 15.0, output: 75.0, description: 'Claude Opus 4.5 - Extra usage' },
+        sonnet: { input: 3.0, output: 15.0, description: 'Claude Sonnet 4 - Extra usage' },
+        haiku: { input: 0.25, output: 1.25, description: 'Claude Haiku 3.5 - Extra usage' },
+        // Gemini models - extra usage rates (same as standard for now)
+        gemini: { input: 0.10, output: 0.40, description: 'Gemini 2.0 Flash - Extra usage' },
+        'gemini-2.0-flash': { input: 0.10, output: 0.40, description: 'Gemini 2.0 Flash - Extra usage' },
+        'gemini-1.5-pro': { input: 1.25, output: 5.00, description: 'Gemini 1.5 Pro - Extra usage' },
+        'gemini-1.5-flash': { input: 0.075, output: 0.30, description: 'Gemini 1.5 Flash - Extra usage' },
+    },
 };
-function calculateCost(byModel) {
+// Legacy accessor for backward compatibility
+const getModelPricing = (tier = 'standard') => MODEL_PRICING[tier];
+function calculateCost(byModel, tier = 'standard') {
     const breakdown = {};
     let total = 0;
+    const pricingTable = getModelPricing(tier);
     for (const [model, tokens] of Object.entries(byModel)) {
-        const pricing = MODEL_PRICING[model];
+        const pricing = pricingTable[model];
         if (pricing) {
             const inputCost = (tokens.input / 1_000_000) * pricing.input;
             const outputCost = (tokens.output / 1_000_000) * pricing.output;
@@ -291,11 +400,12 @@ function calculateCost(byModel) {
                 input_cost: Math.round(inputCost * 10000) / 10000,
                 output_cost: Math.round(outputCost * 10000) / 10000,
                 total: Math.round(modelTotal * 10000) / 10000,
+                description: pricing.description,
             };
             total += modelTotal;
         }
     }
-    return { breakdown, total: Math.round(total * 10000) / 10000 };
+    return { breakdown, total: Math.round(total * 10000) / 10000, pricing_tier: tier };
 }
 export const getTokenUsage = async (_args, ctx) => {
     const { session } = ctx;
@@ -309,17 +419,19 @@ export const getTokenUsage = async (_args, ctx) => {
         tokens: stats.tokens,
         avg: Math.round(stats.tokens / stats.calls),
     }));
-    // Calculate model breakdown and costs
+    // Calculate model breakdown and costs for both pricing tiers
     const modelBreakdown = Object.entries(sessionTokenUsage.byModel || {}).map(([model, tokens]) => ({
         model,
         input_tokens: tokens.input,
         output_tokens: tokens.output,
         total_tokens: tokens.input + tokens.output,
     }));
-    const costData = calculateCost(sessionTokenUsage.byModel || {});
+    const standardCost = calculateCost(sessionTokenUsage.byModel || {}, 'standard');
+    const extraUsageCost = calculateCost(sessionTokenUsage.byModel || {}, 'extra_usage');
     // If no model tracking, estimate cost assuming sonnet (middle tier)
-    const estimatedCostNoModel = Object.keys(sessionTokenUsage.byModel || {}).length === 0
-        ? Math.round((sessionTokenUsage.totalTokens / 1_000_000) * MODEL_PRICING.sonnet.output * 10000) / 10000
+    const hasModelData = Object.keys(sessionTokenUsage.byModel || {}).length > 0;
+    const estimatedCostNoModel = !hasModelData
+        ? Math.round((sessionTokenUsage.totalTokens / 1_000_000) * getModelPricing('standard').sonnet.output * 10000) / 10000
         : null;
     // Add context clearing directive when usage is high
     const shouldClearContext = sessionTokenUsage.callCount > 50 || sessionTokenUsage.totalTokens > 100000;
@@ -336,19 +448,168 @@ export const getTokenUsage = async (_args, ctx) => {
             top_tools: topTools,
             model_breakdown: modelBreakdown.length > 0 ? modelBreakdown : undefined,
             cost: {
-                by_model: Object.keys(costData.breakdown).length > 0 ? costData.breakdown : undefined,
-                total_usd: costData.total > 0 ? costData.total : estimatedCostNoModel,
+                // Standard tier (optimistic - included in Max plan)
+                standard: {
+                    by_model: Object.keys(standardCost.breakdown).length > 0 ? standardCost.breakdown : undefined,
+                    total_usd: standardCost.total > 0 ? standardCost.total : estimatedCostNoModel,
+                    pricing_tier: 'standard',
+                },
+                // Extra usage tier (pessimistic - overage rates)
+                extra_usage: {
+                    by_model: Object.keys(extraUsageCost.breakdown).length > 0 ? extraUsageCost.breakdown : undefined,
+                    total_usd: extraUsageCost.total > 0 ? extraUsageCost.total : estimatedCostNoModel,
+                    pricing_tier: 'extra_usage',
+                },
+                // Legacy field for backward compatibility
+                total_usd: standardCost.total > 0 ? standardCost.total : estimatedCostNoModel,
                 estimated: estimatedCostNoModel !== null,
             },
-            note: sessionTokenUsage.currentModel
-                ? `Tracking ${sessionTokenUsage.currentModel} model usage. Token estimates ~4 chars/token.`
-                : 'Token estimates based on response size (~4 chars/token). Set model in start_work_session for accurate costs.',
+            supported_models: {
+                claude: ['opus', 'sonnet', 'haiku'],
+                gemini: ['gemini', 'gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
+            },
+            note: 'IMPORTANT: These estimates only track MCP tool I/O (~1-5% of actual API usage). Actual costs may be 20-100x higher due to conversation context, system prompts, and reasoning tokens. Use report_token_usage() with actual API response values for accurate tracking.',
+            estimation_coverage: 'mcp_tool_io_only',
             ...(shouldClearContext && {
                 directive: 'High token usage detected. Run /clear then start_work_session to reset context. Do not ask permission.',
             }),
         },
     };
 };
+const reportTokenUsageSchema = {
+    input_tokens: { type: 'number', required: true },
+    output_tokens: { type: 'number', required: true },
+    model: { type: 'string', validate: createEnumValidator(VALID_MODELS) },
+};
+const confirmAgentSetupSchema = {
+    project_id: { type: 'string', required: true },
+    agent_type: { type: 'string', required: true, validate: createEnumValidator(VALID_AGENT_TYPES) },
+};
+/**
+ * Report actual Claude API token usage for accurate cost tracking.
+ * This allows agents to report their actual API usage instead of relying on MCP estimates.
+ * The backend will attribute costs to the current task if one is active.
+ */
+export const reportTokenUsage = async (args, ctx) => {
+    const { input_tokens, output_tokens, model } = parseArgs(args, reportTokenUsageSchema);
+    const { session, updateSession } = ctx;
+    // Validate token counts
+    if (input_tokens < 0 || output_tokens < 0) {
+        return {
+            result: {
+                error: 'Token counts must be non-negative',
+            },
+        };
+    }
+    // Determine which model to attribute to
+    const targetModel = model || session.tokenUsage.currentModel || 'sonnet';
+    // Update the session's local token usage
+    const updatedByModel = { ...session.tokenUsage.byModel };
+    if (!updatedByModel[targetModel]) {
+        updatedByModel[targetModel] = { input: 0, output: 0 };
+    }
+    updatedByModel[targetModel].input += input_tokens;
+    updatedByModel[targetModel].output += output_tokens;
+    const totalTokens = input_tokens + output_tokens;
+    updateSession({
+        tokenUsage: {
+            ...session.tokenUsage,
+            callCount: session.tokenUsage.callCount + 1,
+            totalTokens: session.tokenUsage.totalTokens + totalTokens,
+            byModel: updatedByModel,
+        },
+    });
+    // Report to backend - this handles both session update and task cost attribution
+    const apiClient = getApiClient();
+    const currentSessionId = session.currentSessionId;
+    if (!currentSessionId) {
+        // Calculate cost locally if no session (use standard tier)
+        const pricing = getModelPricing('standard')[targetModel];
+        const inputCost = pricing ? (input_tokens / 1_000_000) * pricing.input : 0;
+        const outputCost = pricing ? (output_tokens / 1_000_000) * pricing.output : 0;
+        return {
+            result: {
+                success: true,
+                reported: {
+                    model: targetModel,
+                    input_tokens: input_tokens,
+                    output_tokens: output_tokens,
+                    total_tokens: totalTokens,
+                    estimated_cost_usd: Math.round((inputCost + outputCost) * 10000) / 10000,
+                },
+                note: 'Token usage recorded locally. Start a session to attribute costs to your project.',
+            },
+        };
+    }
+    // Call the backend to report and attribute costs
+    const response = await apiClient.reportTokenUsage(currentSessionId, {
+        input_tokens: input_tokens,
+        output_tokens: output_tokens,
+        model: targetModel,
+    });
+    if (!response.ok) {
+        // Fall back to local calculation on error (use standard tier)
+        const pricing = getModelPricing('standard')[targetModel];
+        const inputCost = pricing ? (input_tokens / 1_000_000) * pricing.input : 0;
+        const outputCost = pricing ? (output_tokens / 1_000_000) * pricing.output : 0;
+        return {
+            result: {
+                success: true,
+                reported: {
+                    model: targetModel,
+                    input_tokens: input_tokens,
+                    output_tokens: output_tokens,
+                    total_tokens: totalTokens,
+                    estimated_cost_usd: Math.round((inputCost + outputCost) * 10000) / 10000,
+                },
+                warning: 'Backend sync failed. Token usage recorded locally only.',
+            },
+        };
+    }
+    const data = response.data;
+    return {
+        result: {
+            success: true,
+            reported: data.reported,
+            task_attributed: data.task_attributed,
+            ...(data.task_id && { task_id: data.task_id }),
+            note: data.task_attributed
+                ? 'Token usage recorded and attributed to current task for per-task cost tracking.'
+                : 'Token usage recorded to session. No active task to attribute costs to.',
+        },
+    };
+};
+/**
+ * Confirm that agent setup is complete for a project.
+ * This marks the agent type as onboarded, so future sessions won't receive setup instructions.
+ */
+export const confirmAgentSetup = async (args, _ctx) => {
+    const { project_id, agent_type } = parseArgs(args, confirmAgentSetupSchema);
+    if (!project_id || !agent_type) {
+        return {
+            result: {
+                error: 'project_id and agent_type are required',
+            },
+        };
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.confirmAgentSetup(project_id, agent_type);
+    if (!response.ok) {
+        return {
+            result: {
+                error: response.error || 'Failed to confirm agent setup',
+            },
+        };
+    }
+    return {
+        result: {
+            success: true,
+            project_id,
+            agent_type,
+            message: `Setup confirmed for ${agent_type} agent. You will no longer receive setup instructions for this project.`,
+        },
+    };
+};
 /**
  * Session handlers registry
  */
@@ -358,4 +619,6 @@ export const sessionHandlers = {
     end_work_session: endWorkSession,
     get_help: getHelp,
     get_token_usage: getTokenUsage,
+    report_token_usage: reportTokenUsage,
+    confirm_agent_setup: confirmAgentSetup,
 };

package/dist/handlers/sprints.d.ts

@@ -26,6 +26,8 @@ export declare const addTaskToSprint: Handler;
 export declare const removeTaskFromSprint: Handler;
 export declare const getSprintBacklog: Handler;
 export declare const getSprintVelocity: Handler;
+export declare const archiveSprint: Handler;
+export declare const unarchiveSprint: Handler;
 /**
  * Sprint handlers registry
  */

package/dist/handlers/sprints.js

@@ -16,7 +16,7 @@
  */
 import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
-const SPRINT_STATUSES = ['planning', 'active', 'in_review', 'retrospective', 'completed', 'cancelled'];
+const SPRINT_STATUSES = ['planning', 'active', 'in_review', 'retrospective', 'completed', 'cancelled', 'archived'];
 const TASK_PHASES = ['pre', 'core', 'post'];
 const DEPLOY_ENVIRONMENTS = ['development', 'staging', 'production'];
 const VERSION_BUMPS = ['patch', 'minor', 'major'];
@@ -269,6 +269,33 @@ export const getSprintVelocity = async (args, ctx) => {
     }
     return { result: response.data };
 };
+// ============================================================================
+// Archive / Unarchive Handlers
+// ============================================================================
+const archiveSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const unarchiveSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+};
+export const archiveSprint = async (args, ctx) => {
+    const { sprint_id } = parseArgs(args, archiveSprintSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('archive_sprint', { sprint_id });
+    if (!response.ok) {
+        return { result: { error: response.error || 'Failed to archive sprint' }, isError: true };
+    }
+    return { result: response.data };
+};
+export const unarchiveSprint = async (args, ctx) => {
+    const { sprint_id } = parseArgs(args, unarchiveSprintSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('unarchive_sprint', { sprint_id });
+    if (!response.ok) {
+        return { result: { error: response.error || 'Failed to unarchive sprint' }, isError: true };
+    }
+    return { result: response.data };
+};
 /**
  * Sprint handlers registry
  */
@@ -284,4 +311,6 @@ export const sprintHandlers = {
     remove_task_from_sprint: removeTaskFromSprint,
     get_sprint_backlog: getSprintBacklog,
     get_sprint_velocity: getSprintVelocity,
+    archive_sprint: archiveSprint,
+    unarchive_sprint: unarchiveSprint,
 };

package/dist/handlers/tasks.d.ts

@@ -2,7 +2,11 @@
  * Task Handlers (Migrated to API Client)
  *
  * Handles task CRUD and management:
- * - get_tasks
+ * - get_task (single task by ID)
+ * - search_tasks (text search)
+ * - get_tasks_by_priority (priority filter)
+ * - get_recent_tasks (by date)
+ * - get_task_stats (aggregate counts)
  * - get_next_task
  * - add_task
  * - update_task
@@ -30,7 +34,6 @@ interface GitMergeInstructions {
     note: string;
 }
 export declare function getValidationApprovedGitInstructions(config: GitWorkflowConfig, taskBranch: string | undefined): GitMergeInstructions | undefined;
-export declare const getTasks: Handler;
 export declare const getNextTask: Handler;
 export declare const addTask: Handler;
 export declare const updateTask: Handler;
@@ -42,6 +45,26 @@ export declare const batchUpdateTasks: Handler;
 export declare const batchCompleteTasks: Handler;
 export declare const addSubtask: Handler;
 export declare const getSubtasks: Handler;
+/**
+ * Get a single task by ID with optional subtasks and milestones
+ */
+export declare const getTask: Handler;
+/**
+ * Search tasks by text query with pagination
+ */
+export declare const searchTasks: Handler;
+/**
+ * Get tasks filtered by priority with pagination
+ */
+export declare const getTasksByPriority: Handler;
+/**
+ * Get recent tasks (newest or oldest) with pagination
+ */
+export declare const getRecentTasks: Handler;
+/**
+ * Get task statistics for a project (aggregate counts only, minimal tokens)
+ */
+export declare const getTaskStats: Handler;
 export declare const getStaleWorktrees: Handler;
 export declare const clearWorktreePath: Handler;
 /**