@jigyasudham/veto 1.2.12 → 1.2.15

package/dist/server.js

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
-// Veto MCP Server — 45 tools, 16 phases, self-learning router
+// Veto MCP Server — 45 tools, 19 phases complete, auto-learning router
 // Suppress node:sqlite experimental warning — it would corrupt the MCP stdio protocol
 process.removeAllListeners('warning');
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { buildContextString } from './context/reader.js';
-import { saveSession, restoreSession, listSessions, closeSession, getDbPath, saveCouncilOutcome, storeKnowledge, searchKnowledge, deleteKnowledge, updateProjectMap, getProjectMap, upsertPattern, getPatterns, getContextStatus, fetchAndCacheDocs, saveTaskPlan, getUsageStatus, getAuditLog, getHealthStats, CONTEXT_WINDOWS, } from './memory/local.js';
+import { saveSession, restoreSession, listSessions, closeSession, getDbPath, saveCouncilOutcome, storeKnowledge, searchKnowledge, deleteKnowledge, updateProjectMap, getProjectMap, upsertPattern, getPatterns, getContextStatus, fetchAndCacheDocs, saveTaskPlan, getUsageStatus, getAuditLog, getHealthStats, CONTEXT_WINDOWS, logUsage, getUsageLogs, } from './memory/local.js';
 import { exportMemory, importMemory } from './memory/sync.js';
 import { runDebate } from './council/index.js';
-import { routeTask, getRateStatus, recordOutcome, getLearningStats, getLearnedThresholds, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights, getRecommendedAgent } from './router/index.js';
+import { routeTask, getRateStatus, trackTokens, recordOutcome, getLearningStats, getLearnedThresholds, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights, getRecommendedAgent } from './router/index.js';
+import { getConfig, setConfig } from './memory/config.js';
 import { executeParallel, executeOne } from './agents/executor.js';
 import { handoff, continueSession, getPlatformSetup } from './adapters/index.js';
 import { startWatch, pollWatch, stopWatch } from './watcher/index.js';
@@ -63,9 +64,62 @@ const server = new Server({ name: 'veto', version: VERSION }, {
         prompts: {},
     },
 });
+// ─── Tool Risk Annotations (#21) ─────────────────────────────────────────────
+// readOnlyHint: tool makes no writes. destructiveHint: writes are irreversible.
+// openWorldHint: tool reaches outside the local DB (network, filesystem, processes).
+const TOOL_ANNOTATIONS = {
+    // read-only — query/inspect only
+    veto_status: { readOnlyHint: true },
+    veto_autosave_status: { readOnlyHint: true },
+    veto_sessions_list: { readOnlyHint: true },
+    veto_rate_status: { readOnlyHint: true },
+    veto_route_task: { readOnlyHint: true },
+    veto_agent_plan: { readOnlyHint: true },
+    veto_code_review: { readOnlyHint: true },
+    veto_diff_review: { readOnlyHint: true },
+    veto_security_scan: { readOnlyHint: true },
+    veto_secrets_scan: { readOnlyHint: true },
+    veto_project_map_get: { readOnlyHint: true },
+    veto_patterns_list: { readOnlyHint: true },
+    veto_learning_stats: { readOnlyHint: true },
+    veto_watch_poll: { readOnlyHint: true },
+    veto_plugins: { readOnlyHint: true },
+    veto_context_status: { readOnlyHint: true },
+    veto_audit_log: { readOnlyHint: true },
+    veto_health: { readOnlyHint: true },
+    veto_discover: { readOnlyHint: true },
+    veto_summarize: { readOnlyHint: true },
+    veto_explain: { readOnlyHint: true },
+    // read-only + open world (external network)
+    veto_docs_fetch: { readOnlyHint: true, openWorldHint: true },
+    veto_pr_review: { readOnlyHint: true, openWorldHint: true },
+    // reversible writes (local DB — can be deleted/reset)
+    veto_council_debate: { readOnlyHint: false, destructiveHint: false },
+    veto_execute_parallel: { readOnlyHint: false, destructiveHint: false },
+    veto_session_save: { readOnlyHint: false, destructiveHint: false },
+    veto_session_restore: { readOnlyHint: false, destructiveHint: false },
+    veto_memory_store: { readOnlyHint: false, destructiveHint: false },
+    veto_project_map_update: { readOnlyHint: false, destructiveHint: false },
+    veto_pattern_store: { readOnlyHint: false, destructiveHint: false },
+    veto_memory_export: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+    veto_record_outcome: { readOnlyHint: false, destructiveHint: false },
+    veto_learning_apply: { readOnlyHint: false, destructiveHint: false },
+    veto_handoff: { readOnlyHint: false, destructiveHint: false },
+    veto_continue: { readOnlyHint: false, destructiveHint: false },
+    veto_task_parse: { readOnlyHint: false, destructiveHint: false },
+    veto_watch: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+    veto_watch_stop: { readOnlyHint: false, destructiveHint: false },
+    veto_workflow: { readOnlyHint: false, destructiveHint: false },
+    veto_ci_gate: { readOnlyHint: false, destructiveHint: false },
+    veto_usage_status: { readOnlyHint: false, destructiveHint: false },
+    // destructive — permanent deletes or config overwrites
+    veto_memory_delete: { readOnlyHint: false, destructiveHint: true },
+    veto_memory_import: { readOnlyHint: false, destructiveHint: true },
+    veto_platform_setup: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+};
 // ─── Tool Definitions ─────────────────────────────────────────────────────────
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = [
         {
             name: 'veto_status',
             description: 'Returns Veto server status, version, and database info. Pass token_count to trigger auto-save if context usage crosses 70%.',
@@ -240,6 +294,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: 'string',
                         description: 'Optional: session ID to associate this council outcome with an active session.',
                     },
+                    max_tokens: {
+                        type: 'number',
+                        description: 'Optional: token budget for this operation. Veto estimates output tokens and warns in the response if the estimate exceeds this limit. Logged to usage_log for tracking.',
+                    },
                 },
                 required: ['task'],
             },
