verybot 0.1.8

package/dist/memory/store.d.ts

@@ -0,0 +1,36 @@
+import type { MemoryEntry } from "./types.js";
+export declare class MemoryStore {
+    private db;
+    private vectorEnabled;
+    private vecTableCreated;
+    private constructor();
+    /** Async factory — loads sqlite-vec extension if available. */
+    static create(dbPath: string): Promise<MemoryStore>;
+    get hasVectorSearch(): boolean;
+    private createSchema;
+    /** Add team_id column if it doesn't exist yet (idempotent). */
+    private migrateTeamId;
+    private loadVecExtension;
+    private ensureVecTable;
+    /** Ensure rowid is bound as SQLite INTEGER (BigInt) for sqlite-vec tables. */
+    private toSqliteIntegerRowid;
+    /** Save a memory entry. Returns false if duplicate or near-duplicate fact exists. */
+    save(entry: MemoryEntry): boolean;
+    /** Full-text search using FTS5/BM25. Optionally scoped to a source and/or team. */
+    searchByText(query: string, limit?: number, source?: string, teamId?: string): MemoryEntry[];
+    /** Vector similarity search using sqlite-vec. Optionally scoped to a source and/or team. */
+    searchByVector(embedding: number[], limit?: number, source?: string, teamId?: string): MemoryEntry[];
+    /** Delete a single memory by its ID. Optionally verify team ownership. Returns true if found and deleted. */
+    deleteById(id: string, teamId?: string): boolean;
+    /**
+     * Paginated list of memories for a specific team (or global if teamId is null).
+     * Intended for CRUD management (listing/deleting).
+     */
+    listByTeam(teamId: string | null, limit?: number, offset?: number): {
+        entries: MemoryEntry[];
+        total: number;
+    };
+    /** Delete all memories from a given session source. Returns count deleted. */
+    deleteBySource(source: string): number;
+    close(): void;
+}

package/dist/memory/store.js

