@jigyasudham/veto 1.1.0 → 1.2.0

package/dist/memory/local.js

@@ -6,6 +6,12 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { mkdirSync } from 'node:fs';
 import { CREATE_TABLES } from './schema.js';
+// Context window sizes per platform (tokens)
+export const CONTEXT_WINDOWS = {
+    claude: 200_000,
+    gemini: 1_000_000,
+    codex: 128_000,
+};
 const VETO_DIR = join(homedir(), '.veto');
 const DB_PATH = join(VETO_DIR, 'veto.db');
 let _db = null;
@@ -22,7 +28,7 @@ export function getDb() {
     migrateSessionColumns(_db);
     return _db;
 }
-// Adds active_client and last_resumed_at columns if they don't exist
+// Adds active_client, last_resumed_at, and connection_type columns if they don't exist
 function migrateSessionColumns(db) {
     const cols = db.prepare('PRAGMA table_info(sessions)').all();
     const names = new Set(cols.map(c => c.name));
@@ -30,6 +36,8 @@ function migrateSessionColumns(db) {
         db.exec('ALTER TABLE sessions ADD COLUMN active_client TEXT');
     if (!names.has('last_resumed_at'))
         db.exec('ALTER TABLE sessions ADD COLUMN last_resumed_at TEXT');
+    if (!names.has('connection_type'))
+        db.exec("ALTER TABLE sessions ADD COLUMN connection_type TEXT NOT NULL DEFAULT 'subscription'");
 }
 // Adds legal and security columns if they don't exist (Phase 3 → Phase 3.1 migration)
 function migrateCouncilColumns(db) {
@@ -61,12 +69,26 @@ export function saveSession(input) {
     const db = getDb();
     const id = randomUUID();
     const now = new Date().toISOString();
-    const stmt = db.prepare(`
-    INSERT INTO sessions (id, started_at, platform, project_dir, summary, context, task_state, token_count)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-    stmt.run(id, now, input.platform ?? 'claude', input.project_dir ?? null, input.summary ?? null, input.context ? JSON.stringify(input.context) : null, input.task_state ? JSON.stringify(input.task_state) : null, input.token_count ?? 0);
-    return { session_id: id, saved_at: now };
+    const platform = input.platform ?? 'claude';
+    const connection_type = input.connection_type ?? 'subscription';
+    const token_count = input.token_count ?? 0;
+    db.prepare(`
+    INSERT INTO sessions (id, started_at, platform, connection_type, project_dir, summary, context, task_state, token_count)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, now, platform, connection_type, input.project_dir ?? null, input.summary ?? null, input.context ? JSON.stringify(input.context) : null, input.task_state ? JSON.stringify(input.task_state) : null, token_count);
+    // Record usage event
+    db.prepare(`
+    INSERT INTO usage_events (id, session_id, platform, connection_type, tokens, event_type, recorded_at)
+    VALUES (?, ?, ?, ?, ?, 'session_save', ?)
+  `).run(randomUUID(), id, platform, connection_type, token_count, now);
+    // Context window guard
+    const window_size = CONTEXT_WINDOWS[platform] ?? 200_000;
+    const usage_pct = Math.round((token_count / window_size) * 100);
+    const context_warning = usage_pct >= 80;
+    const continuation_prompt = context_warning
+        ? `Session ${id} saved. Context at ${usage_pct}% of ${platform} limit. To continue in a fresh session: call veto_continue { "session_id": "${id}" }`
+        : null;
+    return { session_id: id, saved_at: now, context_warning, usage_pct, continuation_prompt };
 }
 export function restoreSession(session_id, active_client) {
     const db = getDb();
@@ -196,4 +218,198 @@ export function getPatterns(prefix, limit = 20) {
     }
     return db.prepare('SELECT * FROM patterns ORDER BY confidence DESC, seen_count DESC LIMIT ?').all(limit);
 }
+export function getContextStatus(session_id) {
+    const db = getDb();
+    const row = db.prepare('SELECT id, platform, token_count FROM sessions WHERE id = ?').get(session_id);
+    if (!row)
+        return null;
+    const context_window = CONTEXT_WINDOWS[row.platform] ?? 200_000;
+    const usage_pct = Math.round((row.token_count / context_window) * 100);
+    const recommended_action = usage_pct >= 80 ? 'handoff' : usage_pct >= 60 ? 'compress' : 'safe';
+    return { session_id: row.id, platform: row.platform, token_count: row.token_count, context_window, usage_pct, recommended_action };
+}
+// ─── Docs Cache ───────────────────────────────────────────────────────────────
+const DOCS_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+export async function fetchAndCacheDocs(package_name, ecosystem, version, max_chars = 8000) {
+    const db = getDb();
+    // Check cache first
+    const cached = db.prepare('SELECT * FROM docs_cache WHERE package_name = ? AND ecosystem = ? ORDER BY fetched_at DESC LIMIT 1').get(package_name, ecosystem);
+    if (cached) {
+        const age = Date.now() - new Date(cached.fetched_at).getTime();
+        if (age < DOCS_TTL_MS) {
+            return { package_name, version: cached.version, ecosystem, content: cached.content.slice(0, max_chars), cached: true, fetched_at: cached.fetched_at };
+        }
+    }
+    // Fetch from source with 5s timeout
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5000);
+    try {
+        let content = '';
+        let resolved_version = version ?? 'latest';
+        if (ecosystem === 'npm') {
+            const meta = await fetch(`https://registry.npmjs.org/${encodeURIComponent(package_name)}`, { signal: controller.signal });
+            if (!meta.ok)
+                return null;
+            const json = await meta.json();
+            resolved_version = version ?? json['dist-tags']?.['latest'] ?? 'latest';
+            const readme = json['readme'] ?? '';
+            const description = json['description'] ?? '';
+            content = `# ${package_name}@${resolved_version}\n${description}\n\n${readme}`;
+        }
+        else if (ecosystem === 'pypi') {
+            const res = await fetch(`https://pypi.org/pypi/${encodeURIComponent(package_name)}/json`, { signal: controller.signal });
+            if (!res.ok)
+                return null;
+            const json = await res.json();
+            resolved_version = version ?? json.info.version;
+            content = `# ${package_name}@${resolved_version}\n${json.info.summary}\n\n${json.info.description}`;
+        }
+        else {
+            const res = await fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(package_name)}`, {
+                signal: controller.signal,
+                headers: { 'User-Agent': 'veto-mcp/1.1.0' },
+            });
+            if (!res.ok)
+                return null;
+            const json = await res.json();
+            resolved_version = version ?? json.crate.newest_version;
+            content = `# ${package_name}@${resolved_version}\n${json.crate.description}\nDocs: ${json.crate.documentation}`;
+        }
+        const now = new Date().toISOString();
+        db.prepare(`
+      INSERT OR REPLACE INTO docs_cache (id, package_name, ecosystem, version, content, fetched_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(randomUUID(), package_name, ecosystem, resolved_version, content, now);
+        return { package_name, version: resolved_version, ecosystem, content: content.slice(0, max_chars), cached: false, fetched_at: now };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// ─── Task Plans ───────────────────────────────────────────────────────────────
+export function saveTaskPlan(plan_json, description_hash, project_dir) {
+    const db = getDb();
+    const id = randomUUID();
+    db.prepare(`
+    INSERT INTO task_plans (id, description_hash, plan_json, project_dir, created_at)
+    VALUES (?, ?, ?, ?, datetime('now'))
+  `).run(id, description_hash, plan_json, project_dir ?? null);
+    return id;
+}
+export function getUsageStatus() {
+    const db = getDb();
+    const today = new Date().toISOString().slice(0, 10);
+    // Today's requests from rate_usage
+    const rateRows = db.prepare('SELECT platform, request_count FROM rate_usage WHERE date_key = ?').all(today);
+    // Today's tokens + connection_type breakdown from usage_events
+    const eventRows = db.prepare(`
+    SELECT platform, connection_type, SUM(tokens) as total_tokens, COUNT(*) as cnt
+    FROM usage_events
+    WHERE DATE(recorded_at) = ?
+    GROUP BY platform, connection_type
+  `).all(today);
+    const platforms = ['claude', 'gemini', 'codex'];
+    const by_platform = platforms.map(p => {
+        const rate = rateRows.find(r => r.platform === p);
+        const subEvents = eventRows.filter(e => e.platform === p && e.connection_type === 'subscription');
+        const apiEvents = eventRows.filter(e => e.platform === p && e.connection_type === 'api');
+        const tokens = eventRows.filter(e => e.platform === p).reduce((s, e) => s + (e.total_tokens ?? 0), 0);
+        return {
+            platform: p,
+            requests: rate?.request_count ?? 0,
+            tokens_reported: tokens,
+            connection_breakdown: {
+                subscription: subEvents.reduce((s, e) => s + e.cnt, 0),
+                api: apiEvents.reduce((s, e) => s + e.cnt, 0),
+            },
+        };
+    });
+    // Last 7 days history
+    const history = db.prepare(`
+    SELECT DATE(recorded_at) as date, COUNT(*) as total_requests, SUM(tokens) as total_tokens
+    FROM usage_events
+    WHERE recorded_at >= date('now', '-7 days')
+    GROUP BY DATE(recorded_at)
+    ORDER BY date DESC
+  `).all();
+    // Warnings
+    const warnings = [];
+    for (const p of by_platform) {
+        if (p.requests > 0) {
+            const dailyLimit = p.platform === 'gemini' ? 1500 : 500;
+            const pct = Math.round((p.requests / dailyLimit) * 100);
+            if (pct >= 80)
+                warnings.push(`${p.platform} at ${pct}% of estimated daily request limit`);
+        }
+    }
+    return { today: { by_platform }, history, warnings };
+}
+export function getAuditLog(opts = {}) {
+    const db = getDb();
+    const limit = Math.min(opts.limit ?? 20, 100);
+    const events = [];
+    // Council outcomes
+    const councilWhere = ['1=1'];
+    const councilParams = [];
+    if (opts.session_id) {
+        councilWhere.push('session_id = ?');
+        councilParams.push(opts.session_id);
+    }
+    if (opts.verdict) {
+        councilWhere.push('verdict = ?');
+        councilParams.push(opts.verdict);
+    }
+    if (opts.since) {
+        councilWhere.push('debated_at >= ?');
+        councilParams.push(opts.since);
+    }
+    const councilRows = db.prepare(`SELECT id, session_id, task, verdict, recommended, debated_at FROM council_outcomes WHERE ${councilWhere.join(' AND ')} ORDER BY debated_at DESC LIMIT ?`).all(...councilParams, limit);
+    for (const r of councilRows) {
+        if (opts.agent)
+            continue; // council events don't have a single agent
+        events.push({ timestamp: r.debated_at, event_type: 'council', session_id: r.session_id, agent: null, verdict: r.verdict, summary: r.task.slice(0, 100), affected_files: null });
+    }
+    // Decisions
+    const decWhere = ['1=1'];
+    const decParams = [];
+    if (opts.session_id) {
+        decWhere.push('session_id = ?');
+        decParams.push(opts.session_id);
+    }
+    if (opts.since) {
+        decWhere.push('made_at >= ?');
+        decParams.push(opts.since);
+    }
+    const decRows = db.prepare(`SELECT id, session_id, decision, rationale, council_verdict, files_affected, made_at FROM decisions WHERE ${decWhere.join(' AND ')} ORDER BY made_at DESC LIMIT ?`).all(...decParams, limit);
+    for (const r of decRows) {
+        events.push({ timestamp: r.made_at, event_type: 'decision', session_id: r.session_id, agent: null, verdict: r.council_verdict, summary: r.decision.slice(0, 100), affected_files: r.files_affected });
+    }
+    // Sort combined and return limit
+    return events.sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, limit);
+}
+export function getHealthStats() {
+    const db = getDb();
+    const count = (table) => db.prepare(`SELECT COUNT(*) as n FROM ${table}`).get().n;
+    // Avg latency: approximate from 10 most recent council outcomes (debated_at timestamps as proxy)
+    const latencyRows = db.prepare('SELECT debated_at FROM council_outcomes ORDER BY debated_at DESC LIMIT 10').all();
+    let avg_council_latency_ms = null;
+    if (latencyRows.length >= 2) {
+        const diffs = [];
+        for (let i = 0; i < latencyRows.length - 1; i++) {
+            diffs.push(Math.abs(new Date(latencyRows[i].debated_at).getTime() - new Date(latencyRows[i + 1].debated_at).getTime()));
+        }
+        avg_council_latency_ms = Math.round(diffs.reduce((a, b) => a + b, 0) / diffs.length);
+    }
+    return {
+        total_sessions: count('sessions'),
+        total_memories: count('knowledge_base'),
+        total_patterns: count('patterns'),
+        total_council_outcomes: count('council_outcomes'),
+        total_decisions: count('decisions'),
+        avg_council_latency_ms,
+    };
+}
 //# sourceMappingURL=local.js.map

package/dist/memory/schema.js

@@ -8,6 +8,7 @@ export const CREATE_TABLES = `
     platform         TEXT NOT NULL DEFAULT 'claude',
     active_client    TEXT,
     last_resumed_at  TEXT,
+    connection_type  TEXT NOT NULL DEFAULT 'subscription',
     project_dir      TEXT,
     summary          TEXT,
     context          TEXT,
@@ -16,6 +17,34 @@ export const CREATE_TABLES = `
     created_at       TEXT NOT NULL DEFAULT (datetime('now'))
   );
 
+  CREATE TABLE IF NOT EXISTS docs_cache (
+    id           TEXT PRIMARY KEY,
+    package_name TEXT NOT NULL,
+    ecosystem    TEXT NOT NULL,
+    version      TEXT NOT NULL,
+    content      TEXT NOT NULL,
+    fetched_at   TEXT NOT NULL,
+    UNIQUE(package_name, ecosystem, version)
+  );
+
+  CREATE TABLE IF NOT EXISTS task_plans (
+    id               TEXT PRIMARY KEY,
+    description_hash TEXT NOT NULL,
+    plan_json        TEXT NOT NULL,
+    project_dir      TEXT,
+    created_at       TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS usage_events (
+    id              TEXT PRIMARY KEY,
+    session_id      TEXT,
+    platform        TEXT NOT NULL,
+    connection_type TEXT NOT NULL DEFAULT 'subscription',
+    tokens          INTEGER DEFAULT 0,
+    event_type      TEXT NOT NULL DEFAULT 'session_save',
+    recorded_at     TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
   CREATE TABLE IF NOT EXISTS decisions (
     id          TEXT PRIMARY KEY,
     session_id  TEXT NOT NULL,
@@ -114,5 +143,8 @@ export const CREATE_TABLES = `
   CREATE INDEX IF NOT EXISTS idx_knowledge_type       ON knowledge_base(type);
   CREATE INDEX IF NOT EXISTS idx_knowledge_project    ON knowledge_base(project_dir);
   CREATE INDEX IF NOT EXISTS idx_project_map_dir      ON project_map(project_dir);
+  CREATE INDEX IF NOT EXISTS idx_docs_cache_pkg       ON docs_cache(package_name, ecosystem);
+  CREATE INDEX IF NOT EXISTS idx_usage_events_session ON usage_events(session_id);
+  CREATE INDEX IF NOT EXISTS idx_usage_events_date    ON usage_events(recorded_at);
 `;
 //# sourceMappingURL=schema.js.map

package/dist/server.js

@@ -7,7 +7,7 @@ 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, getDbPath, saveCouncilOutcome, storeKnowledge, searchKnowledge, deleteKnowledge, updateProjectMap, getProjectMap, upsertPattern, getPatterns, } from './memory/local.js';
+import { saveSession, restoreSession, listSessions, getDbPath, saveCouncilOutcome, storeKnowledge, searchKnowledge, deleteKnowledge, updateProjectMap, getProjectMap, upsertPattern, getPatterns, getContextStatus, fetchAndCacheDocs, saveTaskPlan, getUsageStatus, getAuditLog, getHealthStats, CONTEXT_WINDOWS, } from './memory/local.js';
 import { exportMemory, importMemory } from './memory/sync.js';
 import { runDebate } from './council/index.js';
 import { routeTask, getRateStatus, recordOutcome, getLearningStats, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights, getRecommendedAgent } from './router/index.js';
@@ -16,13 +16,18 @@ import { handoff, continueSession, getPlatformSetup } from './adapters/index.js'
 import { startWatch, pollWatch, stopWatch } from './watcher/index.js';
 import { runPipeline } from './workflow/pipeline.js';
 import { loadPlugins, listPlugins } from './plugins/loader.js';
-import { readFileSync } from 'node:fs';
+import { readFileSync, statSync } from 'node:fs';
 import { extname, basename } from 'node:path';
-const VERSION = '1.1.0';
+import { createHash } from 'node:crypto';
+const VERSION = '1.2.0';
 // Tracks the project_dir of the most recently active session in this process.
 // Used as a fallback when memory_store/memory_search are called without an explicit project_dir,
 // so memories are automatically scoped to the current project.
 let activeProjectDir = null;
+// Server health tracking
+const SERVER_START_TIME = Date.now();
+let serverErrorCount = 0;
+let lastServerError = null;
 const server = new Server({ name: 'veto', version: VERSION }, {
     capabilities: {
         tools: {},
@@ -69,9 +74,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: 'string',
                         description: 'Absolute path to the current project directory.',
                     },
+                    connection_type: {
+                        type: 'string',
+                        description: 'How you are connected to this AI — "subscription" (Claude Pro, Gemini Advanced) or "api" (API key). Used for usage tracking.',
+                        enum: ['subscription', 'api'],
+                    },
                     token_count: {
                         type: 'number',
-                        description: 'Approximate tokens used this session.',
+                        description: 'Approximate tokens used this session. Veto uses this for context window monitoring.',
                     },
                 },
                 required: ['summary', 'context'],
@@ -578,6 +588,93 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: [],
             },
         },
+        // ── Phase 13: Developer Intelligence ──────────────────────────────────────
+        {
+            name: 'veto_docs_fetch',
+            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.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    package_name: { type: 'string', description: 'Package name (e.g. "react", "requests", "serde").' },
+                    ecosystem: { type: 'string', enum: ['npm', 'pypi', 'crates'], description: 'Package ecosystem.' },
+                    version: { type: 'string', description: 'Specific version. Defaults to latest.' },
+                    max_chars: { type: 'number', description: 'Max characters to return (default 8000). Higher = more complete docs, more tokens.' },
+                },
+                required: ['package_name', 'ecosystem'],
+            },
+        },
+        {
+            name: 'veto_context_status',
+            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.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    session_id: { type: 'string', description: 'Session ID to check.' },
+                },
+                required: ['session_id'],
+            },
+        },
+        {
+            name: 'veto_task_parse',
+            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.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    description: { type: 'string', description: 'Project description, PRD, or feature brief to parse into tasks.' },
+                    project_dir: { type: 'string', description: 'Optional project directory for codebase context injection.' },
+                    max_tasks: { type: 'number', description: 'Maximum number of tasks to generate (default 20).' },
+                },
+                required: ['description'],
+            },
+        },
+        // ── Phase 14: Observability & Safety ──────────────────────────────────────
+        {
+            name: 'veto_usage_status',
+            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.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: 'veto_audit_log',
+            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.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    session_id: { type: 'string', description: 'Filter to a specific session.' },
+                    verdict: { type: 'string', description: 'Filter by council verdict (GREEN, YELLOW, RED).' },
+                    since: { type: 'string', description: 'ISO date — only return events after this time.' },
+                    limit: { type: 'number', description: 'Max events to return (default 20, max 100).' },
+                },
+                required: [],
+            },
+        },
+        {
+            name: 'veto_health',
+            description: 'Returns a live health snapshot of the Veto server — DB size, session/memory/pattern counts, uptime, error count, and average council latency.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        },
+        // ── Phase 15: CI/CD & Distribution ────────────────────────────────────────
+        {
+            name: 'veto_ci_gate',
+            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.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    project_dir: { type: 'string', description: 'Absolute project path. Veto reads git diff HEAD automatically.' },
+                    diff: { type: 'string', description: 'Optional: pass a diff string directly instead of reading from project_dir.' },
+                    context: { type: 'string', description: 'Optional: PR description or ticket number for context.' },
+                    fail_on: { type: 'string', enum: ['warn', 'fail'], description: 'Whether WARN counts as a failure (exit code 1). Default: "fail" — only FAIL exits non-zero.' },
+                },
+                required: ['project_dir'],
+            },
+        },
     ],
 }));
 // ─── Tool Handlers ────────────────────────────────────────────────────────────
@@ -612,21 +709,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 context: String(args?.context ?? ''),
                 task_state: args?.task_state ? String(args.task_state) : undefined,
                 platform: args?.platform ? String(args.platform) : 'claude',
+                connection_type: args?.connection_type ? String(args.connection_type) : 'subscription',
                 project_dir: sessionProjectDir,
                 token_count: typeof args?.token_count === 'number' ? args.token_count : 0,
             });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: 'Session saved. Use this ID to restore on any AI platform.',
-                            ...result,
-                        }, null, 2),
-                    },
-                ],
+            const responseObj = {
+                success: true,
+                message: result.context_warning
+                    ? `⚠️ Context at ${result.usage_pct}% — consider handing off soon.`
+                    : 'Session saved. Use this ID to restore on any AI platform.',
+                session_id: result.session_id,
+                saved_at: result.saved_at,
+                usage_pct: result.usage_pct,
+                context_warning: result.context_warning,
             };
+            if (result.continuation_prompt)
+                responseObj.continuation_prompt = result.continuation_prompt;
+            return { content: [{ type: 'text', text: JSON.stringify(responseObj, null, 2) }] };
         }
         case 'veto_session_restore': {
             const session_id = String(args?.session_id ?? '');
@@ -1242,6 +1341,189 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         case 'veto_plugins': {
             return { content: [{ type: 'text', text: JSON.stringify({ plugins: listPlugins(), plugin_dir: `${process.env.HOME ?? process.env.USERPROFILE}/.veto/agents/`, instructions: 'Drop a .js file exporting plan(task, context?) to register a custom agent.' }, null, 2) }] };
         }
+        // ── Phase 13: Developer Intelligence ──────────────────────────────────────
+        case 'veto_docs_fetch': {
+            const package_name = String(args?.package_name ?? '').trim();
+            const ecosystem = String(args?.ecosystem ?? 'npm');
+            const version = args?.version ? String(args.version) : undefined;
+            const max_chars = typeof args?.max_chars === 'number' ? args.max_chars : 8000;
+            if (!package_name) {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, message: 'package_name is required.' }) }], isError: true };
+            }
+            const result = await fetchAndCacheDocs(package_name, ecosystem, version, max_chars);
+            if (!result) {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, message: `Could not fetch docs for ${package_name} (${ecosystem}). Source may be offline — try again.` }) }], isError: true };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }, null, 2) }] };
+        }
+        case 'veto_context_status': {
+            const session_id = String(args?.session_id ?? '');
+            if (!session_id) {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, message: 'session_id is required.' }) }], isError: true };
+            }
+            const status = getContextStatus(session_id);
+            if (!status) {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, message: `No session found: ${session_id}` }) }], isError: true };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...status }, null, 2) }] };
+        }
+        case 'veto_task_parse': {
+            const description = String(args?.description ?? '').trim();
+            const project_dir = args?.project_dir ? String(args.project_dir) : undefined;
+            const max_tasks = typeof args?.max_tasks === 'number' ? Math.min(args.max_tasks, 50) : 20;
+            if (!description) {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, message: 'description is required.' }) }], isError: true };
+            }
+            const ctx = project_dir ? buildContextString(project_dir) : '';
+            const planResult = await executeOne({ id: 'task-parse-1', agent: 'task-planner', task: `Parse this project description into a structured task breakdown with dependencies and complexity scores (max ${max_tasks} tasks):\n\n${description}`, context: ctx || undefined, project_dir });
+            // Build structured task DAG from planner output
+            const steps = planResult.plan?.steps ?? [];
+            const tasks = steps.slice(0, max_tasks).map((step, i) => ({
+                id: `task-${i + 1}`,
+                title: step,
+                complexity: Math.min(10, Math.max(1, Math.round((i / steps.length) * 10) + 3)),
+                priority: i === 0 ? 'critical' : i < 3 ? 'high' : i < steps.length - 2 ? 'medium' : 'low',
+                depends_on: i > 0 ? [`task-${i}`] : [],
+                suggested_agent: 'coder',
+                estimated_hours: 2,
+            }));
+            const plan = {
+                summary: description.slice(0, 100),
+                total_tasks: tasks.length,
+                total_complexity: tasks.reduce((s, t) => s + t.complexity, 0),
+                critical_path: tasks.map(t => t.id),
+                parallelisable_groups: tasks.length > 2 ? [tasks.slice(1, Math.ceil(tasks.length / 2)).map(t => t.id)] : [],
+                tasks,
+                duration_estimate: planResult.plan?.duration_estimate ?? 'unknown',
+            };
+            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': {
+            const status = getUsageStatus();
+            return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...status }, null, 2) }] };
+        }
+        case 'veto_audit_log': {
+            const events = getAuditLog({
+                session_id: args?.session_id ? String(args.session_id) : undefined,
+                verdict: args?.verdict ? String(args.verdict) : undefined,
+                since: args?.since ? String(args.since) : undefined,
+                limit: typeof args?.limit === 'number' ? args.limit : 20,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify({ success: true, count: events.length, events }, null, 2) }] };
+        }
+        case 'veto_health': {
+            const stats = getHealthStats();
+            let db_size_bytes = 0;
+            try {
+                db_size_bytes = statSync(getDbPath()).size;
+            }
+            catch { /* db may not exist */ }
+            const db_size_human = db_size_bytes < 1024 ? `${db_size_bytes}B`
+                : db_size_bytes < 1048576 ? `${(db_size_bytes / 1024).toFixed(1)}KB`
+                    : `${(db_size_bytes / 1048576).toFixed(1)}MB`;
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            version: VERSION,
+                            status: serverErrorCount > 10 ? 'degraded' : 'healthy',
+                            uptime_seconds: Math.round((Date.now() - SERVER_START_TIME) / 1000),
+                            db_path: getDbPath(),
+                            db_size_bytes,
+                            db_size_human,
+                            error_count_since_start: serverErrorCount,
+                            last_error: lastServerError,
+                            context_windows: CONTEXT_WINDOWS,
+                            ...stats,
+                        }, null, 2),
+                    }],
+            };
+        }
+        // ── Phase 15: CI/CD & Distribution ────────────────────────────────────────
+        case 'veto_ci_gate': {
+            const project_dir = String(args?.project_dir ?? '').trim();
+            const diff_input = args?.diff ? String(args.diff) : undefined;
+            const context = args?.context ? String(args.context) : undefined;
+            const fail_on = args?.fail_on === 'warn' ? 'warn' : 'fail';
+            if (!project_dir) {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, message: 'project_dir is required.' }) }], isError: true };
+            }
+            const start = Date.now();
+            // Read diff if not provided
+            let diff = diff_input;
+            if (!diff) {
+                const { execSync } = await import('node:child_process');
+                try {
+                    diff = execSync('git diff HEAD', { cwd: project_dir, encoding: 'utf8', timeout: 15000 });
+                }
+                catch {
+                    diff = '';
+                }
+            }
+            if (!diff?.trim()) {
+                return { content: [{ type: 'text', text: JSON.stringify({ verdict: 'pass', exit_code: 0, message: 'No changes detected.', duration_ms: Date.now() - start }) }] };
+            }
+            // Run all three checks in parallel
+            const projectCtx = (() => { try {
+                return buildContextString(project_dir);
+            }
+            catch {
+                return '';
+            } })();
+            const fullContext = [context, projectCtx].filter(Boolean).join('\n\n');
+            const [codeResult, secResult, secretsResult] = await Promise.all([
+                executeOne({ id: 'ci-code', agent: 'reviewer', task: `CI code review of this diff:\n\n${diff}`, context: fullContext }),
+                executeOne({ id: 'ci-sec', agent: 'security-scanner', task: `CI security scan of this diff:\n\n${diff}`, context: fullContext }),
+                executeOne({ id: 'ci-secrets', agent: 'secrets', task: `CI secrets scan — check for exposed credentials in this diff:\n\n${diff}`, context: fullContext }),
+            ]);
+            const codeConf = codeResult.output?.confidence ?? 0.8;
+            const secConf = secResult.output?.confidence ?? 0.8;
+            const secretsConf = secretsResult.output?.confidence ?? 1.0;
+            // Determine verdict
+            const hasCritical = codeConf < 0.4 || secConf < 0.4 || secretsConf < 0.5;
+            const hasWarn = codeConf < 0.7 || secConf < 0.6;
+            const rawVerdict = hasCritical ? 'fail' : hasWarn ? 'warn' : 'pass';
+            const verdict = rawVerdict;
+            const exit_code = rawVerdict === 'fail' || (rawVerdict === 'warn' && fail_on === 'warn') ? 1 : 0;
+            const blocking_issues = [];
+            if (codeConf < 0.7)
+                blocking_issues.push(`Code review: ${codeResult.output?.recommendation ?? 'issues found'}`);
+            if (secConf < 0.6)
+                blocking_issues.push(`Security: ${secResult.output?.recommendation ?? 'vulnerabilities detected'}`);
+            if (secretsConf < 0.5)
+                blocking_issues.push(`Secrets: ${secretsResult.output?.recommendation ?? 'potential secrets exposed'}`);
+            const icon = verdict === 'pass' ? '✅' : verdict === 'warn' ? '⚠️' : '❌';
+            const ci_summary = [
+                `${icon} **Veto CI Gate: ${verdict.toUpperCase()}**`,
+                ``,
+                `| Check | Score | Status |`,
+                `|---|---|---|`,
+                `| Code Review | ${Math.round(codeConf * 100)}% | ${codeConf >= 0.7 ? '✅' : '❌'} |`,
+                `| Security Scan | ${Math.round(secConf * 100)}% | ${secConf >= 0.6 ? '✅' : '❌'} |`,
+                `| Secrets Scan | ${Math.round(secretsConf * 100)}% | ${secretsConf >= 0.5 ? '✅' : '❌'} |`,
+                blocking_issues.length > 0 ? `\n**Blocking issues:**\n${blocking_issues.map(i => `- ${i}`).join('\n')}` : '',
+            ].filter(Boolean).join('\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            verdict, exit_code,
+                            checks: {
+                                code_review: { score: Math.round(codeConf * 100) },
+                                security: { score: Math.round(secConf * 100) },
+                                secrets: { score: Math.round(secretsConf * 100) },
+                            },
+                            blocking_issues,
+                            ci_summary,
+                            duration_ms: Date.now() - start,
+                        }, null, 2),
+                    }],
+            };
+        }
         default:
             throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jigyasudham/veto",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "50 agents. 34 tools. 3 AIs. Self-learning. Zero extra cost.",
   "keywords": [
     "mcp",