cowork-os 0.3.21

package/dist/electron/electron/agent/tools/x-tools.js

@@ -0,0 +1,264 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XTools = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const x_manager_1 = require("../../settings/x-manager");
+const x_cli_1 = require("../../utils/x-cli");
+const MAX_COUNT = 50;
+const MAX_MEDIA = 4;
+class XTools {
+    constructor(workspace, daemon, taskId) {
+        this.workspace = workspace;
+        this.daemon = daemon;
+        this.taskId = taskId;
+    }
+    setWorkspace(workspace) {
+        this.workspace = workspace;
+    }
+    static isEnabled() {
+        return x_manager_1.XSettingsManager.loadSettings().enabled;
+    }
+    normalizeHandle(handle) {
+        if (!handle)
+            return undefined;
+        const trimmed = handle.trim();
+        if (!trimmed)
+            return undefined;
+        return trimmed.startsWith('@') ? trimmed : `@${trimmed}`;
+    }
+    resolveMediaPaths(media) {
+        if (!media || media.length === 0)
+            return [];
+        if (!this.workspace.permissions.read) {
+            throw new Error('Read permission not granted for media uploads');
+        }
+        const normalized = media
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0)
+            .slice(0, MAX_MEDIA);
+        const workspaceRoot = path.resolve(this.workspace.path);
+        const allowedPaths = this.workspace.permissions.allowedPaths || [];
+        const canReadOutside = this.workspace.isTemp || this.workspace.permissions.unrestrictedFileAccess;
+        const isPathAllowed = (absolutePath) => {
+            if (allowedPaths.length === 0)
+                return false;
+            const normalizedPath = path.normalize(absolutePath);
+            return allowedPaths.some((allowed) => {
+                const normalizedAllowed = path.normalize(allowed);
+                return normalizedPath === normalizedAllowed || normalizedPath.startsWith(normalizedAllowed + path.sep);
+            });
+        };
+        const resolved = normalized.map((item) => {
+            const candidate = path.isAbsolute(item)
+                ? path.normalize(item)
+                : path.resolve(workspaceRoot, item);
+            const relative = path.relative(workspaceRoot, candidate);
+            const isInsideWorkspace = !(relative.startsWith('..') || path.isAbsolute(relative));
+            if (!isInsideWorkspace && !canReadOutside && !isPathAllowed(candidate)) {
+                throw new Error('Media path must be inside the workspace or in Allowed Paths');
+            }
+            if (!fs.existsSync(candidate)) {
+                throw new Error(`Media file not found: ${item}`);
+            }
+            const stats = fs.statSync(candidate);
+            if (!stats.isFile()) {
+                throw new Error(`Media path is not a file: ${item}`);
+            }
+            return candidate;
+        });
+        return resolved;
+    }
+    async requireApproval(summary, details) {
+        const approved = await this.daemon.requestApproval(this.taskId, 'external_service', summary, details);
+        if (!approved) {
+            throw new Error('User denied X action');
+        }
+    }
+    async executeAction(input) {
+        const settings = x_manager_1.XSettingsManager.loadSettings();
+        if (!settings.enabled) {
+            throw new Error('X integration is disabled. Enable it in Settings > More Channels > X.');
+        }
+        const action = input.action;
+        if (!action) {
+            throw new Error('Missing required "action" parameter');
+        }
+        const args = [];
+        switch (action) {
+            case 'whoami': {
+                args.push('whoami');
+                break;
+            }
+            case 'read': {
+                if (!input.id_or_url)
+                    throw new Error('Missing id_or_url for read');
+                args.push('read', input.id_or_url);
+                break;
+            }
+            case 'thread': {
+                if (!input.id_or_url)
+                    throw new Error('Missing id_or_url for thread');
+                args.push('thread', input.id_or_url);
+                break;
+            }
+            case 'replies': {
+                if (!input.id_or_url)
+                    throw new Error('Missing id_or_url for replies');
+                args.push('replies', input.id_or_url);
+                break;
+            }
+            case 'search': {
+                if (!input.query)
+                    throw new Error('Missing query for search');
+                args.push('search', input.query);
+                if (input.count) {
+                    const count = Math.min(Math.max(1, input.count), MAX_COUNT);
+                    args.push('-n', String(count));
+                }
+                break;
+            }
+            case 'user_tweets': {
+                const handle = this.normalizeHandle(input.user);
+                if (!handle)
+                    throw new Error('Missing user for user_tweets');
+                args.push('user-tweets', handle);
+                if (input.count) {
+                    const count = Math.min(Math.max(1, input.count), MAX_COUNT);
+                    args.push('-n', String(count));
+                }
+                break;
+            }
+            case 'mentions': {
+                args.push('mentions');
+                const handle = this.normalizeHandle(input.user);
+                if (handle) {
+                    args.push('--user', handle);
+                }
+                if (input.count) {
+                    const count = Math.min(Math.max(1, input.count), MAX_COUNT);
+                    args.push('-n', String(count));
+                }
+                break;
+            }
+            case 'home': {
+                args.push('home');
+                if (input.timeline === 'following') {
+                    args.push('--following');
+                }
+                if (input.count) {
+                    const count = Math.min(Math.max(1, input.count), MAX_COUNT);
+                    args.push('-n', String(count));
+                }
+                break;
+            }
+            case 'tweet': {
+                if (!input.text)
+                    throw new Error('Missing text for tweet');
+                const mediaPaths = this.resolveMediaPaths(input.media);
+                const preview = input.text.length > 120 ? `${input.text.slice(0, 117)}...` : input.text;
+                await this.requireApproval(`Post to X: "${preview}"`, {
+                    action: 'tweet',
+                    text: input.text,
+                    mediaCount: mediaPaths.length,
+                });
+                args.push('tweet', input.text);
+                for (const mediaPath of mediaPaths) {
+                    args.push('--media', mediaPath);
+                }
+                if (input.alt) {
+                    args.push('--alt', input.alt);
+                }
+                break;
+            }
+            case 'reply': {
+                if (!input.id_or_url)
+                    throw new Error('Missing id_or_url for reply');
+                if (!input.text)
+                    throw new Error('Missing text for reply');
+                const mediaPaths = this.resolveMediaPaths(input.media);
+                const preview = input.text.length > 120 ? `${input.text.slice(0, 117)}...` : input.text;
+                await this.requireApproval(`Reply on X: "${preview}"`, {
+                    action: 'reply',
+                    inReplyTo: input.id_or_url,
+                    text: input.text,
+                    mediaCount: mediaPaths.length,
+                });
+                args.push('reply', input.id_or_url, input.text);
+                for (const mediaPath of mediaPaths) {
+                    args.push('--media', mediaPath);
+                }
+                if (input.alt) {
+                    args.push('--alt', input.alt);
+                }
+                break;
+            }
+            case 'follow': {
+                const handle = this.normalizeHandle(input.user);
+                if (!handle)
+                    throw new Error('Missing user for follow');
+                await this.requireApproval(`Follow ${handle} on X`, { action: 'follow', user: handle });
+                args.push('follow', handle);
+                break;
+            }
+            case 'unfollow': {
+                const handle = this.normalizeHandle(input.user);
+                if (!handle)
+                    throw new Error('Missing user for unfollow');
+                await this.requireApproval(`Unfollow ${handle} on X`, { action: 'unfollow', user: handle });
+                args.push('unfollow', handle);
+                break;
+            }
+            default:
+                throw new Error(`Unsupported action: ${action}`);
+        }
+        const result = await (0, x_cli_1.runBirdCommand)(settings, args, { json: true });
+        this.daemon.logEvent(this.taskId, 'tool_result', {
+            tool: 'x_action',
+            action,
+            hasData: !!result.data,
+            stderr: result.stderr ? true : false,
+        });
+        return {
+            success: true,
+            action,
+            output: result.stdout,
+            data: result.data,
+            stderr: result.stderr || undefined,
+        };
+    }
+}
+exports.XTools = XTools;

