@jigyasudham/veto 3.0.0 → 3.1.1

package/dist/skills/intelligence/skill-complexity-score.js

@@ -1,66 +0,0 @@
-// Skill: complexity-score — how to write task descriptions that route correctly
-export function run(input) {
-    return {
-        skill: 'complexity-score',
-        template: `
-// ── Complexity Scoring Cheat Sheet ───────────────────────────────────────
-//
-// The router scores 0–100 from five factors:
-//
-// Factor 1: Word count        0–20 pts  (1 pt per 3 words, cap 20)
-// Factor 2: Tech keywords     0–30 pts  HIGH +5, MEDIUM +2
-// Factor 3: Task depth        0–20 pts  conjunctions, commas, length
-// Factor 4: Files affected    0–20 pts  3 pts per file
-// Factor 5: Council bonus     +10 pts   security/auth/migration keywords
-//
-// Tier thresholds (defaults, adjusted by learning loop):
-//   Tier 1: score 0–30   → Haiku / Flash  (fast, cheap)
-//   Tier 2: score 31–70  → Sonnet / Pro   (daily coding)
-//   Tier 3: score 71+    → Sonnet / Advanced  (hard problems)
-//
-// To get a higher tier: add detail, technical keywords, or pass files_affected
-// To get a lower tier: simplify the description or scope down the task
-//
-// Example — under-scored:
-//   "write tests"  →  score 9  →  Tier 1  (too short)
-//
-// Example — correctly scored:
-//   "write unit and integration tests for the JWT auth middleware, covering
-//    token expiry, refresh rotation, and concurrent request edge cases"
-//   →  score 47  →  Tier 2
-//
-// Example — correctly scored, high complexity:
-//   "migrate user authentication from session cookies to JWT with refresh
-//    token rotation — update middleware, session store, and all auth tests"
-//   →  score 78  →  Tier 3 (contains 'migrate', 'authentication', 'jwt')
-`.trim(),
-        checklist: [
-            'Call veto_route_task to see the current score before submitting a task',
-            'If the score is too low: add technical keywords and more specific detail to the description',
-            'If the score is too high: simplify the description or split into sub-tasks',
-            'Pass files_affected if the task touches multiple files — adds 3 pts per file',
-            'Use force_council=true to bypass scoring and go straight to Tier 3',
-            'After completing a task: call veto_record_outcome with the actual quality (0–100)',
-            'After 20+ outcomes: call veto_learning_apply to update the router thresholds',
-        ],
-        patterns: [
-            'Specificity → score: more specific descriptions score higher and route to better models',
-            'Keyword density: security/auth/migration keywords add +5 each and trigger council',
-            'files_affected multiplier: 5 files = +12 pts — use this for multi-file refactors',
-            'Outcome feedback: recording actuals enables the learning loop to tune thresholds over time',
-        ],
-        gotchas: [
-            'Short task descriptions under-score — "fix auth bug" scores ~9, Tier 1 is almost certainly wrong for auth',
-            'The learning loop needs 20 outcomes before it adjusts thresholds — the router is static until then',
-            'force_council=true always routes to Tier 3 regardless of score — use sparingly',
-            'Council auto-triggers on: architecture, security, auth, migration, drop table — you cannot suppress this',
-        ],
-        resources: [
-            'veto_route_task — score a task and see the tier before submitting',
-            'veto_record_outcome — record output quality to feed the learning loop',
-            'veto_learning_apply — apply learned thresholds after 20+ recorded outcomes',
-            'veto_learning_stats — see current tier distribution and suggested thresholds',
-        ],
-    };
-}
-//# sourceMappingURL=skill-complexity-score.js.map

package/dist/skills/intelligence/skill-complexity-score.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-complexity-score.js","sourceRoot":"","sources":["../../../src/skills/intelligence/skill-complexity-score.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAKhF,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,kBAAkB;QACzB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Bb,CAAC,IAAI,EAAE;QACJ,SAAS,EAAE;YACT,wEAAwE;YACxE,6FAA6F;YAC7F,4EAA4E;YAC5E,8EAA8E;YAC9E,oEAAoE;YACpE,mFAAmF;YACnF,8EAA8E;SAC/E;QACD,QAAQ,EAAE;YACR,yFAAyF;YACzF,mFAAmF;YACnF,kFAAkF;YAClF,4FAA4F;SAC7F;QACD,OAAO,EAAE;YACP,2GAA2G;YAC3G,oGAAoG;YACpG,gFAAgF;YAChF,0GAA0G;SAC3G;QACD,SAAS,EAAE;YACT,mEAAmE;YACnE,uEAAuE;YACvE,4EAA4E;YAC5E,8EAA8E;SAC/E;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/intelligence/skill-cost-track.d.ts

