@jigyasudham/veto 1.2.19 → 1.4.0

package/dist/tools/definitions.d.ts

@@ -0,0 +1,1073 @@
+export declare const TOOL_DEFINITIONS: readonly [{
+    readonly name: "veto_status";
+    readonly description: "Returns Veto server status, version, and database info. Pass token_count to trigger auto-save if context usage crosses 70%.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly token_count: {
+                readonly type: "number";
+                readonly description: "Current session token count. If provided and context usage ≥ 70%, Veto auto-saves the last known session context in the background.";
+            };
+            readonly platform: {
+                readonly type: "string";
+                readonly description: "AI platform (claude, gemini, codex). Used to select the correct context window for threshold calculation. Defaults to \"claude\".";
+                readonly enum: readonly ["claude", "gemini", "codex"];
+            };
+            readonly model: {
+                readonly type: "string";
+                readonly description: "Optional: specific model ID (e.g. \"claude-sonnet-4-6\", \"gemini-2-5-pro\", \"gpt-4o\"). When provided, Veto resolves the exact context window for that model instead of using the platform default.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_autosave_status";
+    readonly description: "Returns the current auto-save state: whether a context is cached, the threshold, the last auto-save time, and the session ID.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_health";
+    readonly description: "Returns a live health snapshot of the Veto server — DB size, session/memory/pattern counts, uptime, error count, and average council latency.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_rate_status";
+    readonly description: "Returns current request counts and rate limit status for all AI platforms tracked by Veto.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_session_save";
+    readonly description: "Saves the current session context to SQLite. Pass session_id to update an existing session instead of creating a new one — use this when refreshing context mid-conversation rather than starting a new snapshot.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly summary: {
+                readonly type: "string";
+                readonly description: "A brief summary of what was accomplished this session.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Key context to restore (decisions, current task, file list, etc.).";
+            };
+            readonly task_state: {
+                readonly type: "string";
+                readonly description: "Current task state — what is done and what is next.";
+            };
+            readonly platform: {
+                readonly type: "string";
+                readonly description: "AI platform used (claude, gemini, codex). Defaults to \"claude\".";
+                readonly enum: readonly ["claude", "gemini", "codex"];
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute path to the current project directory.";
+            };
+            readonly connection_type: {
+                readonly type: "string";
+                readonly description: "How you are connected to this AI — \"subscription\" (Claude Pro, Gemini Advanced) or \"api\" (API key). Used for usage tracking.";
+                readonly enum: readonly ["subscription", "api"];
+            };
+            readonly token_count: {
+                readonly type: "number";
+                readonly description: "Approximate tokens used this session. Veto uses this for context window monitoring.";
+            };
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Optional. UUID of an existing session to update in-place. When provided, Veto updates that row instead of inserting a new one — prevents session inflation when refreshing mid-conversation.";
+            };
+            readonly model: {
+                readonly type: "string";
+                readonly description: "Optional: specific model ID (e.g. \"claude-sonnet-4-6\", \"gemini-2-5-pro\", \"gpt-4o\"). Veto resolves the exact context window for this model and uses it for auto-save threshold calculations.";
+            };
+            readonly tags: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional labels for this session (e.g. [\"auth\", \"migration\", \"v1.3\"]). Makes sessions searchable via veto_sessions_list query.";
+            };
+        };
+        readonly required: readonly ["summary", "context"];
+    };
+}, {
+    readonly name: "veto_session_restore";
+    readonly description: "Restores a previously saved session by ID. Use veto_sessions_list to find IDs.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "UUID of the session to restore.";
+            };
+            readonly resuming_as: {
+                readonly type: "string";
+                readonly description: "The AI client resuming this session (e.g. \"claude\", \"gemini\", \"codex\"). Recorded as active_client.";
+                readonly enum: readonly ["claude", "gemini", "codex"];
+            };
+        };
+        readonly required: readonly ["session_id"];
+    };
+}, {
+    readonly name: "veto_sessions_list";
+    readonly description: "Lists the most recent saved sessions. Use query to search by summary, context, tags, or project path.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Number of sessions to return (default 10, max 50).";
+            };
+            readonly query: {
+                readonly type: "string";
+                readonly description: "Optional text search — matches against summary, context, task_state, tags, and project_dir.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_handoff";
+    readonly description: "Saves the current session and returns step-by-step instructions to continue on another AI platform (Gemini or Codex). Call this when Claude is approaching its rate limit. The receiving platform calls veto_continue to restore full context instantly.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly summary: {
+                readonly type: "string";
+                readonly description: "What was accomplished this session — one or two sentences.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Key context the next platform needs: active decisions, file paths, constraints.";
+            };
+            readonly task_state: {
+                readonly type: "string";
+                readonly description: "Current task state — what is done, what is in progress, what is next.";
+            };
+            readonly from_platform: {
+                readonly type: "string";
+                readonly enum: readonly ["claude", "gemini", "codex"];
+                readonly description: "Platform handing off (default: claude).";
+            };
+            readonly to_platform: {
+                readonly type: "string";
+                readonly enum: readonly ["gemini", "codex", "claude"];
+                readonly description: "Target platform. If omitted, Veto picks the platform with the most headroom.";
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute path to the current project directory.";
+            };
+            readonly token_count: {
+                readonly type: "number";
+                readonly description: "Approximate tokens used this session.";
+            };
+        };
+        readonly required: readonly ["summary", "context"];
+    };
+}, {
+    readonly name: "veto_continue";
+    readonly description: "Restores the most recent session on any platform. Call this immediately after switching platforms — Veto returns the full context, summary, and next action. Nothing needs to be re-explained.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Optional. Session ID from veto_handoff. If omitted, the most recent saved session is restored.";
+            };
+            readonly resuming_as: {
+                readonly type: "string";
+                readonly description: "The AI client resuming this session (e.g. \"gemini\"). Recorded as active_client so you can track which tool is currently working on it.";
+                readonly enum: readonly ["claude", "gemini", "codex"];
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_council_debate";
+    readonly description: "Runs the Veto Council — 7 specialist agents (Lead Dev, PM, Architect, UX, Devil's Advocate, Legal, Security) debate your task and return a GREEN / YELLOW / RED / DEADLOCK verdict before any code is written. Use strictness to control depth: fast (3 agents), standard (7, default), strict (7 + rebuttal round).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly task: {
+                readonly type: "string";
+                readonly description: "The task or decision to debate. Be specific — include approach, tech stack, and constraints.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Optional: additional context such as codebase state, prior decisions, or constraints.";
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Optional: absolute path to the project directory. Veto will auto-read package.json, git diff, and stack info to give the council real project context.";
+            };
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Optional: session ID to associate this council outcome with an active session.";
+            };
+            readonly max_tokens: {
+                readonly type: "number";
+                readonly 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.";
+            };
+            readonly strictness: {
+                readonly type: "string";
+                readonly enum: readonly ["fast", "standard", "strict"];
+                readonly description: "Council depth. fast: 3 core agents (dev + architect + security), instant. standard: all 7 agents (default). strict: all 7 + Devil's Advocate rebuttal round on the most critical blocker.";
+            };
+        };
+        readonly required: readonly ["task"];
+    };
+}, {
+    readonly name: "veto_benchmark";
+    readonly description: "Compares two competing approaches by running a full council debate on each in parallel, then returns a structured winner analysis with verdict, confidence delta, warning counts, and council reasoning. Use when you have two valid options and want an unbiased council judgment before committing.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly task: {
+                readonly type: "string";
+                readonly description: "The decision context — what problem are both approaches solving?";
+            };
+            readonly approach_a: {
+                readonly type: "string";
+                readonly description: "First approach to evaluate. Be specific about tech choices, trade-offs, and constraints.";
+            };
+            readonly approach_b: {
+                readonly type: "string";
+                readonly description: "Second approach to evaluate. Same level of detail as approach_a.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Optional: shared context for both debates (architecture notes, constraints, team size, etc.).";
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Optional: auto-inject package.json and git diff context.";
+            };
+        };
+        readonly required: readonly ["task", "approach_a", "approach_b"];
+    };
+}, {
+    readonly name: "veto_route_task";
+    readonly description: "Scores a task for complexity (0-100) and returns the optimal tier, model recommendation, and rate status. Use before any substantial task to let the router decide which model to use.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly task: {
+                readonly type: "string";
+                readonly description: "The task description to score and route.";
+            };
+            readonly agent_type: {
+                readonly type: "string";
+                readonly description: "Optional agent type — some agents are tier-locked regardless of score.";
+                readonly enum: readonly ["lead-developer", "system-architect", "security-scanner", "devil-advocate", "decision-engine", "risk-assessor", "coder", "tester", "reviewer", "database", "documentation", "file-manager", "git-agent", "search-agent", "secrets", "reporter", "dynamic"];
+            };
+            readonly files_affected: {
+                readonly type: "number";
+                readonly description: "Number of files the task will touch (influences complexity score).";
+            };
+            readonly force_council: {
+                readonly type: "boolean";
+                readonly description: "Set true to force a Tier 3 / council-required routing.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Current context text — router will return a compression plan.";
+            };
+            readonly preferred_platform: {
+                readonly type: "string";
+                readonly description: "Preferred AI platform. Router may override if rate-limited.";
+                readonly enum: readonly ["claude", "gemini", "codex"];
+            };
+        };
+        readonly required: readonly ["task"];
+    };
+}, {
+    readonly name: "veto_agent_plan";
+    readonly description: "Gets a domain-expert execution plan from a specific worker agent. Returns approach, ordered steps, checklist, patterns, and pitfalls for the task.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly agent: {
+                readonly type: "string";
+                readonly description: "The worker agent to consult.";
+                readonly enum: readonly ["coder", "reviewer", "tester", "debugger", "refactor", "database", "api", "frontend", "backend", "devops", "performance", "migration", "security-scanner", "auth", "privacy", "secrets", "dependency-audit", "penetration", "context-manager", "decision-logger", "project-mapper", "pattern-learner", "knowledge-base", "researcher", "tech-advisor", "cost-analyzer", "competitor-analyzer", "risk-assessor", "estimator", "ethics-bias", "code-quality", "documentation", "accessibility", "compatibility", "error-handling", "task-planner", "task-coordinator", "file-manager", "git-agent", "search-agent", "reporter", "automation"];
+            };
+            readonly task: {
+                readonly type: "string";
+                readonly description: "The task for the agent to plan.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Optional additional context.";
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Optional: absolute path to the project directory. Auto-injects package.json, git diff, and stack info into the agent context.";
+            };
+        };
+        readonly required: readonly ["agent", "task"];
+    };
+}, {
+    readonly name: "veto_execute_parallel";
+    readonly description: "Runs multiple worker agents simultaneously via Promise.all. Use to get domain expert input from several agents in one round-trip — e.g. coder + tester + security-scanner all planning the same feature together.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly tasks: {
+                readonly type: "array";
+                readonly description: "List of agent tasks to run in parallel.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                            readonly description: "Unique ID for this task (use any string).";
+                        };
+                        readonly agent: {
+                            readonly type: "string";
+                            readonly description: "Worker agent type.";
+                        };
+                        readonly task: {
+                            readonly type: "string";
+                            readonly description: "Task description for this agent.";
+                        };
+                        readonly code: {
+                            readonly type: "string";
+                            readonly description: "Optional code to analyze (triggers analyze() instead of plan()).";
+                        };
+                        readonly context: {
+                            readonly type: "string";
+                            readonly description: "Optional additional context.";
+                        };
+                        readonly project_dir: {
+                            readonly type: "string";
+                            readonly description: "Optional: per-task project dir override.";
+                        };
+                    };
+                    readonly required: readonly ["id", "agent", "task"];
+                };
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Optional: project directory applied to all tasks (per-task project_dir overrides this). Auto-injects codebase context.";
+            };
+            readonly max_tokens: {
+                readonly type: "number";
+                readonly 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.";
+            };
+        };
+        readonly required: readonly ["tasks"];
+    };
+}, {
+    readonly name: "veto_task_parse";
+    readonly description: "Parses a plain-English project description or PRD into a structured task DAG with dependencies, complexity scores, priorities, and suggested agent assignments. Feeds directly into veto_workflow.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Project description, PRD, or feature brief to parse into tasks.";
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Optional project directory for codebase context injection.";
+            };
+            readonly max_tasks: {
+                readonly type: "number";
+                readonly description: "Maximum number of tasks to generate (default 20).";
+            };
+        };
+        readonly required: readonly ["description"];
+    };
+}, {
+    readonly name: "veto_code_review";
+    readonly description: "Runs the Code Reviewer agent on provided code. Returns scored findings (complexity, error handling, magic numbers, nesting, dead code) with severity and fixes. Pass file_path to surface findings as VS Code inline diagnostics (squiggles).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly code: {
+                readonly type: "string";
+                readonly description: "The code to review.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Optional: file name, module description, or review focus.";
+            };
+            readonly file_path: {
+                readonly type: "string";
+                readonly description: "Optional: absolute path to the file being reviewed. When provided, findings are stored as VS Code inline diagnostics.";
+            };
+        };
+        readonly required: readonly ["code"];
+    };
+}, {
+    readonly name: "veto_diff_review";
+    readonly description: "Reviews a git diff — runs code review, security scan, and secrets scan in parallel across all changed files. Returns a structured verdict (pass/warn/fail), per-file findings, and a CI-ready summary. Pass diff directly or let Veto read it from project_dir automatically.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly diff: {
+                readonly type: "string";
+                readonly description: "The git diff to review. If omitted, Veto runs git diff HEAD in project_dir.";
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute project path. Used to auto-read git diff if diff is not provided, and to inject codebase context.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Optional: PR description, ticket number, or focus area.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_security_scan";
+    readonly description: "Runs the Security Scanner (OWASP Top 10) on provided code. Returns vulnerabilities with severity, CWE/OWASP category, and remediation steps. Pass file_path to surface findings as VS Code inline diagnostics.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly code: {
+                readonly type: "string";
+                readonly description: "The code to scan.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Optional: language, framework, or specific concerns.";
+            };
+            readonly file_path: {
+                readonly type: "string";
+                readonly description: "Optional: absolute path to the file being scanned. When provided, findings are stored as VS Code inline diagnostics.";
+            };
+        };
+        readonly required: readonly ["code"];
+    };
+}, {
+    readonly name: "veto_secrets_scan";
+    readonly description: "Scans text or code for exposed credentials — API keys, tokens, passwords, connection strings, private keys. Returns findings with masked values and line numbers. Pass file_path to surface findings as VS Code inline diagnostics.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly text: {
+                readonly type: "string";
+                readonly description: "The text or code to scan for secrets.";
+            };
+            readonly file_path: {
+                readonly type: "string";
+                readonly description: "Optional: absolute path to the file being scanned. When provided, findings are stored as VS Code inline diagnostics.";
+            };
+        };
+        readonly required: readonly ["text"];
+    };
+}, {
+    readonly name: "veto_pr_review";
+    readonly description: "Fetches a GitHub PR diff and runs the full Veto triple-scan (code review + security + secrets). Returns a structured verdict and ready-to-post GitHub review comments. Set GITHUB_TOKEN env var for private repos.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly pr_url: {
+                readonly type: "string";
+                readonly description: "Full GitHub PR URL. e.g. https://github.com/owner/repo/pull/123";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Optional: PR description or ticket number for extra context.";
+            };
+            readonly fail_on: {
+                readonly type: "string";
+                readonly enum: readonly ["warn", "fail"];
+                readonly description: "Whether WARN counts as a failure. Default: \"fail\".";
+            };
+        };
+        readonly required: readonly ["pr_url"];
+    };
+}, {
+    readonly name: "veto_memory_store";
+    readonly description: "Stores a knowledge entry (solution, pattern, error, reference, or decision) in the local knowledge base for retrieval across sessions. Search before storing to avoid duplicates.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly title: {
+                readonly type: "string";
+                readonly description: "Precise, searchable title. Bad: \"Fixed bug\". Good: \"Fix: Node sqlite fails on Windows without --experimental-sqlite\".";
+            };
+            readonly content: {
+                readonly type: "string";
+                readonly description: "Self-contained content: problem → root cause → solution. Future agents must understand it without original context.";
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly description: "Entry type.";
+                readonly enum: readonly ["solution", "pattern", "context", "error", "reference", "decision"];
+            };
+            readonly tags: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Search tags (3–5 recommended). Examples: [\"typescript\", \"auth\", \"jwt\"].";
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute project path. Include for project-specific knowledge; omit for general programming knowledge.";
+            };
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Optional: associate this knowledge entry with an active session.";
+            };
+            readonly relevance: {
+                readonly type: "number";
+                readonly description: "Initial relevance score 0.0–1.0 (default 1.0).";
+            };
+        };
+        readonly required: readonly ["title", "content"];
+    };
+}, {
+    readonly name: "veto_memory_search";
+    readonly description: "Searches the local knowledge base for entries matching a query. Call at the start of every task to find prior solutions before solving from scratch.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly description: "Search terms (full-text search on title and content).";
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly description: "Filter by entry type.";
+                readonly enum: readonly ["solution", "pattern", "context", "error", "reference", "decision"];
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Filter to a specific project directory.";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Max results to return (default 10, max 50).";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_memory_delete";
+    readonly description: "Deletes a knowledge entry by ID. Use to remove stale or duplicate entries found via veto_memory_search.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly id: {
+                readonly type: "string";
+                readonly description: "The knowledge entry ID (from veto_memory_search results).";
+            };
+        };
+        readonly required: readonly ["id"];
+    };
+}, {
+    readonly name: "veto_memory_export";
+    readonly description: "Exports all local memory (sessions, knowledge, patterns, decisions, project maps) to a portable JSON file. Copy the file to another machine and run veto_memory_import there to resume work. No external services required.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly output_path: {
+                readonly type: "string";
+                readonly description: "Where to write the export file. Defaults to ~/.veto/veto-export.json. Use a path on shared storage (Dropbox, OneDrive, USB) to make transfer easy.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_memory_import";
+    readonly description: "Imports memory from a JSON file exported by veto_memory_export on another machine. Merges into local SQLite using INSERT OR IGNORE — existing local rows are never overwritten. Call veto_sessions_list after import to confirm sessions arrived.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly input_path: {
+                readonly type: "string";
+                readonly description: "Path to the export JSON file. Defaults to ~/.veto/veto-export.json.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_pattern_store";
+    readonly description: "Stores or updates a coding pattern observed in the codebase. Patterns are keyed by category.pattern-name and confidence increases with repeated observation.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly pattern_key: {
+                readonly type: "string";
+                readonly description: "Pattern identifier in category.pattern-name format. Example: \"code.async-pattern\" or \"naming.variable-case\".";
+            };
+            readonly pattern_val: {
+                readonly type: "string";
+                readonly description: "The observed pattern value. Example: \"async/await with try/catch, no raw Promise chains\".";
+            };
+            readonly confidence: {
+                readonly type: "number";
+                readonly description: "Confidence score 0.0–1.0 (default 1.0). Increases automatically on repeated observation.";
+            };
+        };
+        readonly required: readonly ["pattern_key", "pattern_val"];
+    };
+}, {
+    readonly name: "veto_patterns_list";
+    readonly description: "Returns stored coding patterns. Filter by prefix to get patterns in a specific category (e.g. prefix=\"naming.\" for all naming conventions).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly prefix: {
+                readonly type: "string";
+                readonly description: "Optional prefix filter. Example: \"code.\" or \"naming.\" or \"testing.\".";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Max patterns to return (default 20).";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_record_outcome";
+    readonly description: "Records a task outcome (quality score) to feed the self-learning router. Call after completing any task. After 20+ outcomes, call veto_learning_apply to update tier thresholds.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly task_type: {
+                readonly type: "string";
+                readonly description: "Short consistent label for the task category (e.g. \"write-unit-tests\", \"fix-auth-bug\"). Use the same label for similar tasks to enable pattern detection.";
+            };
+            readonly complexity: {
+                readonly type: "number";
+                readonly description: "The complexity score from veto_route_task (0–100).";
+            };
+            readonly model_tier: {
+                readonly type: "number";
+                readonly description: "The tier that was actually used (1, 2, or 3).";
+                readonly enum: readonly [1, 2, 3];
+            };
+            readonly output_quality: {
+                readonly type: "number";
+                readonly description: "Output quality score 0–100. 90–100=excellent, 70–89=good, 50–69=acceptable, 30–49=poor, 0–29=failed.";
+            };
+            readonly agent: {
+                readonly type: "string";
+                readonly description: "The worker agent type used (optional but useful for agent performance tracking).";
+            };
+            readonly tokens_used: {
+                readonly type: "number";
+                readonly description: "Approximate tokens used (optional).";
+            };
+            readonly file_ext: {
+                readonly type: "string";
+                readonly description: "File extension of the primary file worked on (e.g. \".ts\", \".sql\", \".tsx\"). Enables predictive agent routing — next time you work on the same extension, veto_route_task will recommend the best agent.";
+            };
+        };
+        readonly required: readonly ["task_type", "complexity", "model_tier", "output_quality"];
+    };
+}, {
+    readonly name: "veto_learning_stats";
+    readonly description: "Returns the self-learning router dashboard: tier distribution, per-agent quality stats, suggested threshold adjustments, and council insights. Use to understand how the router is performing and where to improve.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly include_agent_stats: {
+                readonly type: "boolean";
+                readonly description: "Include per-agent quality breakdown (default true).";
+            };
+            readonly include_task_types: {
+                readonly type: "boolean";
+                readonly description: "Include per-task-type breakdown (default false, verbose).";
+            };
+            readonly include_council_insights: {
+                readonly type: "boolean";
+                readonly description: "Include council decision → debugging correlation (default false).";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_learning_apply";
+    readonly description: "Applies learned tier thresholds to the router based on recorded task outcomes. Requires at least 20 recorded outcomes. The router immediately uses the new thresholds on the next veto_route_task call.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_project_map_update";
+    readonly description: "Updates the project structure map for a directory. Call after creating, deleting, or moving files. The map enables fast codebase navigation without filesystem scans.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute path to the project root.";
+            };
+            readonly structure: {
+                readonly type: "string";
+                readonly description: "JSON string representing the directory tree. Example: {\"src/\":{\"agents/\":[\"coder.ts\",\"reviewer.ts\"],\"router/\":[\"index.ts\"]}}";
+            };
+            readonly key_modules: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "The 10–20 most important files with their roles. Example: [\"src/server.ts (MCP entry point)\", \"src/router/index.ts (task router)\"].";
+            };
+            readonly tech_stack: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Frameworks and key libraries. Example: [\"TypeScript\", \"Node.js 22\", \"Express\", \"SQLite\"].";
+            };
+        };
+        readonly required: readonly ["project_dir", "structure"];
+    };
+}, {
+    readonly name: "veto_project_map_get";
+    readonly description: "Returns the stored project structure map for a directory. Use to navigate the codebase without scanning the filesystem.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute path to the project root.";
+            };
+        };
+        readonly required: readonly ["project_dir"];
+    };
+}, {
+    readonly name: "veto_discover";
+    readonly description: "Scans a project directory and builds a rich context map: git state, tech stack, file structure, dependencies, and key config files. Stores the result in Veto memory so agents always have accurate project context. Call this once per project or after major structural changes.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute path to the project directory to scan.";
+            };
+            readonly depth: {
+                readonly type: "string";
+                readonly enum: readonly ["quick", "standard", "full"];
+                readonly description: "Scan depth. quick: git + package metadata only. standard: + file tree up to 3 levels (default). full: + contents of key config files.";
+            };
+            readonly store: {
+                readonly type: "boolean";
+                readonly description: "Whether to store the discovery in Veto memory as a project map. Default: true.";
+            };
+        };
+        readonly required: readonly ["project_dir"];
+    };
+}, {
+    readonly name: "veto_context_status";
+    readonly description: "Returns the context window usage for a saved session — tokens used, % of platform limit consumed, and whether to compress or hand off before the window fills.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Session ID to check.";
+            };
+        };
+        readonly required: readonly ["session_id"];
+    };
+}, {
+    readonly name: "veto_workflow";
+    readonly description: "Runs a sequential agent pipeline with optional pass/fail gates between steps. Each step runs a worker agent; if a gate score is set and the step confidence falls below it, the pipeline stops. Returns per-step results plus an overall verdict (passed/partial/failed).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly steps: {
+                readonly type: "array";
+                readonly description: "Ordered pipeline steps.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                            readonly description: "Step identifier.";
+                        };
+                        readonly agent: {
+                            readonly type: "string";
+                            readonly description: "Worker agent type.";
+                        };
+                        readonly task: {
+                            readonly type: "string";
+                            readonly description: "Task description for this step.";
+                        };
+                        readonly code: {
+                            readonly type: "string";
+                            readonly description: "Optional code to analyze.";
+                        };
+                        readonly context: {
+                            readonly type: "string";
+                            readonly description: "Optional context.";
+                        };
+                        readonly gate: {
+                            readonly type: "number";
+                            readonly description: "Optional minimum confidence % (0–100) required to proceed to the next step.";
+                        };
+                    };
+                    readonly required: readonly ["id", "agent", "task"];
+                };
+            };
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Optional project directory — auto-injects codebase context into all steps.";
+            };
+        };
+        readonly required: readonly ["steps"];
+    };
+}, {
+    readonly name: "veto_watch";
+    readonly description: "Starts a file watcher on a project directory. Returns a watch_id. Call veto_watch_poll to collect file-change events with recommended agents. Call veto_watch_stop when done.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute path to the project directory to watch.";
+            };
+        };
+        readonly required: readonly ["project_dir"];
+    };
+}, {
+    readonly name: "veto_watch_poll";
+    readonly description: "Polls for file-change events from an active watcher. Returns accumulated events since last poll (events are cleared on read). Each event includes the file, recommended agent, and suggested veto tool to call.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly watch_id: {
+                readonly type: "string";
+                readonly description: "The watch_id returned by veto_watch.";
+            };
+        };
+        readonly required: readonly ["watch_id"];
+    };
+}, {
+    readonly name: "veto_watch_stop";
+    readonly description: "Stops an active file watcher.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly watch_id: {
+                readonly type: "string";
+                readonly description: "The watch_id returned by veto_watch.";
+            };
+        };
+        readonly required: readonly ["watch_id"];
+    };
+}, {
+    readonly name: "veto_ci_gate";
+    readonly description: "CI/CD pipeline gate. Runs code review + security scan + secrets scan on a git diff and returns a structured pass/warn/fail verdict with exit code. Ready for GitHub Actions and GitLab CI.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute project path. Veto reads git diff HEAD automatically.";
+            };
+            readonly diff: {
+                readonly type: "string";
+                readonly description: "Optional: pass a diff string directly instead of reading from project_dir.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Optional: PR description or ticket number for context.";
+            };
+            readonly fail_on: {
+                readonly type: "string";
+                readonly enum: readonly ["warn", "fail"];
+                readonly description: "Whether WARN counts as a failure (exit code 1). Default: \"fail\" — only FAIL exits non-zero.";
+            };
+        };
+        readonly required: readonly ["project_dir"];
+    };
+}, {
+    readonly name: "veto_usage_status";
+    readonly description: "Live AI usage dashboard. Shows tokens consumed today, requests per platform, subscription vs API usage split, 7-day history, and warnings when approaching limits.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_audit_log";
+    readonly description: "Queryable log of every council verdict, decision, and session event. Filter by session, agent, verdict, or date. Essential for tracing what happened and why.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Filter to a specific session.";
+            };
+            readonly verdict: {
+                readonly type: "string";
+                readonly description: "Filter by council verdict (GREEN, YELLOW, RED).";
+            };
+            readonly since: {
+                readonly type: "string";
+                readonly description: "ISO date — only return events after this time.";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Max events to return (default 20, max 100).";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_platform_setup";
+    readonly description: "Returns the exact MCP config and setup steps to connect a specific AI platform to this Veto server.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly platform: {
+                readonly type: "string";
+                readonly enum: readonly ["claude", "gemini", "codex"];
+                readonly description: "The platform to get setup instructions for.";
+            };
+            readonly veto_server_path: {
+                readonly type: "string";
+                readonly description: "Absolute path to the built veto server (dist/server.js).";
+            };
+        };
+        readonly required: readonly ["platform", "veto_server_path"];
+    };
+}, {
+    readonly name: "veto_plugins";
+    readonly description: "Lists all custom agents loaded from ~/.veto/agents/. Drop a .js file there that exports plan(task, context?) to register a new agent available in veto_agent_plan and veto_execute_parallel.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_docs_fetch";
+    readonly description: "Fetches current, version-accurate documentation for any npm, PyPI, or crates.io package and returns it for injection into agent context. Eliminates hallucinated APIs. Results are cached for 24 hours.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Package name (e.g. \"react\", \"requests\", \"serde\").";
+            };
+            readonly ecosystem: {
+                readonly type: "string";
+                readonly enum: readonly ["npm", "pypi", "crates"];
+                readonly description: "Package ecosystem.";
+            };
+            readonly version: {
+                readonly type: "string";
+                readonly description: "Specific version. Defaults to latest.";
+            };
+            readonly max_chars: {
+                readonly type: "number";
+                readonly description: "Max characters to return (default 8000). Higher = more complete docs, more tokens.";
+            };
+        };
+        readonly required: readonly ["package_name", "ecosystem"];
+    };
+}, {
+    readonly name: "veto_explain";
+    readonly description: "Explains a file or raw text using the most appropriate expert agent. Pass file_path to explain a source file, or text to explain an error message, stack trace, or compiler output. Agent is auto-detected from file extension or content.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly file_path: {
+                readonly type: "string";
+                readonly description: "Absolute path to the file to explain.";
+            };
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Raw text to explain — error messages, stack traces, compiler output, or any code snippet. Automatically routes to debugger agent for error-like content.";
+            };
+            readonly depth: {
+                readonly type: "string";
+                readonly enum: readonly ["overview", "detailed", "line-by-line"];
+                readonly description: "Explanation depth. Default: overview.";
+            };
+            readonly context: {
+                readonly type: "string";
+                readonly description: "Optional focus area or context.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_summarize";
+    readonly description: "Generates a concise expert briefing of a project, directory, or file. Use at the start of a session to orient yourself on unfamiliar code. Returns bullet-point summary, key components, tech stack, and entry points. Faster and higher-level than veto_explain.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute path to a project directory to summarize.";
+            };
+            readonly file_path: {
+                readonly type: "string";
+                readonly description: "Absolute path to a single file to summarize. If both project_dir and file_path are given, file_path takes precedence.";
+            };
+            readonly focus: {
+                readonly type: "string";
+                readonly description: "Optional focus area: e.g. \"security\", \"APIs\", \"data flow\", \"architecture\". Narrows the summary.";
+            };
+            readonly format: {
+                readonly type: "string";
+                readonly enum: readonly ["brief", "detailed"];
+                readonly description: "brief: 4–6 bullet points (default). detailed: paragraph-level prose.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_metrics";
+    readonly description: "Returns a usage dashboard for the current Veto installation — sessions saved, council debates, quality trend, most-used agents, and knowledge base stats. Zero cost: pure SQLite reads. Great for a weekly health check.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_git_blame";
+    readonly description: "Returns ownership and contribution history for a file or directory — total commits, contributor list with commit counts, and last-modified metadata. Uses local git history: instant, zero network.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute path to a project directory to analyse.";
+            };
+            readonly file_path: {
+                readonly type: "string";
+                readonly description: "Absolute path to a single file. If both are provided, file_path takes precedence.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "veto_changelog";
+    readonly description: "Generates a structured changelog from git commits since the last tag, grouped by conventional commit type (feat, fix, refactor, etc.). Pure local git — no external calls.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly project_dir: {
+                readonly type: "string";
+                readonly description: "Absolute path to the project directory. Defaults to the active project.";
+            };
+            readonly max_entries: {
+                readonly type: "number";
+                readonly description: "Maximum commits to include (default 50, max 200).";
+            };
+        };
+        readonly required: readonly [];
+    };
+}];
+//# sourceMappingURL=definitions.d.ts.map