@@ -333,6 +391,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         },
                     },
                     project_dir: { type: 'string', description: 'Optional: project directory applied to all tasks (per-task project_dir overrides this). Auto-injects codebase context.' },
+                    max_tokens: {
+                        type: 'number',
+                        description: 'Optional: token budget for this parallel execution. Veto estimates combined output tokens and warns if the estimate exceeds this limit. Logged to usage_log.',
+                    },
                 },
                 required: ['tasks'],
             },
@@ -763,8 +825,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: [],
             },
         },
-    ],
-}));
+    ];
+    return { tools: tools.map(t => ({ ...t, annotations: TOOL_ANNOTATIONS[t.name] ?? {} })) };
+});
 // ─── Shared Scan Utility ──────────────────────────────────────────────────────
 async function runTripleScan(diff, context) {
     const [reviewResult, secResult, secretsResult] = await Promise.all([
@@ -778,8 +841,18 @@ async function runTripleScan(diff, context) {
     const hasWarnings = (reviewResult.analysis?.high_count ?? 0) > 0
         || (secResult.analysis?.high_count ?? 0) > 0;
     const verdict = hasBlocking ? 'fail' : hasWarnings ? 'warn' : 'pass';
+    // auto-record per agent so learning accumulates from every scan (diff_review, ci_gate, pr_review)
+    autoRecord('scan', 'reviewer', reviewResult.analysis?.score ?? Math.round(reviewResult.output.confidence * 100));
+    autoRecord('scan', 'security-scanner', secResult.analysis?.score ?? Math.round(secResult.output.confidence * 100));
+    autoRecord('scan', 'secrets', (secretsResult.analysis?.findings?.length ?? 0) === 0 ? 100 : secretsResult.analysis?.score ?? Math.round(secretsResult.output.confidence * 100));
     return { reviewResult, secResult, secretsResult, verdict };
 }
+// Auto-learning helper — records a learning_data row from any agent result.
+// Keeps call sites to one line rather than repeating the tier/quality logic.
+function autoRecord(taskType, agent, quality, complexity = 50) {
+    const tier = quality >= 80 ? 1 : quality >= 40 ? 2 : 3;
+    recordOutcome(taskType.slice(0, 50), complexity, tier, agent, quality);
+}
 // ─── Tool Handlers ────────────────────────────────────────────────────────────
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
@@ -787,6 +860,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         case 'veto_status': {
             const statusTokenCount = typeof args?.token_count === 'number' ? args.token_count : null;
             const statusPlatform = args?.platform ? String(args.platform) : 'claude';
+            if (statusTokenCount !== null && statusTokenCount > 0) {
+                trackTokens(statusPlatform, statusTokenCount);
+            }
             const autoSaveResult = statusTokenCount !== null ? maybeAutoSave(statusTokenCount, statusPlatform) : null;
             return {
                 content: [
@@ -948,6 +1024,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 preferredPlatform: args?.preferred_platform ? String(args.preferred_platform) : 'claude',
             });
             const recommended_agent = getRecommendedAgent(routeTaskStr, fileExt);
+            // #41: auto-record every routing so tier distribution stats are always populated
+            recordOutcome(routeTaskStr.slice(0, 50), result.complexity.score, result.model.tier, 'router', 70);
             return {
                 content: [{
                         type: 'text',
@@ -980,8 +1058,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 project_dir: args?.project_dir ? String(args.project_dir) : undefined,
             });
             const debateDuration = Date.now() - debateStart;
+            const sessionId = args?.session_id ? String(args.session_id) : undefined;
             const outcomeId = saveCouncilOutcome({
-                session_id: args?.session_id ? String(args.session_id) : undefined,
+                session_id: sessionId,
                 task,
                 verdict: result.final_verdict,
                 lead_dev: JSON.stringify(result.votes.lead_dev),
@@ -994,29 +1073,43 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 recommended: result.recommended,
                 duration_ms: debateDuration,
             });
+            // #38: auto-record learning outcome from verdict — no manual veto_record_outcome needed
+            {
+                const qMap = { GREEN: 90, YELLOW: 60, RED: 20, DEADLOCK: 50 };
+                const tMap = { GREEN: 1, YELLOW: 2, RED: 3, DEADLOCK: 2 };
+                recordOutcome(task.slice(0, 50), 50, tMap[result.final_verdict] ?? 2, 'council', qMap[result.final_verdict] ?? 50);
+            }
+            const responsePayload = {
+                outcome_id: outcomeId,
+                final_verdict: result.final_verdict,
+                block_reasons: result.block_reasons,
+                warnings: result.warnings,
+                recommended: result.recommended,
+                debated_at: result.debated_at,
+                votes: {
+                    lead_dev: result.votes.lead_dev.verdict,
+                    pm: result.votes.pm.verdict,
+                    architect: result.votes.architect.verdict,
+                    ux: result.votes.ux.verdict,
+                    devil: result.votes.devil.verdict,
+                    legal: result.votes.legal.verdict,
+                    security: result.votes.security.verdict,
+                },
+            };
+            const fullText = result.formatted_output + '\n\n' + JSON.stringify(responsePayload, null, 2);
+            if (typeof args?.max_tokens === 'number') {
+                const { exceeded, estimated_tokens } = logUsage({
+                    tool_name: 'veto_council_debate',
+                    session_id: sessionId,
+                    max_tokens: args.max_tokens,
+                    output: fullText,
+                });
+                if (exceeded) {
+                    responsePayload.budget_warning = `Estimated output tokens (${estimated_tokens}) exceeded max_tokens budget (${args.max_tokens}).`;
+                }
+            }
             return {
-                content: [
-                    {
-                        type: 'text',
-                        text: result.formatted_output + '\n\n' + JSON.stringify({
-                            outcome_id: outcomeId,
-                            final_verdict: result.final_verdict,
-                            block_reasons: result.block_reasons,
-                            warnings: result.warnings,
-                            recommended: result.recommended,
-                            debated_at: result.debated_at,
-                            votes: {
-                                lead_dev: result.votes.lead_dev.verdict,
-                                pm: result.votes.pm.verdict,
-                                architect: result.votes.architect.verdict,
-                                ux: result.votes.ux.verdict,
-                                devil: result.votes.devil.verdict,
-                                legal: result.votes.legal.verdict,
-                                security: result.votes.security.verdict,
-                            },
-                        }, null, 2),
-                    },
-                ],
+                content: [{ type: 'text', text: fullText }],
             };
         }
         case 'veto_agent_plan': {
@@ -1035,6 +1128,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (result.error) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: result.error }) }], isError: true };
             }
