verybot 0.1.3

package/dist/memory/store.js

@@ -0,0 +1,328 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import Database from "better-sqlite3";
+import { logger } from "../logger.js";
+const DEFAULT_LIMIT = 10;
+export class MemoryStore {
+    db;
+    vectorEnabled = false;
+    vecTableCreated = false;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Async factory — loads sqlite-vec extension if available. */
+    static async create(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        const store = new MemoryStore(db);
+        store.createSchema();
+        await store.loadVecExtension();
+        return store;
+    }
+    get hasVectorSearch() {
+        return this.vectorEnabled;
+    }
+    // --- Schema ---
+    createSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        fact TEXT NOT NULL,
+        source TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        embedding BLOB
+      );
+      CREATE INDEX IF NOT EXISTS idx_memories_source ON memories(source);
+      CREATE INDEX IF NOT EXISTS idx_memories_timestamp ON memories(timestamp DESC);
+    `);
+        // FTS5 external content table (synced manually in save/delete, no triggers)
+        // Porter tokenizer enables stemming: "like" matches "likes", "running" matches "run"
+        this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+        fact,
+        content='memories',
+        content_rowid='rowid',
+        tokenize='porter unicode61'
+      );
+    `);
+        // Idempotent migration: add team_id column for team-scoped memories
+        this.migrateTeamId();
+    }
+    /** Add team_id column if it doesn't exist yet (idempotent). */
+    migrateTeamId() {
+        const columns = this.db.pragma("table_info(memories)");
+        const hasTeamId = columns.some((c) => c.name === "team_id");
+        if (!hasTeamId) {
+            this.db.exec("ALTER TABLE memories ADD COLUMN team_id TEXT");
+            logger.info("Migrated memories table: added team_id column");
+        }
+        this.db.exec("CREATE INDEX IF NOT EXISTS idx_memories_team_id ON memories(team_id)");
+    }
+    async loadVecExtension() {
+        try {
+            const sqliteVec = await import("sqlite-vec");
+            // Handle both ESM default export and CJS module patterns
+            const loader = sqliteVec.default?.load ?? sqliteVec.load;
+            loader(this.db);
+            this.vectorEnabled = true;
+            // Check if vec table already exists from a previous run
+            const vecExists = this.db
+                .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_vec'")
+                .get();
+            if (vecExists)
+                this.vecTableCreated = true;
+            logger.info(`sqlite-vec extension loaded (vec table: ${this.vecTableCreated ? "exists" : "pending"})`);
+        }
+        catch {
+            logger.info("sqlite-vec not available — vector search disabled");
+        }
+    }
+    ensureVecTable(dims) {
+        if (this.vecTableCreated || !this.vectorEnabled)
+            return;
+        this.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS memories_vec USING vec0(embedding float[${dims}])`);
+        this.vecTableCreated = true;
+        logger.info(`Vector table created (${dims} dimensions)`);
+    }
+    // --- CRUD ---
+    /** Save a memory entry. Returns false if duplicate or near-duplicate fact exists. */
+    save(entry) {
+        // Normalize: trim whitespace and trailing punctuation
+        entry = { ...entry, fact: normalizeFact(entry.fact) };
+        // Skip exact duplicate (scoped to same team)
+        const teamFilter = entry.teamId
+            ? "AND team_id = ?"
+            : "AND team_id IS NULL";
+        const exactParams = entry.teamId
+            ? [entry.fact, entry.teamId]
+            : [entry.fact];
+        const exact = this.db
+            .prepare(`SELECT id FROM memories WHERE fact = ? ${teamFilter}`)
+            .get(...exactParams);
+        if (exact)
+            return false;
+        // Skip near-duplicate via FTS5 (e.g. "lives in US" vs "lives in United States")
+        // Scope dedup to same team
+        const ftsQuery = buildFtsQuery(entry.fact);
+        if (ftsQuery) {
+            const dedupTeamFilter = entry.teamId
+                ? "AND m.team_id = ?"
+                : "AND m.team_id IS NULL";
+            const dedupParams = entry.teamId
+                ? [ftsQuery, entry.source, entry.teamId]
+                : [ftsQuery, entry.source];
+            const similar = this.db
+                .prepare(`SELECT m.fact FROM memories_fts f
+           JOIN memories m ON m.rowid = f.rowid
+           WHERE memories_fts MATCH ? AND m.source = ? ${dedupTeamFilter}
+           LIMIT 3`)
+                .all(...dedupParams);
+            for (const row of similar) {
+                if (isSimilarFact(row.fact, entry.fact))
+                    return false;
+            }
+        }
+        const embeddingBlob = entry.embedding
+            ? Buffer.from(new Float32Array(entry.embedding).buffer)
+            : null;
+        const info = this.db
+            .prepare(`INSERT INTO memories (id, fact, source, timestamp, embedding, team_id)
+         VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(entry.id, entry.fact, entry.source, entry.timestamp, embeddingBlob, entry.teamId ?? null);
+        // Keep as BigInt — better-sqlite3 binds BigInt as INTEGER, but Number as REAL.
+        // sqlite-vec rejects REAL primary keys on virtual tables.
+        const rowid = info.lastInsertRowid;
+        // Sync FTS5 index
+        this.db
+            .prepare("INSERT INTO memories_fts(rowid, fact) VALUES (?, ?)")
+            .run(rowid, entry.fact);
+        // Insert into vector table if we have an embedding
+        if (this.vectorEnabled && entry.embedding) {
+            this.ensureVecTable(entry.embedding.length);
+            this.db
+                .prepare("INSERT INTO memories_vec (rowid, embedding) VALUES (?, ?)")
+                .run(rowid, embeddingBlob);
+        }
+        return true;
+    }
+    /** Full-text search using FTS5/BM25. Optionally scoped to a source and/or team. */
+    searchByText(query, limit = DEFAULT_LIMIT, source, teamId) {
+        const ftsQuery = buildFtsQuery(query);
+        if (!ftsQuery)
+            return [];
+        const conditions = ["memories_fts MATCH ?"];
+        const params = [ftsQuery];
+        if (source) {
+            conditions.push("m.source = ?");
+            params.push(source);
+        }
+        // Team filter: return only team-specific memories
+        if (teamId) {
+            conditions.push("m.team_id = ?");
+            params.push(teamId);
+        }
+        params.push(limit);
+        const rows = this.db
+            .prepare(`SELECT m.id, m.fact, m.source, m.timestamp, m.team_id, rank
+         FROM memories_fts f
+         JOIN memories m ON m.rowid = f.rowid
+         WHERE ${conditions.join(" AND ")}
+         ORDER BY rank
+         LIMIT ?`)
+            .all(...params);
+        return rows.map((r) => ({
+            id: r.id, fact: r.fact, source: r.source, timestamp: r.timestamp,
+            ...(r.team_id ? { teamId: r.team_id } : {}),
+        }));
+    }
+    /** Vector similarity search using sqlite-vec. Optionally scoped to a source and/or team. */
+    searchByVector(embedding, limit = DEFAULT_LIMIT, source, teamId) {
+        if (!this.vectorEnabled || !this.vecTableCreated)
+            return [];
+        const buf = Buffer.from(new Float32Array(embedding).buffer);
+        // Fetch more than needed so we can filter by source/team and still fill the limit
+        const needsPostFilter = !!source || !!teamId;
+        const fetchLimit = needsPostFilter ? limit * 3 : limit;
+        const vecRows = this.db
+            .prepare("SELECT rowid, distance FROM memories_vec WHERE embedding MATCH ? ORDER BY distance LIMIT ?")
+            .all(buf, fetchLimit);
+        if (vecRows.length === 0)
+            return [];
+        const rowids = vecRows.map((r) => r.rowid);
+        const placeholders = rowids.map(() => "?").join(",");
+        const conditions = [`rowid IN (${placeholders})`];
+        const params = [...rowids];
+        if (source) {
+            conditions.push("source = ?");
+            params.push(source);
+        }
+        if (teamId) {
+            conditions.push("team_id = ?");
+            params.push(teamId);
+        }
+        params.push(limit);
+        const memRows = this.db
+            .prepare(`SELECT id, fact, source, timestamp, team_id FROM memories
+         WHERE ${conditions.join(" AND ")}
+         LIMIT ?`)
+            .all(...params);
+        return memRows.map((r) => ({
+            id: r.id, fact: r.fact, source: r.source, timestamp: r.timestamp,
+            ...(r.team_id ? { teamId: r.team_id } : {}),
+        }));
+    }
+    /** Delete a single memory by its ID. Optionally verify team ownership. Returns true if found and deleted. */
+    deleteById(id, teamId) {
+        // Verify ownership when teamId is provided
+        const query = teamId
+            ? "SELECT rowid, fact FROM memories WHERE id = ? AND team_id = ?"
+            : "SELECT rowid, fact FROM memories WHERE id = ?";
+        const params = teamId ? [id, teamId] : [id];
+        const row = this.db
+            .prepare(query)
+            .get(...params);
+        if (!row)
+            return false;
+        const doDelete = this.db.transaction(() => {
+            // Remove from FTS5 index
+            this.db
+                .prepare("INSERT INTO memories_fts(memories_fts, rowid, fact) VALUES('delete', ?, ?)")
+                .run(row.rowid, row.fact);
+            // Remove from vector table
+            if (this.vectorEnabled && this.vecTableCreated) {
+                this.db.prepare("DELETE FROM memories_vec WHERE rowid = ?").run(row.rowid);
+            }
+            // Remove from main table
+            this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+        });
+        doDelete();
+        return true;
+    }
+    /**
+     * Paginated list of memories for a specific team (or global if teamId is null).
+     * Intended for CRUD management (listing/deleting).
+     */
+    listByTeam(teamId, limit = DEFAULT_LIMIT, offset = 0) {
+        const filter = teamId ? "WHERE team_id = ?" : "WHERE team_id IS NULL";
+        const params = teamId ? [teamId] : [];
+        const countRow = this.db
+            .prepare(`SELECT COUNT(*) AS cnt FROM memories ${filter}`)
+            .get(...params);
+        const rows = this.db
+            .prepare(`SELECT id, fact, source, timestamp, team_id FROM memories
+         ${filter}
+         ORDER BY timestamp DESC
+         LIMIT ? OFFSET ?`)
+            .all(...params, limit, offset);
+        return {
+            total: countRow.cnt,
+            entries: rows.map((r) => ({
+                id: r.id, fact: r.fact, source: r.source, timestamp: r.timestamp,
+                ...(r.team_id ? { teamId: r.team_id } : {}),
+            })),
+        };
+    }
+    /** Delete all memories from a given session source. Returns count deleted. */
+    deleteBySource(source) {
+        const rows = this.db
+            .prepare("SELECT rowid, fact FROM memories WHERE source = ?")
+            .all(source);
+        if (rows.length === 0)
+            return 0;
+        const rowids = rows.map((r) => r.rowid);
+        const placeholders = rowids.map(() => "?").join(",");
+        // Remove from FTS5 index
+        for (const row of rows) {
+            this.db
+                .prepare("INSERT INTO memories_fts(memories_fts, rowid, fact) VALUES('delete', ?, ?)")
+                .run(row.rowid, row.fact);
+        }
+        // Remove from vector table
+        if (this.vectorEnabled && this.vecTableCreated) {
+            this.db
+                .prepare(`DELETE FROM memories_vec WHERE rowid IN (${placeholders})`)
+                .run(...rowids);
+        }
+        // Remove from main table
+        const info = this.db
+            .prepare(`DELETE FROM memories WHERE rowid IN (${placeholders})`)
+            .run(...rowids);
+        return info.changes;
+    }
+    close() {
+        this.db.close();
+        logger.info("Memory store closed");
+    }
+}
+/** Build an FTS5 query from raw text. Returns null if no usable tokens. */
+function buildFtsQuery(raw) {
+    const tokens = raw
+        .match(/[A-Za-z0-9_]+/g)
+        ?.map((t) => t.trim())
+        .filter(Boolean) ?? [];
+    if (tokens.length === 0)
+        return null;
+    // Use OR for broader matching (AND would be too strict for memory recall)
+    return tokens.map((t) => `"${t.replaceAll('"', "")}"`).join(" OR ");
+}
+/** Trim whitespace and trailing punctuation from a fact. */
+function normalizeFact(fact) {
+    return fact.trim().replace(/[.\s]+$/, "");
+}
+/** Check if two facts are near-duplicates by comparing their word overlap. */
+function isSimilarFact(a, b) {
+    const wordsA = new Set(a.toLowerCase().match(/[a-z0-9]+/g) ?? []);
+    const wordsB = new Set(b.toLowerCase().match(/[a-z0-9]+/g) ?? []);
+    if (wordsA.size === 0 || wordsB.size === 0)
+        return false;
+    let overlap = 0;
+    for (const w of wordsA) {
+        if (wordsB.has(w))
+            overlap++;
+    }
+    // If 80%+ of words overlap in both directions, it's a near-duplicate
+    const ratioA = overlap / wordsA.size;
+    const ratioB = overlap / wordsB.size;
+    return ratioA >= 0.8 && ratioB >= 0.8;
+}

