verybot 0.1.8

package/dist/teams/store.js

@@ -0,0 +1,671 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+import Database from "better-sqlite3";
+import { logger } from "../logger.js";
+import { DEFAULT_TEAM_ID, DEFAULT_WORKER_TIMEOUT_S, FALLBACK_ORCHESTRATOR } from "../config/agent-config.js";
+import { LEGACY_STATUS_KEYS } from "../tasks/types.js";
+import { validateStatusConfigs } from "./status-config.js";
+/** Max allowed length for team/agent names. */
+export const MAX_NAME_LENGTH = 128;
+/** Max allowed length for agent identity strings. */
+export const MAX_IDENTITY_LENGTH = 10_000;
+/** Max allowed length for model strings. */
+export const MAX_MODEL_LENGTH = 256;
+/** Max allowed length for caller-provided ids. */
+const MAX_ID_LENGTH = 128;
+/** Concurrency bounds for worker agents. */
+const MIN_CONCURRENCY = 1;
+const MAX_CONCURRENCY = 10;
+/** Hex color pattern: #RRGGBB */
+export const HEX_COLOR_RE = /^#[0-9a-fA-F]{6}$/;
+const DEFAULT_TEAM_NAME = "Default";
+/** Validate a caller-provided id string. */
+function validateId(id) {
+    if (typeof id !== "string" || id.trim().length === 0) {
+        throw new Error("id must be a non-empty string");
+    }
+    if (id.length > MAX_ID_LENGTH) {
+        throw new Error(`id exceeds maximum length of ${MAX_ID_LENGTH}`);
+    }
+}
+/** Max allowed length for workspace paths. */
+const MAX_WORKSPACE_LENGTH = 1024;
+/** Max number of user-defined variables per team. */
+const MAX_VARIABLES_COUNT = 50;
+/** Max allowed length for a single variable value. */
+const MAX_VARIABLE_VALUE_LENGTH = 10_000;
+/** Variable key pattern: alphanumeric + underscore. */
+const VARIABLE_KEY_RE = /^\w+$/;
+/**
+ * SQLite-backed persistence for teams and agents.
+ * Shares the same DB file as MemoryStore, TaskStore, etc.
+ */
+export class TeamStore {
+    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 TeamStore(db);
+        store.createSchema();
+        return store;
+    }
+    createSchema() {
+        // Enable foreign key enforcement before creating tables
+        this.db.pragma("foreign_keys = ON");
+        // Ensure prompt_templates table exists (may already be created by PromptTemplateStore)
+        // Needed for agents.template_id FK and toTeamConfigs() JOIN.
+        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
+      );
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS teams (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        team_id TEXT NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        role TEXT NOT NULL,
+        model TEXT NOT NULL,
+        context_window INTEGER DEFAULT 0,
+        max_steps INTEGER DEFAULT 0,
+        identity TEXT NOT NULL DEFAULT '',
+        tools TEXT DEFAULT '[]',
+        timeout INTEGER DEFAULT ${DEFAULT_WORKER_TIMEOUT_S},
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        UNIQUE(team_id, name)
+      );
+      CREATE INDEX IF NOT EXISTS idx_agents_team ON agents(team_id);
+    `);
+        // Add color column to existing tables (idempotent — SQLite errors if column exists)
+        try {
+            this.db.exec("ALTER TABLE teams ADD COLUMN color TEXT NOT NULL DEFAULT ''");
+        }
+        catch {
+            // Column already exists
+        }
+        // Add template_id FK column to agents (idempotent)
+        try {
+            this.db.exec("ALTER TABLE agents ADD COLUMN template_id TEXT REFERENCES prompt_templates(id) ON DELETE SET NULL");
+        }
+        catch {
+            // Column already exists
+        }
+        // Add workspace column to teams (idempotent)
+        try {
+            this.db.exec("ALTER TABLE teams ADD COLUMN workspace TEXT NOT NULL DEFAULT ''");
+        }
+        catch {
+            // Column already exists
+        }
+        // Add variables column to teams (JSON-encoded Record<string, string>)
+        try {
+            this.db.exec("ALTER TABLE teams ADD COLUMN variables TEXT NOT NULL DEFAULT '{}'");
+        }
+        catch {
+            // Column already exists
+        }
+        // Add concurrency column to agents (default 1)
+        try {
+            this.db.exec("ALTER TABLE agents ADD COLUMN concurrency INTEGER NOT NULL DEFAULT 1");
+        }
+        catch {
+            // Column already exists
+        }
+        // Add statuses column to teams (JSON-encoded TaskStatusConfig[])
+        try {
+            this.db.exec("ALTER TABLE teams ADD COLUMN statuses TEXT DEFAULT NULL");
+        }
+        catch {
+            // Column already exists
+        }
+        // Agent subscriptions table for pull-based task execution
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_subscriptions (
+        agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+        task_status TEXT NOT NULL,
+        PRIMARY KEY (agent_id, task_status)
+      );
+    `);
+    }
+    // --- Team CRUD ---
+    /** Run a function inside a SQLite transaction (all-or-nothing). */
+    transaction(fn) {
+        return this.db.transaction(fn)();
+    }
+    createTeam(input) {
+        const { name, color = "", workspace = "", variables = {}, statuses } = input;
+        if (input.id !== undefined)
+            validateId(input.id);
+        if (name.length > MAX_NAME_LENGTH)
+            throw new Error(`Team name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+        if (color !== "" && !HEX_COLOR_RE.test(color))
+            throw new Error("color must be a valid hex color (e.g. #ef4444)");
+        if (workspace.length > MAX_WORKSPACE_LENGTH)
+            throw new Error(`workspace exceeds maximum length of ${MAX_WORKSPACE_LENGTH}`);
+        if (statuses !== undefined)
+            validateStatusConfigs(statuses);
+        validateVariables(variables);
+        const now = Date.now();
+        const id = input.id ?? randomUUID();
+        const statusesJson = statuses ? JSON.stringify(statuses) : null;
+        try {
+            this.db.prepare("INSERT INTO teams (id, name, color, workspace, variables, statuses, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(id, name, color, workspace, JSON.stringify(variables), statusesJson, now, now);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                throw new Error(`A team named "${name}" already exists`);
+            }
+            throw err;
+        }
+        return { id, name, color, workspace, statuses: statuses ?? undefined, createdAt: now, updatedAt: now };
+    }
+    updateTeam(id, input) {
+        const existing = this.getTeamById(id);
+        if (!existing)
+            return null;
+        const name = input.name ?? existing.name;
+        if (name.length > MAX_NAME_LENGTH)
+            throw new Error(`Team name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+        const color = input.color ?? existing.color;
+        const workspace = input.workspace ?? existing.workspace;
+        if (color !== "" && !HEX_COLOR_RE.test(color))
+            throw new Error("color must be a valid hex color (e.g. #ef4444)");
+        if (workspace.length > MAX_WORKSPACE_LENGTH)
+            throw new Error(`workspace exceeds maximum length of ${MAX_WORKSPACE_LENGTH}`);
+        // Variables: replace entirely if provided, otherwise keep existing
+        let variables;
+        if (input.variables !== undefined) {
+            validateVariables(input.variables);
+            variables = input.variables;
+        }
+        const varsJson = variables !== undefined ? JSON.stringify(variables) : undefined;
+        // Statuses: replace entirely if provided, otherwise keep existing
+        if (input.statuses !== undefined)
+            validateStatusConfigs(input.statuses);
+        const statuses = input.statuses !== undefined ? input.statuses : existing.statuses;
+        const statusesJson = input.statuses !== undefined ? (input.statuses ? JSON.stringify(input.statuses) : null) : undefined;
+        const now = Date.now();
+        const sets = ["name = ?", "color = ?", "workspace = ?", "updated_at = ?"];
+        const params = [name, color, workspace, now];
+        if (varsJson !== undefined) {
+            sets.splice(3, 0, "variables = ?");
+            params.splice(3, 0, varsJson);
+        }
+        if (statusesJson !== undefined) {
+            sets.splice(sets.length - 1, 0, "statuses = ?");
+            params.splice(params.length - 1, 0, statusesJson);
+        }
+        params.push(id);
+        this.db.prepare(`UPDATE teams SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+        return { ...existing, name, color, workspace, statuses: statuses ?? undefined, updatedAt: now };
+    }
+    deleteTeam(id) {
+        if (id === DEFAULT_TEAM_ID)
+            throw new Error("Cannot delete the default team");
+        const info = this.db.prepare("DELETE FROM teams WHERE id = ?").run(id);
+        return info.changes > 0;
+    }
+    getTeamById(id) {
+        const row = this.db.prepare("SELECT * FROM teams WHERE id = ?").get(id);
+        return row ? toTeam(row) : null;
+    }
+    getTeamByName(name) {
+        const row = this.db.prepare("SELECT * FROM teams WHERE name = ?").get(name);
+        return row ? toTeam(row) : null;
+    }
+    listTeams() {
+        const rows = this.db.prepare("SELECT * FROM teams ORDER BY created_at ASC").all();
+        return rows.map(toTeam);
+    }
+    /**
+     * Bootstrap helper:
+     * guarantees a team row with id "default" exists.
+     */
+    ensureTeamWhenEmpty() {
+        const existing = this.getTeamById(DEFAULT_TEAM_ID);
+        if (existing)
+            return existing;
+        return this.createTeam({ id: DEFAULT_TEAM_ID, name: DEFAULT_TEAM_NAME });
+    }
+    // --- Agent CRUD ---
+    createAgent(teamId, input) {
+        if (input.id !== undefined)
+            validateId(input.id);
+        if (input.name.length > MAX_NAME_LENGTH)
+            throw new Error(`Agent name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+        if (input.model.length > MAX_MODEL_LENGTH)
+            throw new Error(`Model string exceeds maximum length of ${MAX_MODEL_LENGTH}`);
+        if (input.identity && input.identity.length > MAX_IDENTITY_LENGTH)
+            throw new Error(`Identity exceeds maximum length of ${MAX_IDENTITY_LENGTH}`);
+        // Verify team exists (friendly error instead of FK violation)
+        const team = this.getTeamById(teamId);
+        if (!team)
+            throw new Error(`Team not found: ${teamId}`);
+        // Prevent multiple orchestrators per team
+        if (input.role === "orchestrator") {
+            const existing = this.db.prepare("SELECT id FROM agents WHERE team_id = ? AND role = 'orchestrator'").get(teamId);
+            if (existing)
+                throw new Error("Team already has an orchestrator — update the existing one instead");
+        }
+        const concurrency = input.concurrency ?? 1;
+        if (concurrency < MIN_CONCURRENCY || concurrency > MAX_CONCURRENCY) {
+            throw new Error(`concurrency must be between ${MIN_CONCURRENCY} and ${MAX_CONCURRENCY}`);
+        }
+        const subscriptions = input.subscriptions ?? [];
+        // Validate against team's custom statuses if present
+        const teamStatusKeys = team.statuses?.map((s) => s.key);
+        validateSubscriptions(subscriptions, teamStatusKeys);
+        const now = Date.now();
+        const id = input.id ?? randomUUID();
+        try {
+            this.db.transaction(() => {
+                this.db.prepare(`INSERT INTO agents (id, team_id, name, role, model, context_window, max_steps, identity, tools, timeout, template_id, concurrency, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, teamId, input.name, input.role, input.model, input.contextWindow ?? 0, input.maxSteps ?? 0, input.identity ?? "", JSON.stringify(input.tools ?? []), input.timeout ?? DEFAULT_WORKER_TIMEOUT_S, input.templateId ?? null, concurrency, now, now);
+                if (subscriptions.length > 0) {
+                    const ins = this.db.prepare("INSERT INTO agent_subscriptions (agent_id, task_status) VALUES (?, ?)");
+                    for (const s of subscriptions)
+                        ins.run(id, s);
+                }
+            })();
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                throw new Error(`Agent "${input.name}" already exists in this team`);
+            }
+            throw err;
+        }
+        return {
+            id, teamId, name: input.name, role: input.role, model: input.model,
+            contextWindow: input.contextWindow ?? 0, maxSteps: input.maxSteps ?? 0,
+            identity: input.identity ?? "", tools: input.tools ?? [],
+            timeout: input.timeout ?? DEFAULT_WORKER_TIMEOUT_S,
+            templateId: input.templateId ?? null,
+            subscriptions, concurrency,
+            createdAt: now, updatedAt: now,
+        };
+    }
+    updateAgent(id, input) {
+        if (input.name !== undefined && input.name.length > MAX_NAME_LENGTH)
+            throw new Error(`Agent name exceeds maximum length of ${MAX_NAME_LENGTH}`);
+        if (input.model !== undefined && input.model.length > MAX_MODEL_LENGTH)
+            throw new Error(`Model string exceeds maximum length of ${MAX_MODEL_LENGTH}`);
+        if (input.identity !== undefined && input.identity.length > MAX_IDENTITY_LENGTH)
+            throw new Error(`Identity exceeds maximum length of ${MAX_IDENTITY_LENGTH}`);
+        if (input.concurrency !== undefined && (input.concurrency < MIN_CONCURRENCY || input.concurrency > MAX_CONCURRENCY)) {
+            throw new Error(`concurrency must be between ${MIN_CONCURRENCY} and ${MAX_CONCURRENCY}`);
+        }
+        const existing = this.getAgentById(id);
+        if (!existing)
+            return null;
+        if (input.subscriptions !== undefined) {
+            const team = this.getTeamById(existing.teamId);
+            const teamStatusKeys = team?.statuses?.map((s) => s.key);
+            validateSubscriptions(input.subscriptions, teamStatusKeys);
+        }
+        const now = Date.now();
+        const updated = {
+            ...existing,
+            ...(input.name !== undefined && { name: input.name }),
+            ...(input.role !== undefined && { role: input.role }),
+            ...(input.model !== undefined && { model: input.model }),
+            ...(input.contextWindow !== undefined && { contextWindow: input.contextWindow }),
+            ...(input.maxSteps !== undefined && { maxSteps: input.maxSteps }),
+            ...(input.identity !== undefined && { identity: input.identity }),
+            ...(input.tools !== undefined && { tools: input.tools }),
+            ...(input.timeout !== undefined && { timeout: input.timeout }),
+            ...(input.templateId !== undefined && { templateId: input.templateId }),
+            ...(input.subscriptions !== undefined && { subscriptions: input.subscriptions }),
+            ...(input.concurrency !== undefined && { concurrency: input.concurrency }),
+            updatedAt: now,
+        };
+        this.db.transaction(() => {
+            this.db.prepare(`UPDATE agents SET name = ?, role = ?, model = ?, context_window = ?, max_steps = ?,
+         identity = ?, tools = ?, timeout = ?, template_id = ?, concurrency = ?, updated_at = ? WHERE id = ?`).run(updated.name, updated.role, updated.model, updated.contextWindow, updated.maxSteps, updated.identity, JSON.stringify(updated.tools), updated.timeout, updated.templateId ?? null, updated.concurrency, now, id);
+            if (input.subscriptions !== undefined) {
+                this.setSubscriptions(id, input.subscriptions);
+            }
+        })();
+        return updated;
+    }
+    deleteAgent(id) {
+        // Prevent deleting a team's only orchestrator
+        const agent = this.getAgentById(id);
+        if (agent?.role === "orchestrator") {
+            throw new Error("Cannot delete a team's orchestrator agent");
+        }
+        const info = this.db.prepare("DELETE FROM agents WHERE id = ?").run(id);
+        return info.changes > 0;
+    }
+    getAgentById(id) {
+        const row = this.db.prepare("SELECT * FROM agents WHERE id = ?").get(id);
+        if (!row)
+            return null;
+        return toAgentRow(row, this.getSubscriptions(id));
+    }
+    /**
+     * Runtime lookup for agent execution.
+     * Resolves template-linked identity and interpolates team variables.
+     */
+    getRuntimeAgentById(id) {
+        const row = this.db.prepare(`SELECT a.*,
+              t.name AS tname,
+              t.workspace AS tworkspace,
+              t.variables AS tvariables,
+              pt.content AS template_content
+       FROM agents a
+       LEFT JOIN teams t ON t.id = a.team_id
+       LEFT JOIN prompt_templates pt ON a.template_id = pt.id
+       WHERE a.id = ?`).get(id);
+        if (!row)
+            return null;
+        const resolvedIdentity = resolveAgentIdentity({
+            templateId: row.template_id ?? null,
+            templateContent: row.template_content ?? null,
+            rawIdentity: row.identity ?? "",
+            teamName: row.tname ?? "",
+            workspace: row.tworkspace ?? "",
+            teamVariables: parseTeamVariables(row.tvariables),
+        });
+        return toAgentRow(row, this.getSubscriptions(id), resolvedIdentity);
+    }
+    listAgentsByTeam(teamId) {
+        const rows = this.db.prepare("SELECT * FROM agents WHERE team_id = ? ORDER BY role ASC, created_at ASC").all(teamId);
+        if (rows.length === 0)
+            return [];
+        // Batch-load subscriptions to avoid N+1 queries
+        const agentIds = rows.map((r) => r.id);
+        const placeholders = agentIds.map(() => "?").join(", ");
+        const subRows = this.db.prepare(`SELECT agent_id, task_status FROM agent_subscriptions WHERE agent_id IN (${placeholders})`).all(...agentIds);
+        const subsMap = new Map();
+        for (const s of subRows) {
+            if (!subsMap.has(s.agent_id))
+                subsMap.set(s.agent_id, []);
+            subsMap.get(s.agent_id).push(s.task_status);
+        }
+        return rows.map((row) => toAgentRow(row, subsMap.get(row.id)));
+    }
+    getAgentByName(teamId, name) {
+        const row = this.db.prepare("SELECT * FROM agents WHERE team_id = ? AND name = ?").get(teamId, name);
+        if (!row)
+            return null;
+        return toAgentRow(row, this.getSubscriptions(row.id));
+    }
+    // --- Subscription CRUD ---
+    /** Replace an agent's subscriptions (transactional delete + reinsert). */
+    setSubscriptions(agentId, statuses) {
+        this.db.transaction(() => {
+            this.db.prepare("DELETE FROM agent_subscriptions WHERE agent_id = ?").run(agentId);
+            const insert = this.db.prepare("INSERT INTO agent_subscriptions (agent_id, task_status) VALUES (?, ?)");
+            for (const status of statuses) {
+                insert.run(agentId, status);
+            }
+        })();
+    }
+    /** Get an agent's subscribed task statuses. */
+    getSubscriptions(agentId) {
+        const rows = this.db.prepare("SELECT task_status FROM agent_subscriptions WHERE agent_id = ?").all(agentId);
+        return rows.map((r) => r.task_status);
+    }
+    /**
+     * Find claimable tasks by joining tasks, agent_subscriptions, and agents tables.
+     * Used by TaskSubscriberManager to find task/agent matches without raw DB access.
+     * Enforces concurrency at query time from live claim counts.
+     */
+    findClaimableTasks(limit) {
+        const rows = this.db.prepare(`
+      SELECT t.id AS task_id, s.agent_id, a.team_id, a.name AS agent_name, a.model, a.concurrency
+      FROM tasks t
+      JOIN agent_subscriptions s ON s.task_status = t.status
+      JOIN agents a ON a.id = s.agent_id
+      WHERE t.claimed_by IS NULL
+        AND t.needs_human_review = 0
+        AND t.team_id = a.team_id
+        AND (t.assignee IS NULL OR t.assignee = s.agent_id)
+        AND (
+          t.last_processed_by IS NULL
+          OR t.last_processed_for_updated_at IS NULL
+          OR t.last_processed_by != s.agent_id
+          OR t.last_processed_for_updated_at != t.updated_at
+        )
+        AND (
+          SELECT COUNT(*)
+          FROM tasks claimed
+          WHERE claimed.claimed_by = s.agent_id
+        ) < a.concurrency
+      ORDER BY
+        CASE WHEN t.assignee = s.agent_id THEN 0 ELSE 1 END,
+        t.created_at ASC
+      LIMIT ?
+    `).all(limit);
+        return rows.map((r) => ({
+            taskId: r.task_id,
+            agentId: r.agent_id,
+            teamId: r.team_id,
+            agentName: r.agent_name,
+            model: r.model,
+            concurrency: r.concurrency,
+        }));
+    }
+    /**
+     * Convert DB rows to the existing TeamConfig[] format so TeamRegistry
+     * constructor is unchanged. Uses a single JOIN query instead of N+1.
+     */
+    toTeamConfigs() {
+        const rows = this.db.prepare(`SELECT t.id AS tid, t.name AS tname, t.color AS tcolor,
+              t.workspace AS tworkspace, t.variables AS tvariables,
+              t.statuses AS tstatuses,
+              a.id, a.name, a.role, a.model, a.context_window, a.max_steps,
+              a.identity, a.tools, a.timeout, a.template_id, a.concurrency,
+              pt.content AS template_content
+       FROM teams t LEFT JOIN agents a ON a.team_id = t.id
+       LEFT JOIN prompt_templates pt ON a.template_id = pt.id
+       WHERE t.id != ?
+       ORDER BY t.created_at ASC, a.role ASC, a.created_at ASC`).all(DEFAULT_TEAM_ID);
+        // Batch-load all subscriptions into a map
+        const allSubs = this.db.prepare("SELECT agent_id, task_status FROM agent_subscriptions").all();
+        const subsMap = new Map();
+        for (const s of allSubs) {
+            if (!subsMap.has(s.agent_id))
+                subsMap.set(s.agent_id, []);
+            subsMap.get(s.agent_id).push(s.task_status);
+        }
+        const teamMap = new Map();
+        for (const row of rows) {
+            const tid = row.tid;
+            if (!teamMap.has(tid)) {
+                let variables = {};
+                try {
+                    variables = JSON.parse(row.tvariables || "{}");
+                }
+                catch { /* ignore */ }
+                let statuses;
+                if (typeof row.tstatuses === "string" && row.tstatuses) {
+                    try {
+                        statuses = JSON.parse(row.tstatuses);
+                    }
+                    catch { /* ignore */ }
+                }
+                teamMap.set(tid, {
+                    id: tid,
+                    name: row.tname,
+                    color: row.tcolor ?? "",
+                    workspace: row.tworkspace ?? "",
+                    variables,
+                    statuses,
+                    orchestrator: { ...FALLBACK_ORCHESTRATOR },
+                    workers: [],
+                });
+            }
+            // LEFT JOIN may produce a row with no agent columns
+            if (!row.id)
+                continue;
+            const team = teamMap.get(tid);
+            const agentId = row.id;
+            const agent = toAgentConfig(row, team.variables, subsMap.get(agentId));
+            if (row.role === "orchestrator") {
+                team.orchestrator = agent;
+            }
+            else {
+                team.workers.push(agent);
+            }
+        }
+        return [...teamMap.values()];
+    }
+    close() {
+        this.db.close();
+        logger.info("Team store closed");
+    }
+}
+function toTeam(row) {
+    let statuses;
+    if (typeof row.statuses === "string" && row.statuses) {
+        try {
+            statuses = JSON.parse(row.statuses);
+        }
+        catch { /* ignore */ }
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        color: row.color ?? "",
+        workspace: row.workspace ?? "",
+        statuses,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function toAgentConfig(row, teamVariables, subscriptions) {
+    let tools = [];
+    try {
+        tools = JSON.parse(row.tools || "[]");
+    }
+    catch {
+        tools = [];
+    }
+    const templateId = row.template_id ?? null;
+    const identity = resolveAgentIdentity({
+        templateId,
+        templateContent: row.template_content ?? null,
+        rawIdentity: row.identity ?? "",
+        teamName: row.tname ?? "",
+        workspace: row.tworkspace ?? "",
+        teamVariables,
+    });
+    return {
+        id: row.id,
+        name: row.name,
+        model: row.model,
+        contextWindow: row.context_window ?? 0,
+        maxSteps: row.max_steps ?? 0,
+        identity,
+        tools,
+        timeout: row.timeout ?? DEFAULT_WORKER_TIMEOUT_S,
+        templateId,
+        subscriptions: subscriptions ?? [],
+        concurrency: row.concurrency ?? 1,
+    };
+}
+function validateVariables(variables) {
+    const keys = Object.keys(variables);
+    if (keys.length > MAX_VARIABLES_COUNT) {
+        throw new Error(`Too many variables (max ${MAX_VARIABLES_COUNT})`);
+    }
+    for (const key of keys) {
+        if (!VARIABLE_KEY_RE.test(key)) {
+            throw new Error(`Invalid variable key "${key}": only letters, numbers, and underscores allowed`);
+        }
+        if (typeof variables[key] !== "string") {
+            throw new Error(`Variable "${key}" must have a string value`);
+        }
+        if (variables[key].length > MAX_VARIABLE_VALUE_LENGTH) {
+            throw new Error(`Variable "${key}" value exceeds maximum length of ${MAX_VARIABLE_VALUE_LENGTH}`);
+        }
+    }
+}
+/** Legacy fallback for teams without custom statuses. */
+const LEGACY_VALID_STATUSES = new Set(LEGACY_STATUS_KEYS);
+function validateSubscriptions(statuses, validStatuses) {
+    const allowed = validStatuses ? new Set(validStatuses) : LEGACY_VALID_STATUSES;
+    for (const s of statuses) {
+        if (!allowed.has(s)) {
+            const validList = validStatuses ? validStatuses.join(", ") : LEGACY_STATUS_KEYS.join(", ");
+            throw new Error(`Invalid subscription status "${s}". Valid: ${validList}`);
+        }
+    }
+}
+function toAgentRow(row, subscriptions, identityOverride) {
+    let tools = [];
+    try {
+        tools = JSON.parse(row.tools || "[]");
+    }
+    catch {
+        tools = [];
+    }
+    return {
+        id: row.id,
+        teamId: row.team_id,
+        name: row.name,
+        role: row.role,
+        model: row.model,
+        contextWindow: row.context_window ?? 0,
+        maxSteps: row.max_steps ?? 0,
+        identity: identityOverride ?? (row.identity ?? ""),
+        tools,
+        timeout: row.timeout ?? DEFAULT_WORKER_TIMEOUT_S,
+        templateId: row.template_id ?? null,
+        subscriptions: subscriptions ?? [],
+        concurrency: row.concurrency ?? 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function parseTeamVariables(raw) {
+    if (typeof raw !== "string" || raw.length === 0)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        const out = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (typeof value === "string")
+                out[key] = value;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function resolveAgentIdentity(input) {
+    const { templateId, templateContent, rawIdentity, teamName, workspace, teamVariables, } = input;
+    const baseIdentity = templateId && templateContent != null ? templateContent : rawIdentity;
+    if (!baseIdentity)
+        return "";
+    const variables = {
+        teamName,
+        workspace,
+        ...(teamVariables ?? {}),
+    };
+    return baseIdentity.replace(/\{\{(\w+)\}\}/g, (_, key) => variables[key] ?? `{{${key}}}`);
+}