@johpaz/hive-sdk 0.1.3 → 0.1.5

package/packages/core/src/config/loader.ts

@@ -1,6 +1,7 @@
 import * as z from "zod";
 import { mkdirSync, existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
+import { availableParallelism, homedir } from "node:os";
 
 const LogLevelSchema = z.enum(["debug", "info", "warn", "error"]);
 const DMPolicySchema = z.enum(["open", "pairing", "allowlist"]);
@@ -32,7 +33,7 @@ export function getHiveDir(): string {
   // Priority 1: HIVE_HOME explicitly set
   if (process.env.HIVE_HOME) {
     const hiveDir = process.env.HIVE_HOME.startsWith("~")
-      ? path.join(process.env.HOME || "", process.env.HIVE_HOME.slice(1))
+      ? path.join(homedir(), process.env.HIVE_HOME.slice(1))
       : process.env.HIVE_HOME;
     loadEnv(hiveDir);
     return hiveDir;
@@ -48,7 +49,7 @@ export function getHiveDir(): string {
   }
 
   // Priority 3: Default ~/.hive
-  const defaultDir = path.join(process.env.HOME || "", ".hive");
+  const defaultDir = path.join(homedir(), ".hive");
   loadEnv(defaultDir);
   return defaultDir;
 }
@@ -59,7 +60,7 @@ const expandPath = (p: string): string => {
     return p.replace("~/.hive", hiveDir);
   }
   if (p.startsWith("~")) {
-    return path.join(process.env.HOME || "", p.slice(1));
+    return path.join(homedir(), p.slice(1));
   }
   return p;
 };
@@ -116,9 +117,9 @@ const WebConfigSchema = z.object({
 
 const BrowserConfigSchema = z.object({
   enabled: z.boolean().optional(),
-  sessionName: z.string().optional(),
   headless: z.boolean().optional(),
   timeoutMs: z.number().optional(),
+  sessionName: z.string().optional(),
 });
 
 const CanvasConfigSchema = z.object({
@@ -126,6 +127,13 @@ const CanvasConfigSchema = z.object({
   port: z.number().optional(),
 });
 
+const WorkerPoolConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  maxWorkers: z.number().optional(),
+  toolTimeoutMs: z.number().optional(),
+  parallelToolCalls: z.boolean().optional(),
+});
+
 const SandboxConfigSchema = z.object({
   dm: ToolRestrictionsSchema.optional(),
   group: ToolRestrictionsSchema.optional(),
@@ -138,7 +146,12 @@ const ToolsConfigSchema = z.object({
   web: WebConfigSchema.optional(),
   browser: BrowserConfigSchema.optional(),
   canvas: CanvasConfigSchema.optional(),
+  workerPool: WorkerPoolConfigSchema.optional(),
   sandbox: SandboxConfigSchema.optional(),
+  // Per-tool timeout overrides (ms) keyed by tool name. Falls back to
+  // workerPool.toolTimeoutMs when absent. Long-running tools like cli_exec
+  // should set a higher value (e.g. 600000 = 10min).
+  timeouts: z.record(z.string(), z.number()).optional(),
 });
 
 const ContextConfigSchema = z.object({
@@ -237,6 +250,13 @@ const CronConfigSchema = z.object({
   timezone: z.string().optional(),
 });
 
+// G9 causal event log (HiveDB): IntentLogged/StateTransition/ToolCall emission
+// from agent-loop.ts, consumed by reflector/curator/context-compiler. Off by
+// default — each turn adds N+M+1 awaited db.append() calls to the critical path.
+const CausalLogConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+});
+
 const RetryConfigSchema = z.object({
   maxAttempts: z.number().optional(),
   initialDelayMs: z.number().optional(),
@@ -244,6 +264,25 @@ const RetryConfigSchema = z.object({
   maxDelayMs: z.number().optional(),
 });
 
+const JobRetryConfigSchema = z.object({
+  // Logical-failure retries (executor returned {ok:false}). Separate from
+  // JobDoc.attempts, which only counts crash/lease-expiry reclaims.
+  maxRetries: z.number().optional(),
+  initialDelayMs: z.number().optional(),
+  backoffMultiplier: z.number().optional(),
+  maxDelayMs: z.number().optional(),
+  jitter: z.number().optional(),
+});
+
+const HarnessConfigSchema = z.object({
+  maxGlobalConcurrency: z.number().optional(),
+  taskTimeoutMs: z.number().optional(),
+  jobLeaseMs: z.number().optional(),
+  runLeaseMs: z.number().optional(),
+  leaseRenewMs: z.number().optional(),
+  jobRetry: JobRetryConfigSchema.optional(),
+});
+
 const HooksConfigSchema = z.object({
   scripts: z.object({
     before_model_resolve: z.string().optional(),
@@ -281,7 +320,7 @@ const GatewayConfigSchema = z.object({
 });
 
 const ModelsConfigSchema = z.object({
-  defaultProvider: z.enum(["openai", "anthropic", "gemini", "mistral", "kimi", "ollama", "openrouter", "deepseek"]).optional(),
+  defaultProvider: z.enum(["openai", "anthropic", "gemini", "mistral", "kimi", "ollama", "openrouter", "deepseek", "hiveagents"]).optional(),
   defaults: z.record(z.string(), z.string()).optional(),
   providers: z.record(z.string(), ProviderConfigSchema).optional(),
 });
@@ -307,17 +346,6 @@ const SecurityConfigSchema = z.object({
   allowedUsers: z.array(z.string()).optional(),
 });
 
-const CaptchaConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  autoSolve: z.boolean().optional(),
-  visionProvider: z.enum(["gemini", "openai", "anthropic"]).optional(),
-  visionModel: z.string().optional(),
-  maxAttempts: z.number().optional(),
-  maxRounds: z.number().optional(),
-  apiKey: z.string().optional(),
-  enabledSites: z.array(z.string()).optional(),
-});
-
 const UserConfigSchema = z.object({
   id: z.string(),
   name: z.string(),
@@ -345,10 +373,11 @@ const ConfigSchema = z.object({
   mcp: MCPConfigSchema.optional(),
   memory: MemoryConfigSchema.optional(),
   cron: CronConfigSchema.optional(),
+  causalLog: CausalLogConfigSchema.optional(),
   retry: RetryConfigSchema.optional(),
+  harness: HarnessConfigSchema.optional(),
   security: SecurityConfigSchema.optional(),
   hooks: HooksConfigSchema.optional(),
-  captcha: CaptchaConfigSchema.optional(),
 });
 
 export type Config = z.infer<typeof ConfigSchema>;
@@ -358,7 +387,6 @@ export type MCPServerConfig = z.infer<typeof MCPServerConfigSchema>;
 export type AgentEntry = z.infer<typeof AgentEntrySchema>;
 export type Binding = z.infer<typeof BindingSchema>;
 export type UserConfig = z.infer<typeof UserConfigSchema>;
-export type CaptchaConfig = z.infer<typeof CaptchaConfigSchema>;
 
 function buildDefaultConfig(): Config {
   const hiveDir = getHiveDir();
@@ -428,7 +456,7 @@ function buildDefaultConfig(): Config {
         allowlist: [],
         denylist: ["rm -rf /", "sudo", "chmod 777", "> /dev/", "mkfs"],
         timeoutSeconds: 30,
-        workDir: path.join(process.env.HOME || "", "exec"), // Points to home for exec by default
+        workDir: path.join(homedir(), "exec"), // Points to home for exec by default
       },
       web: {
         allowlist: [],
@@ -437,14 +465,20 @@ function buildDefaultConfig(): Config {
       },
       browser: {
         enabled: true,
-        sessionName: "hive",
         headless: true,
         timeoutMs: 30000,
+        sessionName: "hive",
       },
       canvas: {
         enabled: true,
         port: 18793,
       },
+      workerPool: {
+        enabled: true,
+        maxWorkers: Math.min(4, availableParallelism()),
+        toolTimeoutMs: 300000,
+        parallelToolCalls: true,
+      },
       sandbox: {
         dm: { allow: ["*"], deny: [] },
         group: { allow: ["*"], deny: [] },
@@ -480,12 +514,29 @@ function buildDefaultConfig(): Config {
       maxConcurrentJobs: 5,
       timezone: "UTC",
     },
+    causalLog: {
+      enabled: process.env.HIVE_CAUSAL_LOG === "true",
+    },
     retry: {
       maxAttempts: 3,
       initialDelayMs: 1000,
       backoffMultiplier: 2,
       maxDelayMs: 30000,
     },
+    harness: {
+      maxGlobalConcurrency: parseInt(process.env.HIVE_HARNESS_MAX_CONCURRENCY || "4", 10),
+      taskTimeoutMs: parseInt(process.env.HIVE_HARNESS_TASK_TIMEOUT_MS || String(30 * 60 * 1000), 10),
+      jobLeaseMs: parseInt(process.env.HIVE_HARNESS_JOB_LEASE_MS || String(30 * 60 * 1000), 10),
+      runLeaseMs: parseInt(process.env.HIVE_HARNESS_RUN_LEASE_MS || String(2 * 60 * 1000), 10),
+      leaseRenewMs: parseInt(process.env.HIVE_HARNESS_LEASE_RENEW_MS || "30000", 10),
+      jobRetry: {
+        maxRetries: parseInt(process.env.HIVE_HARNESS_JOB_MAX_RETRIES || "3", 10),
+        initialDelayMs: parseInt(process.env.HIVE_HARNESS_JOB_RETRY_INITIAL_MS || "1000", 10),
+        backoffMultiplier: parseFloat(process.env.HIVE_HARNESS_JOB_RETRY_MULTIPLIER || "2"),
+        maxDelayMs: parseInt(process.env.HIVE_HARNESS_JOB_RETRY_MAX_MS || String(5 * 60 * 1000), 10),
+        jitter: parseFloat(process.env.HIVE_HARNESS_JOB_RETRY_JITTER || "0.2"),
+      },
+    },
     security: {
       maxMessageLength: {
         telegram: 4096,
@@ -500,15 +551,6 @@ function buildDefaultConfig(): Config {
     hooks: {
       scripts: {},
     },
-    captcha: {
-      enabled: false,
-      autoSolve: true,
-      visionProvider: 'gemini',
-      visionModel: 'gemini-2.0-flash-exp',
-      maxAttempts: 3,
-      maxRounds: 5,
-      enabledSites: [],
-    },
   };
 }
 

package/packages/core/src/ethics/EthicsGuard.test.ts

@@ -1,54 +1,108 @@
-import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+process.env.HIVE_DB_PATH = ":memory:";
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { EthicsGuard } from "./EthicsGuard.ts";
-import { getDb, initializeDatabase, dbService } from "../storage/SQLiteStorage.ts";
+import { closeHiveDb } from "../storage/hivedb.ts";
+import { ensureHiveDb } from "../storage/bootstrap.ts";
+import { col } from "../storage/hive.ts";
+import { toIndexable } from "../storage/hive.ts";
+import type { PlaybookDoc } from "../storage/collections.ts";
+
+async function addRule(id: string, rule: string, category: string, opts?: {
+	applicableTo?: string;
+	helpfulCount?: number;
+	active?: boolean;
+}) {
+	const playbookCol = await col<PlaybookDoc>("playbook");
+	const now = Date.now();
+	await playbookCol.put(id, {
+		id,
+		rule,
+		category,
+		applicable_to: opts?.applicableTo ?? null,
+		helpful_count: opts?.helpfulCount ?? 0,
+		harmful_count: 0,
+		active: opts?.active ?? true,
+		source_reflection_id: toIndexable(null),
+		created_at: now,
+		updated_at: now,
+	});
+}
+
+beforeEach(async () => {
+	closeHiveDb();
+	await ensureHiveDb();
+});
+
+afterEach(() => {
+	closeHiveDb();
+});
 
 describe("EthicsGuard", () => {
-	let db: any;
+	it("sólo devuelve reglas de response_quality activas", async () => {
+		await addRule("rq-1", "Verificá las fuentes antes de responder", "response_quality");
+		await addRule("rq-2", "Regla apagada", "response_quality", { active: false });
+		await addRule("otra", "Usá web_search para noticias", "tool_selection");
+
+		const rules = await new EthicsGuard().getRules();
 
-	beforeAll(async () => {
-		await initializeDatabase();
-		db = getDb();
-		db.run(`
-			INSERT OR IGNORE INTO playbook (id, rule, category, applicable_to, helpful_count, active)
-			VALUES (1, 'Siempre verificar fuentes antes de responder', 'response_quality', 'agent', 5, 1)
-		`);
+		expect(rules.map((r) => r.id)).toEqual(["rq-1"]);
 	});
 
-	afterAll(() => {
-		dbService.close();
+	it("ordena por helpful_count descendente", async () => {
+		await addRule("poco", "poco útil", "response_quality", { helpfulCount: 1 });
+		await addRule("mucho", "muy útil", "response_quality", { helpfulCount: 9 });
+
+		const rules = await new EthicsGuard().getRules();
+
+		expect(rules.map((r) => r.id)).toEqual(["mucho", "poco"]);
 	});
 
-	it("loads rules from DB", () => {
-		const guard = new EthicsGuard(db);
-		const rules = guard.getRules();
-		expect(Array.isArray(rules)).toBe(true);
+	it("filtra por agentRole cuando alguna regla lo declara", async () => {
+		await addRule("para-coord", "regla del coordinador", "response_quality", {
+			applicableTo: JSON.stringify(["coordinator"]),
+		});
+		await addRule("para-worker", "regla del worker", "response_quality", {
+			applicableTo: JSON.stringify(["worker"]),
+		});
+
+		const rules = await new EthicsGuard().getRules("coordinator");
+
+		expect(rules.map((r) => r.id)).toEqual(["para-coord"]);
 	});
 
-	it("injectIntoPrompt appends rules to system prompt", () => {
-		const guard = new EthicsGuard(db);
-		const rules = guard.getRules();
-		const result = guard.injectIntoPrompt("Eres un asistente.", rules);
-		expect(result).toContain("Eres un asistente.");
-		if (rules.length > 0) {
-			expect(result).toContain("Calidad de Respuesta");
-		}
+	it("cae a todas las reglas si ninguna declara ese rol", async () => {
+		// Sin esto, un `applicable_to` mal cargado dejaría al agente sin capa
+		// de calidad en vez de con una de más.
+		await addRule("generica", "regla general", "response_quality", {
+			applicableTo: JSON.stringify(["worker"]),
+		});
+
+		const rules = await new EthicsGuard().getRules("coordinator");
+
+		expect(rules.map((r) => r.id)).toEqual(["generica"]);
 	});
 
-	it("hasEthicsLayer detects response quality rules", () => {
-		const guard = new EthicsGuard(db);
-		const has = guard.hasEthicsLayer();
-		expect(typeof has).toBe("boolean");
+	it("injectIntoPrompt agrega las reglas y conserva el prompt original", async () => {
+		await addRule("rq-1", "Verificá las fuentes", "response_quality");
+
+		const guard = new EthicsGuard();
+		const result = guard.injectIntoPrompt("Eres un asistente.", await guard.getRules());
+
+		expect(result).toContain("Eres un asistente.");
+		expect(result).toContain("## Reglas de Calidad de Respuesta");
+		expect(result).toContain("- Verificá las fuentes");
 	});
 
-	it("getRules accepts optional agentRole for FTS5 search", () => {
-		const guard = new EthicsGuard(db);
-		const rules = guard.getRules("agent");
-		expect(Array.isArray(rules)).toBe(true);
+	it("injectIntoPrompt devuelve el prompt intacto sin reglas", () => {
+		expect(new EthicsGuard().injectIntoPrompt("Eres un asistente.", [])).toBe("Eres un asistente.");
 	});
 
-	it("getRules without agentRole returns all rules", () => {
-		const guard = new EthicsGuard(db);
-		const rules = guard.getRules();
-		expect(Array.isArray(rules)).toBe(true);
+	it("hasEthicsLayer refleja si hay reglas cargadas", async () => {
+		const guard = new EthicsGuard();
+		expect(await guard.hasEthicsLayer()).toBe(false);
+
+		await addRule("rq-1", "Verificá las fuentes", "response_quality");
+		expect(await guard.hasEthicsLayer()).toBe(true);
 	});
 });

package/packages/core/src/ethics/EthicsGuard.ts

@@ -1,66 +1,70 @@
+/**
+ * EthicsGuard — capa de reglas de calidad de respuesta sobre el system prompt.
+ *
+ * Lee las reglas `category: "response_quality"` de la colección `playbook`.
+ * Hasta 0.1.5 esta clase recibía un handle de SQLite y armaba SQL a mano
+ * (incluyendo un JOIN contra la tabla virtual `playbook_fts`); esas tablas ya no
+ * existen. Ahora la fuente es HiveDB, igual que para el resto del catálogo.
+ *
+ * Nota: la ética "constitucional" de un agente no pasa por acá — vive en la
+ * colección `ethics` y la ensambla `agent/prompt-builder.ts` como primera
+ * sección del prompt. Este guard es un complemento opcional para hosts que
+ * quieran inyectar reglas aprendidas por ACE.
+ */
+
+import { col } from "../storage/hive.ts";
+import type { PlaybookDoc } from "../storage/collections.ts";
+
 export interface EthicsRule {
-	id: number;
+	id: string;
 	rule: string;
 	category: string;
-	applicable_to: string;
+	applicable_to: string | null;
 	helpful_count: number;
-	active: number;
+	active: boolean;
 }
 
-export class EthicsGuard {
-	private db: any;
+const RESPONSE_QUALITY = "response_quality";
 
-	constructor(db: any) {
-		this.db = db;
-	}
-
-	getRules(agentRole?: string): EthicsRule[] {
-		if (!agentRole) {
-			return this.db
-				.query(
-					`SELECT p.* FROM playbook p
-           WHERE p.category = 'response_quality' AND p.active = 1
-           ORDER BY p.helpful_count DESC`
-				)
-				.all() as EthicsRule[];
-		}
+function byUsefulness(a: EthicsRule, b: EthicsRule): number {
+	return b.helpful_count - a.helpful_count;
+}
 
-		try {
-			const ftsRows = this.db
-				.query(
-					`SELECT p.* FROM playbook p
-           JOIN playbook_fts fts ON p.rowid = fts.rowid
-           WHERE fts.playbook_fts MATCH ?
-           AND p.category = 'response_quality' AND p.active = 1
-         ORDER BY p.helpful_count DESC`,
-					[agentRole]
-				)
-				.all() as EthicsRule[];
+export class EthicsGuard {
+	/**
+	 * Reglas activas de calidad de respuesta.
+	 *
+	 * Con `agentRole` filtra por las que lo declaran en `applicable_to`; si
+	 * ninguna coincide devuelve todas, para no dejar al agente sin capa por un
+	 * `applicable_to` mal cargado.
+	 */
+	async getRules(agentRole?: string): Promise<EthicsRule[]> {
+		const playbookCol = await col<PlaybookDoc>("playbook");
+		const all = (await playbookCol.scan({}))
+			.map((e) => ({
+				id: e.id,
+				rule: e.doc.rule,
+				category: e.doc.category,
+				applicable_to: e.doc.applicable_to,
+				helpful_count: e.doc.helpful_count ?? 0,
+				active: e.doc.active,
+			}))
+			.filter((r) => r.active && r.category === RESPONSE_QUALITY)
+			.sort(byUsefulness);
 
-			if (ftsRows.length > 0) return ftsRows;
-		} catch {}
+		if (!agentRole) return all;
 
-		return this.db
-			.query(
-				`SELECT * FROM playbook
-         WHERE category = 'response_quality' AND active = 1
-         ORDER BY helpful_count DESC`
-			)
-			.all() as EthicsRule[];
+		const matching = all.filter((r) => (r.applicable_to ?? "").includes(agentRole));
+		return matching.length > 0 ? matching : all;
 	}
 
 	injectIntoPrompt(systemPrompt: string, rules: EthicsRule[]): string {
 		if (rules.length === 0) return systemPrompt;
-		const ethicsSection = rules
-			.map(r => `- ${r.rule}`)
-			.join("\n");
+		const ethicsSection = rules.map((r) => `- ${r.rule}`).join("\n");
 		return `${systemPrompt}\n\n## Reglas de Calidad de Respuesta\n${ethicsSection}`;
 	}
 
-	hasEthicsLayer(): boolean {
-		const count = this.db
-			.query(`SELECT COUNT(*) as c FROM playbook WHERE category = 'response_quality' AND active = 1`)
-			.get() as any;
-		return (count?.c ?? 0) > 0;
+	async hasEthicsLayer(): Promise<boolean> {
+		return (await this.getRules()).length > 0;
 	}
 }

package/packages/core/src/events/agent-bus.ts

@@ -11,7 +11,8 @@
 
 import { EventEmitter } from "events";
 import { logger } from "../utils/logger";
-import { getDb } from "../storage/SQLiteStorage";
+import { col, nextId, toIndexable, fromIndexable, BROADCAST } from "../storage/hive";
+import type { AgentBusMessageDoc, TaskDoc } from "../storage/collections";
 
 const log = logger.child("agent-bus");
 
@@ -122,8 +123,6 @@ export interface AgentBusMessage {
  * Guarda un mensaje en la base de datos para persistencia
  */
 function persistMessage(event: AgentBusEventKey, data: any, metadata?: Record<string, unknown>): void {
-  const db = getDb();
-  
   // Extraer IDs de worker según el tipo de evento
   let fromWorkerId: string | null = null;
   let toWorkerId: string | null = null;
@@ -167,87 +166,64 @@ function persistMessage(event: AgentBusEventKey, data: any, metadata?: Record<st
       content = JSON.stringify(data);
   }
 
-  try {
-    db.query(`
-      INSERT OR IGNORE INTO agent_bus_messages
-        (event_type, from_worker_id, to_worker_id, topic, content, metadata, created_at, read)
-      VALUES (?, ?, ?, ?, ?, ?, unixepoch(), 0)
-    `).run(
-      event,
-      fromWorkerId,
-      toWorkerId,
-      topic,
-      content,
-      metadata ? JSON.stringify(metadata) : null
-    );
-  } catch (err) {
-    log.warn(`Failed to persist message (non-critical): ${(err as Error).message}`);
-  }
+  Promise.resolve().then(async () => {
+    try {
+      const messagesCol = await col<AgentBusMessageDoc>("agentBusMessages");
+      const id = await nextId("agentBusMessages");
+      await messagesCol.put(id, {
+        id,
+        event_type: event,
+        from_worker_id: toIndexable(fromWorkerId),
+        to_worker_id: toWorkerId ? toWorkerId : BROADCAST,
+        topic,
+        content,
+        metadata: metadata ? JSON.stringify(metadata) : null,
+        created_at: Date.now(),
+        read: false,
+      }, { expectedVersion: 0 });
+    } catch (err) {
+      log.warn(`Failed to persist message (non-critical): ${(err as Error).message}`);
+    }
+  });
+}
+
+function docToMessage(doc: AgentBusMessageDoc): AgentBusMessage {
+  return {
+    id: parseInt(doc.id, 10),
+    event_type: doc.event_type,
+    from_worker_id: fromIndexable(doc.from_worker_id),
+    to_worker_id: doc.to_worker_id === BROADCAST ? null : doc.to_worker_id,
+    topic: doc.topic,
+    content: doc.content,
+    metadata: doc.metadata,
+    created_at: doc.created_at,
+    read: doc.read ? 1 : 0,
+  };
 }
 
 /**
  * Obtiene mensajes no leídos para un worker específico
  */
-export function getUnreadMessagesForWorker(workerId: string, limit: number = 50): AgentBusMessage[] {
-  const db = getDb();
-  
+export async function getUnreadMessagesForWorker(workerId: string, limit: number = 50): Promise<AgentBusMessage[]> {
   try {
-    const messages = db.query<any, [string, number]>(`
-      SELECT * FROM agent_bus_messages 
-      WHERE (to_worker_id = ? OR to_worker_id IS NULL) AND read = 0
-      ORDER BY created_at ASC
-      LIMIT ?
-    `).all(workerId, limit);
+    const messagesCol = await col<AgentBusMessageDoc>("agentBusMessages");
+    const entries = (await messagesCol.scan({}))
+      .filter(e => !e.doc.read && (e.doc.to_worker_id === workerId || e.doc.to_worker_id === BROADCAST))
+      .sort((a, b) => a.doc.created_at - b.doc.created_at)
+      .slice(0, limit);
 
     // Marcar como leídos
-    if (messages.length > 0) {
-      const ids = messages.map((m: AgentBusMessage) => m.id).join(",");
-      db.query(`UPDATE agent_bus_messages SET read = 1 WHERE id IN (${ids})`).run();
+    for (const entry of entries) {
+      await messagesCol.put(entry.id, { ...entry.doc, read: true }, { expectedVersion: entry.version });
     }
 
-    return messages;
+    return entries.map(e => docToMessage(e.doc));
   } catch (err) {
     log.error(`Failed to get unread messages: ${(err as Error).message}`);
     return [];
   }
 }
 
-/**
- * Obtiene el historial de mensajes de un proyecto
- */
-export function getProjectMessageHistory(projectId: string, limit: number = 100): AgentBusMessage[] {
-  const db = getDb();
-  
-  try {
-    // Primero obtenemos los task_ids del proyecto
-    const tasks = db.query<any, [string]>(
-      "SELECT id FROM tasks WHERE project_id = ?"
-    ).all(projectId);
-
-    if (tasks.length === 0) return [];
-
-    // Obtenemos los agent_ids de las tareas
-    const agentIds = tasks
-      .map((t: any) => t.agent_id)
-      .filter((id: string | null) => id !== null);
-
-    if (agentIds.length === 0) return [];
-
-    // Obtenemos mensajes relacionados a estos agents
-    const placeholders = agentIds.map(() => "?").join(",");
-    const messages = db.query<any, any[]>(`
-      SELECT * FROM agent_bus_messages 
-      WHERE from_worker_id IN (${placeholders})
-      ORDER BY created_at DESC
-      LIMIT ?
-    `).all([...agentIds, limit]);
-
-    return messages;
-  } catch (err) {
-    log.error(`Failed to get project message history: ${(err as Error).message}`);
-    return [];
-  }
-}
 
 // ─── Agent Bus Implementation ────────────────────────────────────────────────