@johpaz/hive 1.1.0

package/packages/core/src/agent/reflector.ts

@@ -0,0 +1,170 @@
+/**
+ * ACE Reflector — analyzes recent traces and produces insights.
+ *
+ * Runs in the background (never blocks the main agent loop).
+ * Triggered by the tracer after N new traces.
+ *
+ * Output → `reflections` table → picked up by Curator.
+ */
+
+import { logger } from "../utils/logger"
+
+const log = logger.child("reflector")
+
+const MAX_TRACES_TO_ANALYZE = 30
+const MIN_TRACES_TO_RUN = 10
+
+/** Main entry point — called from tracer.ts */
+export async function runReflector(): Promise<void> {
+  try {
+    const { getDb } = await import("../storage/sqlite")
+    const db = getDb()
+
+    // Fetch traces not yet covered by any reflection
+    const lastReflectionId = (db.query<any, []>(
+      "SELECT MAX(id) as mid FROM reflections"
+    ).get() as any)?.mid ?? 0
+
+    // Get last processed trace ID from reflections
+    const lastProcessedTrace = (db.query<any, []>(
+      `SELECT MAX(CAST(json_each.value AS INTEGER)) as max_id
+       FROM reflections, json_each(trace_ids)
+       WHERE id = (SELECT MAX(id) FROM reflections)`
+    ).get() as any)?.max_id ?? 0
+
+    const traces = db.query<any, [number, number]>(`
+      SELECT id, agent_id, agent_name, tool_used, input_summary,
+             output_summary, success, error_message, duration_ms, tokens_used, created_at
+      FROM traces
+      WHERE id > ?
+      ORDER BY id ASC
+      LIMIT ?
+    `).all(lastProcessedTrace, MAX_TRACES_TO_ANALYZE)
+
+    if (traces.length < MIN_TRACES_TO_RUN) {
+      log.debug(`[reflector] Not enough traces (${traces.length}/${MIN_TRACES_TO_RUN}), skipping`)
+      return
+    }
+
+    log.info(`[reflector] Analyzing ${traces.length} traces...`)
+
+    const insights = analyzeTracesLocally(traces)
+
+    if (insights.length === 0) {
+      log.debug("[reflector] No insights generated")
+      return
+    }
+
+    const traceIds = JSON.stringify(traces.map((t: any) => t.id))
+
+    for (const insight of insights) {
+      db.query(`
+        INSERT INTO reflections (trace_ids, insight_type, description, affected_tools, affected_agents, confidence)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(
+        traceIds,
+        insight.type,
+        insight.description,
+        insight.affectedTools ? JSON.stringify(insight.affectedTools) : null,
+        insight.affectedAgents ? JSON.stringify(insight.affectedAgents) : null,
+        insight.confidence,
+      )
+    }
+
+    log.info(`[reflector] Generated ${insights.length} insights`)
+
+    // Trigger curator
+    const { runCurator } = await import("./curator")
+    await runCurator()
+  } catch (err) {
+    log.warn("[reflector] Error during reflection:", err)
+  }
+}
+
+// ─── Local analysis (heuristic, no LLM call needed for basic patterns) ────────
+
+interface Insight {
+  type: "success_pattern" | "failure_pattern" | "optimization" | "ethics_violation"
+  description: string
+  affectedTools?: string[]
+  affectedAgents?: string[]
+  confidence: number
+}
+
+function analyzeTracesLocally(traces: any[]): Insight[] {
+  const insights: Insight[] = []
+
+  // ── Failure patterns ─────────────────────────────────────────────────────
+  const failures = traces.filter((t: any) => !t.success)
+  if (failures.length > 3) {
+    // Group by tool
+    const toolFailures: Record<string, number> = {}
+    for (const f of failures) {
+      if (f.tool_used) {
+        toolFailures[f.tool_used] = (toolFailures[f.tool_used] || 0) + 1
+      }
+    }
+    for (const [tool, count] of Object.entries(toolFailures)) {
+      if (count >= 3) {
+        insights.push({
+          type: "failure_pattern",
+          description: `Tool '${tool}' failed ${count} times recently. Consider verifying its configuration or avoiding it for this type of task.`,
+          affectedTools: [tool],
+          confidence: Math.min(0.9, count / 10),
+        })
+      }
+    }
+  }
+
+  // ── Slow tools ───────────────────────────────────────────────────────────
+  const slowThresholdMs = 5000
+  const slowTools: Record<string, number[]> = {}
+  for (const t of traces) {
+    if (t.tool_used && t.duration_ms > slowThresholdMs) {
+      if (!slowTools[t.tool_used]) slowTools[t.tool_used] = []
+      slowTools[t.tool_used].push(t.duration_ms)
+    }
+  }
+  for (const [tool, durations] of Object.entries(slowTools)) {
+    if (durations.length >= 3) {
+      const avg = Math.round(durations.reduce((a, b) => a + b, 0) / durations.length)
+      insights.push({
+        type: "optimization",
+        description: `Tool '${tool}' is consistently slow (avg ${avg}ms). Cache results when possible or use a faster alternative.`,
+        affectedTools: [tool],
+        confidence: 0.6,
+      })
+    }
+  }
+
+  // ── High success pattern ─────────────────────────────────────────────────
+  const successByTool: Record<string, { ok: number; total: number }> = {}
+  for (const t of traces) {
+    if (!t.tool_used) continue
+    if (!successByTool[t.tool_used]) successByTool[t.tool_used] = { ok: 0, total: 0 }
+    successByTool[t.tool_used].total++
+    if (t.success) successByTool[t.tool_used].ok++
+  }
+  for (const [tool, stats] of Object.entries(successByTool)) {
+    if (stats.total >= 5 && stats.ok / stats.total >= 0.9) {
+      insights.push({
+        type: "success_pattern",
+        description: `Tool '${tool}' has a high success rate (${stats.ok}/${stats.total}). Prefer it for related tasks.`,
+        affectedTools: [tool],
+        confidence: stats.ok / stats.total,
+      })
+    }
+  }
+
+  // ── High token usage ─────────────────────────────────────────────────────
+  const highTokenTraces = traces.filter((t: any) => t.tokens_used > 4000)
+  if (highTokenTraces.length > 3) {
+    insights.push({
+      type: "optimization",
+      description: `${highTokenTraces.length} recent calls used >4000 tokens. Be more concise and use tool results as summaries, not raw dumps.`,
+      confidence: 0.7,
+    })
+  }
+
+  return insights
+}

package/packages/core/src/agent/service.ts

@@ -0,0 +1,64 @@
+/**
+ * service.ts — thin wrapper over the native AgentLoop.
+ * No LangChain dependency.
+ */
+
+import { getSupervisorGraph } from "./supervisor"
+import { buildSystemPromptWithProjects } from "./prompt-builder"
+import { getDb } from "../storage/sqlite"
+
+export interface AgentRunOptions {
+  threadId: string
+  message: string
+  agentId?: string
+  userId: string
+}
+
+export interface AgentRunResult {
+  content: string
+}
+
+export async function runAgent(options: AgentRunOptions): Promise<AgentRunResult> {
+  const { threadId, message, userId } = options
+  const db = getDb()
+
+  let agentId = options.agentId
+  if (!agentId) {
+    const coordinatorAgent = db
+      .query<any, []>("SELECT id FROM agents WHERE is_coordinator = 1 LIMIT 1")
+      .get()
+    agentId = coordinatorAgent?.id || "bee"
+  }
+
+  const systemPrompt = await buildSystemPromptWithProjects({ agentId, userId })
+  const agentLoop = getSupervisorGraph()
+
+  if (!agentLoop) {
+    return { content: "Agent not initialized. Please restart the gateway." }
+  }
+
+  let finalContent = ""
+
+  const stream = agentLoop.stream(
+    { messages: [{ role: "user", content: message }] },
+    {
+      configurable: {
+        thread_id: threadId,
+        agent_id: agentId,
+        user_id: userId,
+        system_prompt: systemPrompt,
+      },
+    }
+  )
+
+  for await (const chunk of stream) {
+    if (chunk.agent?.messages) {
+      const lastMsg = chunk.agent.messages[chunk.agent.messages.length - 1]
+      if (lastMsg?.content) {
+        finalContent = typeof lastMsg.content === "string" ? lastMsg.content : ""
+      }
+    }
+  }
+
+  return { content: finalContent }
+}

package/packages/core/src/agent/stuck-loop.ts

@@ -0,0 +1,133 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+import { hashObject } from "../utils/crypto.ts";
+
+interface ToolCallRecord {
+  toolName: string;
+  argsHash: string;
+  errorMessage?: string;
+  timestamp: number;
+}
+
+interface StuckLoopState {
+  detected: boolean;
+  toolName: string;
+  count: number;
+  lastError?: string;
+}
+
+export class StuckLoopDetector {
+  private log = logger.child("stuck-loop");
+  private history: Map<string, ToolCallRecord[]> = new Map();
+  private readonly maxHistoryPerSession = 50;
+  private readonly triggerThreshold = 3;
+
+  constructor(_config: Config) {}
+
+  recordToolCall(
+    sessionId: string,
+    toolName: string,
+    args: Record<string, unknown>,
+    error?: string
+  ): void {
+    let sessionHistory = this.history.get(sessionId);
+    if (!sessionHistory) {
+      sessionHistory = [];
+      this.history.set(sessionId, sessionHistory);
+    }
+
+    const record: ToolCallRecord = {
+      toolName,
+      argsHash: hashObject(args),
+      errorMessage: error,
+      timestamp: Date.now(),
+    };
+
+    sessionHistory.push(record);
+
+    if (sessionHistory.length > this.maxHistoryPerSession) {
+      sessionHistory.shift();
+    }
+
+    this.log.debug(`Recorded tool call: ${toolName} for session ${sessionId}`);
+  }
+
+  check(sessionId: string): StuckLoopState {
+    const sessionHistory = this.history.get(sessionId) ?? [];
+    
+    if (sessionHistory.length < this.triggerThreshold) {
+      return { detected: false, toolName: "", count: 0 };
+    }
+
+    const recent = sessionHistory.slice(-10);
+    const counts = new Map<string, { count: number; error?: string }>();
+
+    for (const record of recent) {
+      const key = `${record.toolName}:${record.argsHash}`;
+      const existing = counts.get(key);
+      
+      if (existing) {
+        existing.count++;
+        if (record.errorMessage) {
+          existing.error = record.errorMessage;
+        }
+      } else {
+        counts.set(key, { count: 1, error: record.errorMessage });
+      }
+    }
+
+    for (const [key, data] of counts) {
+      if (data.count >= this.triggerThreshold && data.error) {
+        const toolName = key.split(":")[0] ?? "unknown";
+        
+        this.log.warn(`Stuck loop detected: ${toolName} called ${data.count} times with same args and error`);
+        
+        return {
+          detected: true,
+          toolName,
+          count: data.count,
+          lastError: data.error,
+        };
+      }
+    }
+
+    return { detected: false, toolName: "", count: 0 };
+  }
+
+  getInterventionMessage(state: StuckLoopState): string | null {
+    if (!state.detected) return null;
+
+    if (state.count >= this.triggerThreshold + 1) {
+      return `CRITICAL: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing with: "${state.lastError}". The user has been notified. You MUST try a completely different approach or ask the user for guidance.`;
+    }
+
+    return `WARNING: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing. You MUST try a completely different approach instead of repeating the same action.`;
+  }
+
+  clear(sessionId: string): void {
+    this.history.delete(sessionId);
+    this.log.debug(`Cleared stuck loop history for session ${sessionId}`);
+  }
+
+  prune(maxAgeMs: number = 30 * 60 * 1000): number {
+    const now = Date.now();
+    let pruned = 0;
+
+    for (const [sessionId, history] of this.history) {
+      const filtered = history.filter(r => now - r.timestamp < maxAgeMs);
+      
+      if (filtered.length === 0) {
+        this.history.delete(sessionId);
+        pruned++;
+      } else if (filtered.length !== history.length) {
+        this.history.set(sessionId, filtered);
+      }
+    }
+
+    return pruned;
+  }
+}
+
+export function createStuckLoopDetector(config: Config): StuckLoopDetector {
+  return new StuckLoopDetector(config);
+}

package/packages/core/src/agent/supervisor.ts

@@ -0,0 +1,39 @@
+/**
+ * supervisor.ts — compatibility shim over the native AgentLoop.
+ *
+ * Maintains the same external API used by initializer.ts and server.ts:
+ *   buildSupervisorGraph({ mcpManager })
+ *   getSupervisorGraph()
+ *   rebuildSupervisorGraph({ mcpManager })
+ *
+ * Internally delegates to agent-loop.ts — no LangGraph dependency.
+ */
+
+import { buildAgentLoop, getAgentLoop } from "./agent-loop"
+import type { MCPClientManager } from "@johpaz/hive-mcp"
+import { logger } from "../utils/logger"
+
+const log = logger.child("supervisor")
+
+export async function buildSupervisorGraph(options: {
+  mcpManager?: MCPClientManager | null
+}): Promise<ReturnType<typeof getAgentLoop>> {
+  log.info("[supervisor] Initializing native AgentLoop...")
+  const loop = buildAgentLoop({ mcpManager: options.mcpManager ?? null })
+  log.info("[supervisor] AgentLoop ready")
+  return loop
+}
+
+export function getSupervisorGraph() {
+  return getAgentLoop()
+}
+
+export async function rebuildSupervisorGraph(options: {
+  mcpManager?: MCPClientManager | null
+}): Promise<ReturnType<typeof getAgentLoop>> {
+  log.info("[supervisor] Rebuilding AgentLoop...")
+  return buildSupervisorGraph(options)
+}
+
+// Re-export AgentStateType for any code that imports it (now a plain object)
+export type AgentStateType = { messages: any[] }

package/packages/core/src/agent/tracer.ts

@@ -0,0 +1,102 @@
+/**
+ * Tracer — ACE Generator output.
+ *
+ * Records every agent execution to the `traces` table.
+ * Fire-and-forget (non-blocking). Also updates playbook helpful/harmful counts
+ * based on execution outcome.
+ */
+
+import { logger } from "../utils/logger"
+
+const log = logger.child("tracer")
+
+export interface TraceInput {
+  threadId: string
+  agentId: string
+  agentName: string
+  toolUsed?: string | null
+  inputSummary: string
+  outputSummary: string
+  success: boolean
+  errorMessage?: string | null
+  durationMs?: number
+  tokensUsed?: number
+}
+
+/**
+ * Save a trace record. Non-blocking — errors are swallowed so they never
+ * affect the main agent loop.
+ */
+export function saveTrace(trace: TraceInput): void {
+  // Run asynchronously so it never blocks the caller
+  Promise.resolve().then(async () => {
+    try {
+      const { getDb } = await import("../storage/sqlite")
+      const db = getDb()
+
+      db.query(`
+        INSERT INTO traces
+          (thread_id, agent_id, agent_name, tool_used, input_summary,
+           output_summary, success, error_message, duration_ms, tokens_used)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        trace.threadId,
+        trace.agentId,
+        trace.agentName,
+        trace.toolUsed ?? null,
+        trace.inputSummary.substring(0, 500),
+        trace.outputSummary.substring(0, 500),
+        trace.success ? 1 : 0,
+        trace.errorMessage ?? null,
+        trace.durationMs ?? null,
+        trace.tokensUsed ?? null,
+      )
+
+      // Trigger reflector check in background
+      checkReflectorTrigger().catch(() => { /* ignore */ })
+    } catch (err) {
+      log.warn("[tracer] Failed to save trace:", err)
+    }
+  })
+}
+
+// ─── Reflector trigger ────────────────────────────────────────────────────────
+
+const REFLECTOR_TRACE_THRESHOLD = 20  // run reflector after N new traces
+
+let _tracesSinceLastReflection = 0
+
+async function checkReflectorTrigger(): Promise<void> {
+  _tracesSinceLastReflection++
+  if (_tracesSinceLastReflection < REFLECTOR_TRACE_THRESHOLD) return
+  _tracesSinceLastReflection = 0
+
+  // Lazy import to avoid circular deps
+  const { runReflector } = await import("./reflector")
+  runReflector().catch((err) => {
+    log.warn("[tracer] Reflector run failed:", err)
+  })
+}
+
+// ─── Usage recording ──────────────────────────────────────────────────────────
+
+export function recordLLMUsage(opts: {
+  provider: string
+  model: string
+  inputTokens: number
+  outputTokens: number
+}): void {
+  Promise.resolve().then(async () => {
+    try {
+      const { recordUsage } = await import("../storage/usage")
+      recordUsage({
+        provider: opts.provider,
+        model: opts.model,
+        inputTokens: opts.inputTokens,
+        outputTokens: opts.outputTokens,
+        toonSavedTokens: 0,
+        toonSavedCost: 0,
+      })
+    } catch { /* ignore */ }
+  })
+}

