@johpaz/hive-sdk 0.1.4 → 0.1.5

package/packages/core/src/agent/playbook-selector.ts

@@ -0,0 +1,119 @@
+/**
+ * HiveDB-based Playbook Rules Selector (ACE Curator)
+ *
+ * This module allows the Context Compiler to inject relevant evolved rules
+ * into the agent prompt based on semantic relevance to the current message.
+ * Search runs on the HiveDB capability index (Spanish stemming + accent
+ * folding, lenient parsing — raw user text never throws).
+ */
+
+import { col } from "../storage/hive"
+import type { PlaybookDoc } from "../storage/collections"
+import { logger } from "../utils/logger"
+import {
+    searchCapabilities,
+    applyRelativeCutoff,
+    replaceCapabilityDocs,
+    type CapabilityDoc,
+} from "./capability-search"
+
+const log = logger.child("playbook-selector")
+
+// ─── Types ───────────────────────────────────────────────────────────────────────
+
+export interface PlaybookRule {
+    id: string
+    rule: string
+    category: string
+    applicable_to?: string
+}
+
+// ─── Configuration ─────────────────────────────────────────────────────────────
+
+/** Maximum rules to inject per context window */
+const MAX_RULES_PER_TURN = 5
+
+/**
+ * Relative relevance cutoff: keep a hit only if it scores at least this
+ * fraction of the top hit (HiveDB BM25 scores are positive, higher = better).
+ */
+const RELEVANCE_RATIO = 0.3
+
+// ─── Selection Logic ───────────────────────────────────────────────────────────
+
+/**
+ * Select relevant rules from the Playbook based on semantic matching
+ */
+export async function selectPlaybookRules(message: string): Promise<PlaybookRule[]> {
+    const startTime = performance.now()
+
+    if (!message.trim()) return []
+
+    try {
+        const hits = await searchCapabilities(message, {
+            types: ["playbook"],
+            k: MAX_RULES_PER_TURN,
+        })
+
+        const relevantIds = applyRelativeCutoff(hits, RELEVANCE_RATIO).map(h => h.rawId)
+
+        if (relevantIds.length === 0) return []
+
+        // Fetch full rules
+        const playbookCol = await col<PlaybookDoc>("playbook")
+        const entries = await Promise.all(relevantIds.map(id => playbookCol.get(id)))
+        const rules: PlaybookRule[] = entries
+            .filter((e): e is NonNullable<typeof e> => !!e && e.doc.active)
+            .map(e => ({
+                id: e.id,
+                rule: e.doc.rule,
+                category: e.doc.category,
+                applicable_to: e.doc.applicable_to ?? undefined,
+            }))
+
+        const timing = performance.now() - startTime
+        log.info(`[playbook-selector] Selected ${rules.length} rules in ${timing.toFixed(2)}ms`)
+        if (rules.length > 0) {
+          log.debug(`[playbook-selector] Rules: ${rules.map(r => `[${r.id}] ${r.rule.substring(0, 60)}`).join(', ')}`)
+        }
+
+        return rules
+    } catch (err) {
+        log.error(`[playbook-selector] Failed to select rules:`, err)
+        return []
+    }
+}
+
+// ─── Sync Logic ───────────────────────────────────────────────────────────────
+
+/**
+ * Sync active playbook rules to the HiveDB capability index.
+ * Replaces all `type=playbook` documents atomically.
+ */
+export async function syncPlaybookToIndex(): Promise<void> {
+    try {
+        // Step 1: Get active rules
+        const playbookCol = await col<PlaybookDoc>("playbook")
+        const rules = (await playbookCol.scan({})).map(e => e.doc).filter(r => r.active)
+
+        if (rules.length === 0) {
+            log.debug(`[playbook-selector] No rules in playbook to sync`)
+        }
+
+        // Step 2: Replace all playbook documents in the capability index
+        const docs: CapabilityDoc[] = rules.map(item => ({
+            type: "playbook" as const,
+            rawId: item.id,
+            body: item.rule,
+            tags: [item.category, item.applicable_to].filter(Boolean).join(" "),
+        }))
+
+        await replaceCapabilityDocs("playbook", docs)
+
+        log.info(`[playbook-selector] Sync complete: ${rules.length} rules indexed in HiveDB`)
+
+    } catch (err) {
+        log.error(`[playbook-selector] Playbook index sync failed:`, err)
+        throw err
+    }
+}

