amalfa 1.0.28 → 1.0.30

package/src/daemon/sonar-agent.ts

@@ -1,28 +1,63 @@
 #!/usr/bin/env bun
+
 /**
  * AMALFA Sonar Multi-Purpose Sub-Agent
- * Daemon for search intelligence, metadata enhancement, and interactive chat
+ * Main Entry Point & Daemon Controller
  */
 
-import { join } from "path";
-import { readdirSync, existsSync, renameSync, writeFileSync } from "node:fs";
-import { loadConfig, AMALFA_DIRS } from "@src/config/defaults";
+import { existsSync, mkdirSync } from "node:fs";
+import { readdir, rename } from "node:fs/promises";
+
+import { join } from "node:path";
+import { AMALFA_DIRS, loadConfig } from "@src/config/defaults";
+import { GraphEngine } from "@src/core/GraphEngine";
+import { GraphGardener } from "@src/core/GraphGardener";
+import { VectorEngine } from "@src/core/VectorEngine";
+import { ResonanceDB } from "@src/resonance/db";
 import { getLogger } from "@src/utils/Logger";
-import { ServiceLifecycle } from "@src/utils/ServiceLifecycle";
 import { sendNotification } from "@src/utils/Notifications";
 import {
 	checkOllamaHealth,
 	discoverOllamaCapabilities,
 } from "@src/utils/ollama-discovery";
+import { ServiceLifecycle } from "@src/utils/ServiceLifecycle";
+import {
+	handleBatchEnhancement,
+	handleChat,
+	handleContextExtraction,
+	handleGardenTask,
+	handleMetadataEnhancement,
+	handleResearchTask,
+	handleResultReranking,
+	handleSearchAnalysis,
+	handleSynthesisTask,
+	handleTimelineTask,
+	type SonarContext,
+} from "./sonar-logic";
+import { getTaskModel } from "./sonar-strategies";
+import type {
+	ChatRequest,
+	ChatSession,
+	MetadataEnhanceRequest,
+	SearchAnalyzeRequest,
+	SearchContextRequest,
+	SearchRerankRequest,
+	SonarTask,
+} from "./sonar-types";
+import { inferenceState } from "./sonar-inference";
 
 const args = process.argv.slice(2);
 const command = args[0] || "serve";
 const log = getLogger("SonarAgent");
 
-// Database initialization
-import { ResonanceDB } from "@src/resonance/db";
-import { VectorEngine } from "@src/core/VectorEngine";
 let DB_PATH: string;