package/dist/memory/types.d.ts

@@ -0,0 +1,9 @@
+export interface MemoryEntry {
+    id: string;
+    fact: string;
+    source: string;
+    timestamp: number;
+    embedding?: number[];
+    /** Team scope — undefined/null = global memory visible to all teams. */
+    teamId?: string;
+}

package/dist/memory/types.js

@@ -0,0 +1,2 @@
+// TODO: phase 7 — memory types
+export {};

package/dist/paths.d.ts

@@ -0,0 +1,20 @@
+/** Root data directory: ~/.verybot */
+export declare const BASE_DIR: string;
+/** Conversation history (JSONL files): ~/.verybot/sessions/ */
+export declare const SESSIONS_DIR: string;
+/** Long-term memory + schedules (SQLite): ~/.verybot/memory.db */
+export declare const MEMORY_DB_PATH: string;
+/** Chromium user data: ~/.verybot/browser/ */
+export declare const BROWSER_PROFILE_DIR: string;
+/** Named browser profiles: ~/.verybot/browser-profiles/ */
+export declare const BROWSER_PROFILES_DIR: string;
+/** User skill definitions: ~/.verybot/skills/ */
+export declare const SKILLS_DIR: string;
+/** User integration definitions: ~/.verybot/integrations/ */
+export declare const INTEGRATIONS_DIR: string;
+/** Docker sandbox workspace: ~/.verybot/workspace/ */
+export declare const SANDBOX_WORKSPACE: string;
+/** WhatsApp Baileys auth state: ~/.verybot/whatsapp-auth/ */
+export declare const WHATSAPP_AUTH_DIR: string;
+/** Ensure all data directories exist. Call once at startup. */
+export declare function ensureDirs(): void;