package/packages/core/src/agent/{PromptBuilder.ts → prompt-builder.ts}

@@ -13,10 +13,11 @@
  * - Skills activos
  */
 
-import { getDb } from "../storage/SQLiteStorage.ts"
-import { logger } from "../utils/logger.ts"
-import { formatContext } from "../utils/toon.ts"
-import { resolveUserId } from "../storage/onboarding.ts"
+import { col } from "../storage/hive"
+import type { EthicsDoc, AgentDoc, UserDoc } from "../storage/collections"
+import { logger } from "../utils/logger"
+import { formatContext } from "../utils/toon"
+import { resolveUserId } from "../storage/onboarding"
 
 const log = logger.child("prompt-builder")
 
@@ -35,18 +36,16 @@ export interface BuildSystemPromptOpts {
  * 4. Identidad del usuario (nombre, preferencias, contexto)
  */
 export async function buildSystemPrompt(opts: BuildSystemPromptOpts): Promise<string> {
-  const db = getDb()
   const { agentId, userId } = opts
 
   // ──────────────────────────────────────────────────────────────────────────
   // 1. ÉTICA — Capa constitucional (siempre completa)
   // ──────────────────────────────────────────────────────────────────────────
-  const ethicsRules = db.query<any, []>(`
-    SELECT name, content, description
-    FROM ethics
-    WHERE enabled = 1 AND active = 1
-    ORDER BY is_default DESC, id ASC
-  `).all()
+  const ethicsCol = await col<EthicsDoc>("ethics")
+  const ethicsRules = (await ethicsCol.scan({}))
+    .map(e => e.doc)
+    .filter(r => r.enabled && r.active)
+    .sort((a, b) => (b.is_default ? 1 : 0) - (a.is_default ? 1 : 0) || a.id.localeCompare(b.id))
 
   let ethicsSection = ""
   if (ethicsRules.length > 0) {
@@ -68,11 +67,9 @@ export async function buildSystemPrompt(opts: BuildSystemPromptOpts): Promise<st
   // ──────────────────────────────────────────────────────────────────────────
   // 2. IDENTIDAD DEL AGENTE
   // ──────────────────────────────────────────────────────────────────────────
-  const agent = db.query<any, [string]>(`
-    SELECT id, name, role, description, system_prompt, tone, max_iterations, workspace
-    FROM agents
-    WHERE id = ?
-  `).get(agentId)
+  const agentsCol = await col<AgentDoc>("agents")
+  const agentEntry = await agentsCol.get(agentId)
+  const agent = agentEntry?.doc
 
   if (!agent) {
     throw new Error(`Agent not found: ${agentId}`)
@@ -119,11 +116,9 @@ export async function buildSystemPrompt(opts: BuildSystemPromptOpts): Promise<st
   // ──────────────────────────────────────────────────────────────────────────
   // 3. IDENTIDAD DEL USUARIO
   // ──────────────────────────────────────────────────────────────────────────
-  const user = db.query<any, [string]>(`
-    SELECT id, name, language,  timezone, occupation, notes
-    FROM users
-    WHERE id = ?
-  `).get(userId)
+  const usersCol = await col<UserDoc>("users")
+  const userEntry = await usersCol.get(userId)
+  const user = userEntry?.doc
 
   let userSection = `# IDENTIDAD DEL USUARIO\n\n`
 
@@ -131,6 +126,7 @@ export async function buildSystemPrompt(opts: BuildSystemPromptOpts): Promise<st
     const userData: Record<string, string | null> = {}
 
     if (user.name) userData.Nombre = user.name
+    if (agent.role === "coordinator" && user.email) userData.CorreoPropio = user.email
     if (user.language) userData.Idioma = user.language
     if (user.timezone) userData.ZonaHoraria = user.timezone
     if (user.occupation) userData.Ocupación = user.occupation
@@ -139,6 +135,9 @@ export async function buildSystemPrompt(opts: BuildSystemPromptOpts): Promise<st
     // Usar TOON para comprimir datos del usuario
     if (Object.keys(userData).length > 0) {
       userSection += formatContext(userData) + "\n\n"
+      if (agent.role === "coordinator" && user.email) {
+        userSection += `Cuando el usuario diga "envíame", "mándame" o "a mi correo" sin indicar otro destinatario, usá CorreoPropio. Para terceras personas, resolvé su dirección por separado.\n\n`
+      }
     } else {
       userSection += `Usuario ID: ${userId}\n\n`
     }
@@ -164,6 +163,6 @@ export async function buildSystemPromptWithProjects(opts: {
   agentId: string
   userId?: string
 }): Promise<string> {
-  const userId = opts.userId || resolveUserId({}) || "default"
+  const userId = opts.userId || (await resolveUserId({})) || "default"
   return buildSystemPrompt({ agentId: opts.agentId, userId })
 }

package/packages/core/src/{harness → agent}/proof-packet.ts

@@ -1,20 +1,18 @@
 /**
- * Proof packets — compressed evidence artifact for a completed run
- * (harness-engineering "proof" practice): what was intended, what was
+ * Proof packets — compressed evidence artifact for a completed goal/project
+ * run (harness-engineering "proof" practice): what was intended, what was
  * checked, what evidence backs the verdict, and known limits. Written once
- * per run so a reviewer doesn't have to replay the whole run to trust its
- * outcome.
+ * per run by the goal_run / project_task executors after verification, so a
+ * reviewer doesn't have to replay the whole run to trust its outcome.
  */
 
-import { col, nextId } from "./db-helpers";
-import type { ProofPacketDoc } from "./collections";
-import type { AcceptanceResult } from "./goal-verifier";
+import { col, nextId, toIndexable } from "../storage/hive";
+import type { ProofPacketDoc } from "../storage/collections";
+import type { AcceptanceResult } from "./goal-runner";
 import type { RunEpoch } from "./run-epoch";
 import { logger } from "../utils/logger";
 
-const log = logger.child("harness:proof-packet");
-
-const COLLECTION = "harness_proofPackets";
+const log = logger.child("proof-packet");
 
 export interface BuildProofPacketInput {
   runId: string;
@@ -27,10 +25,14 @@ export interface BuildProofPacketInput {
   evidence: string[];
   knownLimits?: string | null;
   epoch?: RunEpoch | null;
+  catalogAgentId?: string | null;
 }
 
 export async function buildProofPacket(input: BuildProofPacketInput): Promise<ProofPacketDoc> {
-  const id = await nextId(COLLECTION);
+  if (input.met && (input.checksRun.length === 0 || input.evidence.length === 0)) {
+    throw new Error("A successful proof packet requires at least one check run and non-empty evidence");
+  }
+  const id = await nextId("proofPackets");
   const acceptanceResults: AcceptanceResult[] =
     input.acceptanceResults ?? [{ id: "goal", description: input.intendedOutcome, met: input.met, evidence: input.evidence.join("; ") || "n/a" }];
 
@@ -44,26 +46,19 @@ export async function buildProofPacket(input: BuildProofPacketInput): Promise<Pr
     evidence_json: JSON.stringify(input.evidence),
     known_limits: input.knownLimits ?? null,
     epoch_json: input.epoch ? JSON.stringify(input.epoch) : null,
+    catalog_agent_id: toIndexable(input.catalogAgentId),
     met: input.met,
     created_at: Date.now(),
   };
 
-  const c = await col<ProofPacketDoc>(COLLECTION);
+  const c = await col<ProofPacketDoc>("proofPackets");
   await c.put(id, doc, { expectedVersion: 0 });
   log.info(`[buildProofPacket] Packet ${id} written for run ${input.runId} (met=${input.met})`);
   return doc;
 }
 
 export async function findProofPacketsByRun(runId: string): Promise<ProofPacketDoc[]> {
-  const c = await col<ProofPacketDoc>(COLLECTION);
+  const c = await col<ProofPacketDoc>("proofPackets");
   const entries = await c.findBy("run_id", runId);
   return entries.map((e) => e.doc);
 }
-
-export async function ensureProofPacketIndexes(): Promise<void> {
-  const c = await col<ProofPacketDoc>(COLLECTION);
-  await c.createIndex("run_id");
-  await c.createIndex("agent_id");
-}
-
-export { COLLECTION as PROOF_PACKETS_COLLECTION };

package/packages/core/src/agent/providers/index.ts

@@ -7,14 +7,19 @@
 
 import type { Config } from "../../config/loader.ts"
 import { logger } from "../../utils/logger.ts"
-import { getDb } from "../../storage/SQLiteStorage.ts"
-import { getAgentLoop } from "../AgentRunner.ts"
-import { resolveUserId, resolveAgentId } from "../../storage/onboarding.ts"
-import type { ContentPart } from "../../multimodal/types.ts"
-
-export type Provider = "openai" | "anthropic" | "gemini" | "mistral" | "kimi" | "ollama" | "openrouter" | "deepseek" | "nvidia"
-
-import type { StepEvent } from "../AgentRunner.ts"
+import { getAgentLoop } from "../agent-loop"
+import { resolveUserId, resolveAgentId } from "../../storage/onboarding"
+import type { ContentPart } from "../../multimodal/types"
+import type { TurnSource } from "../../storage/collections"
+
+export type Provider = "openai" | "anthropic" | "gemini" | "mistral" | "kimi" | "ollama" | "openrouter" | "deepseek" | "nvidia" | "hiveagents" | "z-ai" | "modelscope" | "minimax" | "qwen" | "groq" | "opencode-go"
+
+export interface StepEvent {
+  type: "text" | "plan" | "tool_call" | "tool_result"
+  message: string
+  toolName?: string
+  isError?: boolean
+}
 
 export interface ModelOptions {
   provider?: Provider
@@ -26,12 +31,22 @@ export interface ModelOptions {
   tools?: Record<string, any>
   maxSteps?: number
   onToken?: (token: string) => void
+  onReasoningToken?: (token: string) => void
   onStep?: (step: StepEvent) => Promise<void>
   threadId?: string
   userId?: string
+  agentId?: string
   channel?: string
   rawUserMessage?: string
   signal?: AbortSignal
+  /** Durable run options — checkpoint/resume via agentRuns (see run-store). */
+  runId?: string
+  resume?: boolean
+  durable?: boolean
+  turnId?: string
+  sessionId?: string
+  /** See AgentLoopOptions.historySource in agent-loop.ts. */
+  historySource?: TurnSource
 }
 
 export interface ModelResponse {
@@ -57,12 +72,11 @@ export class AgentRunner {
   }
 
   async generate(options: ModelOptions): Promise<ModelResponse> {
-    const db = getDb()
-    // Resolve agentId from database (coordinator or first enabled)
-    const agentId = resolveAgentId(null) || "main"
+    // Resolve agentId from explicit option or database (coordinator/first enabled)
+    const agentId = options.agentId || (await resolveAgentId(null)) || "main"
 
     // Resolve userId from database
-    const userId = options.userId || resolveUserId({})
+    const userId = options.userId || (await resolveUserId({}))
     if (!userId) {
       throw new Error("No userId provided. Please complete onboarding first.")
     }
@@ -90,8 +104,16 @@ export class AgentRunner {
             // system_prompt intentionally omitted — context-compiler builds it
             channel: options.channel,
             raw_user_message: options.rawUserMessage,
+            run_id: options.runId,
+            resume: options.resume,
+            durable: options.durable,
+            turn_id: options.turnId,
+            session_id: options.sessionId,
+            history_source: options.historySource,
           },
           signal: options.signal,
+          onToken: options.onToken,
+          onReasoningToken: options.onReasoningToken,
         }
       )
 
@@ -122,7 +144,7 @@ export class AgentRunner {
             } else {
               logger.debug(`[STREAM] Content empty or whitespace only, skipping accumulation`)
             }
-            if (options.onToken) options.onToken(content)
+            if (options.onToken && !chunk.agent.streamed) options.onToken(content)
           } else {
             logger.debug(`[STREAM] No content in chunk, lastMsg.content is falsy`)
           }
@@ -194,6 +216,3 @@ export class AgentRunner {
   }
 }
 
-export function createAgentRunner(config: Config): AgentRunner {
-  return new AgentRunner(config)
-}