@jigyasudham/veto 0.8.0

package/dist/council/ux-designer.js

@@ -0,0 +1,109 @@
+// Backend-only tasks: UX approves without friction
+const BACKEND_ONLY = /\b(api|backend|server|database|db|query|schema|migration|auth.*middleware|jwt|oauth|cron|cli|script|worker|queue|cache|redis|sql|index|trigger|webhook)\b/i;
+const FRONTEND_SIGNALS = /\b(ui|ux|form|button|modal|page|screen|component|view|layout|menu|nav|input|field|label|error.?message|loading|user.?interface|frontend|react|vue|svelte|html|css)\b/i;
+const BLOCK_RULES = [
+    {
+        pattern: /window\.alert\s*\(|window\.confirm\s*\(/i,
+        reason: 'window.alert/confirm blocks the page and cannot be styled. Users hate it.',
+        recommendation: 'Replace with toast notifications (react-hot-toast) or inline dialogs.',
+    },
+    {
+        pattern: /no.{0,20}error.{0,20}(message|state|feedback).{0,30}(form|submit|input)/i,
+        reason: 'Forms without error feedback leave users confused and drive support tickets.',
+        recommendation: 'Add inline validation messages for every field that can fail.',
+    },
+    {
+        pattern: /(?:7|8|9|10|eleven|twelve).{0,15}step/i,
+        reason: 'More than 6 steps in a flow loses 70%+ of users before completion.',
+        recommendation: 'Break into smaller flows or use progressive disclosure.',
+    },
+];
+const WARN_RULES = [
+    {
+        pattern: /no.{0,15}(mobile|responsive|viewport)/i,
+        concern: '60%+ of users are on mobile. Responsive is baseline, not a bonus.',
+        recommendation: 'Mobile-first CSS. Test breakpoints: 375px, 768px, 1280px.',
+    },
+    {
+        pattern: /no.{0,15}(loading|spinner|progress|skeleton)/i,
+        concern: 'Missing loading state — users cannot tell if their action registered.',
+        recommendation: 'Show loading indicator for any operation that takes >300ms.',
+    },
+    {
+        pattern: /\bmodal\b|\bpopup\b|\bdialog\b/i,
+        concern: 'Modals interrupt flow and fail on small screens. Use sparingly.',
+        recommendation: 'Reserve modals for destructive confirmations only. Use inline for everything else.',
+    },
+    {
+        pattern: /no.{0,15}(accessib|aria|a11y|wcag)/i,
+        concern: 'Missing accessibility — 15% of users cannot use the product.',
+        recommendation: 'Add aria-labels, keyboard nav, focus management. Test with VoiceOver.',
+    },
+    {
+        pattern: /color.{0,20}only|rely.{0,15}on.{0,15}color/i,
+        concern: '8% of users are colorblind — color-only signals are invisible to them.',
+        recommendation: 'Add icons, patterns, or text alongside color to convey meaning.',
+    },
+    {
+        pattern: /no.{0,15}(empty.?state|zero.?state|first.?time)/i,
+        concern: 'No empty state — first-time users see a blank screen that looks broken.',
+        recommendation: 'Design empty state that explains what goes here and how to start.',
+    },
+    {
+        pattern: /no.{0,15}(confirm|confirmation|undo|undo.?redo)/i,
+        concern: 'Destructive action without confirmation leads to user data loss.',
+        recommendation: 'Add confirmation dialog for destructive actions. Provide undo where possible.',
+    },
+    {
+        pattern: /auto.?submit|submit.{0,10}without.{0,10}(confirm|review)/i,
+        concern: 'Auto-submitting without user review removes user agency.',
+        recommendation: 'Always let users review before final submission.',
+    },
+];
+const TRIVIAL = /^(rename|fix typo|reorder|reformat|format|update comment|add comment)\b/i;
+export function analyze(task) {
+    if (TRIVIAL.test(task.trim())) {
+        return { verdict: 'approve', reason: 'Trivial change — no UX concerns.', concerns: [] };
+    }
+    // Pure backend tasks get a light pass
+    const isBackend = BACKEND_ONLY.test(task) && !FRONTEND_SIGNALS.test(task);
+    if (isBackend) {
+        return {
+            verdict: 'approve',
+            reason: 'Backend task — no direct UX concerns. Ensure API errors surface clearly to users.',
+            concerns: [],
+        };
+    }
+    const blocks = [];
+    const concerns = [];
+    const recommendations = [];
+    for (const rule of BLOCK_RULES) {
+        if (rule.pattern.test(task)) {
+            blocks.push({ reason: rule.reason, recommendation: rule.recommendation });
+        }
+    }
+    for (const rule of WARN_RULES) {
+        if (rule.pattern.test(task)) {
+            concerns.push(rule.concern);
+            recommendations.push(rule.recommendation);
+        }
+    }
+    if (blocks.length > 0) {
+        return {
+            verdict: 'block',
+            reason: blocks[0].reason,
+            concerns: blocks.slice(1).map(b => b.reason),
+            recommendation: blocks.map(b => b.recommendation).join(' | '),
+        };
+    }
+    if (concerns.length > 0) {
+        return {
+            verdict: 'warn',
+            reason: `${concerns.length} UX concern${concerns.length > 1 ? 's' : ''} — real users will notice this.`,
+            concerns,
+            recommendation: recommendations[0],
+        };
+    }
+    return { verdict: 'approve', reason: 'UX looks solid. No user experience concerns.', concerns: [] };
+}
+//# sourceMappingURL=ux-designer.js.map

package/dist/memory/local.js

@@ -0,0 +1,182 @@
+// Local SQLite memory — all operations for session save/restore
+// Uses Node.js built-in node:sqlite (Node 22.5+, no native compilation needed)
+import { DatabaseSync } from 'node:sqlite';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { mkdirSync } from 'node:fs';
+import { CREATE_TABLES } from './schema.js';
+const VETO_DIR = join(homedir(), '.veto');
+const DB_PATH = join(VETO_DIR, 'veto.db');
+let _db = null;
+export function getDb() {
+    if (_db)
+        return _db;
+    mkdirSync(VETO_DIR, { recursive: true });
+    _db = new DatabaseSync(DB_PATH);
+    _db.exec('PRAGMA journal_mode = WAL');
+    _db.exec('PRAGMA foreign_keys = ON');
+    _db.exec(CREATE_TABLES);
+    migrateCouncilOutcomes(_db);
+    migrateCouncilColumns(_db);
+    return _db;
+}
+// Adds legal and security columns if they don't exist (Phase 3 → Phase 3.1 migration)
+function migrateCouncilColumns(db) {
+    const cols = db.prepare('PRAGMA table_info(council_outcomes)').all();
+    const names = new Set(cols.map(c => c.name));
+    if (!names.has('legal'))
+        db.exec('ALTER TABLE council_outcomes ADD COLUMN legal TEXT');
+    if (!names.has('security'))
+        db.exec('ALTER TABLE council_outcomes ADD COLUMN security TEXT');
+}
+// Migrates council_outcomes if it was created with NOT NULL session_id (Phase 1/2 schema)
+function migrateCouncilOutcomes(db) {
+    const cols = db.prepare('PRAGMA table_info(council_outcomes)').all();
+    const col = cols.find(c => c.name === 'session_id');
+    if (!col || col.notnull !== 1)
+        return;
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS _council_outcomes_new (
+      id TEXT PRIMARY KEY, session_id TEXT, task TEXT NOT NULL,
+      verdict TEXT NOT NULL, lead_dev TEXT, pm TEXT, architect TEXT,
+      ux TEXT, devil TEXT, recommended TEXT, debated_at TEXT NOT NULL
+    );
+    INSERT OR IGNORE INTO _council_outcomes_new SELECT * FROM council_outcomes;
+    DROP TABLE council_outcomes;
+    ALTER TABLE _council_outcomes_new RENAME TO council_outcomes;
+  `);
+}
+export function saveSession(input) {
+    const db = getDb();
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    const stmt = db.prepare(`
+    INSERT INTO sessions (id, started_at, platform, project_dir, summary, context, task_state, token_count)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(id, now, input.platform ?? 'claude', input.project_dir ?? null, input.summary ?? null, input.context ? JSON.stringify(input.context) : null, input.task_state ? JSON.stringify(input.task_state) : null, input.token_count ?? 0);
+    return { session_id: id, saved_at: now };
+}
+export function restoreSession(session_id) {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM sessions WHERE id = ?').get(session_id);
+    if (!row)
+        return { found: false };
+    return { found: true, session: row };
+}
+export function listSessions(limit = 10) {
+    const db = getDb();
+    return db.prepare('SELECT * FROM sessions ORDER BY created_at DESC LIMIT ?').all(limit);
+}
+export function closeSession(session_id) {
+    const db = getDb();
+    db.prepare('UPDATE sessions SET ended_at = ? WHERE id = ?')
+        .run(new Date().toISOString(), session_id);
+}
+export function getDbPath() {
+    return DB_PATH;
+}
+export function saveCouncilOutcome(input) {
+    const db = getDb();
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    db.prepare(`
+    INSERT INTO council_outcomes
+      (id, session_id, task, verdict, lead_dev, pm, architect, ux, devil, legal, security, recommended, debated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, input.session_id ?? null, input.task, input.verdict, input.lead_dev, input.pm, input.architect, input.ux, input.devil, input.legal, input.security, input.recommended, now);
+    return id;
+}
+export function storeKnowledge(input) {
+    const db = getDb();
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    db.prepare(`
+    INSERT INTO knowledge_base (id, type, title, content, tags, project_dir, session_id, relevance, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, input.type ?? 'solution', input.title, input.content, input.tags ? JSON.stringify(input.tags) : null, input.project_dir ?? null, input.session_id ?? null, input.relevance ?? 1.0, now, now);
+    return id;
+}
+export function searchKnowledge(opts) {
+    const db = getDb();
+    const limit = Math.min(opts.limit ?? 10, 50);
+    const conditions = [];
+    const params = [];
+    if (opts.query) {
+        conditions.push('(title LIKE ? OR content LIKE ?)');
+        const q = `%${opts.query}%`;
+        params.push(q, q);
+    }
+    if (opts.type) {
+        conditions.push('type = ?');
+        params.push(opts.type);
+    }
+    if (opts.project_dir) {
+        conditions.push('project_dir = ?');
+        params.push(opts.project_dir);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT * FROM knowledge_base ${where} ORDER BY relevance DESC, accessed_count DESC, created_at DESC LIMIT ?`).all(...params, limit);
+    if (rows.length > 0 && opts.query) {
+        const ids = rows.map(r => `'${r.id}'`).join(',');
+        db.exec(`UPDATE knowledge_base SET accessed_count = accessed_count + 1 WHERE id IN (${ids})`);
+    }
+    return rows;
+}
+export function deleteKnowledge(id) {
+    const db = getDb();
+    const result = db.prepare('DELETE FROM knowledge_base WHERE id = ?').run(id);
+    return result.changes > 0;
+}
+export function updateProjectMap(input) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    const existing = db.prepare('SELECT id FROM project_map WHERE project_dir = ?').get(input.project_dir);
+    const structure = typeof input.structure === 'string' ? input.structure : JSON.stringify(input.structure);
+    const key_modules = input.key_modules ? JSON.stringify(input.key_modules) : null;
+    const tech_stack = input.tech_stack ? JSON.stringify(input.tech_stack) : null;
+    if (existing) {
+        db.prepare(`
+      UPDATE project_map SET structure = ?, key_modules = ?, tech_stack = ?, updated_at = ?
+      WHERE project_dir = ?
+    `).run(structure, key_modules, tech_stack, now, input.project_dir);
+        return existing.id;
+    }
+    const id = randomUUID();
+    db.prepare(`
+    INSERT INTO project_map (id, project_dir, structure, key_modules, tech_stack, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(id, input.project_dir, structure, key_modules, tech_stack, now);
+    return id;
+}
+export function getProjectMap(project_dir) {
+    const db = getDb();
+    return db.prepare('SELECT * FROM project_map WHERE project_dir = ?').get(project_dir);
+}
+export function upsertPattern(input) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    const existing = db.prepare('SELECT id, seen_count, confidence FROM patterns WHERE pattern_key = ?').get(input.pattern_key);
+    if (existing) {
+        const newConfidence = Math.min(1.0, (existing.confidence + (input.confidence ?? 1.0)) / 2);
+        db.prepare(`
+      UPDATE patterns SET pattern_val = ?, confidence = ?, seen_count = seen_count + 1, updated_at = ?
+      WHERE pattern_key = ?
+    `).run(input.pattern_val, newConfidence, now, input.pattern_key);
+    }
+    else {
+        db.prepare(`
+      INSERT INTO patterns (id, pattern_key, pattern_val, confidence, seen_count, updated_at)
+      VALUES (?, ?, ?, ?, 1, ?)
+    `).run(randomUUID(), input.pattern_key, input.pattern_val, input.confidence ?? 1.0, now);
+    }
+}
+export function getPatterns(prefix, limit = 20) {
+    const db = getDb();
+    if (prefix) {
+        return db.prepare('SELECT * FROM patterns WHERE pattern_key LIKE ? ORDER BY confidence DESC, seen_count DESC LIMIT ?').all(`${prefix}%`, limit);
+    }
+    return db.prepare('SELECT * FROM patterns ORDER BY confidence DESC, seen_count DESC LIMIT ?').all(limit);
+}
+//# sourceMappingURL=local.js.map

package/dist/memory/schema.js

@@ -0,0 +1,116 @@
+// Database schema definitions for veto.db
+// All tables created on first run — zero setup required
+export const CREATE_TABLES = `
+  CREATE TABLE IF NOT EXISTS sessions (
+    id          TEXT PRIMARY KEY,
+    started_at  TEXT NOT NULL,
+    ended_at    TEXT,
+    platform    TEXT NOT NULL DEFAULT 'claude',
+    project_dir TEXT,
+    summary     TEXT,
+    context     TEXT,
+    task_state  TEXT,
+    token_count INTEGER DEFAULT 0,
+    created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS decisions (
+    id          TEXT PRIMARY KEY,
+    session_id  TEXT NOT NULL,
+    made_at     TEXT NOT NULL,
+    decision    TEXT NOT NULL,
+    rationale   TEXT,
+    council_verdict TEXT,
+    files_affected  TEXT,
+    overridden  INTEGER DEFAULT 0,
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
+  );
+
+  CREATE TABLE IF NOT EXISTS files_modified (
+    id          TEXT PRIMARY KEY,
+    session_id  TEXT NOT NULL,
+    file_path   TEXT NOT NULL,
+    operation   TEXT NOT NULL,
+    modified_at TEXT NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
+  );
+
+  CREATE TABLE IF NOT EXISTS council_outcomes (
+    id          TEXT PRIMARY KEY,
+    session_id  TEXT,
+    task        TEXT NOT NULL,
+    verdict     TEXT NOT NULL,
+    lead_dev    TEXT,
+    pm          TEXT,
+    architect   TEXT,
+    ux          TEXT,
+    devil       TEXT,
+    legal       TEXT,
+    security    TEXT,
+    recommended TEXT,
+    debated_at  TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS learning_data (
+    id            TEXT PRIMARY KEY,
+    task_type     TEXT NOT NULL,
+    complexity    INTEGER NOT NULL,
+    model_tier    INTEGER NOT NULL,
+    output_quality INTEGER,
+    tokens_used   INTEGER,
+    agent         TEXT,
+    recorded_at   TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS patterns (
+    id          TEXT PRIMARY KEY,
+    pattern_key TEXT NOT NULL UNIQUE,
+    pattern_val TEXT NOT NULL,
+    confidence  REAL DEFAULT 1.0,
+    seen_count  INTEGER DEFAULT 1,
+    updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS rate_usage (
+    id            TEXT PRIMARY KEY,
+    platform      TEXT NOT NULL,
+    date_key      TEXT NOT NULL,
+    request_count INTEGER DEFAULT 0,
+    updated_at    TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(platform, date_key)
+  );
+
+  CREATE TABLE IF NOT EXISTS knowledge_base (
+    id             TEXT PRIMARY KEY,
+    type           TEXT NOT NULL DEFAULT 'solution',
+    title          TEXT NOT NULL,
+    content        TEXT NOT NULL,
+    tags           TEXT,
+    project_dir    TEXT,
+    session_id     TEXT,
+    relevance      REAL DEFAULT 1.0,
+    accessed_count INTEGER DEFAULT 0,
+    created_at     TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at     TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS project_map (
+    id          TEXT PRIMARY KEY,
+    project_dir TEXT NOT NULL UNIQUE,
+    structure   TEXT NOT NULL,
+    key_modules TEXT,
+    tech_stack  TEXT,
+    updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_sessions_platform    ON sessions(platform);
+  CREATE INDEX IF NOT EXISTS idx_decisions_session    ON decisions(session_id);
+  CREATE INDEX IF NOT EXISTS idx_files_session        ON files_modified(session_id);
+  CREATE INDEX IF NOT EXISTS idx_learning_task_type   ON learning_data(task_type);
+  CREATE INDEX IF NOT EXISTS idx_patterns_key         ON patterns(pattern_key);
+  CREATE INDEX IF NOT EXISTS idx_rate_usage_platform  ON rate_usage(platform, date_key);
+  CREATE INDEX IF NOT EXISTS idx_knowledge_type       ON knowledge_base(type);
+  CREATE INDEX IF NOT EXISTS idx_knowledge_project    ON knowledge_base(project_dir);
+  CREATE INDEX IF NOT EXISTS idx_project_map_dir      ON project_map(project_dir);
+`;
+//# sourceMappingURL=schema.js.map

package/dist/memory/sync.js

@@ -0,0 +1,199 @@
+// Memory export/import — file-based cross-machine continuity
+// No external services. Export to JSON, copy the file, import on another machine.
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { getDb, getDbPath } from './local.js';
+const DEFAULT_EXPORT_PATH = join(homedir(), '.veto', 'veto-export.json');
+export function exportMemory(outputPath) {
+    const exportPath = outputPath ?? DEFAULT_EXPORT_PATH;
+    const db = getDb();
+    try {
+        const sessions = db.prepare('SELECT * FROM sessions ORDER BY created_at DESC').all();
+        const decisions = db.prepare('SELECT * FROM decisions ORDER BY made_at DESC').all();
+        const knowledge = db.prepare('SELECT * FROM knowledge_base ORDER BY created_at DESC').all();
+        const patterns = db.prepare('SELECT * FROM patterns ORDER BY confidence DESC').all();
+        const projectMaps = db.prepare('SELECT * FROM project_map ORDER BY updated_at DESC').all();
+        const councilOutcomes = db.prepare('SELECT * FROM council_outcomes ORDER BY debated_at DESC').all();
+        const payload = {
+            veto_export_version: 1,
+            exported_at: new Date().toISOString(),
+            db_path: getDbPath(),
+            data: {
+                sessions,
+                decisions,
+                knowledge_base: knowledge,
+                patterns,
+                project_map: projectMaps,
+                council_outcomes: councilOutcomes,
+            },
+        };
+        writeFileSync(exportPath, JSON.stringify(payload, null, 2), 'utf-8');
+        const exported = {
+            sessions: sessions.length,
+            decisions: decisions.length,
+            knowledge_base: knowledge.length,
+            patterns: patterns.length,
+            project_map: projectMaps.length,
+            council_outcomes: councilOutcomes.length,
+        };
+        return {
+            success: true,
+            export_path: exportPath,
+            exported,
+            exported_at: payload.exported_at,
+            next_step: `Copy ${exportPath} to your other machine, then call veto_memory_import with that file path.`,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            export_path: exportPath,
+            exported: {},
+            exported_at: new Date().toISOString(),
+            error: err instanceof Error ? err.message : String(err),
+            next_step: 'Fix the error above and retry.',
+        };
+    }
+}
+export function importMemory(inputPath) {
+    const importPath = inputPath ?? DEFAULT_EXPORT_PATH;
+    if (!existsSync(importPath)) {
+        return {
+            success: false,
+            import_path: importPath,
+            merged: {},
+            skipped: {},
+            imported_at: new Date().toISOString(),
+            error: `File not found: ${importPath}. Run veto_memory_export on your other machine first, then copy the file here.`,
+        };
+    }
+    const db = getDb();
+    const merged = {};
+    const skipped = {};
+    try {
+        const raw = readFileSync(importPath, 'utf-8');
+        const payload = JSON.parse(raw);
+        if (payload.veto_export_version !== 1) {
+            throw new Error(`Unknown export version: ${payload.veto_export_version}`);
+        }
+        const { sessions = [], decisions = [], knowledge_base = [], patterns = [], project_map = [], council_outcomes = [] } = payload.data;
+        merged['sessions'] = 0;
+        skipped['sessions'] = 0;
+        for (const s of sessions) {
+            const r = db.prepare(`
+        INSERT OR IGNORE INTO sessions
+          (id, started_at, ended_at, platform, project_dir, summary, context, task_state, token_count, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(String(s['id'] ?? ''), String(s['started_at'] ?? ''), s['ended_at'] != null ? String(s['ended_at']) : null, String(s['platform'] ?? 'claude'), s['project_dir'] != null ? String(s['project_dir']) : null, s['summary'] != null ? String(s['summary']) : null, s['context'] != null ? String(s['context']) : null, s['task_state'] != null ? String(s['task_state']) : null, typeof s['token_count'] === 'number' ? s['token_count'] : 0, String(s['created_at'] ?? new Date().toISOString()));
+            if (r.changes > 0)
+                merged['sessions']++;
+            else
+                skipped['sessions']++;
+        }
+        merged['decisions'] = 0;
+        skipped['decisions'] = 0;
+        for (const d of decisions) {
+            const r = db.prepare(`
+        INSERT OR IGNORE INTO decisions
+          (id, session_id, made_at, decision, rationale, council_verdict, files_affected, overridden)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(String(d['id'] ?? ''), String(d['session_id'] ?? ''), String(d['made_at'] ?? ''), String(d['decision'] ?? ''), d['rationale'] != null ? String(d['rationale']) : null, d['council_verdict'] != null ? String(d['council_verdict']) : null, d['files_affected'] != null ? String(d['files_affected']) : null, typeof d['overridden'] === 'number' ? d['overridden'] : 0);
+            if (r.changes > 0)
+                merged['decisions']++;
+            else
+                skipped['decisions']++;
+        }
+        merged['knowledge_base'] = 0;
+        skipped['knowledge_base'] = 0;
+        for (const k of knowledge_base) {
+            const r = db.prepare(`
+        INSERT OR IGNORE INTO knowledge_base
+          (id, type, title, content, tags, project_dir, session_id, relevance, accessed_count, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(String(k['id'] ?? ''), k['type'] != null ? String(k['type']) : 'solution', String(k['title'] ?? ''), String(k['content'] ?? ''), k['tags'] != null ? String(k['tags']) : null, k['project_dir'] != null ? String(k['project_dir']) : null, k['session_id'] != null ? String(k['session_id']) : null, typeof k['relevance'] === 'number' ? k['relevance'] : 1.0, typeof k['accessed_count'] === 'number' ? k['accessed_count'] : 0, String(k['created_at'] ?? new Date().toISOString()), String(k['updated_at'] ?? new Date().toISOString()));
+            if (r.changes > 0)
+                merged['knowledge_base']++;
+            else
+                skipped['knowledge_base']++;
+        }
+        merged['patterns'] = 0;
+        skipped['patterns'] = 0;
+        for (const p of patterns) {
+            const existing = db.prepare('SELECT seen_count, confidence FROM patterns WHERE pattern_key = ?').get(String(p['pattern_key'] ?? ''));
+            if (existing) {
+                // Merge: take higher confidence, sum seen counts
+                const mergedConf = Math.max(existing.confidence, typeof p['confidence'] === 'number' ? p['confidence'] : 1.0);
+                const mergedCount = existing.seen_count + (typeof p['seen_count'] === 'number' ? p['seen_count'] : 1);
+                db.prepare('UPDATE patterns SET confidence = ?, seen_count = ?, updated_at = ? WHERE pattern_key = ?')
+                    .run(mergedConf, mergedCount, new Date().toISOString(), String(p['pattern_key'] ?? ''));
+                skipped['patterns']++;
+            }
+            else {
+                db.prepare(`
+          INSERT INTO patterns (id, pattern_key, pattern_val, confidence, seen_count, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `).run(String(p['id'] ?? ''), String(p['pattern_key'] ?? ''), String(p['pattern_val'] ?? ''), typeof p['confidence'] === 'number' ? p['confidence'] : 1.0, typeof p['seen_count'] === 'number' ? p['seen_count'] : 1, String(p['updated_at'] ?? new Date().toISOString()));
+                merged['patterns']++;
+            }
+        }
+        merged['project_map'] = 0;
+        skipped['project_map'] = 0;
+        for (const m of project_map) {
+            const r = db.prepare(`
+        INSERT OR IGNORE INTO project_map (id, project_dir, structure, key_modules, tech_stack, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(String(m['id'] ?? ''), String(m['project_dir'] ?? ''), String(m['structure'] ?? '{}'), m['key_modules'] != null ? String(m['key_modules']) : null, m['tech_stack'] != null ? String(m['tech_stack']) : null, String(m['updated_at'] ?? new Date().toISOString()));
+            if (r.changes > 0)
+                merged['project_map']++;
+            else
+                skipped['project_map']++;
+        }
+        merged['council_outcomes'] = 0;
+        skipped['council_outcomes'] = 0;
+        for (const c of council_outcomes) {
+            const r = db.prepare(`
+        INSERT OR IGNORE INTO council_outcomes
+          (id, session_id, task, verdict, lead_dev, pm, architect, ux, devil, legal, security, recommended, debated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(String(c['id'] ?? ''), c['session_id'] != null ? String(c['session_id']) : null, String(c['task'] ?? ''), String(c['verdict'] ?? ''), c['lead_dev'] != null ? String(c['lead_dev']) : null, c['pm'] != null ? String(c['pm']) : null, c['architect'] != null ? String(c['architect']) : null, c['ux'] != null ? String(c['ux']) : null, c['devil'] != null ? String(c['devil']) : null, c['legal'] != null ? String(c['legal']) : null, c['security'] != null ? String(c['security']) : null, c['recommended'] != null ? String(c['recommended']) : null, String(c['debated_at'] ?? new Date().toISOString()));
+            if (r.changes > 0)
+                merged['council_outcomes']++;
+            else
+                skipped['council_outcomes']++;
+        }
+        return {
+            success: true,
+            import_path: importPath,
+            merged,
+            skipped,
+            imported_at: new Date().toISOString(),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            import_path: importPath,
+            merged,
+            skipped,
+            imported_at: new Date().toISOString(),
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export function getLocalDbSize() {
+    const db = getDb();
+    const tables = ['sessions', 'decisions', 'council_outcomes', 'knowledge_base', 'patterns', 'project_map', 'learning_data'];
+    const counts = {};
+    for (const table of tables) {
+        try {
+            const row = db.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
+            counts[table] = row.c;
+        }
+        catch {
+            counts[table] = 0;
+        }
+    }
+    return { db_path: getDbPath(), tables: counts };
+}
+//# sourceMappingURL=sync.js.map