+            autoRecord(task, agentType, Math.round(result.output.confidence * 100));
             return { content: [{ type: 'text', text: JSON.stringify({ ...(result.plan ?? result.analysis), output: result.output }, null, 2) }] };
         }
         case 'veto_code_review': {
@@ -1046,6 +1140,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (result.error) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: result.error }) }], isError: true };
             }
+            autoRecord('code review', 'reviewer', result.analysis?.score ?? Math.round(result.output.confidence * 100));
             return { content: [{ type: 'text', text: JSON.stringify(result.analysis, null, 2) }] };
         }
         case 'veto_diff_review': {
@@ -1130,6 +1225,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (result.error) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: result.error }) }], isError: true };
             }
+            autoRecord('security scan', 'security-scanner', result.analysis?.score ?? Math.round(result.output.confidence * 100));
             return { content: [{ type: 'text', text: JSON.stringify(result.analysis, null, 2) }] };
         }
         case 'veto_secrets_scan': {
@@ -1141,6 +1237,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (result.error) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: result.error }) }], isError: true };
             }
+            autoRecord('secrets scan', 'secrets', (result.analysis?.findings?.length ?? 0) === 0 ? 100 : result.analysis?.score ?? Math.round(result.output.confidence * 100));
             return { content: [{ type: 'text', text: JSON.stringify(result.analysis, null, 2) }] };
         }
         case 'veto_execute_parallel': {
@@ -1158,21 +1255,39 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 project_dir: t.project_dir ? String(t.project_dir) : parallelProjectDir,
             }));
             const results = await executeParallel(tasks);
