@jigyasudham/veto 3.1.0 → 3.1.2

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"}

package/dist/skills/memory/skill-decision-log.js

@@ -1,103 +0,0 @@
-// Skill: decision-log — guide to logging architectural and design decisions
-const TEMPLATE = `
-// ── Decision Log Entry ────────────────────────────────────────────────────
-//
-// Use this template for any decision that is:
-//   - Non-obvious (a reasonable engineer could choose differently)
-//   - Hard to reverse (schema changes, API contracts, auth architecture)
-//   - Frequently re-discussed (keeps relitigating the same debate)
-//   - A deliberate trade-off (performance vs correctness, simplicity vs flexibility)
-//
-{
-  "id": "ADR-001",                        // Sequential ID for referencing
-  "title": "Use JWT with rotating refresh tokens for authentication",
-  "status": "accepted",                   // proposed | accepted | deprecated | superseded-by:ADR-xxx
-  "date": "2026-05-01",
-  "deciders": ["agent:auth", "human:alice"],
-
-  "context": "We need an authentication mechanism for a stateless REST API that will be consumed by a mobile app and a web SPA. Session cookies are not ideal for the mobile client.",
-
-  "decision": "Implement stateless JWTs for access (15-minute TTL) with rotating refresh tokens stored server-side in a database table.",
-
-  "rationale": "JWTs allow stateless verification on every request without a DB lookup. Refresh token rotation limits the window of token theft. httpOnly cookies for refresh tokens prevent XSS access.",
-
-  "alternatives": [
-    {
-      "option": "Server-side sessions with Redis",
-      "pros": ["Instant revocation", "No JWT complexity"],
-      "cons": ["Requires Redis infrastructure", "Not stateless — every request hits Redis", "Mobile clients struggle with cookie-based sessions"],
-      "rejected_because": "Adds Redis dependency; poor fit for mobile client"
-    },
-    {
-      "option": "Long-lived JWTs with no refresh",
-      "pros": ["Simple implementation"],
-      "cons": ["Cannot revoke without infrastructure", "Long-lived tokens are a large attack window"],
-      "rejected_because": "Unacceptable security risk if token is stolen"
-    }
-  ],
-
-  "consequences": {
-    "positive": [
-      "Stateless verification — no DB lookup per request",
-      "Refresh token rotation limits theft window to 15 minutes",
-      "Mobile and web clients use the same auth mechanism"
-    ],
-    "negative": [
-      "Access tokens cannot be revoked before expiry (15-minute window)",
-      "Requires refresh token table with periodic cleanup job",
-      "More complex than simple sessions"
-    ],
-    "neutral": [
-      "JWT library (jsonwebtoken) must be kept up to date for security patches"
-    ]
-  },
-
-  "references": [
-    "OWASP Authentication Cheat Sheet: https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html",
-    "RFC 6749 OAuth 2.0 Bearer Tokens",
-    "Related implementation: src/services/auth.service.ts"
-  ]
-}
-`.trim();
-export function run(input) {
-    return {
-        skill: 'decision-log',
-        template: TEMPLATE,
-        checklist: [
-            'Log the decision as soon as it is made — memory fades quickly and context is lost',
-            'Assign a sequential ID (ADR-001, ADR-002) to enable referencing in code comments and PRs',
-            'Write the context section first: describe the forces and constraints that made a choice necessary',
-            'State the decision explicitly and unambiguously — one clear sentence of what was decided',
-            'Document the rationale: why this option over the alternatives?',
-            'List at least two alternatives that were genuinely considered, not just strawmen',
-            'For each alternative, record pros, cons, and the specific reason it was rejected',
-            'Document positive, negative, and neutral consequences of the chosen option',
-            'Set the status field: proposed → accepted → deprecated or superseded-by:ADR-xxx',
-            'Add file references so future engineers can find the implementation',
-            'Reference the decision ID in relevant code comments: // See ADR-001',
-            'Store the decision log in docs/decisions/ or as a session memory entry',
-            'Update the status to "deprecated" or "superseded" when the decision changes — never delete',
-            'Review the decision log when revisiting a design — check if the original constraints still apply',
-        ],
-        patterns: [
-            'Architecture Decision Record (ADR) format: context → decision → rationale → alternatives → consequences',
-            'Decision-in-context: link from code to the decision that explains the design choice',
-            'Living document: update status when decisions change rather than deleting entries',
-            'Lightweight ADR: one file per decision, stored in git alongside the code it describes',
-        ],
-        gotchas: [
-            'Writing the decision without the rationale — future engineers will not know why, only what',
-            'Only documenting the chosen option without listing alternatives — looks like no thought went into it',
-            'Not updating stale decisions — a deprecated decision still marked "accepted" causes confusion',
-            'Writing the ADR after the fact with the benefit of hindsight — capture the original thinking at decision time',
-            'Logging trivial decisions — reserve the log for non-obvious choices; not every variable name needs an ADR',
-        ],
-        resources: [
-            'https://adr.github.io/ (Architectural Decision Records overview)',
-            'https://github.com/joelparkerhenderson/architecture-decision-record (templates and examples)',
-            'https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions (original Michael Nygard post)',
-            'https://www.thoughtworks.com/radar/techniques/lightweight-architecture-decision-records',
-        ],
-    };
-}
-//# sourceMappingURL=skill-decision-log.js.map