package/packages/core/src/agent/workspace.ts

@@ -0,0 +1,110 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logger } from "../utils/logger.ts";
+
+export interface WorkspaceLoader {
+  read(file: "soul" | "user" | "ethics"): Promise<string>;
+  write(file: "soul" | "user", content: string): Promise<void>;
+  patch(file: "soul" | "user", section: string, content: string): Promise<void>;
+  append(file: "user", section: string, content: string): Promise<void>;
+}
+
+export function createWorkspaceLoader(workspacePath: string): WorkspaceLoader {
+  const log = logger.child("workspace");
+
+  function getFilePath(file: "soul" | "user" | "ethics"): string {
+    return path.join(workspacePath, `${file}.md`);
+  }
+
+  async function readFile(file: "soul" | "user" | "ethics"): Promise<string> {
+    const filePath = getFilePath(file);
+    if (!fs.existsSync(filePath)) {
+      return "";
+    }
+    return fs.readFileSync(filePath, "utf-8");
+  }
+
+  async function writeFile(file: "soul" | "user", content: string): Promise<void> {
+    const filePath = getFilePath(file);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, content, "utf-8");
+    log.debug(`Wrote ${file}.md`);
+  }
+
+  return {
+    read: async (file: "soul" | "user" | "ethics"): Promise<string> => {
+      return readFile(file);
+    },
+
+    write: async (file: "soul" | "user", content: string): Promise<void> => {
+      await writeFile(file, content);
+    },
+
+    patch: async (file: "soul" | "user", section: string, newContent: string): Promise<void> => {
+      const current = await readFile(file);
+      const sectionHeader = `## ${section}`;
+      
+      let result: string;
+      const lines = current.split("\n");
+      const sectionStart = lines.findIndex((l) => l.trim() === sectionHeader);
+      
+      if (sectionStart === -1) {
+        // Section doesn't exist, append at end
+        result = current + `\n\n${sectionHeader}\n\n${newContent}\n`;
+      } else {
+        // Find next section
+        let sectionEnd = lines.length;
+        for (let i = sectionStart + 1; i < lines.length; i++) {
+          if (lines[i].startsWith("## ")) {
+            sectionEnd = i;
+            break;
+          }
+        }
+        
+        // Replace section content
+        const before = lines.slice(0, sectionStart + 1).join("\n");
+        const after = lines.slice(sectionEnd).join("\n");
+        result = `${before}\n${newContent}\n${after}`;
+      }
+      
+      await writeFile(file, result);
+      log.debug(`Patched section "${section}" in ${file}.md`);
+    },
+
+    append: async (file: "user", section: string, content: string): Promise<void> => {
+      const current = await readFile(file);
+      const sectionHeader = `## ${section}`;
+      
+      let result: string;
+      const lines = current.split("\n");
+      const sectionStart = lines.findIndex((l) => l.trim() === sectionHeader);
+      
+      if (sectionStart === -1) {
+        // Section doesn't exist, create it
+        result = current + `\n\n${sectionHeader}\n\n${content}\n`;
+      } else {
+        // Find next section
+        let sectionEnd = lines.length;
+        for (let i = sectionStart + 1; i < lines.length; i++) {
+          if (lines[i].startsWith("## ")) {
+            sectionEnd = i;
+            break;
+          }
+        }
+        
+        // Append to section
+        const before = lines.slice(0, sectionEnd).join("\n");
+        const after = lines.slice(sectionEnd).join("\n");
+        const existingContent = lines.slice(sectionStart + 1, sectionEnd).join("\n").trim();
+        const newSectionContent = existingContent ? `${existingContent}\n\n${content}` : content;
+        result = `${before}\n${newSectionContent}\n${after}`;
+      }
+      
+      await writeFile(file, result);
+      log.debug(`Appended to section "${section}" in ${file}.md`);
+    },
+  };
+}