package/dist/paths.js

@@ -0,0 +1,29 @@
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+/** Root data directory: ~/.verybot */
+export const BASE_DIR = join(homedir(), ".verybot");
+/** Conversation history (JSONL files): ~/.verybot/sessions/ */
+export const SESSIONS_DIR = join(BASE_DIR, "sessions");
+/** Long-term memory + schedules (SQLite): ~/.verybot/memory.db */
+export const MEMORY_DB_PATH = join(BASE_DIR, "memory.db");
+/** Chromium user data: ~/.verybot/browser/ */
+export const BROWSER_PROFILE_DIR = join(BASE_DIR, "browser");
+/** Named browser profiles: ~/.verybot/browser-profiles/ */
+export const BROWSER_PROFILES_DIR = join(BASE_DIR, "browser-profiles");
+/** User skill definitions: ~/.verybot/skills/ */
+export const SKILLS_DIR = join(BASE_DIR, "skills");
+/** User integration definitions: ~/.verybot/integrations/ */
+export const INTEGRATIONS_DIR = join(BASE_DIR, "integrations");
+/** Docker sandbox workspace: ~/.verybot/workspace/ */
+export const SANDBOX_WORKSPACE = join(BASE_DIR, "workspace");
+/** WhatsApp Baileys auth state: ~/.verybot/whatsapp-auth/ */
+export const WHATSAPP_AUTH_DIR = join(BASE_DIR, "whatsapp-auth");
+/** All directories that should exist at startup. */
+const REQUIRED_DIRS = [BASE_DIR, SESSIONS_DIR, BROWSER_PROFILE_DIR, BROWSER_PROFILES_DIR, SKILLS_DIR, INTEGRATIONS_DIR, WHATSAPP_AUTH_DIR];
+/** Ensure all data directories exist. Call once at startup. */
+export function ensureDirs() {
+    for (const dir of REQUIRED_DIRS) {
+        mkdirSync(dir, { recursive: true });
+    }
+}