@@ -1,14 +0,0 @@
-export interface SkillInput {
-    task: string;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-export interface SkillOutput {
-    skill: string;
-    checklist: string[];
-    patterns: string[];
-    gotchas: string[];
-    resources: string[];
-}
-export declare function run(input: SkillInput): SkillOutput;
-//# sourceMappingURL=skill-cost-track.d.ts.map

package/dist/skills/intelligence/skill-cost-track.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-cost-track.d.ts","sourceRoot":"","sources":["../../../src/skills/intelligence/skill-cost-track.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAAE;AAClG,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;CAAE;AAEhI,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAiClD"}

package/dist/skills/intelligence/skill-cost-track.js

@@ -1,36 +0,0 @@
-// Skill: cost-track — monitor and reduce AI token spend and infrastructure costs
-export function run(input) {
-    return {
-        skill: 'cost-track',
-        checklist: [
-            'Call veto_learning_stats to see the current Tier 1/2/3 distribution',
-            'A healthy distribution is roughly 40% T1 / 45% T2 / 15% T3 — more T3 than this is expensive',
-            'Identify tasks that are routed to Tier 3 but could be Tier 2 with a better description',
-            'Call veto_rate_status to check current daily usage % per platform',
-            'If Claude is above 70%: T1/T2 tasks are already auto-routing to Gemini — verify this is working',
-            'Call veto_agent_performance_stats to identify agents with low quality scores — they waste tokens on retries',
-            'Record task outcomes via veto_record_outcome — this is the only way to measure actual cost/quality ratio',
-            'After 20+ outcomes: call veto_learning_apply — learned thresholds reduce over-routing to expensive tiers',
-            'Monthly: export veto_memory_export and review knowledge base size — prune irrelevant entries',
-        ],
-        patterns: [
-            'Tier distribution monitoring: T3% × avg_T3_tokens = the main cost driver',
-            'Outcome recording: quality data enables threshold calibration which directly reduces cost',
-            'Rate limit utilisation: 70–90% is healthy; under 30% means you are paying for unused capacity',
-            'Context compression: veto_route_task with context= returns a compression plan — use it',
-        ],
-        gotchas: [
-            'Not recording outcomes — the learning loop cannot calibrate without quality data',
-            'Treating all Tier 3 tasks as justified — many are there because of a short description, not actual complexity',
-            'Ignoring context compression — a 15,000 token context costs 10× more than a compressed 1,500 token context',
-            'Optimising AI cost while ignoring developer time — developer time is almost always the larger cost',
-        ],
-        resources: [
-            'veto_learning_stats — current tier distribution and suggested thresholds',
-            'veto_rate_status — daily usage % per platform',
-            'veto_learning_apply — apply learned thresholds to reduce over-routing',
-            'veto_record_outcome — record output quality to feed the cost/quality calibration loop',
-        ],
-    };
-}
-//# sourceMappingURL=skill-cost-track.js.map

package/dist/skills/intelligence/skill-cost-track.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-cost-track.js","sourceRoot":"","sources":["../../../src/skills/intelligence/skill-cost-track.ts"],"names":[],"mappings":"AAAA,iFAAiF;AAKjF,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,YAAY;QACnB,SAAS,EAAE;YACT,qEAAqE;YACrE,6FAA6F;YAC7F,wFAAwF;YACxF,mEAAmE;YACnE,iGAAiG;YACjG,6GAA6G;YAC7G,0GAA0G;YAC1G,0GAA0G;YAC1G,8FAA8F;SAC/F;QACD,QAAQ,EAAE;YACR,0EAA0E;YAC1E,2FAA2F;YAC3F,+FAA+F;YAC/F,wFAAwF;SACzF;QACD,OAAO,EAAE;YACP,kFAAkF;YAClF,+GAA+G;YAC/G,4GAA4G;YAC5G,oGAAoG;SACrG;QACD,SAAS,EAAE;YACT,0EAA0E;YAC1E,+CAA+C;YAC/C,uEAAuE;YACvE,uFAAuF;SACxF;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/intelligence/skill-learning-loop.d.ts

@@ -1,15 +0,0 @@
-export interface SkillInput {
-    task: string;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-export interface SkillOutput {
-    skill: string;
-    template?: string;
-    checklist: string[];
-    patterns: string[];
-    gotchas: string[];
-    resources: string[];
-}
-export declare function run(input: SkillInput): SkillOutput;
-//# sourceMappingURL=skill-learning-loop.d.ts.map

package/dist/skills/intelligence/skill-learning-loop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-learning-loop.d.ts","sourceRoot":"","sources":["../../../src/skills/intelligence/skill-learning-loop.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAAE;AAClG,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;CAAE;AAEnJ,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CA+DlD"}

package/dist/skills/intelligence/skill-learning-loop.js

@@ -1,66 +0,0 @@
-// Skill: learning-loop — how to feed outcome data back into the router and agents
-export function run(input) {
-    return {
-        skill: 'learning-loop',
-        template: `
-// ── Learning Loop Protocol ────────────────────────────────────────────────
-//
-// The router gets smarter when you record task outcomes.
-// Without outcome data, thresholds stay at the default 30/70 forever.
-//
-// Step 1: Complete a task
-//
-// Step 2: Score the output quality (0–100):
-//   90–100  Excellent — exactly what was needed, no revision required
-//   70–89   Good — minor revisions needed
-//   50–69   Acceptable — significant revision needed but usable
-//   30–49   Poor — required a full rewrite
-//   0–29    Failed — output was wrong or harmful
-//
-// Step 3: Record via veto_record_outcome:
-//   {
-//     task_type: "write-auth-middleware",  // short label, consistent naming helps
-//     complexity: 58,                      // from veto_route_task result
-//     model_tier: 2,                       // tier that was actually used
-//     agent: "coder",                      // agent type used
-//     output_quality: 87,                  // your score
-//     tokens_used: 1240                    // optional but useful
-//   }
-//
-// Step 4: After 20+ outcomes: call veto_learning_apply
-//   The router reads the quality data and adjusts tier1_max and tier2_max
-//   Adjustment is conservative — it needs 20+ data points to act
-//
-// Step 5: Check veto_learning_stats to see what changed
-`.trim(),
-        checklist: [
-            'Record every task outcome, not just the bad ones — the loop needs both successes and failures',
-            'Use consistent task_type labels across sessions (e.g. "write-unit-tests" not "tests")',
-            'Score output quality honestly — over-reporting quality prevents threshold improvement',
-            'Include tokens_used when possible — this feeds cost/quality optimisation',
-            'Call veto_learning_apply after every 10 new outcomes to keep thresholds current',
-            'Call veto_learning_stats monthly to review the tier distribution and agent performance',
-            'If an agent consistently scores below 70%: check veto_agent_performance_stats for patterns',
-            'Council insights: review veto_council_insights monthly to see if any GREEN verdicts led to debugging',
-        ],
-        patterns: [
-            'Consistent labelling: task_type labels that vary prevent pattern detection ("test" vs "write-tests" vs "unit-tests" are invisible to the loop)',
-            'Regular application: apply thresholds every 10 outcomes — waiting for 100 delays improvement by months',
-            'Quality honesty: the loop self-corrects only when quality scores reflect reality',
-            'Council correlation: the council insights loop needs decisions logged with veto_memory_store to work',
-        ],
-        gotchas: [
-            'Only recording failures — a loop trained on failures sees everything as over-tiered',
-            'Inconsistent task_type labels — "auth", "authentication", "write-auth" look like three different task types',
-            'Not calling veto_learning_apply — recording outcomes without applying has zero effect on routing',
-            'Applying thresholds with fewer than 20 data points — results will be noisy and unreliable',
-        ],
-        resources: [
-            'veto_record_outcome — record a task quality score',
-            'veto_learning_apply — apply recorded outcomes to adjust tier thresholds',
-            'veto_learning_stats — view tier distribution, agent performance, and suggested thresholds',
-            'veto_council_insights — review council decisions correlated with debugging sessions',
-        ],
-    };
-}
-//# sourceMappingURL=skill-learning-loop.js.map

package/dist/skills/intelligence/skill-learning-loop.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-learning-loop.js","sourceRoot":"","sources":["../../../src/skills/intelligence/skill-learning-loop.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAKlF,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,eAAe;QACtB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Bb,CAAC,IAAI,EAAE;QACJ,SAAS,EAAE;YACT,+FAA+F;YAC/F,uFAAuF;YACvF,uFAAuF;YACvF,0EAA0E;YAC1E,iFAAiF;YACjF,wFAAwF;YACxF,4FAA4F;YAC5F,sGAAsG;SACvG;QACD,QAAQ,EAAE;YACR,gJAAgJ;YAChJ,wGAAwG;YACxG,kFAAkF;YAClF,sGAAsG;SACvG;QACD,OAAO,EAAE;YACP,qFAAqF;YACrF,6GAA6G;YAC7G,kGAAkG;YAClG,2FAA2F;SAC5F;QACD,SAAS,EAAE;YACT,mDAAmD;YACnD,yEAAyE;YACzE,2FAA2F;YAC3F,qFAAqF;SACtF;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/intelligence/skill-pattern-detect.d.ts

@@ -1,14 +0,0 @@
-export interface SkillInput {
-    task: string;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-export interface SkillOutput {
-    skill: string;
-    checklist: string[];
-    patterns: string[];
-    gotchas: string[];
-    resources: string[];
-}
-export declare function run(input: SkillInput): SkillOutput;
-//# sourceMappingURL=skill-pattern-detect.d.ts.map

package/dist/skills/intelligence/skill-pattern-detect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-pattern-detect.d.ts","sourceRoot":"","sources":["../../../src/skills/intelligence/skill-pattern-detect.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAAE;AAClG,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;CAAE;AAEhI,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAgClD"}

package/dist/skills/intelligence/skill-pattern-detect.js

@@ -1,35 +0,0 @@
-// Skill: pattern-detect — find repeated patterns and anti-patterns in a codebase
-export function run(input) {
-    return {
-        skill: 'pattern-detect',
-        checklist: [
-            'Call veto_patterns_list to load all stored coding patterns before scanning',
-            'Scan the 5 most recently modified files for structural patterns (not style — structure)',
-            'Look for: repeated try/catch shapes, recurring if/else chains, duplicated utility logic',
-            'Look for anti-patterns: N+1 loops, empty catch blocks, hardcoded magic strings/numbers',
-            'Compare found patterns against stored patterns — update confidence via veto_pattern_store',
-            'New patterns not yet stored: add via veto_pattern_store with a category.name key format',
-            'Anti-patterns found: flag them via veto_memory_store (type="pattern", title="Anti-pattern: X")',
-            'After scanning: call veto_agent_plan with agent="pattern-learner" for deeper style analysis',
-        ],
-        patterns: [
-            'Structure over style: detect structural patterns (how code is organised) not style (how it is formatted)',
-            'Frequency threshold: a pattern seen in 3+ files is established; seen in 1–2 files is tentative',
-            'Anti-pattern distinction: store anti-patterns separately with "Anti-pattern:" title prefix',
-            'Confidence accumulation: every confirmed observation of a pattern increments its confidence score',
-        ],
-        gotchas: [
-            'Detecting style instead of structure — style is enforced by a linter; pattern detection adds no value there',
-            'Flagging intentional deviations as anti-patterns — some files deliberately break the pattern (e.g. test fixtures)',
-            'Not updating stored patterns when the codebase evolves — stale patterns mislead future agents',
-            'Storing too-specific patterns ("function X uses this exact shape") vs. too-generic ("uses functions")',
-        ],
-        resources: [
-            'veto_patterns_list — list all stored patterns with confidence scores',
-            'veto_pattern_store — add or update a pattern',
-            'veto_memory_store (type="pattern") — store anti-patterns and architectural patterns',
-            'veto_agent_plan with agent="pattern-learner" — deeper coding style analysis',
-        ],
-    };
-}
-//# sourceMappingURL=skill-pattern-detect.js.map

package/dist/skills/intelligence/skill-pattern-detect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-pattern-detect.js","sourceRoot":"","sources":["../../../src/skills/intelligence/skill-pattern-detect.ts"],"names":[],"mappings":"AAAA,iFAAiF;AAKjF,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,gBAAgB;QACvB,SAAS,EAAE;YACT,4EAA4E;YAC5E,yFAAyF;YACzF,yFAAyF;YACzF,wFAAwF;YACxF,2FAA2F;YAC3F,yFAAyF;YACzF,gGAAgG;YAChG,6FAA6F;SAC9F;QACD,QAAQ,EAAE;YACR,0GAA0G;YAC1G,gGAAgG;YAChG,4FAA4F;YAC5F,mGAAmG;SACpG;QACD,OAAO,EAAE;YACP,6GAA6G;YAC7G,mHAAmH;YACnH,+FAA+F;YAC/F,uGAAuG;SACxG;QACD,SAAS,EAAE;YACT,sEAAsE;YACtE,8CAA8C;YAC9C,qFAAqF;YACrF,6EAA6E;SAC9E;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/intelligence/skill-rate-watch.d.ts

@@ -1,15 +0,0 @@
-export interface SkillInput {
-    task: string;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-export interface SkillOutput {
-    skill: string;
-    template?: string;
-    checklist: string[];
-    patterns: string[];
-    gotchas: string[];
-    resources: string[];
-}
-export declare function run(input: SkillInput): SkillOutput;
-//# sourceMappingURL=skill-rate-watch.d.ts.map

package/dist/skills/intelligence/skill-rate-watch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-rate-watch.d.ts","sourceRoot":"","sources":["../../../src/skills/intelligence/skill-rate-watch.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAAE;AAClG,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;CAAE;AAEnJ,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAuDlD"}

package/dist/skills/intelligence/skill-rate-watch.js

@@ -1,58 +0,0 @@
-// Skill: rate-watch — monitor AI rate limits and trigger platform switches proactively
-export function run(input) {
-    return {
-        skill: 'rate-watch',
-        template: `
-// ── Rate Limit Thresholds ─────────────────────────────────────────────────
-//
-//  0–69%   Green zone  — normal routing, no action needed
-// 70–89%   Warning     — Tier 1/2 auto-routes to Gemini/Codex
-//                        Tier 3 stays on Claude (too important to downgrade)
-// 90%+     Critical    — all tasks routed to Gemini/Codex
-//                        Non-urgent work queued for reset
-//
-// Cross-platform switch (manual):
-//
-//   Claude at 90%+ mid-task?
-//   1. Call veto_session_save (capture current state)
-//   2. Note the session ID
-//   3. Open Gemini terminal
-//   4. Call veto_session_restore {session_id}
-//   5. Continue — Gemini has full context
-//   Total interruption: under 10 seconds
-//
-// All platforms at limit simultaneously?
-//   Check veto_rate_status for reset times
-//   Work on tasks that don't need AI (docs, planning, code review checklists)
-//   Auto-resumes when first platform resets
-`.trim(),
-        checklist: [
-            'Call veto_rate_status at the start of long sessions to check headroom',
-            'At 70%: start Tier 1/2 tasks on Gemini/Codex proactively instead of waiting for auto-routing',
-            'At 80%: save the current session via veto_session_save as a precaution',
-            'At 90%: switch platform manually using veto_session_save → veto_session_restore',
-            'At 100%: check reset times from veto_rate_status, switch to non-AI tasks until reset',
-            'After a platform switch: verify the session restored correctly before continuing',
-            'Prefer Gemini for T1/T2 overflow — it has higher rate limits on the free tier',
-        ],
-        patterns: [
-            'Proactive switch at 80%: switching before hitting 90% avoids a mid-task interruption',
-            'Session save at 70%: ensures context is preserved if a hard limit is hit unexpectedly',
-            'Platform diversity: using two platforms in parallel halves the effective rate limit pressure',
-            'Tier-based overflow: only T1/T2 overflow — never route T3 to a lower-capability model',
-        ],
-        gotchas: [
-            'Switching platforms without saving the session — the receiving platform starts blind',
-            'Routing Tier 3 tasks to Gemini Flash or Haiku to avoid rate limits — quality loss is not worth it',
-            'Not checking rate status before a long task — hitting the limit mid-migration is high risk',
-            'Forgetting that rate limits reset daily at midnight UTC — a limit today may reset in 2 hours',
-        ],
-        resources: [
-            'veto_rate_status — current usage % and advisory for all platforms',
-            'veto_route_task — routes tasks to the least-loaded platform automatically',
-            'veto_session_save — save context before switching platforms',
-            'veto_session_restore — restore on the receiving platform',
-        ],
-    };
-}
-//# sourceMappingURL=skill-rate-watch.js.map

package/dist/skills/intelligence/skill-rate-watch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-rate-watch.js","sourceRoot":"","sources":["../../../src/skills/intelligence/skill-rate-watch.ts"],"names":[],"mappings":"AAAA,uFAAuF;AAKvF,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,YAAY;QACnB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;CAuBb,CAAC,IAAI,EAAE;QACJ,SAAS,EAAE;YACT,uEAAuE;YACvE,8FAA8F;YAC9F,wEAAwE;YACxE,iFAAiF;YACjF,sFAAsF;YACtF,kFAAkF;YAClF,+EAA+E;SAChF;QACD,QAAQ,EAAE;YACR,sFAAsF;YACtF,uFAAuF;YACvF,8FAA8F;YAC9F,uFAAuF;SACxF;QACD,OAAO,EAAE;YACP,sFAAsF;YACtF,mGAAmG;YACnG,4FAA4F;YAC5F,8FAA8F;SAC/F;QACD,SAAS,EAAE;YACT,mEAAmE;YACnE,2EAA2E;YAC3E,6DAA6D;YAC7D,0DAA0D;SAC3D;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/memory/skill-context-compress.d.ts

@@ -1,15 +0,0 @@
-export interface SkillInput {
-    task: string;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-export interface SkillOutput {
-    skill: string;
-    template?: string;
-    checklist: string[];
-    patterns: string[];
-    gotchas: string[];
-    resources: string[];
-}
-export declare function run(input: SkillInput): SkillOutput;
-//# sourceMappingURL=skill-context-compress.d.ts.map

package/dist/skills/memory/skill-context-compress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-context-compress.d.ts","sourceRoot":"","sources":["../../../src/skills/memory/skill-context-compress.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AA2CD,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAuClD"}

package/dist/skills/memory/skill-context-compress.js

@@ -1,82 +0,0 @@
-// Skill: context-compress — when and how to compress context before model calls
-const TEMPLATE = `
-// ── Context Compression Protocol ─────────────────────────────────────────
-//
-// Apply when token count > 8,000 or before any cross-platform handoff.
-// Target: < 30% of original token count, zero loss of active constraints.
-//
-// Compression tiers:
-//
-// TIER 1 — Keep verbatim (never compress):
-//   - Active blockers that require human input
-//   - Open decisions that have not been resolved
-//   - File paths of files currently being modified
-//   - The single next action
-//   - Error messages that have not been diagnosed
-//
-// TIER 2 — Compress to 1–3 sentences:
-//   - Completed subtasks (collapse to "✓ Implemented X")
-//   - Read-back confirmations ("confirmed the file exists")
-//   - Resolved blockers ("fixed: dependency conflict — used --legacy-peer-deps")
-//   - Prior session context (collapse to a 2-sentence progress summary)
-//
-// TIER 3 — Drop entirely:
-//   - Superseded decisions (replaced by a newer ADR)
-//   - Files read but not modified and not needed going forward
-//   - Exploratory steps that led to dead ends and have been abandoned
-//   - Console output that has already been analyzed
-//
-// Compressed context shape:
-{
-  "phase": "implementing",
-  "completed": ["Brief one-liner per completed subtask"],
-  "inProgress": "The exact current subtask in one sentence",
-  "remaining": ["Ordered list of remaining subtasks"],
-  "activeConstraints": ["Each constraint in one sentence"],
-  "openDecisions": [{ "question": "...", "options": ["A", "B"] }],
-  "blockers": ["Any current blocker with full detail"],
-  "keyFiles": ["Only files still needed going forward"],
-  "nextAction": "Single concrete step — unambiguous"
-}
-`.trim();
-export function run(input) {
-    return {
-        skill: 'context-compress',
-        template: TEMPLATE,
-        checklist: [
-            'Measure the current context token estimate before compressing',
-            'Apply compression only when token count exceeds 8,000 or before a platform handoff',
-            'Identify Tier 1 items first — these are never touched',
-            'Identify Tier 3 items — drop them completely without summarising',
-            'For Tier 2 items: write one sentence per completed subtask; the reader does not need the history',
-            'Preserve the full text of any active blocker — the receiving agent must understand it in full',
-            'Preserve the nextAction as a concrete step, not "continue the task"',
-            'After compressing: verify the compressed context is complete by simulating a cold-start agent reading it',
-            'Save the compressed context via veto_session_save before switching context',
-            'Target a compression ratio of at least 3:1 — if you cannot achieve this, you have too many Tier 1 items',
-            'Do not compress active error messages — they need full context to diagnose',
-            'Do not summarise open decisions — they need all options preserved',
-        ],
-        patterns: [
-            'Tier-based compression: verbatim | summarise | drop — never binary keep/delete',
-            'Cold-start test: can a fresh agent read the compressed context and continue the task without questions?',
-            'Constraint-first ordering: active constraints at the top, history at the bottom',
-            'Forward-only compression: compress backward-looking content, not forward-looking content',
-        ],
-        gotchas: [
-            'Compressing active constraints as if they were completed work — causes silent violations in the next session',
-            'Summarising blockers instead of preserving them verbatim — the receiving agent gets a vague summary and cannot resolve the blocker',
-            'Dropping unresolved error messages — the receiving agent restarts diagnosis from scratch',
-            'Targeting a fixed token count without checking completeness — may cut load-bearing context',
-            'Not saving the compressed context — the compression is lost on the next context switch',
-            'Treating all prior session content as droppable — some prior-session decisions are still active constraints',
-        ],
-        resources: [
-            'Use veto_route_task with context= to get the router\'s compression estimate',
-            'Use veto_session_save to persist the compressed context',
-            'Use veto_memory_store to permanently record key decisions before they are compressed away',
-            'The compression target is based on the router\'s context-compressor module heuristics',
-        ],
-    };
-}
-//# sourceMappingURL=skill-context-compress.js.map

package/dist/skills/memory/skill-context-compress.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-context-compress.js","sourceRoot":"","sources":["../../../src/skills/memory/skill-context-compress.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAiBhF,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuChB,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,kBAAkB;QACzB,QAAQ,EAAE,QAAQ;QAClB,SAAS,EAAE;YACT,+DAA+D;YAC/D,oFAAoF;YACpF,uDAAuD;YACvD,kEAAkE;YAClE,kGAAkG;YAClG,+FAA+F;YAC/F,qEAAqE;YACrE,0GAA0G;YAC1G,4EAA4E;YAC5E,yGAAyG;YACzG,4EAA4E;YAC5E,mEAAmE;SACpE;QACD,QAAQ,EAAE;YACR,gFAAgF;YAChF,yGAAyG;YACzG,iFAAiF;YACjF,0FAA0F;SAC3F;QACD,OAAO,EAAE;YACP,8GAA8G;YAC9G,oIAAoI;YACpI,0FAA0F;YAC1F,4FAA4F;YAC5F,wFAAwF;YACxF,6GAA6G;SAC9G;QACD,SAAS,EAAE;YACT,6EAA6E;YAC7E,yDAAyD;YACzD,2FAA2F;YAC3F,uFAAuF;SACxF;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/memory/skill-cross-sync.d.ts

@@ -1,15 +0,0 @@
-export interface SkillInput {
-    task: string;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-export interface SkillOutput {
-    skill: string;
-    template?: string;
-    checklist: string[];
-    patterns: string[];
-    gotchas: string[];
-    resources: string[];
-}
-export declare function run(input: SkillInput): SkillOutput;
-//# sourceMappingURL=skill-cross-sync.d.ts.map

package/dist/skills/memory/skill-cross-sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-cross-sync.d.ts","sourceRoot":"","sources":["../../../src/skills/memory/skill-cross-sync.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAmDD,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAqClD"}

package/dist/skills/memory/skill-cross-sync.js

@@ -1,88 +0,0 @@
-// Skill: cross-sync — how to move veto memory between machines using file export/import
-const TEMPLATE = `
-// ── Cross-Machine Memory Transfer ────────────────────────────────────────
-//
-// Veto stores everything in ~/.veto/veto.db (SQLite).
-// To continue work on another machine: export → copy → import.
-//
-// No external services. No accounts. No env vars.
-//
-// ── Step 1: Export on Machine A ───────────────────────────────────────────
-//
-//   veto_memory_export
-//   → writes to ~/.veto/veto-export.json by default
-//   → or specify output_path to write directly to shared storage
-//
-//   Example with shared storage:
-//   veto_memory_export { output_path: "/Users/you/Dropbox/veto-export.json" }
-//
-// ── Step 2: Copy the file ─────────────────────────────────────────────────
-//
-//   Options (pick any):
-//   • Dropbox / OneDrive / Google Drive — put output_path in your sync folder
-//   • USB drive
-//   • scp / rsync over SSH
-//   • Email / messaging app
-//   • AirDrop (Mac)
-//
-// ── Step 3: Import on Machine B ───────────────────────────────────────────
-//
-//   veto_memory_import { input_path: "/path/to/veto-export.json" }
-//   → merges into local ~/.veto/veto.db
-//   → INSERT OR IGNORE — local rows are never overwritten
-//   → returns { merged: {...}, skipped: {...} } showing what was added
-//
-// ── Step 4: Verify and resume ─────────────────────────────────────────────
-//
-//   veto_sessions_list           — confirm sessions arrived
-//   veto_session_restore { id }  — load the session you want to continue
-//   veto_memory_search { query } — confirm knowledge base arrived
-//
-// ── What gets exported ────────────────────────────────────────────────────
-//
-//   sessions         — all saved sessions with task state and context
-//   decisions        — all logged decisions and rationale
-//   knowledge_base   — all stored solutions, patterns, errors, references
-//   patterns         — coding style and convention patterns
-//   project_map      — codebase structure maps
-//   council_outcomes — all council debate results
-`.trim();
-export function run(input) {
-    return {
-        skill: 'cross-sync',
-        template: TEMPLATE,
-        checklist: [
-            'Before leaving Machine A: call veto_memory_export to create the export file',
-            'Check the export result — confirm row counts look right for sessions and knowledge_base',
-            'Copy the export file to Machine B via any method (Dropbox, USB, scp, etc.)',
-            'On Machine B: call veto_memory_import with the file path',
-            'Check the import result — merged counts show what was added, skipped counts show duplicates',
-            'Call veto_sessions_list to confirm the sessions you need are present',
-            'Call veto_session_restore with the session ID to load your prior context',
-            'Call veto_memory_search to confirm knowledge base entries are available',
-            'If working across multiple machines regularly: use a shared folder (Dropbox) as output_path so no manual copy is needed',
-            'After significant work on Machine B: run veto_memory_export again before switching back',
-        ],
-        patterns: [
-            'Export-before-switch: always export before ending a session, not only when switching machines',
-            'Shared-folder shortcut: point output_path at a Dropbox/OneDrive folder — no manual copy step',
-            'Merge semantics: INSERT OR IGNORE means both machines can export/import in any order without data loss',
-            'Verify-after-import: always call veto_sessions_list after import to confirm data arrived before starting work',
-        ],
-        gotchas: [
-            'Forgetting to export before switching — Machine B starts with no memory of Machine A\'s work',
-            'Importing a stale export (from yesterday) — you lose today\'s work on Machine A; always export fresh',
-            'The export file is plain JSON — it contains your session context. Don\'t commit it to a public git repo',
-            'Pattern merge adds seen_counts from both machines — this is intentional (more observations = higher confidence)',
-            'INSERT OR IGNORE means if Machine B already has a session with the same ID, it is not updated. Export fresh from Machine A if you need the latest version of a session',
-        ],
-        resources: [
-            'veto_memory_export — export all memory to JSON (default path: ~/.veto/veto-export.json)',
-            'veto_memory_import — import and merge JSON into local SQLite',
-            'veto_sessions_list — verify sessions after import',
-            'veto_session_restore — load a specific session to resume work',
-            'veto_memory_search — verify knowledge base after import',
-        ],
-    };
-}
-//# sourceMappingURL=skill-cross-sync.js.map

package/dist/skills/memory/skill-cross-sync.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-cross-sync.js","sourceRoot":"","sources":["../../../src/skills/memory/skill-cross-sync.ts"],"names":[],"mappings":"AAAA,wFAAwF;AAiBxF,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+ChB,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,YAAY;QACnB,QAAQ,EAAE,QAAQ;QAClB,SAAS,EAAE;YACT,6EAA6E;YAC7E,yFAAyF;YACzF,4EAA4E;YAC5E,0DAA0D;YAC1D,6FAA6F;YAC7F,sEAAsE;YACtE,0EAA0E;YAC1E,yEAAyE;YACzE,yHAAyH;YACzH,yFAAyF;SAC1F;QACD,QAAQ,EAAE;YACR,+FAA+F;YAC/F,8FAA8F;YAC9F,wGAAwG;YACxG,+GAA+G;SAChH;QACD,OAAO,EAAE;YACP,8FAA8F;YAC9F,sGAAsG;YACtG,yGAAyG;YACzG,iHAAiH;YACjH,wKAAwK;SACzK;QACD,SAAS,EAAE;YACT,yFAAyF;YACzF,8DAA8D;YAC9D,mDAAmD;YACnD,+DAA+D;YAC/D,yDAAyD;SAC1D;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/memory/skill-decision-log.d.ts

@@ -1,15 +0,0 @@
-export interface SkillInput {
-    task: string;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-export interface SkillOutput {
-    skill: string;
-    template?: string;
-    checklist: string[];
-    patterns: string[];
-    gotchas: string[];
-    resources: string[];
-}
-export declare function run(input: SkillInput): SkillOutput;
-//# sourceMappingURL=skill-decision-log.d.ts.map

package/dist/skills/memory/skill-decision-log.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-decision-log.d.ts","sourceRoot":"","sources":["../../../src/skills/memory/skill-decision-log.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AA+DD,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAwClD"}