+let db: ResonanceDB;
+const graphEngine = new GraphEngine();
+let gardener: GraphGardener;
+let vectorEngine: VectorEngine;
+
+// Global state
+const chatSessions = new Map<string, ChatSession>();
 
 // Service lifecycle management
 const lifecycle = new ServiceLifecycle({
@@ -32,927 +67,221 @@ const lifecycle = new ServiceLifecycle({
 	entryPoint: "src/daemon/sonar-agent.ts",
 });
 
-// Global state
-// Global state
-let server: Bun.Server<unknown> | null = null;
-let ollamaAvailable = false;
-let ollamaModel = "phi3:latest";
-
-// Chat Session Management
-const chatSessions = new Map<string, ChatSession>();
-
-interface ChatSession {
-	id: string;
-	messages: Message[];
-	startedAt: Date;
-}
-
-/**
- * Message interface for chat API
- */
-interface Message {
-	role: "system" | "user" | "assistant";
-	content: string;
-}
-
-/**
- * Request options for Ollama API
- */
-interface RequestOptions {
-	temperature?: number;
-	num_predict?: number;
-	stream?: boolean;
-	format?: "json"; // Enable GBNF-constrained JSON output
-	model?: string; // Override model for this specific call (tiered strategy)
-}
-
 /**
- * Call Ollama HTTP API for inference
- * This is the preferred method for inference (faster, supports streaming)
+ * Main logical loop for the Sonar Agent
  */
-async function callOllama(
-	messages: Message[],
-	options: RequestOptions = {},
-): Promise<{ message: Message }> {
+async function main() {
 	const config = await loadConfig();
-	// @ts-ignore - backward compatibility with phi3 config
-	const hostArgs = config.sonar || config.phi3 || {};
-
-	// Cloud toggle: dev-cloud/prod-local strategy
-	const cloudConfig = hostArgs.cloud;
-	const useCloud = cloudConfig?.enabled === true;
-	const provider = useCloud ? cloudConfig.provider || "ollama" : "ollama";
-
-	// Tiered model strategy: options.model > cloud.model > discovered > config > default
-	const { format, model: overrideModel, ...modelOptions } = options;
-	const model =
-		overrideModel ||
-		(useCloud ? cloudConfig.model : null) ||
-		ollamaModel ||
-		hostArgs.model ||
-		"qwen2.5:1.5b";
-
-	// Build headers
-	const headers: Record<string, string> = {
-		"Content-Type": "application/json",
-	};
-	// API key: prefer env var (OPENROUTER_API_KEY) over config
-	const apiKey = process.env.OPENROUTER_API_KEY || cloudConfig?.apiKey;
-	if (useCloud && apiKey) {
-		headers["Authorization"] = `Bearer ${apiKey}`;
-		log.info(
-			{ provider, hasKey: !!apiKey, keyLength: apiKey?.length },
-			"Cloud request with API key",
-		);
-	} else if (useCloud) {
-		log.warn("Cloud enabled but no API key found in env or config!");
-	}
-	// OpenRouter requires site headers for tracking
-	if (provider === "openrouter") {
-		headers["HTTP-Referer"] = "https://github.com/pjsvis/amalfa";
-		headers["X-Title"] = "AMALFA Knowledge Graph";
-	}
-
-	// Determine endpoint and request format based on provider
-	let endpoint: string;
-	let body: string;
-
-	if (provider === "openrouter") {
-		// OpenRouter uses OpenAI-compatible format at openrouter.ai/api/v1
-		endpoint = "https://openrouter.ai/api/v1/chat/completions";
-		body = JSON.stringify({
-			model,
-			messages,
-			stream: false,
-			temperature: modelOptions.temperature ?? 0.1,
-			max_tokens: modelOptions.num_predict ?? 500,
-		});
-	} else {
-		// Ollama format (local or cloud Ollama server)
-		const host = useCloud
-			? cloudConfig.host
-			: hostArgs.host || "localhost:11434";
-		endpoint = `http://${host}/api/chat`;
-		body = JSON.stringify({
-			model,
-			messages,
-			stream: false,
-			format, // Pass format (e.g. "json") for GBNF grammar
-			options: {
-				temperature: 0.1,
-				num_predict: 200,
-				...modelOptions,
-			},
-		});
+	if (!config.sonar.enabled) {
+		log.info("Sonar Agent is disabled in config. Exiting.");
+		return;
 	}
 
-	const response = await fetch(endpoint, {
-		method: "POST",
-		headers,
-		body,
+	DB_PATH = config.database;
+	db = new ResonanceDB(DB_PATH);
+	vectorEngine = new VectorEngine(db.getRawDb());
+	gardener = new GraphGardener(db, graphEngine, vectorEngine);
+
+	// Ensure task directories exist
+	[
+		AMALFA_DIRS.tasks.pending,
+		AMALFA_DIRS.tasks.processing,
+		AMALFA_DIRS.tasks.completed,
+	].forEach((dir) => {
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 	});
 
-	if (!response.ok) {
-		// Try to get error details from response body
-		let errorBody = "";
-		try {
-			errorBody = await response.text();
-		} catch {}
-		log.error(
-			{
-				status: response.status,
-				statusText: response.statusText,
-				body: errorBody,
-			},
-			"API request failed",
-		);
-		throw new Error(`${provider} API error: ${response.statusText}`);
-	}
-
-	const result = await response.json();
-
-	// Normalize response format (OpenRouter uses OpenAI format)
-	if (provider === "openrouter") {
-		// OpenAI format: { choices: [{ message: { role, content } }] }
-		const openaiResult = result as { choices: { message: Message }[] };
-		return {
-			message: openaiResult.choices[0]?.message || {
-				role: "assistant",
-				content: "",
-			},
-		};
-	}
-
-	// Ollama format: { message: { role, content } }
-	return result as { message: Message };
-}
-
-/**
- * Handle search analysis task
- * Analyzes query intent, entities, and technical level
- */
-async function handleSearchAnalysis(query: string): Promise<unknown> {
-	if (!ollamaAvailable) {
-		throw new Error("Sonar is not available");
-	}
+	// Initial health check
+	inferenceState.ollamaAvailable = await checkOllamaHealth();
 
-	try {
-		const response = await callOllama(
-			[
-				{
-					role: "system",
-					content: "You are a search query analyzer. Return JSON only.",
-				},
-				{
-					role: "user",
-					content: `Analyze this query: "${query}"
-
-    Return JSON:
-    {
-      "intent": "implementation|conceptual|example",
-      "entities": ["term1", "term2"],
-      "technical_level": "high|medium|low",
-      "suggested_queries": ["query1", "query2"]
-    }`,
-				},
-			],
-			{
-				temperature: 0.1,
-				num_predict: 200,
-				format: "json", // Force valid JSON output
-			},
-		);
-
-		// Parse JSON response
-		const content = response.message.content;
-		try {
-			return JSON.parse(content);
-		} catch {
-			// Fallback if not JSON
-			return {
-				intent: "unknown",
-				entities: [],
-				technical_level: "medium",
-				suggested_queries: [],
-			};
+	if (inferenceState.ollamaAvailable) {
+		const capabilities = await discoverOllamaCapabilities();
+		const firstModel = capabilities.allModels?.[0];
+		if (capabilities.available && firstModel) {
+			inferenceState.ollamaModel = config.sonar.model || firstModel.name;
+			log.info({ model: inferenceState.ollamaModel }, "Sonar Agent ready");
 		}
-	} catch (error) {
-		log.error({ error, query }, "Search analysis failed");
-		throw error;
-	}
-}
-
-/**
- * Handle metadata enhancement task
- * Comprehensive document analysis for enhanced metadata
- */
-async function handleMetadataEnhancement(docId: string): Promise<unknown> {
-	if (!ollamaAvailable) {
-		throw new Error("Sonar is not available");
+	} else if (config.sonar.cloud?.enabled) {
+		log.info("Local Ollama not found, but Cloud is enabled. Proceeding.");
+		inferenceState.ollamaAvailable = true;
+	} else {
+		log.warn("Sonar Agent limited: Ollama unreachable and Cloud disabled.");
 	}
 
-	try {
-		// Connect to DB and fetch node source path
-		const db = new ResonanceDB(DB_PATH);
-		const node = db.getNode(docId);
-		if (!node) {
-			throw new Error(`Node not found: ${docId}`);
-		}
-
-		const meta = node.meta || {};
-		const sourcePath = meta.source as string | undefined;
-		if (!sourcePath) {
-			throw new Error(`No source file for node: ${docId}`);
-		}
-
-		// Read content from filesystem
-		const file = Bun.file(sourcePath);
-		if (!(await file.exists())) {
-			throw new Error(`File not found: ${sourcePath}`);
-		}
-		const content = await file.text();
-
-		const response = await callOllama(
-			[
-				{
-					role: "system",
-					content:
-						"You are a document analyzer. Extract comprehensive metadata.",
-				},
-				{
-					role: "user",
-					content: `Analyze this document comprehensively:
-
-    Content: ${content}
-
-    Return JSON:
-    {
-      "themes": ["theme1", "theme2"],
-      "code_patterns": ["pattern1", "pattern2"],
-      "summary": "2-3 sentence summary",
-      "doc_type": "implementation|conceptual|architecture|reference",
-      "technical_depth": "deep|medium|shallow",
-      "audience": "developer|user|architect",
-      "related_docs": ["doc1", "doc2"]
-    }`,
-				},
-			],
-			{
-				temperature: 0.2,
-				num_predict: 500,
-				format: "json", // Force valid JSON output
-			},
-		);
-
-		// Save enhanced metadata back to DB
-		const contentStr = response.message.content;
-		let enhancedMeta: Record<string, unknown>;
-		try {
-			enhancedMeta = JSON.parse(contentStr);
-		} catch {
-			enhancedMeta = {
-				themes: [],
-				code_patterns: [],
-				summary: "",
-				doc_type: "unknown",
-				technical_depth: "medium",
-				audience: "developer",
-				related_docs: [],
-			};
-		}
-
-		// Update node metadata
-		const newMeta = {
-			...node.meta,
-			sonar_enhanced: true,
-			sonar_enhanced_at: new Date().toISOString(),
-			...enhancedMeta,
-		};
-
-		db.updateNodeMeta(docId, newMeta);
-		return enhancedMeta;
-	} catch (error) {
-		log.error({ error, docId }, "Metadata enhancement failed");
-		throw error;
-	}
-}
+	// Initial graph load
+	await graphEngine.load(db.getRawDb());
 
-/**
- * Handle batch enhancement task
- * Processes multiple documents for metadata enhancement
- */
-async function handleBatchEnhancement(limit = 50): Promise<{
-	successful: number;
-	failed: number;
-	total: number;
-}> {
-	if (!ollamaAvailable) {
-		throw new Error("Sonar is not available");
+	// Start HTTP API if serve mode
+	if (command === "serve") {
+		startServer(config.sonar.port || 3030);
 	}
 
-	const db = new ResonanceDB(DB_PATH);
-
-	// Find unenhanced nodes
-	// Note: We need to query nodes that don't have 'sonar_enhanced' in meta
-	const allNodes = db.getRawDb().query("SELECT id, meta FROM nodes").all() as {
-		id: string;
-		meta: string;
-	}[];
-
-	const unenhanced = allNodes
-		.filter((row) => {
-			try {
-				const meta = JSON.parse(row.meta);
-				// Check for sonar_enhanced OR phi3_enhanced (migration)
-				return !meta.sonar_enhanced && !meta.phi3_enhanced;
-			} catch {
-				return false;
-			}
-		})
-		.map((row) => ({ id: row.id }));
-
-	const batch = unenhanced.slice(0, limit);
-
-	log.info(`🔄 Enhancing ${batch.length} docs with Sonar...`);
-
-	const results = await Promise.allSettled(
-		batch.map((node) => handleMetadataEnhancement(node.id)),
+	// Task Watcher Loop
+	log.info(
+		"Watcher started: Listening for tasks in .amalfa/agent/tasks/pending",
 	);
-
-	const successful = results.filter((r) => r.status === "fulfilled").length;
-	const failed = results.filter((r) => r.status === "rejected").length;
-
-	log.info(`✅ Enhanced: ${successful}, ❌ Failed: ${failed}`);
-
-	return { successful, failed, total: batch.length };
-}
-
-/**
- * Handle result re-ranking
- * Re-ranks search results based on query intent and context
- */
-async function handleResultReranking(
-	results: Array<{ id: string; content: string; score: number }>,
-	query: string,
-	intent?: string,
-): Promise<
-	Array<{ id: string; content: string; score: number; relevance_score: number }>
-> {
-	if (!ollamaAvailable) {
-		throw new Error("Sonar is not available");
-	}
-
-	try {
-		const response = await callOllama(
-			[
-				{
-					role: "system",
-					content:
-						"You are a search result re-ranker. Analyze relevance and provide scores.",
-				},
-				{
-					role: "user",
-					content: `Re-rank these search results for query: "${query}"${
-						intent ? `\nQuery intent: ${intent}` : ""
-					}
-
-Results:
-${results.map((r, i) => `${i + 1}. ${r.content.slice(0, 200)}`).join("\n")}
-
-Return JSON array with relevance scores (0.0 to 1.0):
-[
-  {"index": 1, "relevance": 0.95, "reason": "Direct match"},
-  {"index": 2, "relevance": 0.7, "reason": "Related concept"}
-]`,
-				},
-			],
-			{
-				temperature: 0.2,
-				num_predict: 300,
-				format: "json", // Force valid JSON output
-			},
-		);
-
-		const content = response.message.content;
-		try {
-			const rankings = JSON.parse(content);
-
-			// Apply rankings to results
-			return results.map((result, idx) => {
-				const ranking = rankings.find(
-					(r: { index: number }) => r.index === idx + 1,
-				);
-				return {
-					...result,
-					relevance_score: ranking?.relevance || 0.5,
-				};
-			});
-		} catch {
-			// Fallback: return original scores
-			return results.map((r) => ({ ...r, relevance_score: r.score }));
-		}
-	} catch (error) {
-		log.error({ error, query }, "Result re-ranking failed");
-		throw error;
+	while (true) {
+		// Reload graph to pick up new edges before processing tasks
+		await graphEngine.load(db.getRawDb());
+		await processPendingTasks();
+		await new Promise((resolve) => setTimeout(resolve, 5000));
 	}
 }
 
 /**
- * Handle chat request
- * Maintains session context and converses with user
+ * Start Bun HTTP Server
  */
-async function handleChat(
-	sessionId: string,
-	userMessage: string,
-	modelOverride?: string, // Optional: Use specific model (e.g., mistral-nemo for research)
-): Promise<{ message: Message; sessionId: string }> {
-	if (!ollamaAvailable) {
-		throw new Error("Sonar is not available");
-	}
-
-	// Get or create session
-	let session = chatSessions.get(sessionId);
-	if (!session) {
-		session = {
-			id: sessionId,
-			messages: [
-				{
-					role: "system",
-					content: `You are AMALFA Corpus Assistant. Help users understand and explore their knowledge base.
-Current Date: ${new Date().toISOString().split("T")[0]}
-
-User can ask you about:
-1. Corpus structure and themes
-2. What you're currently working on
-3. Search for documents by theme/type
-4. Guide enhancement process
-5. Natural language queries to knowledge base`,
-				},
-			],
-			startedAt: new Date(),
-		};
-		chatSessions.set(sessionId, session);
-	}
-
-	// Add user message
-
-	// RAG: Perform vector search to augment context
-	const db = new ResonanceDB(DB_PATH);
-	const vectors = new VectorEngine(db.getRawDb());
-	try {
-		const results = await vectors.search(userMessage, 3);
-
-		let augmentContext = "";
-		if (results.length > 0) {
-			augmentContext = `\n\nRELEVANT CONTEXT FROM KNOWLEDGE BASE:\n`;
-			results.forEach((r: { id: string; score: number }, i: number) => {
-				// Read full node content if possible, or just use what we have
-				const node = db.getNode(r.id);
-				// Truncate content to avoid blowing up context window
-				const content = node?.content ?? "";
-				const snippet = content.slice(0, 1000);
-				augmentContext += `[Document ${i + 1}: ${r.id}] (Score: ${r.score.toFixed(2)})\n${snippet}\n\n`;
-			});
-			augmentContext += `INSTRUCTIONS: Use the above context to answer the user's question. Cite sources if possible.\n`;
-		}
-
-		// Append context to user message
-		session.messages.push({
-			role: "user",
-			content: userMessage + augmentContext,
-		});
-	} catch (e) {
-		// Fallback to ignoring RAG on error
-		log.warn({ err: e }, "RAG search failed, proceeding without context");
-		session.messages.push({ role: "user", content: userMessage });
-	}
-
-	// Maintain context window (keep system msg + last 10 messages)
-	const contextMessages = [
-		session.messages[0],
-		...session.messages.slice(-10),
-	].filter((m): m is Message => m !== undefined);
-
-	try {
-		// NOTE: No format: "json" for chat! We want natural language.
-		// Use modelOverride if provided (e.g., mistral-nemo for research)
-		const response = await callOllama(contextMessages, {
-			temperature: 0.7,
-			num_predict: 500,
-			model: modelOverride,
-		});
-
-		// Add assistant response to history
-		session.messages.push(response.message);
-
-		return {
-			message: response.message,
-			sessionId: session.id,
-		};
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		log.error({ err: error, sessionId, errorMessage }, "Chat request failed");
-		throw error;
-	}
-}
-
-/**
- * Handle context extraction
- * Generates smart snippets with context awareness
- */
-async function handleContextExtraction(
-	result: { id: string; content: string },
-	query: string,
-): Promise<{ snippet: string; context: string; confidence: number }> {
-	if (!ollamaAvailable) {
-		throw new Error("Sonar is not available");
-	}
-
-	try {
-		const response = await callOllama(
-			[
-				{
-					role: "system",
-					content:
-						"You are a context extractor. Provide relevant snippets with context.",
-				},
-				{
-					role: "user",
-					content: `Extract relevant context for query: "${query}"
-
-Content:
-${result.content}
-
-Return JSON:
-{
-  "snippet": "Most relevant 2-3 sentences",
-  "context": "Brief explanation of relevance",
-  "confidence": 0.9
-}`,
-				},
-			],
-			{
-				temperature: 0.1,
-				num_predict: 200,
-				format: "json", // Force valid JSON output
-			},
-		);
-
-		const content = response.message.content;
-		try {
-			const parsed = JSON.parse(content);
-			if (!parsed.snippet && !parsed.context) {
-				throw new Error("Missing snippet/context in JSON");
-			}
-			return parsed;
-		} catch {
-			// Fallback: return simple snippet
-			const words = result.content.split(" ");
-			const snippet = words.slice(0, 50).join(" ");
-			return {
-				snippet,
-				context: "Full content available",
-				confidence: 0.5,
-			};
-		}
-	} catch (error) {
-		log.error({ error, resultId: result.id }, "Context extraction failed");
-		throw error;
-	}
-}
-
-/**
- * Main daemon logic
- */
-async function main() {
-	const config = await loadConfig();
-	DB_PATH = join(process.cwd(), config.database);
-
-	// @ts-ignore
-	const isEnabled = config.sonar?.enabled ?? config.phi3?.enabled;
-
-	if (!isEnabled) {
-		log.warn("⚠️  Sonar is disabled in configuration. Exiting.");
-		process.exit(0);
-	}
-
-	log.info("🚀 Sonar Agent starting...");
-
-	// Check Ollama availability
-	log.info("🔍 Checking Ollama availability...");
-	const capabilities = await discoverOllamaCapabilities();
-	ollamaAvailable = capabilities.available;
-
-	if (ollamaAvailable) {
-		log.info("✅ Ollama is available and healthy");
-		// Use discovered preferred model (e.g., tinydolphin) unless overridden in config
-		// @ts-ignore
-		ollamaModel =
-			config.sonar?.model ||
-			config.phi3?.model ||
-			capabilities.model ||
-			"phi3:latest";
-		log.info(`✅ Using model: ${ollamaModel}`);
-	} else {
-		log.warn("⚠️  Ollama is not available");
-		log.warn("   Sonar features will be disabled");
-		log.info("   Install: curl -fsSL https://ollama.ai/install.sh | sh");
-		log.info("   Then run: ollama pull phi3:latest (or minidolphin)");
-	}
-
-	log.info("✅ Sonar Agent ready");
-
-	// Register signal handlers for graceful shutdown
-	const shutdown = async (signal: string) => {
-		log.info(`🛑 Received ${signal}, shutting down...`);
-		if (server) {
-			server.stop();
-			server = null;
-		}
-		process.exit(0);
+function startServer(port: number) {
+	const corsHeaders = {
+		"Access-Control-Allow-Origin": "*",
+		"Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+		"Access-Control-Allow-Headers": "Content-Type",
 	};
 
-	process.on("SIGTERM", () => shutdown("SIGTERM"));
-	process.on("SIGINT", () => shutdown("SIGINT"));
+	const context: SonarContext = { db, graphEngine, gardener, chatSessions };
 
-	// Start HTTP server
-	// @ts-ignore
-	const port = (config.sonar || config.phi3)?.port || 3012;
-
-	log.info(`🚀 Starting HTTP server on port ${port}`);
-	log.info("📋 Available endpoints:");
-	log.info("   POST /search/analyze - Query analysis");
-	log.info("   POST /search/rerank  - Result re-ranking");
-	log.info("   POST /search/context - Smart snippet generation");
-	log.info("   GET  /health        - Health check");
-
-	server = Bun.serve({
+	Bun.serve({
 		port,
 		async fetch(req) {
-			const url = new URL(req.url);
-
-			// CORS headers
-			const corsHeaders = {
-				"Access-Control-Allow-Origin": "*",
-				"Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-				"Access-Control-Allow-Headers": "Content-Type",
-			};
-
-			// Handle preflight requests
-			if (req.method === "OPTIONS") {
+			if (req.method === "OPTIONS")
 				return new Response(null, { headers: corsHeaders });
-			}
+			const url = new URL(req.url);
 
-			// Health check endpoint
+			// Health check
 			if (url.pathname === "/health") {
-				const healthy = await checkOllamaHealth();
 				return Response.json(
-					{
-						status: healthy ? "healthy" : "unhealthy",
-						ollama_available: ollamaAvailable,
-						model: ollamaModel,
-					},
+					{ status: "ok", ollama: inferenceState.ollamaAvailable },
 					{ headers: corsHeaders },
 				);
 			}
 
-			// Search analysis endpoint
-			if (url.pathname === "/search/analyze" && req.method === "POST") {
+			// Chat endpoint
+			if (url.pathname === "/chat" && req.method === "POST") {
 				try {
-					const body = (await req.json()) as { query: unknown };
-					const { query } = body;
-
-					if (!query || typeof query !== "string") {
-						return Response.json(
-							{ error: "Missing or invalid 'query' parameter" },
-							{ status: 400, headers: corsHeaders },
-						);
-					}
-
-					const analysis = await handleSearchAnalysis(query);
-					return Response.json(analysis, { headers: corsHeaders });
+					const body = (await req.json()) as ChatRequest;
+					const { sessionId, message, model } = body;
+					const result = await handleChat(sessionId, message, context, model);
+					return Response.json(result, { headers: corsHeaders });
 				} catch (error) {
-					log.error({ error }, "Search analysis failed");
 					return Response.json(
-						{ error: error instanceof Error ? error.message : "Unknown error" },
+						{ error: String(error) },
 						{ status: 500, headers: corsHeaders },
 					);
 				}
 			}
 
-			// Result re-ranking endpoint
-			if (url.pathname === "/search/rerank" && req.method === "POST") {
+			// Metadata enhancement endpoint
+			if (url.pathname === "/metadata/enhance" && req.method === "POST") {
 				try {
-					const body = (await req.json()) as {
-						results: unknown;
-						query: unknown;
-						intent: unknown;
-					};
-					const { results, query, intent } = body;
-
-					if (
-						!results ||
-						!Array.isArray(results) ||
-						!query ||
-						typeof query !== "string"
-					) {
-						return Response.json(
-							{ error: "Missing or invalid 'results' parameter" },
-							{ status: 400, headers: corsHeaders },
-						);
-					}
-
-					const ranked = await handleResultReranking(
-						results as { id: string; content: string; score: number }[],
-						query,
-						intent as string | undefined,
-					);
-					return Response.json(ranked, { headers: corsHeaders });
+					const body = (await req.json()) as MetadataEnhanceRequest;
+					const { docId } = body;
+					await handleMetadataEnhancement(docId, context);
+					return Response.json({ status: "success" }, { headers: corsHeaders });
 				} catch (error) {
-					log.error({ error }, "Result re-ranking failed");
 					return Response.json(
-						{ error: error instanceof Error ? error.message : "Unknown error" },
+						{ error: String(error) },
 						{ status: 500, headers: corsHeaders },
 					);
 				}
 			}
 
-			// Context extraction endpoint
-			if (url.pathname === "/search/context" && req.method === "POST") {
-				try {
-					const body = (await req.json()) as {
-						result: unknown;
-						query: unknown;
-					};
-					const { result, query } = body;
-
-					if (!result || !query || typeof query !== "string") {
-						return Response.json(
-							{ error: "Missing 'result' or 'query' parameter" },
-							{ status: 400, headers: corsHeaders },
-						);
-					}
-
-					const context = await handleContextExtraction(
-						result as { id: string; content: string },
-						query,
-					);
-					return Response.json(context, { headers: corsHeaders });
-				} catch (error) {
-					log.error({ error }, "Context extraction failed");
-					return Response.json(
-						{ error: error instanceof Error ? error.message : "Unknown error" },
-						{ status: 500, headers: corsHeaders },
-					);
-				}
+			// Graph Stats endpoint
+			if (url.pathname === "/graph/stats" && req.method === "GET") {
+				return Response.json(graphEngine.getStats(), { headers: corsHeaders });
 			}
 
-			// Metadata enhancement endpoint
-			if (url.pathname === "/metadata/enhance" && req.method === "POST") {
+			// Search endpoints (analysis, rerank, context)
+			if (url.pathname === "/search/analyze" && req.method === "POST") {
 				try {
-					const body = (await req.json()) as { docId: unknown };
-					const { docId } = body;
-
-					if (!docId || typeof docId !== "string") {
-						return Response.json(
-							{ error: "Missing 'docId' parameter" },
-							{ status: 400, headers: corsHeaders },
-						);
-					}
-
-					const enhancement = await handleMetadataEnhancement(docId);
-					return Response.json(enhancement, { headers: corsHeaders });
+					const body = (await req.json()) as SearchAnalyzeRequest;
+					const { query } = body;
+					const result = await handleSearchAnalysis(query, context);
+					return Response.json(result, { headers: corsHeaders });
 				} catch (error) {
-					log.error({ error }, "Metadata enhancement endpoint failed");
 					return Response.json(
-						{ error: error instanceof Error ? error.message : "Unknown error" },
+						{ error: String(error) },
 						{ status: 500, headers: corsHeaders },
 					);
 				}
 			}
 
-			// Batch enhancement endpoint
-			if (url.pathname === "/metadata/batch" && req.method === "POST") {
+			if (url.pathname === "/search/rerank" && req.method === "POST") {
 				try {
-					const body = (await req.json()) as { limit: unknown };
-					const limit = typeof body.limit === "number" ? body.limit : 50;
-
-					const result = await handleBatchEnhancement(limit);
+					const body = (await req.json()) as SearchRerankRequest;
+					const { results, query, intent } = body;
+					const result = await handleResultReranking(results, query, intent);
 					return Response.json(result, { headers: corsHeaders });
 				} catch (error) {
-					log.error({ error }, "Batch enhancement endpoint failed");
 					return Response.json(
-						{ error: error instanceof Error ? error.message : "Unknown error" },
+						{ error: String(error) },
 						{ status: 500, headers: corsHeaders },
 					);
 				}
 			}
 
-			// Chat endpoint
-			if (url.pathname === "/chat" && req.method === "POST") {
+			if (url.pathname === "/search/context" && req.method === "POST") {
 				try {
-					const body = (await req.json()) as {
-						sessionId?: unknown;
-						message: unknown;
-					};
-					const sessionId =
-						typeof body.sessionId === "string"
-							? body.sessionId
-							: crypto.randomUUID();
-					const message = body.message;
-
-					if (!message || typeof message !== "string") {
-						return Response.json(
-							{ error: "Missing 'message' parameter" },
-							{ status: 400, headers: corsHeaders },
-						);
-					}
-
-					const response = await handleChat(sessionId, message);
-					return Response.json(response, { headers: corsHeaders });
+					const body = (await req.json()) as SearchContextRequest;
+					const { result, query } = body;
+					const contextResult = await handleContextExtraction(result, query);
+					return Response.json(contextResult, { headers: corsHeaders });
 				} catch (error) {
-					log.error({ error }, "Chat endpoint failed");
 					return Response.json(
-						{ error: error instanceof Error ? error.message : "Unknown error" },
+						{ error: String(error) },
 						{ status: 500, headers: corsHeaders },
 					);
 				}
 			}
 
-			// 404 for unknown endpoints
-			return Response.json(
-				{ error: "Not found" },
-				{ status: 404, headers: corsHeaders },
-			);
+			return new Response("Not Found", { status: 404, headers: corsHeaders });
 		},
 	});
 
-	log.info(`✅ HTTP server listening on port ${port}`);
-	log.info("⏳ Daemon ready to handle requests");
-
-	// Task Watcher Loop
-	log.info(`👀 Watching for tasks in ${AMALFA_DIRS.tasks.pending}`);
-
-	// Check every 5 seconds
-	setInterval(async () => {
-		try {
-			await processPendingTasks();
-		} catch (error) {
-			log.error({ error }, "Task processing error");
-		}
-	}, 5000);
+	log.info(`Server started on port ${port}`);
 }
 
 /**
- * Scan and process pending tasks
+ * Process tasks from the pending directory
  */
 async function processPendingTasks() {
-	if (!ollamaAvailable) return;
-
 	const pendingDir = AMALFA_DIRS.tasks.pending;
 	if (!existsSync(pendingDir)) return;
 
-	const files = readdirSync(pendingDir);
-	for (const file of files) {
-		if (!file.endsWith(".json")) continue;
+	const files = (await readdir(pendingDir)).filter((f: string) =>
+		f.endsWith(".json"),
+	);
 
-		const taskPath = join(pendingDir, file);
+	for (const file of files) {
+		const pendingPath = join(pendingDir, file);
 		const processingPath = join(AMALFA_DIRS.tasks.processing, file);
 
 		try {
-			// Move to processing
-			renameSync(taskPath, processingPath);
-			log.info({ file }, "🔄 Processing task...");
+			await rename(pendingPath, processingPath);
+			const taskContent = JSON.parse(
+				await Bun.file(processingPath).text(),
+			) as SonarTask;
 
-			const taskContent = await Bun.file(processingPath).json();
 			const report = await executeTask(taskContent);
-
-			// Save report
 			const reportName = file.replace(".json", "-report.md");
 			const reportPath = join(AMALFA_DIRS.tasks.completed, reportName);
-			writeFileSync(reportPath, report);
-
-			// Move original task to completed
-			const completedPath = join(AMALFA_DIRS.tasks.completed, file);
-			renameSync(processingPath, completedPath);
+			await Bun.write(reportPath, report);
 
+			await rename(processingPath, join(AMALFA_DIRS.tasks.completed, file));
 			log.info({ file }, "✅ Task completed");
 
-			// Notification
 			if (taskContent.notify !== false) {
 				await sendNotification("Sonar Agent", `Task Complete: ${file}`);
 			}
 		} catch (error) {
 			log.error({ file, error }, "❌ Task failed");
-			// Move back to pending? Or to a failed dir? For now, leave in processing or move to failed could be better.
-			// Let's create a failed report so user knows.
-			const reportName = file.replace(".json", "-FAILED.md");
-			const reportPath = join(AMALFA_DIRS.tasks.completed, reportName);
-			writeFileSync(reportPath, `# Task Failed\n\nError: ${error}`);
-
-			// Move to completed so we don't loop forever
-			const completedPath = join(AMALFA_DIRS.tasks.completed, file);
-			renameSync(processingPath, completedPath);
+			const failedReport = join(
+				AMALFA_DIRS.tasks.completed,
+				file.replace(".json", "-FAILED.md"),
+			);
+			await Bun.write(failedReport, `# Task Failed\n\nError: ${error}`);
+			if (existsSync(processingPath)) {
+				await rename(processingPath, join(AMALFA_DIRS.tasks.completed, file));
+			}
 		}
 	}
 }
@@ -960,47 +289,38 @@ async function processPendingTasks() {
 /**
  * Execute a specific task based on its type
  */
-async function executeTask(task: any): Promise<string> {
+async function executeTask(task: SonarTask): Promise<string> {
+	log.info({ type: task.type }, "🚀 Starting executeTask");
 	const startTime = Date.now();
 	let output = `# Task Report: ${task.type}\nDate: ${new Date().toISOString()}\n\n`;
 
-	if (task.type === "enhance_batch") {
-		const limit = task.limit || 10;
-		output += `## Objective\nEnhance ${limit} documents with metadata.\n\n`;
-
-		const result = await handleBatchEnhancement(limit);
-
-		output += `## Results\n`;
-		output += `- Total: ${result.total}\n`;
-		output += `- Successful: ${result.successful}\n`;
-		output += `- Failed: ${result.failed}\n\n`;
+	const taskModel = task.model || (await getTaskModel(task.type));
+	if (taskModel)
+		output += `> **Routing:** Task assigned to model \`${taskModel}\`\n\n`;
 
-		output += `Check daemon logs for detailed errors per document.\n`;
-	} else if (task.type === "research") {
-		output += `## Objective\nResearch Query: "${task.query}"\n\n`;
+	const context: SonarContext = { db, graphEngine, gardener, chatSessions };
 
-		try {
-			const sessionId = `task-${Date.now()}`;
-			// For research: use task.model if specified, otherwise let the cloud/local config decide
-			// Don't hardcode mistral-nemo since it's not valid on OpenRouter
-			const researchModel = task.model || undefined;
-			const response = await handleChat(sessionId, task.query, researchModel);
-
-			output += `## Analysis\n${response.message.content}\n\n`;
-			output += `(Model: ${researchModel || "default"})\n`;
-
-			// Note: chat doesn't return structured sources yet
-			output += `(Source citation not available in simple research task)\n`;
-		} catch (e) {
-			output += `## Error\nResearch failed: ${e instanceof Error ? e.message : String(e)}\n`;
+	try {
+		if (task.type === "synthesis") {
+			output += await handleSynthesisTask(task, context, taskModel);
+		} else if (task.type === "timeline") {
+			output += await handleTimelineTask(task, context, taskModel);
+		} else if (task.type === "garden") {
+			output += await handleGardenTask(task, context, taskModel);
+		} else if (task.type === "research") {
+			output += await handleResearchTask(task, context, taskModel);
+		} else if (task.type === "enhance_batch") {
+			const result = await handleBatchEnhancement(task.limit || 10, context);
+			output += `## Results\n- Successful: ${result.successful}\n- Failed: ${result.failed}\n- Total: ${result.total}\n`;
+		} else {
+			output += `⚠️ Unknown task type: ${task.type}\n`;
 		}
-	} else {
-		output += `Error: Unknown task type '${task.type}'\n`;
+	} catch (error) {
+		output += `❌ Error during task execution: ${error}\n`;
+		throw error;
 	}
 
-	const duration = ((Date.now() - startTime) / 1000).toFixed(1);
-	output += `\n---\n**Duration:** ${duration}s\n`;
-
+	output += `\n---\n**Duration:** ${((Date.now() - startTime) / 1000).toFixed(1)}s\n`;
 	return output;
 }