@johpaz/hive-sdk 0.1.4 → 0.1.5

package/packages/core/src/{harness → agent}/run-store.ts

@@ -1,49 +1,48 @@
 /**
- * run-store — persistent checkpoint + lease for harness runs. Ported from
- * `hive`'s agent/run-store.ts.
+ * run-store — persistent checkpoint + lease for agentRuns.
  *
- * A HarnessRunDoc tracks the lifecycle of a single durable agent invocation
+ * An AgentRun tracks the lifecycle of a single agent-loop invocation
  * (chat turn, worker task, goal run). Its checkpoint (state_json) allows
  * resuming after a crash: messages, iteration count, token totals and
- * pending tool calls are persisted after every round-trip — when the host
- * app chooses to call `checkpoint()` from its own agent loop (this module
- * does not wire itself into `AgentRunner` automatically).
+ * pending tool calls are persisted after every round-trip.
  *
  * All write operations use OCC (expectedVersion). Only the owning loop
  * should write to a run; single-writer pattern keeps contention minimal.
  */
 
-import { col, updateDoc, nextId } from "./db-helpers";
-import type { HarnessRunDoc } from "./collections";
-import { getBootId } from "./boot-id";
+import { col, updateDoc, nextId, toIndexable } from "../storage/hive";
+import type { AgentRunDoc } from "../storage/collections";
+import { getBootId } from "../storage/boot-id";
 import { logger } from "../utils/logger";
+import { loadConfig } from "../config/loader";
+import type { LLMMessage } from "./llm-client";
 import type { RunEpoch } from "./run-epoch";
+import { formatInternalEvent } from "./conversation-store";
 
-const log = logger.child("harness:run-store");
+const log = logger.child("run-store");
 
-const COLLECTION = "harness_agentRuns";
 const MAX_STATE_BYTES = 1_500_000;
+const MAX_RETRIES = 5;
 
-let leaseRenewIntervalMs = 30_000;
-let leaseDurationMs = 2 * 60 * 1000;
+function runLeaseDurationMs(): number {
+  return loadConfig().harness?.runLeaseMs ?? 2 * 60 * 1000;
+}
 