package/dist/prompt-templates/builtins.d.ts

@@ -0,0 +1,2 @@
+import type { PromptTemplate } from "./types.js";
+export declare const BUILTIN_TEMPLATES: Omit<PromptTemplate, "createdAt" | "updatedAt">[];

package/dist/prompt-templates/builtins.js

@@ -0,0 +1,72 @@
+/** Stable IDs for built-in templates — never change these. */
+const ID_CODE_REVIEW_PIPELINE = "builtin-code-review-pipeline";
+const ID_CODE_REVIEWER = "builtin-code-reviewer";
+const ID_SECURITY_REVIEWER = "builtin-security-reviewer";
+const ID_RESEARCHER = "builtin-researcher";
+export const BUILTIN_TEMPLATES = [
+    {
+        id: ID_CODE_REVIEW_PIPELINE,
+        name: "Code Review Pipeline",
+        description: "Orchestrator that coordinates a multi-pass code review across workers.",
+        role: "orchestrator",
+        builtin: true,
+        content: `You are a code review orchestrator. Your job is to coordinate a thorough review of code changes by delegating to specialist workers.
+
+When reviewing code:
+1. First delegate to the Code Reviewer for general quality, readability, and correctness.
+2. Then delegate to the Security Reviewer for vulnerability analysis.
+3. Synthesize the findings into a single, actionable review summary.
+
+Prioritize issues by severity: critical > major > minor > suggestion.
+Always include specific file paths and line references.`,
+    },
+    {
+        id: ID_CODE_REVIEWER,
+        name: "Code Reviewer",
+        description: "Worker that reviews code for quality, readability, and correctness.",
+        role: "worker",
+        builtin: true,
+        content: `You are a senior code reviewer. Analyze code changes for:
+
+- **Correctness**: Logic errors, edge cases, off-by-one errors, race conditions.
+- **Readability**: Naming, structure, comments where non-obvious.
+- **Maintainability**: DRY violations, coupling, complexity.
+- **Performance**: Unnecessary allocations, N+1 queries, missing indexes.
+- **Testing**: Missing test coverage, brittle tests, untested edge cases.
+
+Be specific — reference file paths and line numbers. Suggest concrete improvements, not vague advice.`,
+    },
+    {
+        id: ID_SECURITY_REVIEWER,
+        name: "Security Reviewer",
+        description: "Worker that reviews code for security vulnerabilities.",
+        role: "worker",
+        builtin: true,
+        content: `You are a security reviewer. Analyze code for vulnerabilities including:
+
+- **Injection**: SQL injection, command injection, XSS, template injection.
+- **Authentication/Authorization**: Broken access control, missing auth checks.
+- **Data Exposure**: Leaked secrets, verbose errors, insecure logging.
+- **Input Validation**: Missing or insufficient validation at trust boundaries.
+- **Cryptography**: Weak algorithms, hardcoded keys, insecure randomness.
+- **Dependencies**: Known vulnerable packages, supply chain risks.
+
+Rate each finding by severity (Critical/High/Medium/Low) and provide a remediation recommendation.`,
+    },
+    {
+        id: ID_RESEARCHER,
+        name: "Researcher",
+        description: "Worker that gathers information from the web and documentation.",
+        role: "worker",
+        builtin: true,
+        content: `You are a research specialist. When given a research task:
+
+1. Break the question into sub-questions if needed.
+2. Use web search and documentation to gather authoritative sources.
+3. Cross-reference multiple sources to verify accuracy.
+4. Summarize findings with citations and source links.
+5. Clearly distinguish facts from opinions and note any conflicting information.
+
+Prefer primary sources (official docs, RFCs, academic papers) over secondary ones.`,
+    },
+];

