@jigyasudham/veto 0.8.0

package/dist/router/complexity-scorer.js

@@ -0,0 +1,78 @@
+// Scores a task description 0-100 locally — zero tokens spent
+// 5 pts each — strong signal of high complexity
+const HIGH_KEYWORDS = [
+    'architecture', 'security', 'authenticat', 'authorizat', 'migrat',
+    'refactor', 'scalab', 'concurrent', 'distributed', 'oauth', 'jwt',
+    'rbac', 'encryption', 'cryptograph', 'penetration', 'vulnerabilit',
+    'infrastructure', 'compliance', 'performance',
+];
+// 2 pts each — moderate complexity signal
+const MEDIUM_KEYWORDS = [
+    'component', 'function', 'test', 'api', 'database', 'query', 'schema',
+    'deploy', 'docker', 'implement', 'build', 'feature', 'module',
+    'service', 'endpoint', 'integration', 'configuration',
+];
+// Council is always required for these topics
+const COUNCIL_TRIGGERS = [
+    'architecture', 'security', 'auth', 'migrat', 'vulnerabilit',
+    'encryption', 'infrastructure', 'breaking change', 'drop table',
+    'delete all', 'remove all',
+];
+export function scoreComplexity(task, filesAffected = 1, forceCouncil = false, thresholds) {
+    const TIER1_MAX = thresholds?.tier1_max ?? 30;
+    const TIER2_MAX = thresholds?.tier2_max ?? 70;
+    const lower = task.toLowerCase();
+    const words = lower.split(/\s+/).filter(Boolean);
+    // Factor 1: word count → 0-20 pts (1 pt per 3 words, cap 20)
+    const word_count_score = Math.min(20, Math.floor(words.length / 3));
+    // Factor 2: technical keywords → 0-30 pts
+    let keyword_score = 0;
+    let council_required = forceCouncil;
+    for (const word of words) {
+        for (const kw of HIGH_KEYWORDS) {
+            if (word.includes(kw)) {
+                keyword_score += 5;
+                break;
+            }
+        }
+        for (const kw of MEDIUM_KEYWORDS) {
+            if (word.includes(kw)) {
+                keyword_score += 2;
+                break;
+            }
+        }
+    }
+    for (const trigger of COUNCIL_TRIGGERS) {
+        if (lower.includes(trigger)) {
+            council_required = true;
+            break;
+        }
+    }
+    keyword_score = Math.min(30, keyword_score);
+    // Factor 3: task depth → 0-20 pts (conjunctions, length, multi-step)
+    let depth_score = 0;
+    if (lower.includes(' and ') || lower.includes(' with '))
+        depth_score += 5;
+    if (lower.includes(',') || lower.includes(' plus '))
+        depth_score += 5;
+    if (words.length > 20)
+        depth_score += 5;
+    if (words.length > 40)
+        depth_score += 5;
+    depth_score = Math.min(20, depth_score);
+    // Factor 4: files affected → 0-20 pts
+    const files_score = Math.min(20, (filesAffected - 1) * 3);
+    // Factor 5: council bonus — pushes score into Tier 3 territory
+    const council_bonus = council_required ? 10 : 0;
+    const raw = word_count_score + keyword_score + depth_score + files_score + council_bonus;
+    // Council tasks always land in Tier 3 — floor at 71
+    const score = Math.min(100, council_required ? Math.max(71, raw) : raw);
+    const tier = score <= TIER1_MAX ? 1 : score <= TIER2_MAX ? 2 : 3;
+    return {
+        score,
+        tier,
+        factors: { word_count_score, keyword_score, depth_score, files_score, council_bonus },
+        council_required,
+    };
+}
+//# sourceMappingURL=complexity-scorer.js.map

package/dist/router/context-compressor.js