+            // #40: auto-record learning outcome per completed parallel task
+            for (let i = 0; i < results.length; i++) {
+                const r = results[i];
+                if (r.error)
+                    continue;
+                const quality = Math.round(r.output.confidence * 100);
+                const tier = quality >= 80 ? 1 : quality >= 40 ? 2 : 3;
+                recordOutcome(tasks[i]?.task.slice(0, 50) ?? r.agent, 50, tier, r.agent, quality);
+            }
+            const parallelPayload = {
+                count: results.length,
+                total_duration_ms: results.reduce((s, r) => s + r.duration_ms, 0),
+                results: results.map(r => ({
+                    id: r.id,
+                    agent: r.agent,
+                    duration_ms: r.duration_ms,
+                    error: r.error,
+                    output: { ...(r.plan ?? r.analysis), structured: r.output },
+                })),
+            };
+            if (typeof args?.max_tokens === 'number') {
+                const outputText = JSON.stringify(parallelPayload, null, 2);
+                const { exceeded, estimated_tokens } = logUsage({
+                    tool_name: 'veto_execute_parallel',
+                    max_tokens: args.max_tokens,
+                    output: outputText,
+                });
+                if (exceeded) {
+                    parallelPayload.budget_warning = `Estimated output tokens (${estimated_tokens}) exceeded max_tokens budget (${args.max_tokens}).`;
+                }
+            }
             return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            count: results.length,
-                            total_duration_ms: results.reduce((s, r) => s + r.duration_ms, 0),
-                            results: results.map(r => ({
-                                id: r.id,
-                                agent: r.agent,
-                                duration_ms: r.duration_ms,
-                                error: r.error,
-                                output: { ...(r.plan ?? r.analysis), structured: r.output },
-                            })),
-                        }, null, 2),
-                    }],
+                content: [{ type: 'text', text: JSON.stringify(parallelPayload, null, 2) }],
             };
         }
         case 'veto_memory_store': {
@@ -1454,6 +1569,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 gate: typeof s.gate === 'number' ? s.gate : undefined,
             }));
             const result = await runPipeline(steps, args?.project_dir ? String(args.project_dir) : undefined);