-/** Override the run lease duration / renewal interval (defaults: 2min / 30s). */
-export function setRunLeaseConfig(opts: { leaseDurationMs?: number; leaseRenewIntervalMs?: number }): void {
-  if (opts.leaseDurationMs !== undefined) leaseDurationMs = opts.leaseDurationMs;
-  if (opts.leaseRenewIntervalMs !== undefined) leaseRenewIntervalMs = opts.leaseRenewIntervalMs;
+function leaseRenewIntervalMs(): number {
+  return loadConfig().harness?.leaseRenewMs ?? 30_000;
 }
 
 export interface RunCheckpointState {
   version: 1
-  messages: unknown[]
+  messages: LLMMessage[]
   iterations: number
   totalInputTokens: number
   totalOutputTokens: number
-  lastToolSignature?: string
-  consecutiveRepeat?: number
-  idleIterations?: number
-  injectedToolNames?: string[]
-  systemPromptSkillSections?: string[]
+  lastToolSignature: string
+  consecutiveRepeat: number
+  idleIterations: number
+  injectedToolNames: string[]
+  systemPromptSkillSections: string[]
 }
 
 /** Whole-job acceptance criterion (harness-engineering "proof" concept). */
@@ -59,22 +58,23 @@ export interface CreateRunInput {
   agent_id: string
   user_id: string
   channel: string | null
-  kind: string
+  kind: AgentRunDoc["kind"]
   max_iterations: number
   max_turns?: number | null
   max_tokens?: number | null
   goal?: string | null
   goal_check_tool?: string | null
-  resume_policy?: HarnessRunDoc["resume_policy"]
+  resume_policy?: AgentRunDoc["resume_policy"]
   acceptance?: AcceptanceCriterion[]
   epoch?: RunEpoch
+  catalog_agent_id?: string | null
 }
 
-export async function createRun(input: CreateRunInput): Promise<HarnessRunDoc> {
+export async function createRun(input: CreateRunInput): Promise<AgentRunDoc> {
   const id = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
   const now = Date.now();
   const bootId = getBootId();
-  const doc: HarnessRunDoc = {
+  const doc: AgentRunDoc = {
     id,
     thread_id: input.thread_id,
     agent_id: input.agent_id,
@@ -96,66 +96,72 @@ export async function createRun(input: CreateRunInput): Promise<HarnessRunDoc> {
     pending_tool_calls_json: null,
     checkpointed_at: now,
     boot_id: bootId,
-    lease_expires_at: now + leaseDurationMs,
+    lease_expires_at: now + runLeaseDurationMs(),
     resume_policy: input.resume_policy ?? "resume",
     acceptance_json: input.acceptance ? JSON.stringify(input.acceptance) : null,
     epoch_json: input.epoch ? JSON.stringify(input.epoch) : null,
+    catalog_agent_id: toIndexable(input.catalog_agent_id),
     error: null,
     created_at: now,
     updated_at: now,
     finished_at: null,
   };
-  const c = await col<HarnessRunDoc>(COLLECTION);
+  const c = await col<AgentRunDoc>("agentRuns");
   await c.put(id, doc, { expectedVersion: 0 });
   log.info(`[createRun] Run ${id} created (agent=${input.agent_id} kind=${input.kind})`);
   return doc;
 }
 
-/** Save a checkpoint to the run: serialize messages, trim state if too big. */
+/**
+ * Save a checkpoint to the run: serialize messages, trim state if too big.
+ * Uses updateDoc (OCC retry x5).
+ */
 export async function checkpoint(
   runId: string,
   state: RunCheckpointState,
   pendingToolCalls?: unknown[] | null
-): Promise<HarnessRunDoc> {
-  const serialized = JSON.stringify(state);
-  let stateJson = serialized;
-  let stateBytes = new TextEncoder().encode(serialized).length;
+): Promise<AgentRunDoc> {
+  const serialized = serializeCheckpoint(state);
+  let stateJson = serialized.json;
+  let stateBytes = serialized.bytes;
 
   if (stateBytes > MAX_STATE_BYTES) {
     stateJson = truncateState(state);
     stateBytes = new TextEncoder().encode(stateJson).length;
   }
 
-  const patch: Partial<HarnessRunDoc> = {
+  const patch: Partial<AgentRunDoc> = {
     state_json: stateJson,
     state_bytes: stateBytes,
     pending_tool_calls_json: pendingToolCalls ? JSON.stringify(pendingToolCalls) : null,
     checkpointed_at: Date.now(),
     iterations_used: state.iterations,
     tokens_used: state.totalInputTokens + state.totalOutputTokens,
-    lease_expires_at: Date.now() + leaseDurationMs,
+    lease_expires_at: Date.now() + runLeaseDurationMs(),
     boot_id: getBootId(),
     updated_at: Date.now(),
   };
 
-  return updateDoc<HarnessRunDoc>(COLLECTION, runId, patch);
+  return updateDoc<AgentRunDoc>("agentRuns", runId, patch);
 }
 
-export async function bumpTurn(runId: string, tokensDelta: number): Promise<HarnessRunDoc> {
+/**
+ * Bump turns_used and update lease.
+ */
+export async function bumpTurn(runId: string, tokensDelta: number): Promise<AgentRunDoc> {
   const existing = await getRun(runId);
   if (!existing) throw new Error(`Run ${runId} not found`);
-  return updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+  return updateDoc<AgentRunDoc>("agentRuns", runId, {
     turns_used: existing.turns_used + 1,
     tokens_used: existing.tokens_used + tokensDelta,
-    lease_expires_at: Date.now() + leaseDurationMs,
+    lease_expires_at: Date.now() + runLeaseDurationMs(),
     updated_at: Date.now(),
   });
 }
 
 export async function completeRun(runId: string, finalContent?: string): Promise<void> {
   const now = Date.now();
-  void finalContent;
-  await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+  await updateDoc<AgentRunDoc>("agentRuns", runId, {
     status: "completed",
     state_json: "",
     state_bytes: 0,
@@ -163,13 +169,13 @@ export async function completeRun(runId: string, finalContent?: string): Promise
     lease_expires_at: now,
     finished_at: now,
     updated_at: now,
-  } as Partial<HarnessRunDoc>);
+  } as Partial<AgentRunDoc>);
   log.info(`[completeRun] Run ${runId} completed`);
 }
 
 export async function failRun(runId: string, error: string): Promise<void> {
   const now = Date.now();
-  await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+  await updateDoc<AgentRunDoc>("agentRuns", runId, {
     status: "failed",
     error,
     lease_expires_at: now,
@@ -184,7 +190,7 @@ export async function failRun(runId: string, error: string): Promise<void> {
 
 export async function interruptRun(runId: string, reason: string): Promise<void> {
   const now = Date.now();
-  await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+  await updateDoc<AgentRunDoc>("agentRuns", runId, {
     status: "interrupted",
     error: reason,
     lease_expires_at: now,
@@ -196,46 +202,50 @@ export async function interruptRun(runId: string, reason: string): Promise<void>
 
 /**
  * Take ownership of an existing run before (re-)executing it. After a crash,
- * reconcile leaves the row "interrupted" with the dead process's boot_id;
- * both must be reset before resuming.
+ * reconcile leaves the row "interrupted" with the dead process's boot_id; the
+ * lease renewer self-stops unless status is "running", so both must be reset.
  */
 export async function reclaimRun(runId: string): Promise<void> {
   const now = Date.now();
-  await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+  await updateDoc<AgentRunDoc>("agentRuns", runId, {
     status: "running",
     boot_id: getBootId(),
-    lease_expires_at: now + leaseDurationMs,
+    lease_expires_at: now + runLeaseDurationMs(),
     error: null,
     finished_at: null,
     updated_at: now,
   });
 }
 
-export async function getRun(runId: string): Promise<HarnessRunDoc | null> {
-  const c = await col<HarnessRunDoc>(COLLECTION);
+export async function getRun(runId: string): Promise<AgentRunDoc | null> {
+  const c = await col<AgentRunDoc>("agentRuns");
   const entry = await c.get(runId);
   return entry ? entry.doc : null;
 }
 
-export async function findRunsByStatus(status: HarnessRunDoc["status"]): Promise<HarnessRunDoc[]> {
-  const c = await col<HarnessRunDoc>(COLLECTION);
+export async function findRunsByStatus(status: AgentRunDoc["status"]): Promise<AgentRunDoc[]> {
+  const c = await col<AgentRunDoc>("agentRuns");
   const entries = await c.findBy("status", status);
   return entries.map((e) => e.doc);
 }
 
-export async function findRunsByThread(threadId: string): Promise<HarnessRunDoc[]> {
-  const c = await col<HarnessRunDoc>(COLLECTION);
+export async function findRunsByThread(threadId: string): Promise<AgentRunDoc[]> {
+  const c = await col<AgentRunDoc>("agentRuns");
   const entries = await c.findBy("thread_id", threadId);
   return entries.map((e) => e.doc);
 }
 
-export async function findExpiredRuns(): Promise<HarnessRunDoc[]> {
+/**
+ * Find runs whose lease has expired (status=running + lease_expires_at < now).
+ */
+export async function findExpiredRuns(): Promise<AgentRunDoc[]> {
   const running = await findRunsByStatus("running");
   const now = Date.now();
   return running.filter((r) => r.lease_expires_at < now);
 }
 
-export function deserializeAcceptance(run: HarnessRunDoc): AcceptanceCriterion[] | null {
+/** Deserialize acceptance criteria back from AgentRunDoc.acceptance_json, or null if none were set. */
+export function deserializeAcceptance(run: AgentRunDoc): AcceptanceCriterion[] | null {
   if (!run.acceptance_json) return null;
   try {
     return JSON.parse(run.acceptance_json) as AcceptanceCriterion[];
@@ -245,7 +255,8 @@ export function deserializeAcceptance(run: HarnessRunDoc): AcceptanceCriterion[]
   }
 }
 
-export function deserializeEpoch(run: HarnessRunDoc): RunEpoch | null {
+/** Deserialize the fixed-worker epoch back from AgentRunDoc.epoch_json, or null if unset. */
+export function deserializeEpoch(run: AgentRunDoc): RunEpoch | null {
   if (!run.epoch_json) return null;
   try {
     return JSON.parse(run.epoch_json) as RunEpoch;
@@ -255,35 +266,95 @@ export function deserializeEpoch(run: HarnessRunDoc): RunEpoch | null {
   }
 }
 
-/** Deserialize a checkpoint, or null if the run has no checkpoint. */
-export function deserializeCheckpoint(run: HarnessRunDoc): RunCheckpointState | null {
+/**
+ * Deserialize a checkpoint back into RunCheckpointState, or null if the
+ * run has no checkpoint (empty state_json — chat runs that never promoted
+ * to durable).
+ */
+/**
+ * Checkpoints written before `source`-based internal events existed may still
+ * carry a stray `role:"system"` message after index 0 — either the
+ * compaction summary (formerly prepended to `ctx.messages`) or a delegation
+ * fan-in notice. `messages[0]` is always the real system prompt and stays;
+ * anything after it must not reach the provider as a second system message
+ * (see gemini.ts/anthropic.ts, which hoist ALL role:"system" messages into a
+ * single system instruction). Rewrite those as wrapped user turns in place —
+ * this is a read-time fixup, not a migration, so no version bump is needed.
+ */
+function normalizeStraySystemMessages(messages: LLMMessage[]): LLMMessage[] {
+  return messages.map((m, i) => {
+    if (i === 0 || m.role !== "system" || typeof m.content !== "string") return m;
+    return { ...m, role: "user" as const, content: formatInternalEvent("legacy_internal", m.content) };
+  });
+}
+
+export function deserializeCheckpoint(run: AgentRunDoc): RunCheckpointState | null {
   if (!run.state_json) return null;
   try {
     const raw = JSON.parse(run.state_json);
     if (raw.version !== 1) return null;
-    return raw as RunCheckpointState;
+    const state = raw as RunCheckpointState;
+    return { ...state, messages: normalizeStraySystemMessages(state.messages) };
   } catch {
     log.warn(`[deserializeCheckpoint] Failed to parse state_json for run ${run.id}`);
     return null;
   }
 }
 
+// ─── internals ─────────────────────────────────────────────────────────────
+
+function serializeCheckpoint(state: RunCheckpointState): { json: string; bytes: number } {
+  const json = JSON.stringify(state);
+  const bytes = new TextEncoder().encode(json).length;
+  return { json, bytes };
+}
+
+/**
+ * Truncate state to fit under MAX_STATE_BYTES by replacing old tool
+ * messages with a placeholder, keeping the system prompt and the last
+ * N messages intact.
+ */
 function truncateState(state: RunCheckpointState): string {
-  const messages = [...state.messages] as Array<Record<string, unknown>>;
+  const messages = [...state.messages];
   const keepLastN = 8;
   const cutoff = messages.length - keepLastN;
 
   for (let i = 0; i < cutoff; i++) {
     const msg = messages[i];
-    if (msg.role === "tool" && typeof msg.content === "string" && msg.content.length > 200) {
-      messages[i] = { ...msg, content: `[Truncated: ${(msg.content as string).substring(0, 200)}...]` };
+    if (msg.role === "tool" && typeof msg.content === "string") {
+      messages[i] = {
+        ...msg,
+        content: msg.content.length > 200
+          ? `[Truncated: ${msg.content.substring(0, 200)}...]`
+          : msg.content,
+      };
     }
-    if (msg.role === "assistant" && typeof msg.content === "string" && (msg.content as string).length > 500) {
-      messages[i] = { ...msg, content: (msg.content as string).substring(0, 500) + "[...]" };
+    if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.length > 500) {
+      messages[i] = {
+        ...msg,
+        content: msg.content.substring(0, 500) + "[...]",
+      };
     }
   }
 
-  return JSON.stringify({ ...state, messages });
+  // Replace base64 images with placeholder
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (Array.isArray(msg.content)) {
+      messages[i] = {
+        ...msg,
+        content: (msg.content as any[]).map((part) =>
+          part.type === "image_url" || part.type === "image" ? "[imagen omitida]" : part
+        ),
+      };
+    }
+  }
+
+  const truncated: RunCheckpointState = {
+    ...state,
+    messages,
+  };
+  return JSON.stringify(truncated);
 }
 
 // ─── Lease renewal timer ────────────────────────────────────────────────────
@@ -299,14 +370,14 @@ export function startLeaseRenewal(runId: string): void {
         stopLeaseRenewal(runId);
         return;
       }
-      await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
-        lease_expires_at: Date.now() + leaseDurationMs,
+      await updateDoc<AgentRunDoc>("agentRuns", runId, {
+        lease_expires_at: Date.now() + runLeaseDurationMs(),
         updated_at: Date.now(),
-      } as Partial<HarnessRunDoc>);
+      } as Partial<AgentRunDoc>);
     } catch (err) {
       log.warn(`[startLeaseRenewal] Failed to renew lease for ${runId}: ${(err as Error).message}`);
     }
-  }, leaseRenewIntervalMs);
+  }, leaseRenewIntervalMs());
   leaseTimers.set(runId, timer);
 }
 
@@ -322,13 +393,3 @@ export function stopAllLeaseRenewals(): void {
   for (const [, timer] of leaseTimers) clearInterval(timer);
   leaseTimers.clear();
 }
-
-export async function ensureRunStoreIndexes(): Promise<void> {
-  const c = await col<HarnessRunDoc>(COLLECTION);
-  await c.createIndex("status");
-  await c.createIndex("thread_id");
-  await c.createIndex("agent_id");
-  await c.createIndex("kind");
-}
-
-export { COLLECTION as AGENT_RUNS_COLLECTION };

package/packages/core/src/agent/{Service.ts → service.ts}

@@ -12,14 +12,15 @@
  * - Eventos (cron, etc.)
  */
 
-import { getDb } from "../storage/SQLiteStorage.ts"
-import { logger } from "../utils/logger.ts"
-import { buildSystemPromptWithProjects } from "./PromptBuilder"
-import { getAgentLoop, rebuildAgentLoop } from "./AgentRunner"
+import { logger } from "../utils/logger"
+import { buildSystemPromptWithProjects } from "./prompt-builder"
+import { getAgentLoop, rebuildAgentLoop } from "./agent-loop"
 import type { MCPClientManager } from "../mcp/index.ts"
-import { resolveAgentId, resolveUserId } from "../storage/onboarding.ts"
-import { getMCPManager as getSingletonMCPManager } from "../mcp/singleton.ts"
-import type { ContentPart } from "./providers/LLMClient"
+import { resolveAgentId, resolveUserId } from "../storage/onboarding"
+import { getMCPManager as getSingletonMCPManager } from "../mcp/singleton"
+import type { ContentPart } from "./llm-client"
+import { col, fromIndexable } from "../storage/hive"
+import type { AgentDoc, EthicsDoc } from "../storage/collections"
 
 const log = logger.child("agent-service")
 
@@ -55,14 +56,16 @@ export interface AgentDBRecord {
 
 export class AgentService {
   private agentId: string
+  private explicitAgentId?: string
   private workspacePath: string
   private mcpManager: MCPClientManager | null = null
   private cronHandlers: CronHandler[] = []
   private initialized: boolean = false
 
   constructor(config?: AgentServiceConfig) {
-    // Resolve agentId from database if not provided
-    this.agentId = config?.agentId || resolveAgentId(null) || "main"
+    // Resolved against the database in initialize() if not provided explicitly.
+    this.explicitAgentId = config?.agentId
+    this.agentId = config?.agentId || "main"
     this.workspacePath = config?.workspacePath || ""
   }
 
@@ -78,6 +81,11 @@ export class AgentService {
     }
 
     try {
+      // Resolve agentId from database if not provided explicitly
+      if (!this.explicitAgentId) {
+        this.agentId = (await resolveAgentId(null)) || "main"
+      }
+
       // Obtener MCP Manager del agent loop
       const agentLoop = getAgentLoop()
       if (agentLoop) {
@@ -97,26 +105,29 @@ export class AgentService {
    * Obtiene el registro del agente desde la DB
    */
   async getAgent(agentId?: string): Promise<AgentDBRecord | null> {
-    const db = getDb()
     const id = agentId || this.agentId
-    
-    const agent = db.query<any, [string]>(
-      "SELECT * FROM agents WHERE id = ? LIMIT 1"
-    ).get(id) as AgentDBRecord | undefined
-
-    return agent || null
+    const agentsCol = await col<AgentDoc>("agents")
+    const entry = await agentsCol.get(id)
+    if (!entry) return null
+    return {
+      id: entry.doc.id, user_id: entry.doc.user_id, name: entry.doc.name,
+      description: entry.doc.description, system_prompt: entry.doc.system_prompt, tone: entry.doc.tone,
+      role: entry.doc.role, status: entry.doc.status, enabled: entry.doc.enabled ? 1 : 0,
+      provider_id: entry.doc.provider_id, model_id: entry.doc.model_id,
+      tools_json: entry.doc.tools_json, skills_json: entry.doc.skills_json,
+      parent_id: fromIndexable(entry.doc.parent_id), max_iterations: entry.doc.max_iterations,
+      headers_encrypted: null, headers_iv: null,
+      created_at: entry.doc.created_at, updated_at: entry.doc.updated_at,
+    }
   }
 
   /**
    * Obtiene la ética desde la DB
    */
   async getEthics(): Promise<string> {
-    const db = getDb()
-    const ethics = db.query<any, []>(
-      "SELECT content FROM ethics WHERE active = 1 LIMIT 1"
-    ).get() as { content: string } | undefined
-
-    return ethics?.content || ""
+    const ethicsCol = await col<EthicsDoc>("ethics")
+    const entries = await ethicsCol.scan({})
+    return entries.find((e) => e.doc.active)?.doc.content || ""
   }
 
   /**
@@ -150,8 +161,8 @@ export class AgentService {
    */
   async reloadSkills(): Promise<void> {
     log.info("Reloading skills...")
-    const { syncSkillsToFTS } = await import("./selectors/index.ts")
-    await syncSkillsToFTS()
+    const { syncSkillsToIndex } = await import("./context-compiler")
+    await syncSkillsToIndex()
     log.info("Skills reloaded")
   }
 
@@ -233,7 +244,7 @@ export class AgentService {
    */
   async getSystemPrompt(agentId?: string, userId?: string): Promise<string> {
     const id = agentId || this.agentId
-    const uid = userId || resolveUserId({}) || "default"
+    const uid = userId || (await resolveUserId({})) || "default"
     return buildSystemPromptWithProjects({ agentId: id, userId: uid })
   }
 
@@ -241,7 +252,7 @@ export class AgentService {
    * Ejecuta un agente con un mensaje
    */
   async runAgent(message: string | ContentPart[], threadId: string, userId?: string): Promise<string> {
-    const { runAgentIsolated } = await import("./AgentRunner.ts")
+    const { runAgentIsolated } = await import("./agent-loop")
     const result = await runAgentIsolated({
       agentId: this.agentId,
       taskDescription: message,