@@ -0,0 +1,58 @@
+// Trims context before model calls to avoid wasting tokens
+// Thresholds from VETO_VISION_FINAL.md:
+//   < 2k tokens  → passthrough
+//   2k-8k tokens → compress (drop irrelevant sections)
+//   > 8k tokens  → hard-compress (tail + file references only)
+// Rough 4-chars-per-token estimate — good enough for routing decisions
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function extractRelevantSections(context, relevantFiles) {
+    if (relevantFiles.length === 0)
+        return context;
+    const lines = context.split('\n');
+    const kept = [];
+    let inRelevant = false;
+    for (const line of lines) {
+        const isHeader = /^(---|===|##|#)/.test(line.trim());
+        if (isHeader) {
+            inRelevant = relevantFiles.some((f) => line.includes(f));
+        }
+        if (inRelevant || relevantFiles.some((f) => line.includes(f))) {
+            kept.push(line);
+        }
+    }
+    return kept.length > 0 ? kept.join('\n') : context;
+}
+function hardCompress(context, relevantFiles) {
+    const lines = context.split('\n');
+    const fileRefs = relevantFiles.length > 0
+        ? lines.filter((l) => relevantFiles.some((f) => l.includes(f)))
+        : [];
+    const tail = lines.slice(-50);
+    const combined = [...new Set([...fileRefs, ...tail])];
+    return combined.join('\n');
+}
+export function compressContext(context, relevantFiles = []) {
+    const original_tokens = estimateTokens(context);
+    let strategy;
+    let content;
+    if (original_tokens < 2000) {
+        strategy = 'passthrough';
+        content = context;
+    }
+    else if (original_tokens < 8000) {
+        strategy = 'compress';
+        content = extractRelevantSections(context, relevantFiles);
+    }
+    else {
+        strategy = 'hard-compress';
+        content = hardCompress(context, relevantFiles);
+    }
+    const compressed_tokens = estimateTokens(content);
+    const compression_ratio = original_tokens > 0
+        ? Math.round((1 - compressed_tokens / original_tokens) * 100) / 100
+        : 0;
+    return { original_tokens, compressed_tokens, compression_ratio, content, strategy };
+}
+//# sourceMappingURL=context-compressor.js.map

package/dist/router/index.js

@@ -0,0 +1,29 @@
+// Router entry point — composes all sub-modules into a single routeTask() call
+import { scoreComplexity } from './complexity-scorer.js';
+import { selectModel } from './model-selector.js';
+import { getRateStatus, trackRequest, getRoutingAdvice } from './rate-monitor.js';
+import { compressContext, estimateTokens } from './context-compressor.js';
+import { recordOutcome, getLearningStats, getLearnedThresholds, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights } from './learning-updater.js';
+export { estimateTokens, getRateStatus, trackRequest, recordOutcome, getLearningStats, getLearnedThresholds, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights };
+export function routeTask(task, options = {}) {
+    const learned = getLearnedThresholds();
+    const complexity = scoreComplexity(task, options.filesAffected, options.forceCouncil, learned.source === 'learned' ? learned : undefined);
+    const model = selectModel(complexity.score, options.agentType ?? 'dynamic');
+    const preferred = options.preferredPlatform ?? 'claude';
+    // Only shift Tier 1/2 away from Claude on warning; Tier 3 always stays on best model
+    const effective_platform = model.tier === 3 ? preferred : getRoutingAdvice(preferred);
+    trackRequest(effective_platform);
+    const rate_status = getRateStatus();
+    const context_plan = options.context
+        ? compressContext(options.context, options.relevantFiles ?? [])
+        : undefined;
+    return {
+        complexity,
+        model,
+        rate_status,
+        context_plan,
+        effective_platform,
+        routed_at: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/router/learning-updater.js

@@ -0,0 +1,186 @@
+// Records routing outcomes to SQLite and adjusts tier thresholds from historical quality data
+import { randomUUID } from 'node:crypto';
+import { getDb } from '../memory/local.js';
+// ─── Record ───────────────────────────────────────────────────────────────────
+export function recordOutcome(taskType, complexity, modelTier, agent, outputQuality, tokensUsed = 0) {
+    const db = getDb();
+    db.prepare(`INSERT INTO learning_data (id, task_type, complexity, model_tier, output_quality, tokens_used, agent)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), taskType, complexity, modelTier, outputQuality, tokensUsed, agent);
+}
+// ─── Stats ────────────────────────────────────────────────────────────────────
+export function getLearningStats() {
+    const db = getDb();
+    const rows = db.prepare(`SELECT model_tier, COUNT(*) as count, AVG(output_quality) as avg_quality
+     FROM learning_data GROUP BY model_tier`).all();
+    const total_tasks = rows.reduce((sum, r) => sum + r.count, 0);
+    const tier_breakdown = {};
+    for (const r of rows) {
+        tier_breakdown[r.model_tier] = {
+            count: r.count,
+            avg_quality: Math.round((r.avg_quality ?? 0) * 100) / 100,
+        };
+    }
+    const thresholds = computeSuggestedThresholds(tier_breakdown);
+    return { total_tasks, tier_breakdown, suggested_thresholds: thresholds };
+}
+export function getAgentPerformanceStats() {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT agent,
+           COUNT(*) as task_count,
+           AVG(output_quality) as avg_quality,
+           AVG(tokens_used) as avg_tokens,
+           SUM(CASE WHEN output_quality < 60 THEN 1 ELSE 0 END) as low_quality_count
+    FROM learning_data
+    WHERE agent IS NOT NULL
+    GROUP BY agent
+    ORDER BY avg_quality ASC
+  `).all();
+    return rows.map(r => ({
+        agent: r.agent,
+        task_count: r.task_count,
+        avg_quality: Math.round(r.avg_quality * 10) / 10,
+        avg_tokens: Math.round(r.avg_tokens),
+        low_quality_count: r.low_quality_count,
+        needs_attention: r.avg_quality < 70 || (r.low_quality_count / r.task_count) > 0.25,
+    }));
+}
+export function getTaskTypeBreakdown() {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT task_type,
+           COUNT(*) as count,
+           AVG(complexity) as avg_complexity,
+           AVG(output_quality) as avg_quality,
+           model_tier as dominant_tier
+    FROM learning_data
+    GROUP BY task_type, model_tier
+    HAVING COUNT(*) = (
+      SELECT MAX(c) FROM (
+        SELECT COUNT(*) as c FROM learning_data l2
+        WHERE l2.task_type = learning_data.task_type
+        GROUP BY l2.model_tier
+      )
+    )
+    ORDER BY count DESC
+    LIMIT 50
+  `).all();
+    return rows.map(r => {
+        // Under-tiered: task scored high quality but at a tier below what complexity suggests
+        const expectedTier = r.avg_complexity <= 30 ? 1 : r.avg_complexity <= 70 ? 2 : 3;
+        const under_tiered = r.dominant_tier < expectedTier && r.avg_quality < 70;
+        return {
+            task_type: r.task_type,
+            count: r.count,
+            avg_complexity: Math.round(r.avg_complexity),
+            avg_quality: Math.round(r.avg_quality * 10) / 10,
+            dominant_tier: r.dominant_tier,
+            under_tiered,
+        };
+    });
+}
+export function getCouncilInsights() {
+    const db = getDb();
+    // Correlate council approvals (GREEN/YELLOW) with debugging sessions that came after
+    const rows = db.prepare(`
+    SELECT co.verdict, co.task, co.debated_at,
+           d.decision as related_decision, d.made_at as decision_at
+    FROM council_outcomes co
+    LEFT JOIN decisions d ON d.session_id = co.session_id
+      AND d.decision LIKE '%debug%' OR d.decision LIKE '%fix%' OR d.decision LIKE '%bug%'
+    WHERE co.verdict IN ('GREEN', 'YELLOW')
+    ORDER BY co.debated_at DESC
+    LIMIT 30
+  `).all();
+    return rows.map(r => {
+        let days_to_debug = null;
+        if (r.decision_at) {
+            const debated = new Date(r.debated_at).getTime();
+            const decided = new Date(r.decision_at).getTime();
+            days_to_debug = Math.round((decided - debated) / (1000 * 60 * 60 * 24));
+        }
+        return {
+            verdict: r.verdict,
+            task_snippet: r.task.substring(0, 80),
+            debated_at: r.debated_at,
+            days_to_debug,
+            related_decision: r.related_decision,
+        };
+    });
+}
+// ─── Threshold Computation ────────────────────────────────────────────────────
+function computeSuggestedThresholds(tier_breakdown) {
+    const t1 = tier_breakdown[1];
+    const t2 = tier_breakdown[2];
+    const t3 = tier_breakdown[3];
+    let tier1_max = 30;
+    let tier2_max = 70;
+    // Tier 2 consistently great → can handle more tasks, raise Tier 1 ceiling slightly
+    if (t2 && t2.count >= 20 && t2.avg_quality >= 88)
+        tier1_max = 35;
+    // Tier 2 quality poor → tighten Tier 1 ceiling (fewer tasks escape to T2)
+    if (t2 && t2.count >= 10 && t2.avg_quality < 65)
+        tier1_max = 25;
+    // Tier 3 consistently great → can push harder tasks to T3, lower T2 ceiling
+    if (t3 && t3.count >= 10 && t3.avg_quality >= 88)
+        tier2_max = 65;
+    // Tier 3 quality poor → be more conservative, raise T2 ceiling (keep more in T2)
+    if (t3 && t3.count >= 10 && t3.avg_quality < 65)
+        tier2_max = 75;
+    // Tier 1 quality poor → lower its ceiling (fewer tasks stay at T1)
+    if (t1 && t1.count >= 10 && t1.avg_quality < 65)
+        tier1_max = Math.max(20, tier1_max - 5);
+    return { tier1_max, tier2_max };
+}
+// ─── Apply ────────────────────────────────────────────────────────────────────
+export function applyLearnedThresholds() {
+    const db = getDb();
+    const total = db.prepare('SELECT COUNT(*) as c FROM learning_data').get().c;
+    // Need at least 20 data points before adjusting
+    if (total < 20) {
+        return {
+            applied: false,
+            thresholds: { tier1_max: 30, tier2_max: 70 },
+            data_points: total,
+            reason: `Not enough data yet. Need 20 task outcomes, have ${total}. Record outcomes via veto_record_outcome.`,
+        };
+    }
+    const stats = getLearningStats();
+    const { tier1_max, tier2_max } = stats.suggested_thresholds;
+    // Persist to patterns table so the router picks them up on next call
+    const now = new Date().toISOString();
+    for (const [key, val] of [['router.tier1_max', String(tier1_max)], ['router.tier2_max', String(tier2_max)]]) {
+        const existing = db.prepare('SELECT id FROM patterns WHERE pattern_key = ?').get(key);
+        if (existing) {
+            db.prepare('UPDATE patterns SET pattern_val = ?, updated_at = ? WHERE pattern_key = ?').run(val, now, key);
+        }
+        else {
+            db.prepare('INSERT INTO patterns (id, pattern_key, pattern_val, confidence, seen_count, updated_at) VALUES (?, ?, ?, ?, ?, ?)')
+                .run(randomUUID(), key, val, 1.0, total, now);
+        }
+    }
+    return {
+        applied: true,
+        thresholds: { tier1_max, tier2_max },
+        data_points: total,
+        reason: `Thresholds updated from ${total} task outcomes. Default was 30/70; learned is ${tier1_max}/${tier2_max}.`,
+    };
+}
+export function getLearnedThresholds() {
+    const db = getDb();
+    const t1row = db.prepare('SELECT pattern_val, seen_count FROM patterns WHERE pattern_key = ?').get('router.tier1_max');
+    const t2row = db.prepare('SELECT pattern_val, seen_count FROM patterns WHERE pattern_key = ?').get('router.tier2_max');
+    if (!t1row || !t2row) {
+        return { tier1_max: 30, tier2_max: 70, source: 'default', data_points: 0 };
+    }
+    return {
+        tier1_max: parseInt(t1row.pattern_val, 10),
+        tier2_max: parseInt(t2row.pattern_val, 10),
+        source: 'learned',
+        data_points: t1row.seen_count,
+    };
+}
+export function getSuggestedThresholds() {
+    return getLearningStats().suggested_thresholds;
+}
+//# sourceMappingURL=learning-updater.js.map

package/dist/router/model-selector.js

@@ -0,0 +1,51 @@
+// Assigns Tier 1/2/3 and specific model recommendations
+// Some agents are permanently locked to a tier regardless of complexity score
+const TIER3_LOCKED = new Set([
+    'lead-developer', 'system-architect', 'security-scanner',
+    'devil-advocate', 'decision-engine', 'risk-assessor',
+]);
+const TIER2_LOCKED = new Set([
+    'coder', 'tester', 'reviewer', 'database', 'documentation',
+]);
+const TIER1_LOCKED = new Set([
+    'file-manager', 'git-agent', 'search-agent', 'secrets', 'reporter',
+]);
+const TIER_MODELS = {
+    1: { claude: 'claude-haiku-4-5', gemini: 'gemini-2.0-flash', codex: 'gpt-4o-mini' },
+    2: { claude: 'claude-sonnet-4-6', gemini: 'gemini-2.0-pro', codex: 'gpt-4o' },
+    3: { claude: 'claude-sonnet-4-6', gemini: 'gemini-2.0-advanced', codex: 'gpt-4o' },
+};
+export function selectModel(complexityScore, agentType = 'dynamic') {
+    if (TIER3_LOCKED.has(agentType)) {
+        return {
+            tier: 3,
+            models: TIER_MODELS[3],
+            reason: `${agentType} is always Tier 3 — stakes too high for cheaper models`,
+            agent_locked: true,
+        };
+    }
+    if (TIER2_LOCKED.has(agentType)) {
+        return {
+            tier: 2,
+            models: TIER_MODELS[2],
+            reason: `${agentType} is always Tier 2 — balanced complexity`,
+            agent_locked: true,
+        };
+    }
+    if (TIER1_LOCKED.has(agentType)) {
+        return {
+            tier: 1,
+            models: TIER_MODELS[1],
+            reason: `${agentType} is always Tier 1 — simple structured operations`,
+            agent_locked: true,
+        };
+    }
+    const tier = complexityScore <= 30 ? 1 : complexityScore <= 70 ? 2 : 3;
+    const reason = tier === 1
+        ? `Score ${complexityScore}/100 — simple task, use fastest/cheapest model`
+        : tier === 2
+            ? `Score ${complexityScore}/100 — mid-range task, use balanced model`
+            : `Score ${complexityScore}/100 — complex task, use best available model`;
+    return { tier, models: TIER_MODELS[tier], reason, agent_locked: false };
+}
+//# sourceMappingURL=model-selector.js.map

package/dist/router/rate-monitor.js

@@ -0,0 +1,73 @@
+// Tracks request counts per platform per day, exposes routing advice
+// Veto cannot read actual API rate limits — it tracks its own routed requests
+// and lets users configure their daily limits in patterns table
+import { randomUUID } from 'node:crypto';
+import { getDb } from '../memory/local.js';
+const DEFAULT_LIMITS = {
+    claude: 100,
+    gemini: 200,
+    codex: 150,
+};
+function getTodayKey() {
+    return new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+}
+function getNextResetISO() {
+    const reset = new Date();
+    reset.setUTCHours(0, 0, 0, 0);
+    reset.setUTCDate(reset.getUTCDate() + 1);
+    return reset.toISOString();
+}
+export function trackRequest(platform, count = 1) {
+    const db = getDb();
+    const today = getTodayKey();
+    const existing = db.prepare('SELECT id, request_count FROM rate_usage WHERE platform = ? AND date_key = ?').get(platform, today);
+    if (existing) {
+        db.prepare('UPDATE rate_usage SET request_count = ?, updated_at = ? WHERE id = ?').run(existing.request_count + count, new Date().toISOString(), existing.id);
+    }
+    else {
+        db.prepare('INSERT INTO rate_usage (id, platform, date_key, request_count) VALUES (?, ?, ?, ?)').run(randomUUID(), platform, today, count);
+    }
+}
+function getRequestCount(platform) {
+    const db = getDb();
+    const row = db.prepare('SELECT request_count FROM rate_usage WHERE platform = ? AND date_key = ?').get(platform, getTodayKey());
+    return row?.request_count ?? 0;
+}
+function buildEntry(platform) {
+    const requests_today = getRequestCount(platform);
+    const daily_limit = DEFAULT_LIMITS[platform];
+    const used_percent = Math.min(100, Math.round((requests_today / daily_limit) * 100));
+    let status;
+    if (used_percent >= 90)
+        status = 'critical';
+    else if (used_percent >= 70)
+        status = 'warning';
+    else
+        status = 'normal';
+    return { platform, requests_today, daily_limit, used_percent, resets_at: getNextResetISO(), status };
+}
+export function getRateStatus() {
+    return {
+        claude: buildEntry('claude'),
+        gemini: buildEntry('gemini'),
+        codex: buildEntry('codex'),
+        updated_at: new Date().toISOString(),
+    };
+}
+// Returns a fallback platform when the preferred one is at warning/critical level
+export function getRoutingAdvice(preferred) {
+    const entry = buildEntry(preferred);
+    if (entry.status === 'critical') {
+        if (preferred === 'claude')
+            return 'gemini';
+        if (preferred === 'gemini')
+            return 'codex';
+        return 'claude';
+    }
+    if (entry.status === 'warning' && preferred === 'claude') {
+        // Tier 1+2 tasks shift to Gemini; caller decides based on tier
+        return 'gemini';
+    }
+    return preferred;
+}
+//# sourceMappingURL=rate-monitor.js.map