package/dist/skills/memory/skill-decision-log.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-decision-log.js","sourceRoot":"","sources":["../../../src/skills/memory/skill-decision-log.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAiB5E,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DhB,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,cAAc;QACrB,QAAQ,EAAE,QAAQ;QAClB,SAAS,EAAE;YACT,mFAAmF;YACnF,0FAA0F;YAC1F,mGAAmG;YACnG,0FAA0F;YAC1F,gEAAgE;YAChE,kFAAkF;YAClF,kFAAkF;YAClF,4EAA4E;YAC5E,iFAAiF;YACjF,qEAAqE;YACrE,qEAAqE;YACrE,wEAAwE;YACxE,4FAA4F;YAC5F,kGAAkG;SACnG;QACD,QAAQ,EAAE;YACR,yGAAyG;YACzG,qFAAqF;YACrF,mFAAmF;YACnF,uFAAuF;SACxF;QACD,OAAO,EAAE;YACP,4FAA4F;YAC5F,sGAAsG;YACtG,+FAA+F;YAC/F,+GAA+G;YAC/G,2GAA2G;SAC5G;QACD,SAAS,EAAE;YACT,kEAAkE;YAClE,8FAA8F;YAC9F,yGAAyG;YACzG,yFAAyF;SAC1F;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/memory/skill-session-restore.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-session-restore.d.ts.map

package/dist/skills/memory/skill-session-restore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-session-restore.d.ts","sourceRoot":"","sources":["../../../src/skills/memory/skill-session-restore.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;AAED,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAoClD"}

package/dist/skills/memory/skill-session-restore.js

@@ -1,39 +0,0 @@
-// Skill: session-restore — guide to restoring context from a saved session
-export function run(input) {
-    return {
-        skill: 'session-restore',
-        template: undefined,
-        checklist: [
-            'Call veto_sessions_list to find available sessions; pick the most recent one matching your task',
-            'Call veto_session_restore with the session_id — read the resume_instructions field first',
-            'Trust the restored context. Do NOT re-read source files to orient yourself — that defeats session restore and wastes tokens',
-            'Read task_state.nextAction (or context.nextAction) — that is your starting instruction, execute it directly',
-            'Read decisions[] to understand constraints already made — do not revisit them without cause',
-            'Read progress.completed to know what is done — do not redo this work',
-            'Read progress.remaining to know what is left before you start',
-            'Only open a file if you are about to EDIT it — not to "familiarize yourself" or "verify" it',
-            'If you find a file has changed since the save (e.g. a function is missing), read only that file, note the discrepancy, and continue',
-            'Save a new checkpoint after restore so future sessions start from your updated state, not the old one',
-        ],
-        patterns: [
-            'Trust-then-act: the saved session is your context — start working from nextAction immediately',
-            'Read-only-to-edit: only read a file when you are about to change it, never for orientation',
-            'Stale-signal: if restored context mentions a symbol that does not exist, read only that file to reconcile',
-            'Checkpoint-on-restore: always save a new session immediately after restoring so the next session is current',
-        ],
-        gotchas: [
-            'Re-reading the whole codebase after restore — this is the token-waste the tool exists to prevent; do not do it',
-            'Ignoring resume_instructions and falling back to default "read all files" behavior',
-            'Picking the wrong session when multiple tasks are in progress — check the task/summary field carefully',
-            'Not saving a new checkpoint after restore — the next session will start from the old stale state',
-            'Acting on a session saved in "blocked" state without first resolving the listed blocker',
-        ],
-        resources: [
-            'Use the veto_session_restore MCP tool: { sessionId } → returns full session object',
-            'Use the veto_sessions_list MCP tool: returns all sessions sorted by updatedAt',
-            'Use the veto_session_save MCP tool after restoration to record the new starting point',
-            'MCP Session spec: https://modelcontextprotocol.io/docs/concepts/resources',
-        ],
-    };
-}
-//# sourceMappingURL=skill-session-restore.js.map