+            // #39: auto-record learning outcome per executed workflow step
+            for (const step of result.results) {
+                if (step.status === 'skipped')
+                    continue;
+                const quality = step.error ? 0 : step.confidence;
+                const tier = quality >= 80 ? 1 : quality >= 40 ? 2 : 3;
+                const taskStr = steps.find(s => s.id === step.id)?.task.slice(0, 50) ?? step.id;
+                recordOutcome(taskStr, 50, tier, step.agent, quality);
+            }
             return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
         }
         case 'veto_explain': {
@@ -1489,6 +1613,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const userContext = args?.context ? String(args.context) : undefined;
             const task = `Explain this ${ext} file at ${depth} depth. File: ${basename(filePath)}${userContext ? `. Focus: ${userContext}` : ''}`;
             const result = await executeOne({ id: 'explain-1', agent, task, code: fileContent, project_dir: undefined });
+            autoRecord(`explain ${basename(filePath)}`, agent, Math.round(result.output.confidence * 100));
             return {
                 content: [{ type: 'text', text: JSON.stringify({
                             file: filePath, agent_used: agent, depth,
@@ -1594,14 +1719,55 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 tasks,
                 duration_estimate: planResult.plan?.duration_estimate ?? 'unknown',
             };
+            autoRecord(description, 'task-planner', Math.round(planResult.output.confidence * 100));
             const hash = createHash('sha256').update(description).digest('hex').slice(0, 16);
             const plan_id = saveTaskPlan(JSON.stringify(plan), hash, project_dir);
             return { content: [{ type: 'text', text: JSON.stringify({ success: true, plan_id, ...plan }, null, 2) }] };
         }
         // ── Phase 14: Observability & Safety ──────────────────────────────────────
         case 'veto_usage_status': {
+            if (args?.set_budget && typeof args.set_budget === 'object') {
+                const b = args.set_budget;
+                const current = getConfig().dailyTokenBudget;
+                setConfig({
+                    dailyTokenBudget: {
+                        claude: typeof b.claude === 'number' ? b.claude : current.claude,
+                        gemini: typeof b.gemini === 'number' ? b.gemini : current.gemini,
+                        codex: typeof b.codex === 'number' ? b.codex : current.codex,
+                    },
+                });
+            }
             const status = getUsageStatus();
-            return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...status }, null, 2) }] };
+            const { dailyTokenBudget } = getConfig();
+            const rateStatus = getRateStatus();
+            const recentBudgetLog = getUsageLogs({ limit: 10 });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            ...status,
+                            daily_token_budget: dailyTokenBudget,
+                            tokens_today: {
+                                claude: rateStatus.claude.tokens_today,
+                                gemini: rateStatus.gemini.tokens_today,
+                                codex: rateStatus.codex.tokens_today,
+                            },
+                            budget_used_pct: {
+                                claude: rateStatus.claude.used_percent,
+                                gemini: rateStatus.gemini.used_percent,
+                                codex: rateStatus.codex.used_percent,
+                            },
+                            operation_budget_log: recentBudgetLog.map(e => ({
+                                tool: e.tool_name,
+                                max_tokens: e.max_tokens,
+                                estimated_tokens: e.estimated_tokens,
+                                exceeded: e.exceeded === 1,
+                                at: e.created_at,
+                            })),
+                        }, null, 2),
+                    }],
+            };
         }
         case 'veto_audit_log': {
             const events = getAuditLog({
@@ -1846,6 +2012,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const depthNote = sumFormat === 'detailed' ? 'Write paragraph-level prose.' : 'Return 4–6 bullet points only.';
                 const task = `Summarize this file concisely for a developer who has never seen it.${focusNote} ${depthNote} File: ${basename(sumFilePath)}`;
                 const r = await executeOne({ id: 'sum-file', agent, task, code: fileContent.slice(0, 8000) });
+                autoRecord(`summarize ${basename(sumFilePath)}`, agent, Math.round(r.output.confidence * 100));
                 return { content: [{ type: 'text', text: JSON.stringify({
                                 success: true, subject: 'file', path: sumFilePath, format: sumFormat,
                                 summary: r.plan ?? r.analysis ?? r.output,
@@ -1867,6 +2034,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const depthNote = sumFormat === 'detailed' ? 'Write paragraph-level prose with sections.' : 'Return 5–7 bullet points that capture the essence.';
             const task = `You are a senior engineer briefing a colleague on this codebase.${focusNote} ${depthNote} Be concise and precise — no filler.`;
             const r = await executeOne({ id: 'sum-proj', agent: 'project-mapper', task, context: ctx });
+            autoRecord('summarize project', 'project-mapper', Math.round(r.output.confidence * 100));
             return { content: [{ type: 'text', text: JSON.stringify({
                             success: true, subject: 'project', path: sumProjectDir, format: sumFormat,
                             tech_stack: discResult.tech_stack,