package/dist/electron/electron/agents/AgentRoleRepository.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRoleRepository = void 0;
+const uuid_1 = require("uuid");
+const types_1 = require("../../shared/types");
+/**
+ * Safely parse JSON with error handling
+ */
+function safeJsonParse(jsonString, defaultValue, context) {
+    if (!jsonString)
+        return defaultValue;
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (error) {
+        console.error(`Failed to parse JSON${context ? ` in ${context}` : ''}:`, error);
+        return defaultValue;
+    }
+}
+/**
+ * Repository for managing agent roles in the database
+ */
+class AgentRoleRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Create a new agent role
+     */
+    create(request) {
+        const now = Date.now();
+        const role = {
+            id: (0, uuid_1.v4)(),
+            name: request.name,
+            displayName: request.displayName,
+            description: request.description,
+            icon: request.icon || '🤖',
+            color: request.color || '#6366f1',
+            personalityId: request.personalityId,
+            modelKey: request.modelKey,
+            providerType: request.providerType,
+            systemPrompt: request.systemPrompt,
+            capabilities: request.capabilities,
+            toolRestrictions: request.toolRestrictions,
+            isSystem: false,
+            isActive: true,
+            sortOrder: 100,
+            createdAt: now,
+            updatedAt: now,
+            // Mission Control fields
+            autonomyLevel: request.autonomyLevel || 'specialist',
+            soul: request.soul,
+            heartbeatEnabled: request.heartbeatEnabled || false,
+            heartbeatIntervalMinutes: request.heartbeatIntervalMinutes || 15,
+            heartbeatStaggerOffset: request.heartbeatStaggerOffset || 0,
+            heartbeatStatus: 'idle',
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO agent_roles (
+        id, name, display_name, description, icon, color,
+        personality_id, model_key, provider_type, system_prompt,
+        capabilities, tool_restrictions, is_system, is_active,
+        sort_order, created_at, updated_at,
+        autonomy_level, soul, heartbeat_enabled, heartbeat_interval_minutes,
+        heartbeat_stagger_offset, heartbeat_status
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(role.id, role.name, role.displayName, role.description || null, role.icon, role.color, role.personalityId || null, role.modelKey || null, role.providerType || null, role.systemPrompt || null, JSON.stringify(role.capabilities), role.toolRestrictions ? JSON.stringify(role.toolRestrictions) : null, role.isSystem ? 1 : 0, role.isActive ? 1 : 0, role.sortOrder, role.createdAt, role.updatedAt, role.autonomyLevel, role.soul || null, role.heartbeatEnabled ? 1 : 0, role.heartbeatIntervalMinutes, role.heartbeatStaggerOffset, role.heartbeatStatus);
+        return role;
+    }
+    /**
+     * Find an agent role by ID
+     */
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM agent_roles WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToAgentRole(row) : undefined;
+    }
+    /**
+     * Find an agent role by name
+     */
+    findByName(name) {
+        const stmt = this.db.prepare('SELECT * FROM agent_roles WHERE name = ?');
+        const row = stmt.get(name);
+        return row ? this.mapRowToAgentRole(row) : undefined;
+    }
+    /**
+     * Find all agent roles
+     */
+    findAll(includeInactive = false) {
+        const stmt = includeInactive
+            ? this.db.prepare('SELECT * FROM agent_roles ORDER BY sort_order ASC, created_at ASC')
+            : this.db.prepare('SELECT * FROM agent_roles WHERE is_active = 1 ORDER BY sort_order ASC, created_at ASC');
+        const rows = stmt.all();
+        return rows.map(row => this.mapRowToAgentRole(row));
+    }
+    /**
+     * Find all active agent roles
+     */
+    findActive() {
+        return this.findAll(false);
+    }
+    /**
+     * Update an agent role
+     */
+    update(request) {
+        const existing = this.findById(request.id);
+        if (!existing) {
+            return undefined;
+        }
+        // Don't allow updating system roles' core properties
+        if (existing.isSystem && (request.capabilities || request.toolRestrictions)) {
+            console.warn('Cannot modify capabilities or tool restrictions of system agent roles');
+        }
+        const fields = [];
+        const values = [];
+        if (request.displayName !== undefined) {
+            fields.push('display_name = ?');
+            values.push(request.displayName);
+        }
+        if (request.description !== undefined) {
+            fields.push('description = ?');
+            values.push(request.description);
+        }
+        if (request.icon !== undefined) {
+            fields.push('icon = ?');
+            values.push(request.icon);
+        }
+        if (request.color !== undefined) {
+            fields.push('color = ?');
+            values.push(request.color);
+        }
+        if (request.personalityId !== undefined) {
+            fields.push('personality_id = ?');
+            values.push(request.personalityId);
+        }
+        if (request.modelKey !== undefined) {
+            fields.push('model_key = ?');
+            values.push(request.modelKey);
+        }
+        if (request.providerType !== undefined) {
+            fields.push('provider_type = ?');
+            values.push(request.providerType);
+        }
+        if (request.systemPrompt !== undefined) {
+            fields.push('system_prompt = ?');
+            values.push(request.systemPrompt);
+        }
+        if (request.capabilities !== undefined && !existing.isSystem) {
+            fields.push('capabilities = ?');
+            values.push(JSON.stringify(request.capabilities));
+        }
+        if (request.toolRestrictions !== undefined && !existing.isSystem) {
+            fields.push('tool_restrictions = ?');
+            values.push(request.toolRestrictions ? JSON.stringify(request.toolRestrictions) : null);
+        }
+        if (request.isActive !== undefined) {
+            fields.push('is_active = ?');
+            values.push(request.isActive ? 1 : 0);
+        }
+        if (request.sortOrder !== undefined) {
+            fields.push('sort_order = ?');
+            values.push(request.sortOrder);
+        }
+        // Mission Control fields
+        if (request.autonomyLevel !== undefined) {
+            fields.push('autonomy_level = ?');
+            values.push(request.autonomyLevel);
+        }
+        if (request.soul !== undefined) {
+            fields.push('soul = ?');
+            values.push(request.soul);
+        }
+        if (request.heartbeatEnabled !== undefined) {
+            fields.push('heartbeat_enabled = ?');
+            values.push(request.heartbeatEnabled ? 1 : 0);
+        }
+        if (request.heartbeatIntervalMinutes !== undefined) {
+            fields.push('heartbeat_interval_minutes = ?');
+            values.push(request.heartbeatIntervalMinutes);
+        }
+        if (request.heartbeatStaggerOffset !== undefined) {
+            fields.push('heartbeat_stagger_offset = ?');
+            values.push(request.heartbeatStaggerOffset);
+        }
+        if (fields.length === 0) {
+            return existing;
+        }
+        fields.push('updated_at = ?');
+        values.push(Date.now());
+        values.push(request.id);
+        const sql = `UPDATE agent_roles SET ${fields.join(', ')} WHERE id = ?`;
+        this.db.prepare(sql).run(...values);
+        return this.findById(request.id);
+    }
+    /**
+     * Delete an agent role (only non-system roles)
+     */
+    delete(id) {
+        const existing = this.findById(id);
+        if (!existing) {
+            return false;
+        }
+        if (existing.isSystem) {
+            console.warn('Cannot delete system agent roles');
+            return false;
+        }
+        const stmt = this.db.prepare('DELETE FROM agent_roles WHERE id = ? AND is_system = 0');
+        const result = stmt.run(id);
+        return result.changes > 0;
+    }
+    /**
+     * Seed default agent roles if none exist
+     */
+    seedDefaults() {
+        const existing = this.findAll(true);
+        if (existing.length > 0) {
+            return existing;
+        }
+        const seeded = [];
+        const now = Date.now();
+        for (const defaultRole of types_1.DEFAULT_AGENT_ROLES) {
+            const role = {
+                id: (0, uuid_1.v4)(),
+                ...defaultRole,
+                createdAt: now,
+                updatedAt: now,
+                // Ensure Mission Control fields have defaults
+                heartbeatEnabled: false,
+                heartbeatIntervalMinutes: 15,
+                heartbeatStaggerOffset: 0,
+                heartbeatStatus: 'idle',
+            };
+            const stmt = this.db.prepare(`
+        INSERT INTO agent_roles (
+          id, name, display_name, description, icon, color,
+          personality_id, model_key, provider_type, system_prompt,
+          capabilities, tool_restrictions, is_system, is_active,
+          sort_order, created_at, updated_at,
+          autonomy_level, heartbeat_enabled, heartbeat_interval_minutes,
+          heartbeat_stagger_offset, heartbeat_status
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            stmt.run(role.id, role.name, role.displayName, role.description || null, role.icon, role.color, role.personalityId || null, role.modelKey || null, role.providerType || null, role.systemPrompt || null, JSON.stringify(role.capabilities), role.toolRestrictions ? JSON.stringify(role.toolRestrictions) : null, role.isSystem ? 1 : 0, role.isActive ? 1 : 0, role.sortOrder, role.createdAt, role.updatedAt, role.autonomyLevel || 'specialist', role.heartbeatEnabled ? 1 : 0, role.heartbeatIntervalMinutes, role.heartbeatStaggerOffset, role.heartbeatStatus);
+            seeded.push(role);
+        }
+        return seeded;
+    }
+    /**
+     * Check if any agent roles exist
+     */
+    hasAny() {
+        const stmt = this.db.prepare('SELECT COUNT(*) as count FROM agent_roles');
+        const result = stmt.get();
+        return result.count > 0;
+    }
+    /**
+     * Sync new default agents to existing workspace
+     * This adds any missing default agents without overwriting existing ones
+     */
+    syncNewDefaults() {
+        const existing = this.findAll(true);
+        const existingNames = new Set(existing.map(a => a.name));
+        const added = [];
+        const now = Date.now();
+        for (const defaultRole of types_1.DEFAULT_AGENT_ROLES) {
+            // Skip if already exists
+            if (existingNames.has(defaultRole.name)) {
+                continue;
+            }
+            const role = {
+                id: (0, uuid_1.v4)(),
+                ...defaultRole,
+                createdAt: now,
+                updatedAt: now,
+                heartbeatEnabled: false,
+                heartbeatIntervalMinutes: 15,
+                heartbeatStaggerOffset: 0,
+                heartbeatStatus: 'idle',
+            };
+            const stmt = this.db.prepare(`
+        INSERT INTO agent_roles (
+          id, name, display_name, description, icon, color,
+          personality_id, model_key, provider_type, system_prompt,
+          capabilities, tool_restrictions, is_system, is_active,
+          sort_order, created_at, updated_at,
+          autonomy_level, heartbeat_enabled, heartbeat_interval_minutes,
+          heartbeat_stagger_offset, heartbeat_status
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            stmt.run(role.id, role.name, role.displayName, role.description || null, role.icon, role.color, role.personalityId || null, role.modelKey || null, role.providerType || null, role.systemPrompt || null, JSON.stringify(role.capabilities), role.toolRestrictions ? JSON.stringify(role.toolRestrictions) : null, role.isSystem ? 1 : 0, role.isActive ? 1 : 0, role.sortOrder, role.createdAt, role.updatedAt, role.autonomyLevel || 'specialist', role.heartbeatEnabled ? 1 : 0, role.heartbeatIntervalMinutes, role.heartbeatStaggerOffset, role.heartbeatStatus);
+            added.push(role);
+            console.log(`[AgentRoleRepository] Added new default agent: ${role.displayName}`);
+        }
+        if (added.length > 0) {
+            console.log(`[AgentRoleRepository] Synced ${added.length} new default agent(s)`);
+        }
+        return added;
+    }
+    /**
+     * Map database row to AgentRole object
+     */
+    mapRowToAgentRole(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            displayName: row.display_name,
+            description: row.description || undefined,
+            icon: row.icon || '🤖',
+            color: row.color || '#6366f1',
+            personalityId: row.personality_id || undefined,
+            modelKey: row.model_key || undefined,
+            providerType: row.provider_type || undefined,
+            systemPrompt: row.system_prompt || undefined,
+            capabilities: safeJsonParse(row.capabilities, [], 'agentRole.capabilities'),
+            toolRestrictions: safeJsonParse(row.tool_restrictions, undefined, 'agentRole.toolRestrictions'),
+            isSystem: row.is_system === 1,
+            isActive: row.is_active === 1,
+            sortOrder: row.sort_order || 100,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            // Mission Control fields
+            autonomyLevel: row.autonomy_level || 'specialist',
+            soul: row.soul || undefined,
+            heartbeatEnabled: row.heartbeat_enabled === 1,
+            heartbeatIntervalMinutes: row.heartbeat_interval_minutes || 15,
+            heartbeatStaggerOffset: row.heartbeat_stagger_offset || 0,
+            lastHeartbeatAt: row.last_heartbeat_at || undefined,
+            heartbeatStatus: row.heartbeat_status || 'idle',
+        };
+    }
+    // ============ Mission Control Methods ============
+    /**
+     * Find all agents with heartbeat enabled
+     */
+    findHeartbeatEnabled() {
+        const stmt = this.db.prepare('SELECT * FROM agent_roles WHERE heartbeat_enabled = 1 AND is_active = 1 ORDER BY sort_order ASC');
+        const rows = stmt.all();
+        return rows.map(row => this.mapRowToAgentRole(row));
+    }
+    /**
+     * Update heartbeat configuration for an agent
+     */
+    updateHeartbeatConfig(id, config) {
+        const existing = this.findById(id);
+        if (!existing) {
+            return undefined;
+        }
+        const fields = [];
+        const values = [];
+        if (config.heartbeatEnabled !== undefined) {
+            fields.push('heartbeat_enabled = ?');
+            values.push(config.heartbeatEnabled ? 1 : 0);
+        }
+        if (config.heartbeatIntervalMinutes !== undefined) {
+            fields.push('heartbeat_interval_minutes = ?');
+            values.push(config.heartbeatIntervalMinutes);
+        }
+        if (config.heartbeatStaggerOffset !== undefined) {
+            fields.push('heartbeat_stagger_offset = ?');
+            values.push(config.heartbeatStaggerOffset);
+        }
+        if (fields.length === 0) {
+            return existing;
+        }
+        fields.push('updated_at = ?');
+        values.push(Date.now());
+        values.push(id);
+        const sql = `UPDATE agent_roles SET ${fields.join(', ')} WHERE id = ?`;
+        this.db.prepare(sql).run(...values);
+        return this.findById(id);
+    }
+    /**
+     * Update heartbeat status for an agent
+     */
+    updateHeartbeatStatus(id, status, lastHeartbeatAt) {
+        const fields = ['heartbeat_status = ?'];
+        const values = [status];
+        if (lastHeartbeatAt !== undefined) {
+            fields.push('last_heartbeat_at = ?');
+            values.push(lastHeartbeatAt);
+        }
+        values.push(id);
+        const sql = `UPDATE agent_roles SET ${fields.join(', ')} WHERE id = ?`;
+        this.db.prepare(sql).run(...values);
+    }
+    /**
+     * Update soul (extended personality) for an agent
+     */
+    updateSoul(id, soul) {
+        const existing = this.findById(id);
+        if (!existing) {
+            return undefined;
+        }
+        const stmt = this.db.prepare('UPDATE agent_roles SET soul = ?, updated_at = ? WHERE id = ?');
+        stmt.run(soul, Date.now(), id);
+        return this.findById(id);
+    }
+    /**
+     * Update autonomy level for an agent
+     */
+    updateAutonomyLevel(id, level) {
+        const existing = this.findById(id);
+        if (!existing) {
+            return undefined;
+        }
+        const stmt = this.db.prepare('UPDATE agent_roles SET autonomy_level = ?, updated_at = ? WHERE id = ?');
+        stmt.run(level, Date.now(), id);
+        return this.findById(id);
+    }
+    /**
+     * Get agents by autonomy level
+     */
+    findByAutonomyLevel(level) {
+        const stmt = this.db.prepare('SELECT * FROM agent_roles WHERE autonomy_level = ? AND is_active = 1 ORDER BY sort_order ASC');
+        const rows = stmt.all(level);
+        return rows.map(row => this.mapRowToAgentRole(row));
+    }
+}
+exports.AgentRoleRepository = AgentRoleRepository;