package/dist/skills/memory/skill-session-restore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-session-restore.js","sourceRoot":"","sources":["../../../src/skills/memory/skill-session-restore.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAiB3E,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,iBAAiB;QACxB,QAAQ,EAAE,SAAS;QACnB,SAAS,EAAE;YACT,iGAAiG;YACjG,0FAA0F;YAC1F,6HAA6H;YAC7H,6GAA6G;YAC7G,6FAA6F;YAC7F,sEAAsE;YACtE,+DAA+D;YAC/D,6FAA6F;YAC7F,qIAAqI;YACrI,uGAAuG;SACxG;QACD,QAAQ,EAAE;YACR,+FAA+F;YAC/F,4FAA4F;YAC5F,2GAA2G;YAC3G,6GAA6G;SAC9G;QACD,OAAO,EAAE;YACP,gHAAgH;YAChH,oFAAoF;YACpF,wGAAwG;YACxG,kGAAkG;YAClG,yFAAyF;SAC1F;QACD,SAAS,EAAE;YACT,oFAAoF;YACpF,+EAA+E;YAC/E,uFAAuF;YACvF,2EAA2E;SAC5E;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/memory/skill-session-save.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-session-save.d.ts.map

package/dist/skills/memory/skill-session-save.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-session-save.d.ts","sourceRoot":"","sources":["../../../src/skills/memory/skill-session-save.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;AAqCD,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAqClD"}

package/dist/skills/memory/skill-session-save.js