package/dist/prompt-templates/store.d.ts

@@ -0,0 +1,39 @@
+import type { PromptTemplate } from "./types.js";
+/** Max allowed length for template names. */
+export declare const MAX_TEMPLATE_NAME_LENGTH = 128;
+/** Max allowed length for template content. */
+export declare const MAX_TEMPLATE_CONTENT_LENGTH = 50000;
+export interface CreatePromptTemplateInput {
+    id?: string;
+    name: string;
+    description?: string;
+    role: "orchestrator" | "worker";
+    content: string;
+}
+export interface UpdatePromptTemplateInput {
+    name?: string;
+    description?: string;
+    role?: "orchestrator" | "worker";
+    content?: string;
+}
+/**
+ * SQLite-backed persistence for prompt templates.
+ * Shares the same DB file as TeamStore, TaskStore, etc.
+ */
+export declare class PromptTemplateStore {
+    private db;
+    private constructor();
+    static create(dbPath: string): Promise<PromptTemplateStore>;
+    private createSchema;
+    createPromptTemplate(input: CreatePromptTemplateInput): PromptTemplate;
+    updatePromptTemplate(id: string, input: UpdatePromptTemplateInput): PromptTemplate | null;
+    deletePromptTemplate(id: string): boolean;
+    getPromptTemplateById(id: string): PromptTemplate | null;
+    listPromptTemplates(): PromptTemplate[];
+    /**
+     * Upsert built-in templates by id on boot.
+     * Only updates name/description/role/content for existing builtins.
+     */
+    seedBuiltins(templates: Omit<PromptTemplate, "createdAt" | "updatedAt">[]): void;
+    close(): void;
+}