@@ -0,0 +1,334 @@
+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)`);
+    }
+    /** Ensure rowid is bound as SQLite INTEGER (BigInt) for sqlite-vec tables. */
+    toSqliteIntegerRowid(value) {
+        return typeof value === "bigint" ? value : BigInt(value);
+    }
+    // --- 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 = this.toSqliteIntegerRowid(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(this.toSqliteIntegerRowid(row.rowid), row.fact);
+            // Remove from vector table
+            if (this.vectorEnabled && this.vecTableCreated) {
+                this.db
+                    .prepare("DELETE FROM memories_vec WHERE rowid = ?")
+                    .run(this.toSqliteIntegerRowid(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) => this.toSqliteIntegerRowid(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(this.toSqliteIntegerRowid(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,28 @@
+/** 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;
+/** Global command aliases file: ~/.verybot/command-aliases.json */
+export declare const COMMAND_ALIASES_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;
+/** Playbook root: ~/.verybot/playbook */
+export declare const PLAYBOOK_DIR: string;
+/** Playbook folders: ~/.verybot/playbook/playbooks */
+export declare const PLAYBOOKS_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;
+/** Task image attachments: ~/.verybot/attachments/ */
+export declare const ATTACHMENTS_DIR: string;
+/** Ensure all data directories exist. Call once at startup. */
+export declare function ensureDirs(): void;

package/dist/paths.js

@@ -0,0 +1,48 @@
+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");
+/** Global command aliases file: ~/.verybot/command-aliases.json */
+export const COMMAND_ALIASES_PATH = join(BASE_DIR, "command-aliases.json");
+/** 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");
+/** Playbook root: ~/.verybot/playbook */
+export const PLAYBOOK_DIR = join(BASE_DIR, "playbook");
+/** Playbook folders: ~/.verybot/playbook/playbooks */
+export const PLAYBOOKS_DIR = join(PLAYBOOK_DIR, "playbooks");
+/** 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");
+/** Task image attachments: ~/.verybot/attachments/ */
+export const ATTACHMENTS_DIR = join(BASE_DIR, "attachments");
+/** All directories that should exist at startup. */
+const REQUIRED_DIRS = [
+    BASE_DIR,
+    SESSIONS_DIR,
+    BROWSER_PROFILE_DIR,
+    BROWSER_PROFILES_DIR,
+    SKILLS_DIR,
+    INTEGRATIONS_DIR,
+    PLAYBOOK_DIR,
+    PLAYBOOKS_DIR,
+    WHATSAPP_AUTH_DIR,
+    ATTACHMENTS_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/index.d.ts

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

package/dist/prompt-templates/builtins/index.js

@@ -0,0 +1,5 @@
+import { PLANNER } from "./planner.js";
+export { PLANNER };
+export const BUILTIN_TEMPLATES = [
+    PLANNER,
+];

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

@@ -0,0 +1,4 @@
+import type { PromptTemplate } from "../types.js";
+/** Stable ID — never change (used as DB primary key for built-in seeding). */
+export declare const PLANNER_TEMPLATE_ID = "builtin-planner";
+export declare const PLANNER: Omit<PromptTemplate, "createdAt" | "updatedAt">;

package/dist/prompt-templates/builtins/planner.js

@@ -0,0 +1,77 @@
+/** Stable ID — never change (used as DB primary key for built-in seeding). */
+export const PLANNER_TEMPLATE_ID = "builtin-planner";
+export const PLANNER = {
+    id: PLANNER_TEMPLATE_ID,
+    name: "Planner",
+    description: "Interactive planning worker that clarifies requirements via task comments.",
+    role: "worker",
+    builtin: true,
+    content: `You are an interactive Planning agent. Your job is to refine vague or incomplete tasks by talking to the user, asking questions, gathering requirements, and recording everything as task comments.
+
+## Tools (whitelist — use nothing else)
+
+\`task_get\` · \`task_comment_list\` · \`task_comment_add\` · \`task_update\` (needsHumanReview only)
+
+## Rules
+
+- Never change task status, title, or description. Only set \`needsHumanReview: true\` during finalization.
+- Only work on tasks in "plan" status. If the task is in any other status, stop immediately.
+- Anti-loop: after posting a comment, stop and return. Do not call \`task_get\` again. Do not post follow-up comments in the same invocation. One round of questions per invocation.
+- Check \`updated_by\`: if the last update was by you (the Planner), stop and wait for external input.
+- Be conversational and concise. Ask at most 3-5 questions per round.
+- Always record questions and answers as task comments. This is the source of truth.
+- Never write code, run builds, or make file changes. You are a planner, not a coder.
+
+## Lifecycle
+
+You are invoked once per round. Each invocation follows this flow:
+
+1. Read the task and all comments: call \`task_get\` and \`task_comment_list\`.
+2. If the last comment is yours, stop (waiting for user or external input).
+3. If this is a fresh task (no comments), identify gaps (acceptance criteria, scope, constraints, priority, dependencies) and post your first round of questions as a task comment.
+4. If the user answered, post a Q&A summary comment, then either ask the next round of questions or finalize.
+5. If all gaps are filled, post the "Agreed Plan" comment and set \`needsHumanReview: true\`.
+6. Return. Do not loop.
+
+## Asking Questions
+
+Write questions as a task comment. Use Quick Question Blocks so the UI renders clickable choices:
+
+\`\`\`question
+title: Decision title
+options:
+  - Option A
+  - Option B
+  - Option C
+\`\`\`
+
+Add \`type: multi\` only for multi-select. No JSON. Write brief context (1-3 lines) before each block.
+
+## Recording Answers
+
+After receiving answers, add a summary comment:
+
+\`\`\`
+## Planning Notes
+**Q:** <question>
+**A:** <answer>
+...
+\`\`\`
+
+## Finalizing
+
+Once you have enough clarity, add a final comment:
+
+\`\`\`
+## Agreed Plan
+- **Goal:** ...
+- **Scope:** ...
+- **Acceptance Criteria:**
+  - [ ] ...
+  - [ ] ...
+- **Out of Scope:** ...
+- **Notes:** ...
+\`\`\`
+
+Then call \`task_update\` to set \`needsHumanReview: true\`. This signals planning is complete and ready for human review.`,
+};

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

@@ -0,0 +1,45 @@
+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;
+}
+export interface ForkPromptTemplateInput {
+    name?: string;
+    description?: 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;
+    forkPromptTemplate(sourceId: string, input?: ForkPromptTemplateInput): PromptTemplate | null;
+    updatePromptTemplate(id: string, input: UpdatePromptTemplateInput): PromptTemplate | null;
+    deletePromptTemplate(id: string): boolean;
+    getPromptTemplateById(id: string): PromptTemplate | null;
+    listPromptTemplates(): PromptTemplate[];
+    private listPromptTemplateNames;
+    /**
+     * 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;
+}