@@ -1,74 +0,0 @@
-// Skill: session-save — when and how to save MCP sessions
-const TEMPLATE = `
-// ── What to include in a session save ────────────────────────────────────
-//
-// A session save should capture enough context so that a future agent
-// can resume work without re-reading all the source files.
-//
-// Recommended session object shape:
-{
-  "task": "The original task description in one sentence",
-  "phase": "planning | implementing | reviewing | blocked | complete",
-  "progress": {
-    "completed": ["List of finished subtasks or files written"],
-    "inProgress": ["Current subtask being worked on"],
-    "remaining": ["Subtasks still to do"]
-  },
-  "decisions": [
-    {
-      "decision": "What was decided",
-      "rationale": "Why this approach was chosen",
-      "alternatives": ["Other options that were considered"],
-      "timestamp": "ISO 8601 timestamp"
-    }
-  ],
-  "findings": [
-    "Any important discoveries that affect future work",
-    "File paths of key files that were read or modified",
-    "Patterns or constraints discovered in the codebase"
-  ],
-  "blockers": [
-    "Anything preventing progress that needs human input"
-  ],
-  "nextAction": "The single most important next step to resume work"
-}
-`.trim();
-export function run(input) {
-    return {
-        skill: 'session-save',
-        template: TEMPLATE,
-        checklist: [
-            'Preferred: call veto_session_save { auto_summarize: true } — Veto reads the full conversation and generates the structured summary, context, and task_state for you. No manual writing needed.',
-            'Save at the start of every new significant phase: planning, implementing, reviewing',
-            'Save after completing each major file or subtask — checkpoint before moving to the next',
-            'Save before any risky operation (file overwrites, schema migrations, destructive commands)',
-            'Save immediately when a blocker is encountered that requires human input',
-            'Save when token context is getting large — a compact save enables a fresh continuation',
-            'If writing manually (auto_summarize: false): nextAction MUST be a concrete, file-specific instruction the NEXT AI can execute WITHOUT reading any files first — e.g. "Edit src/server.ts line 302 — add zod .max(2000) on summary field"',
-            'If writing manually: include only the specific file paths you actually modified, not a general codebase list',
-            'If writing manually: include enough inline context that the restoring AI does not need to re-read those files',
-            'Include blockers: anything requiring human action before work can continue',
-            'Verify the save succeeded — check auto_summarized: true in the response if you used auto_summarize',
-        ],
-        patterns: [
-            'Checkpoint pattern: save after each completed unit of work, not only at the end',
-            'Progressive detail: early saves capture intent; later saves add findings and decisions',
-            'Minimal viable context: save enough to resume, not a full transcript of every action',
-            'Blocker-first save: when stuck, save immediately with the blocker clearly stated',
-        ],
-        gotchas: [
-            'Not saving before a context switch — the next session starts blind without a save',
-            'Saving too much detail — a 5,000-token session save is expensive to restore and read',
-            'Forgetting to include nextAction — the restoring agent does not know where to start',
-            'Saving only at the very end — if the task fails partway through, the intermediate work is lost',
-            'Using vague phase descriptions ("working") instead of concrete phases (implementing step 3 of 7)',
-        ],
-        resources: [
-            'Use the veto_session_save MCP tool: { sessionId, task, phase, progress, decisions, findings }',
-            'Use the veto_sessions_list MCP tool to verify saves and list available sessions',
-            'Use the veto_session_restore MCP tool to reload a previous session',
-            'MCP Session spec: https://modelcontextprotocol.io/docs/concepts/resources',
-        ],
-    };
-}
-//# sourceMappingURL=skill-session-save.js.map

package/dist/skills/memory/skill-session-save.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-session-save.js","sourceRoot":"","sources":["../../../src/skills/memory/skill-session-save.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAiB1D,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiChB,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,cAAc;QACrB,QAAQ,EAAE,QAAQ;QAClB,SAAS,EAAE;YACT,gMAAgM;YAChM,qFAAqF;YACrF,yFAAyF;YACzF,4FAA4F;YAC5F,0EAA0E;YAC1E,wFAAwF;YACxF,0OAA0O;YAC1O,8GAA8G;YAC9G,+GAA+G;YAC/G,4EAA4E;YAC5E,oGAAoG;SACrG;QACD,QAAQ,EAAE;YACR,iFAAiF;YACjF,wFAAwF;YACxF,sFAAsF;YACtF,kFAAkF;SACnF;QACD,OAAO,EAAE;YACP,mFAAmF;YACnF,sFAAsF;YACtF,qFAAqF;YACrF,gGAAgG;YAChG,kGAAkG;SACnG;QACD,SAAS,EAAE;YACT,+FAA+F;YAC/F,iFAAiF;YACjF,oEAAoE;YACpE,2EAA2E;SAC5E;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/quality/skill-accessibility.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-accessibility.d.ts.map

package/dist/skills/quality/skill-accessibility.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-accessibility.d.ts","sourceRoot":"","sources":["../../../src/skills/quality/skill-accessibility.ts"],"names":[],"mappings":""}

package/dist/skills/quality/skill-accessibility.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-accessibility.js.map

package/dist/skills/quality/skill-accessibility.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-accessibility.js","sourceRoot":"","sources":["../../../src/skills/quality/skill-accessibility.ts"],"names":[],"mappings":""}

package/dist/skills/quality/skill-code-review.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-code-review.d.ts.map

package/dist/skills/quality/skill-code-review.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-code-review.d.ts","sourceRoot":"","sources":["../../../src/skills/quality/skill-code-review.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;AAED,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAkElD"}