package/dist/prompt-templates/store.js

@@ -0,0 +1,174 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+import Database from "better-sqlite3";
+import { logger } from "../logger.js";
+/** Max allowed length for template names. */
+export const MAX_TEMPLATE_NAME_LENGTH = 128;
+/** Max allowed length for template content. */
+export const MAX_TEMPLATE_CONTENT_LENGTH = 50_000;
+const VALID_ROLES = new Set(["orchestrator", "worker"]);
+/**
+ * SQLite-backed persistence for prompt templates.
+ * Shares the same DB file as TeamStore, TaskStore, etc.
+ */
+export class PromptTemplateStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static async create(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        const store = new PromptTemplateStore(db);
+        store.createSchema();
+        return store;
+    }
+    createSchema() {
+        this.db.pragma("foreign_keys = ON");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_templates (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        description TEXT NOT NULL DEFAULT '',
+        role TEXT NOT NULL,
+        content TEXT NOT NULL DEFAULT '',
+        builtin INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+    }
+    createPromptTemplate(input) {
+        validateName(input.name);
+        validateContent(input.content);
+        validateRole(input.role);
+        const now = Date.now();
+        const id = input.id ?? randomUUID();
+        try {
+            this.db.prepare(`INSERT INTO prompt_templates (id, name, description, role, content, builtin, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, 0, ?, ?)`).run(id, input.name, input.description ?? "", input.role, input.content, now, now);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                throw new Error(`A template named "${input.name}" already exists`);
+            }
+            throw err;
+        }
+        return {
+            id, name: input.name, description: input.description ?? "",
+            role: input.role, content: input.content, builtin: false,
+            createdAt: now, updatedAt: now,
+        };
+    }
+    updatePromptTemplate(id, input) {
+        const existing = this.getPromptTemplateById(id);
+        if (!existing)
+            return null;
+        if (existing.builtin)
+            throw new Error("Cannot modify a built-in template");
+        if (input.name !== undefined)
+            validateName(input.name);
+        if (input.content !== undefined)
+            validateContent(input.content);
+        if (input.role !== undefined)
+            validateRole(input.role);
+        const now = Date.now();
+        const updated = {
+            ...existing,
+            ...(input.name !== undefined && { name: input.name }),
+            ...(input.description !== undefined && { description: input.description }),
+            ...(input.role !== undefined && { role: input.role }),
+            ...(input.content !== undefined && { content: input.content }),
+            updatedAt: now,
+        };
+        try {
+            this.db.prepare(`UPDATE prompt_templates SET name = ?, description = ?, role = ?, content = ?, updated_at = ? WHERE id = ?`).run(updated.name, updated.description, updated.role, updated.content, now, id);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                throw new Error(`A template named "${input.name}" already exists`);
+            }
+            throw err;
+        }
+        return updated;
+    }
+    deletePromptTemplate(id) {
+        const existing = this.getPromptTemplateById(id);
+        if (existing?.builtin)
+            throw new Error("Cannot delete a built-in template");
+        const info = this.db.prepare("DELETE FROM prompt_templates WHERE id = ?").run(id);
+        return info.changes > 0;
+    }
+    getPromptTemplateById(id) {
+        const row = this.db.prepare("SELECT * FROM prompt_templates WHERE id = ?").get(id);
+        return row ? toPromptTemplate(row) : null;
+    }
+    listPromptTemplates() {
+        const rows = this.db.prepare("SELECT * FROM prompt_templates ORDER BY builtin DESC, created_at ASC").all();
+        return rows.map(toPromptTemplate);
+    }
+    /**
+     * Upsert built-in templates by id on boot.
+     * Only updates name/description/role/content for existing builtins.
+     */
+    seedBuiltins(templates) {
+        const upsert = this.db.prepare(`
+      INSERT INTO prompt_templates (id, name, description, role, content, builtin, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, 1, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        name = excluded.name,
+        description = excluded.description,
+        role = excluded.role,
+        content = excluded.content,
+        builtin = 1,
+        updated_at = excluded.updated_at
+    `);
+        const now = Date.now();
+        const runAll = this.db.transaction(() => {
+            for (const t of templates) {
+                upsert.run(t.id, t.name, t.description, t.role, t.content, now, now);
+            }
+        });
+        runAll();
+        logger.info(`Seeded ${templates.length} built-in prompt templates`);
+    }
+    close() {
+        this.db.close();
+        logger.info("Prompt template store closed");
+    }
+}
+function toPromptTemplate(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        description: row.description ?? "",
+        role: row.role,
+        content: row.content ?? "",
+        builtin: row.builtin === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function validateName(name) {
+    if (typeof name !== "string" || name.trim().length === 0) {
+        throw new Error("Template name is required");
+    }
+    if (name.length > MAX_TEMPLATE_NAME_LENGTH) {
+        throw new Error(`Template name exceeds maximum length of ${MAX_TEMPLATE_NAME_LENGTH}`);
+    }
+}
+function validateContent(content) {
+    if (typeof content !== "string") {
+        throw new Error("Template content must be a string");
+    }
+    if (content.length > MAX_TEMPLATE_CONTENT_LENGTH) {
+        throw new Error(`Template content exceeds maximum length of ${MAX_TEMPLATE_CONTENT_LENGTH}`);
+    }
+}
+function validateRole(role) {
+    if (!VALID_ROLES.has(role)) {
+        throw new Error("role must be 'orchestrator' or 'worker'");
+    }
+}