@vinaes/succ 1.4.0 → 1.5.37

package/dist/daemon/service.js

@@ -16,52 +16,36 @@
 import http from 'http';
 import fs from 'fs';
 import path from 'path';
-import { createSessionManager, createIdleWatcher } from './sessions.js';
+import { createIdleWatcher, createSessionManager } from './sessions.js';
 import { logError, logWarn } from '../lib/fault-logger.js';
 import { processRegistry } from '../lib/process-registry.js';
-import { processSessionEnd } from './session-processor.js';
-import { ValidationError, NotFoundError, NetworkError } from '../lib/errors.js';
-import { startWatcher, stopWatcher, getWatcherStatus, indexFileOnDemand } from './watcher.js';
-import { startAnalyzer, stopAnalyzer, getAnalyzerStatus, triggerAnalysis } from './analyzer.js';
-import { getProjectRoot, getSuccDir, getIdleReflectionConfig, getIdleWatcherConfig, getConfig, getObserverConfig, } from '../lib/config.js';
-import { hybridSearchDocs, hybridSearchCode, hybridSearchMemories, saveMemory, closeDb, getStats, getMemoryStats, incrementMemoryAccessBatch, getRecentMemories, getPinnedMemories, setMemoryInvariant, getMemoriesByTag, 
-// Global memory
-saveGlobalMemory, closeGlobalDb, 
-// Dispatcher lifecycle
-initStorageDispatcher, closeStorageDispatcher, getStorageDispatcher, } from '../lib/storage/index.js';
-import { getEmbedding, cleanupEmbeddings } from '../lib/embeddings.js';
-import { scoreMemory, passesQualityThreshold, cleanupQualityScoring } from '../lib/quality.js';
-import { scanSensitive } from '../lib/sensitive-filter.js';
-import { generateCompactBriefing } from '../lib/compact-briefing.js';
-import { callLLM } from '../lib/llm.js';
-import { extractSessionSummary } from '../lib/session-summary.js';
-import { recordTranscriptTokens, recordExtraction, resetTranscriptCounter, loadBudgets, flushBudgets, removeBudget, } from '../lib/token-budget.js';
-import { appendObservations, removeObservations, cleanupStaleObservations, } from '../lib/session-observations.js';
-import { REFLECTION_SYSTEM, REFLECTION_PROMPT } from '../prompts/index.js';
-import { matchRules } from '../lib/hook-rules.js';
-// ============================================================================
-// Constants
-// ============================================================================
+import { NotFoundError, NetworkError, ValidationError } from '../lib/errors.js';
+import { startWatcher, stopWatcher } from './watcher.js';
+import { startAnalyzer, stopAnalyzer } from './analyzer.js';
+import { getConfig, getIdleReflectionConfig, getIdleWatcherConfig, getProjectRoot, getSuccDir, } from '../lib/config.js';
+import { getStablePort } from '../lib/daemon-port.js';
+import { closeDb, closeGlobalDb, closeStorageDispatcher, initStorageDispatcher, } from '../lib/storage/index.js';
+import { cleanupEmbeddings } from '../lib/embeddings.js';
+import { cleanupReranker } from '../lib/reranker.js';
+import { cleanupQualityScoring } from '../lib/quality.js';
+import { loadBudgets } from '../lib/token-budget.js';
+import { getErrorMessage, } from './routes/types.js';
+import { sessionRoutes } from './routes/sessions.js';
+import { searchRoutes, resetSearchRoutesState } from './routes/search.js';
+import { memoryRoutes, resetMemoryRoutesState } from './routes/memory.js';
+import { clearBriefingCache, initReflectionMaintenance, performReflection, preGenerateBriefing, reflectionRoutes, resetReflectionRoutesState, } from './routes/reflection.js';
+import { statusRoutes } from './routes/status.js';
+import { watcherRoutes } from './routes/watcher.js';
+import { analyzerRoutes } from './routes/analyzer.js';
+import { skillRoutes } from './routes/skills.js';
+import { hookRoutes } from './routes/hooks.js';
+import { addVersionedRoutes, getApiVersionInfo } from './routes/versioning.js';
 const DEFAULT_PORT_RANGE_START = 37842;
 const MAX_PORT_ATTEMPTS = 100;
-// ============================================================================
-// Daemon State
-// ============================================================================
+const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10MB
 let state = null;
 let sessionManager = null;
 let idleWatcher = null;
-const briefingCache = new Map();
-const briefingGenerationInProgress = new Set();
-// In-flight dedup: prevents race condition when identical /api/remember requests
-// arrive within a short window (e.g. hook fires twice for same tool_use)
-const rememberInFlight = new Map();
-const REMEMBER_DEDUP_TTL_MS = 5000;
-// Hook rules cache — stores all hook-rule memories, invalidated on remember with hook-rule tag
-let hookRulesCache = null;
-const HOOK_RULES_CACHE_TTL = 60_000; // 60s
-// ============================================================================
-// File Paths
-// ============================================================================
 function getDaemonPidFile() {
     const succDir = getSuccDir();
     const tmpDir = path.join(succDir, '.tmp');
@@ -70,13 +54,6 @@ function getDaemonPidFile() {
     }
     return path.join(tmpDir, 'daemon.pid');
 }
-// ============================================================================
-// Progress File Management
-// ============================================================================
-/**
- * Get path to session progress file
- * Progress files accumulate idle reflection briefings for session-end processing
- */
 function getProgressFilePath(sessionId) {
     const succDir = getSuccDir();
     const tmpDir = path.join(succDir, '.tmp');
@@ -85,10 +62,6 @@ function getProgressFilePath(sessionId) {
     }
     return path.join(tmpDir, `session-${sessionId}-progress.md`);
 }
-/**
- * Append a briefing to the session progress file
- * Creates file with header if it doesn't exist
- */
 export function appendToProgressFile(sessionId, briefing) {
     const progressPath = getProgressFilePath(sessionId);
     const timestamp = new Date().toISOString();
@@ -106,10 +79,6 @@ export function appendToProgressFile(sessionId, briefing) {
     content += '\n\n---\n\n';
     fs.appendFileSync(progressPath, content);
 }
-/**
- * Read tail of transcript file (for fallback when no progress file)
- * Returns the last maxBytes of the file, starting from a complete line
- */
 export function readTailTranscript(transcriptPath, maxBytes = 2 * 1024 * 1024) {
     if (!fs.existsSync(transcriptPath)) {
         return '';
@@ -118,107 +87,14 @@ export function readTailTranscript(transcriptPath, maxBytes = 2 * 1024 * 1024) {
     if (stats.size <= maxBytes) {
         return fs.readFileSync(transcriptPath, 'utf8');
     }
-    // Read only tail
     const fd = fs.openSync(transcriptPath, 'r');
     const buffer = Buffer.alloc(maxBytes);
     fs.readSync(fd, buffer, 0, maxBytes, stats.size - maxBytes);
     fs.closeSync(fd);
-    // Find first complete line (skip partial line at start)
     const content = buffer.toString('utf8');
     const firstNewline = content.indexOf('\n');
     return firstNewline > 0 ? content.slice(firstNewline + 1) : content;
 }
-// ============================================================================
-// Briefing Pre-Generation
-// ============================================================================
-const BRIEFING_CACHE_MAX_AGE_MS = 5 * 60 * 1000; // 5 minutes
-const BRIEFING_MIN_TRANSCRIPT_GROWTH = 5000; // Re-generate after 5KB growth
-// const BRIEFING_PREGENERATE_IDLE_MS = 120 * 1000;  // Pre-generate after 2 min idle
-/**
- * Pre-generate briefing for a session in background
- * Called when session is idle or transcript grows significantly
- */
-async function preGenerateBriefing(sessionId, transcriptPath) {
-    // Skip if already generating
-    if (briefingGenerationInProgress.has(sessionId)) {
-        return;
-    }
-    if (!fs.existsSync(transcriptPath)) {
-        return;
-    }
-    const stats = fs.statSync(transcriptPath);
-    const currentSize = stats.size;
-    // Check if we need to regenerate
-    const cached = briefingCache.get(sessionId);
-    if (cached) {
-        const age = Date.now() - cached.generatedAt;
-        const growth = currentSize - cached.transcriptSize;
-        // Skip if cache is fresh and transcript hasn't grown much
-        if (age < BRIEFING_CACHE_MAX_AGE_MS && growth < BRIEFING_MIN_TRANSCRIPT_GROWTH) {
-            return;
-        }
-    }
-    briefingGenerationInProgress.add(sessionId);
-    log(`[briefing] Pre-generating for session ${sessionId.slice(0, 8)}...`);
-    try {
-        const transcriptContent = fs.readFileSync(transcriptPath, 'utf-8');
-        const result = await generateCompactBriefing(transcriptContent);
-        if (result.success && result.briefing) {
-            briefingCache.set(sessionId, {
-                briefing: result.briefing,
-                generatedAt: Date.now(),
-                transcriptSize: currentSize,
-            });
-            log(`[briefing] Pre-generated for session ${sessionId.slice(0, 8)} (${result.briefing.length} chars)`);
-        }
-        else {
-            log(`[briefing] Pre-generation failed: ${result.error}`);
-        }
-    }
-    catch (error) {
-        log(`[briefing] Pre-generation error: ${error}`);
-    }
-    finally {
-        briefingGenerationInProgress.delete(sessionId);
-    }
-}
-/**
- * Get cached briefing or generate on-demand
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-async function getCachedBriefing(sessionId, transcriptPath) {
-    const cached = briefingCache.get(sessionId);
-    if (cached) {
-        // Check if cache is still valid
-        const age = Date.now() - cached.generatedAt;
-        if (age < BRIEFING_CACHE_MAX_AGE_MS) {
-            return { briefing: cached.briefing, cached: true };
-        }
-    }
-    // Cache miss or stale - generate fresh
-    if (!fs.existsSync(transcriptPath)) {
-        return { cached: false };
-    }
-    const transcriptContent = fs.readFileSync(transcriptPath, 'utf-8');
-    const result = await generateCompactBriefing(transcriptContent);
-    if (result.success && result.briefing) {
-        const stats = fs.statSync(transcriptPath);
-        briefingCache.set(sessionId, {
-            briefing: result.briefing,
-            generatedAt: Date.now(),
-            transcriptSize: stats.size,
-        });
-        return { briefing: result.briefing, cached: false };
-    }
-    return { cached: false };
-}
-/**
- * Clear briefing cache for a session (called when session ends)
- */
-function clearBriefingCache(sessionId) {
-    briefingCache.delete(sessionId);
-    briefingGenerationInProgress.delete(sessionId);
-}
 function getDaemonPortFile() {
     const succDir = getSuccDir();
     const tmpDir = path.join(succDir, '.tmp');
@@ -231,13 +107,9 @@ function getDaemonLogFile() {
     const succDir = getSuccDir();
     return path.join(succDir, 'daemon.log');
 }
-// ============================================================================
-// Logging
-// ============================================================================
 function log(message) {
     const timestamp = new Date().toISOString();
     const line = `[${timestamp}] ${message}\n`;
-    // Write to daemon.log
     try {
         fs.appendFileSync(getDaemonLogFile(), line);
     }
@@ -246,291 +118,43 @@ function log(message) {
             error: err instanceof Error ? err.message : String(err),
         });
     }
-    // Also write to stderr for debugging
     process.stderr.write(line);
 }
-// ============================================================================
-// Write Reflection
-// ============================================================================
-/**
- * Write a human-like reflection to the brain vault
- * Uses Claude CLI or local LLM to generate introspective text
- */
-async function writeReflection(transcript, _idleConfig) {
-    const projectRoot = getProjectRoot();
-    const reflectionsDir = path.join(projectRoot, '.succ', 'brain', 'reflections');
-    // Create reflections directory if needed
-    if (!fs.existsSync(reflectionsDir)) {
-        fs.mkdirSync(reflectionsDir, { recursive: true });
-    }
-    const now = new Date();
-    const dateStr = now.toISOString().split('T')[0];
-    const timeStr = now.toTimeString().split(' ')[0].substring(0, 5);
-    const timestamp = `${dateStr} ${timeStr}`;
-    const prompt = REFLECTION_PROMPT.replace('{transcript}', transcript.substring(0, 3000));
-    let reflectionText = null;
-    // Use sleep agent for background reflection if enabled
-    try {
-        reflectionText = await callLLM(prompt, {
-            timeout: 60000,
-            useSleepAgent: true,
-            systemPrompt: REFLECTION_SYSTEM,
-        });
-    }
-    catch (err) {
-        log(`[reflection] LLM call failed: ${err}`);
-        reflectionText = null;
-    }
-    if (!reflectionText || reflectionText.trim().length < 50) {
-        log(`[reflection] Reflection text too short or empty, skipping`);
-        return;
-    }
-    // Write reflection file with YAML frontmatter
-    const reflectionFile = path.join(reflectionsDir, `${timestamp}.md`);
-    const content = `---
-date: ${dateStr}
-time: ${timeStr}
-trigger: idle
-tags:
-  - reflection
----
-
-# Reflection ${dateStr} ${timeStr}
-
-${reflectionText.trim()}
-`;
-    fs.writeFileSync(reflectionFile, content);
-    // Also save to memory (with dedup to prevent duplicate reflections)
-    const embedding = await getEmbedding(reflectionText.trim());
-    await saveMemory(reflectionText.trim(), embedding, ['reflection'], 'observation', {
-        qualityScore: { score: 0.6, factors: { hasContext: 1 } },
-        deduplicate: true,
-    });
+function isErrnoException(error) {
+    return typeof error === 'object' && error !== null && 'code' in error;
 }
-// LLM functions moved to shared module: src/lib/llm.ts
-// ============================================================================
-// Reflection Handler
-// ============================================================================
-async function handleReflection(sessionId, session) {
-    // Skip reflection for service sessions (reflection subagents, analyzers, etc.)
-    if (session.isService) {
-        log(`[reflection] Skipping service session ${sessionId}`);
-        return;
-    }
-    log(`[reflection] Starting reflection for session ${sessionId}`);
-    const idleConfig = getIdleReflectionConfig();
-    // Only run if we have a transcript
-    if (!session.transcriptPath || !fs.existsSync(session.transcriptPath)) {
-        log(`[reflection] No transcript found for session ${sessionId}`);
-        return;
-    }
-    try {
-        // ── Change detection: skip redundant work during long AFK ──
-        let transcriptChanged = true;
-        let memoriesChanged = true;
-        try {
-            const currentSize = fs.statSync(session.transcriptPath).size;
-            if (session.lastTranscriptSize !== undefined && currentSize === session.lastTranscriptSize) {
-                transcriptChanged = false;
-                log(`[reflection] Transcript unchanged (${currentSize}b), skipping briefing`);
-            }
-            session.lastTranscriptSize = currentSize;
-        }
-        catch {
-            /* transcript file gone — skip size check */
-        }
-        // Check memory count for consolidation skip
-        const memStats = await getMemoryStats();
-        const currentMemCount = memStats.total;
-        if (session.lastMemoryCount !== undefined && currentMemCount === session.lastMemoryCount) {
-            memoriesChanged = false;
-        }
-        session.lastMemoryCount = currentMemCount;
-        // ── Mid-conversation observer: extract facts when enough new content ──
-        const observerConfig = getObserverConfig();
-        if (observerConfig.enabled && transcriptChanged) {
-            try {
-                const currentSize = session.lastTranscriptSize ?? 0;
-                const lastObsSize = session.lastObservationSize ?? 0;
-                const lastObsTime = session.lastObservation ?? session.registeredAt;
-                const now = Date.now();
-                // Read new content and track real token count via budget
-                const newBytes = currentSize - lastObsSize;
-                const timeThresholdMs = observerConfig.max_minutes * 60 * 1000;
-                const enoughTime = now - lastObsTime >= timeThresholdMs;
-                // Use byte-estimated token check first (cheap), then verify with real count
-                const estimatedTokens = Math.ceil(newBytes / 3.5);
-                const enoughNewContent = estimatedTokens >= observerConfig.min_tokens;
-                if (enoughNewContent || enoughTime) {
-                    const newContent = readTailTranscript(session.transcriptPath, newBytes);
-                    // Track real tokens in budget
-                    const realTokens = recordTranscriptTokens(sessionId, newContent);
-                    log(`[observer] Triggering extraction (tokens: ~${realTokens}, time: ${Math.round((now - lastObsTime) / 60000)}min)`);
-                    if (newContent.length > 200) {
-                        const result = await extractSessionSummary(newContent, { verbose: false });
-                        recordExtraction(sessionId, result.transcriptTokens ?? 0, result.summaryTokens ?? 0, result.factsExtracted, result.factsSaved);
-                        resetTranscriptCounter(sessionId);
-                        // Persist extraction metadata to session observations (append-only)
-                        if (result.factsSaved > 0) {
-                            appendObservations(sessionId, [
-                                {
-                                    content: `Extracted ${result.factsExtracted} facts, saved ${result.factsSaved}`,
-                                    type: 'observation',
-                                    tags: ['mid-session'],
-                                    extractedAt: new Date().toISOString(),
-                                    source: 'mid-session-observer',
-                                    transcriptOffset: currentSize,
-                                    memoryId: null,
-                                },
-                            ]);
-                        }
-                        log(`[observer] Extracted ${result.factsExtracted} facts, saved ${result.factsSaved} (skipped ${result.factsSkipped})`);
-                    }
-                    session.lastObservation = now;
-                    session.lastObservationSize = currentSize;
-                    flushBudgets();
-                }
-            }
-            catch (err) {
-                log(`[observer] Mid-session extraction failed: ${err}`);
-            }
-        }
-        // ── Generate briefing (skip if transcript unchanged) ──
-        let briefingResult = { success: false };
-        if (transcriptChanged) {
-            const transcriptContent = readTailTranscript(session.transcriptPath, 100 * 1024); // 100KB max
-            briefingResult = await generateCompactBriefing(transcriptContent, {
-                format: 'structured',
-                include_memories: true,
-                max_memories: 3,
-            });
-            if (briefingResult.success && briefingResult.briefing) {
-                appendToProgressFile(sessionId, briefingResult.briefing);
-                log(`[reflection] Appended briefing to progress file (${briefingResult.briefing.length} chars)`);
-            }
-            else {
-                log(`[reflection] Failed to generate briefing for ${sessionId}`);
-            }
-        }
-        // ── Parallel operations ──
-        const globalConfig = getConfig();
-        const parallelOps = [];
-        // memory_consolidation - skip if no new memories (disabled by default, opt-in only)
-        if (memoriesChanged && idleConfig.operations?.memory_consolidation === true) {
-            parallelOps.push((async () => {
-                const threshold = idleConfig.thresholds?.similarity_for_merge ?? 0.92;
-                const limit = idleConfig.max_memories_to_process ?? 50;
-                log(`[reflection] Running memory consolidation (threshold=${threshold}, limit=${limit})`);
-                const { consolidate } = await import('../commands/consolidate.js');
-                await consolidate({
-                    threshold: String(threshold),
-                    limit: String(limit),
-                    llm: true,
-                    verbose: false,
-                });
-                log(`[reflection] Memory consolidation complete`);
-            })());
-        }
-        // retention_cleanup - independent (always runs if enabled)
-        if (globalConfig.retention?.enabled && idleConfig.operations?.retention_cleanup !== false) {
-            parallelOps.push((async () => {
-                log(`[reflection] Running retention cleanup`);
-                const { retention } = await import('../commands/retention.js');
-                await retention({ apply: true, verbose: false });
-                log(`[reflection] Retention cleanup complete`);
-            })());
-        }
-        await Promise.all(parallelOps);
-        // ── Graph cleanup: prune → enrich → orphans → communities → centrality ──
-        if (idleConfig.operations?.graph_refinement !== false ||
-            idleConfig.operations?.graph_enrichment !== false) {
-            const shouldRun = memoriesChanged || session.lastLinkCount === undefined;
-            if (shouldRun) {
-                log(`[reflection] Running graph cleanup pipeline`);
-                try {
-                    const { graphCleanup } = await import('../lib/graph/cleanup.js');
-                    const cleanupResult = await graphCleanup({
-                        skipEnrich: idleConfig.operations?.graph_enrichment === false,
-                        onProgress: (step, detail) => log(`[reflection] [${step}] ${detail}`),
-                    });
-                    log(`[reflection] Cleanup: pruned ${cleanupResult.pruned}, enriched ${cleanupResult.enriched}, orphans ${cleanupResult.orphansConnected}, communities ${cleanupResult.communitiesDetected}, centrality ${cleanupResult.centralityUpdated}`);
-                    // Proximity links from co-occurrence (not part of cleanup pipeline)
-                    try {
-                        const { createProximityLinks } = await import('../lib/graph/contextual-proximity.js');
-                        const r = await createProximityLinks({ minCooccurrence: 2 });
-                        log(`[reflection] Created ${r.created} proximity links`);
-                    }
-                    catch (err) {
-                        log(`[reflection] Proximity failed: ${err}`);
-                    }
-                    // Synthesize patterns from community clusters (uses cleanup's community result)
-                    if (cleanupResult.communityResult &&
-                        cleanupResult.communityResult.communities.length > 0) {
-                        try {
-                            const { synthesizeFromCommunities } = await import('../lib/reflection-synthesizer.js');
-                            const synthResult = await synthesizeFromCommunities(cleanupResult.communityResult, {
-                                log,
-                            });
-                            const hasSynthActivity = synthResult.patternsCreated > 0 ||
-                                synthResult.duplicatesSkipped > 0 ||
-                                synthResult.reinforced > 0;
-                            if (hasSynthActivity) {
-                                log(`[reflection] Synthesized ${synthResult.patternsCreated} patterns from ${synthResult.clustersProcessed} clusters` +
-                                    (synthResult.reinforced > 0
-                                        ? `, reinforced ${synthResult.reinforced} existing`
-                                        : '') +
-                                    (synthResult.duplicatesSkipped > 0
-                                        ? `, skipped ${synthResult.duplicatesSkipped} duplicates`
-                                        : '') +
-                                    (synthResult.observationsMarked > 0
-                                        ? `, marked ${synthResult.observationsMarked} as reflected`
-                                        : ''));
-                            }
-                        }
-                        catch (err) {
-                            log(`[reflection] Synthesis failed: ${err}`);
-                        }
-                    }
-                    session.lastLinkCount = (session.lastLinkCount ?? 0) + cleanupResult.orphansConnected;
-                }
-                catch (err) {
-                    log(`[reflection] Graph cleanup failed: ${err}`);
-                }
-            }
-            else {
-                log(`[reflection] Skipping graph cleanup (no changes)`);
-            }
-        }
-        // ── Write reflection (runs last, may use LLM) ──
-        if (idleConfig.operations?.write_reflection !== false) {
-            log(`[reflection] Writing reflection for ${sessionId}`);
-            try {
-                const progressPath = getProgressFilePath(sessionId);
-                const briefingContent = fs.existsSync(progressPath)
-                    ? fs.readFileSync(progressPath, 'utf-8')
-                    : briefingResult.briefing || '';
-                if (briefingContent.length >= 100) {
-                    await writeReflection(briefingContent, idleConfig);
-                    log(`[reflection] Reflection written`);
-                }
-            }
-            catch (err) {
-                log(`[reflection] Write reflection error: ${err}`);
-            }
-        }
-        log(`[reflection] Completed reflection for session ${sessionId}`);
-    }
-    catch (err) {
-        log(`[reflection] Error for session ${sessionId}: ${err}`);
-    }
+function createRouteContext() {
+    return {
+        state,
+        sessionManager,
+        log,
+        checkShutdown,
+        clearBriefingCache,
+        appendToProgressFile,
+        readTailTranscript,
+        getProgressFilePath,
+    };
+}
+function buildRoutes(ctx) {
+    const baseRoutes = {
+        ...statusRoutes(ctx),
+        ...sessionRoutes(ctx),
+        ...searchRoutes(ctx),
+        ...memoryRoutes(ctx),
+        ...reflectionRoutes(ctx),
+        ...watcherRoutes(ctx),
+        ...analyzerRoutes(ctx),
+        ...skillRoutes(ctx),
+        ...hookRoutes(ctx),
+        // API version info endpoint
+        'GET /api/version': async () => getApiVersionInfo(),
+    };
+    // Add /v1/api/* aliases for all /api/* routes
+    return addVersionedRoutes(baseRoutes);
 }
-// ============================================================================
-// HTTP Request Handler
-// ============================================================================
 async function handleRequest(req, res) {
     const reqUrl = new URL(req.url || '/', `http://localhost`);
     const method = req.method || 'GET';
-    // CORS headers (for potential web clients)
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
@@ -539,500 +163,120 @@ async function handleRequest(req, res) {
         res.end();
         return;
     }
-    // Parse JSON body for POST requests
     let body = null;
     if (method === 'POST') {
-        body = await parseBody(req);
+        try {
+            body = await parseBody(req);
+        }
+        catch (error) {
+            const message = getErrorMessage(error);
+            if (message.includes('too large')) {
+                res.writeHead(413, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Request body too large' }));
+                return;
+            }
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid request body' }));
+            return;
+        }
     }
     try {
-        // Route request
         const result = await routeRequest(method, reqUrl.pathname, reqUrl.searchParams, body);
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(result));
     }
     catch (err) {
-        log(`[http] Error: ${err.message}`);
+        const message = getErrorMessage(err);
+        log(`[http] Error: ${message}`);
+        if (err instanceof ValidationError) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+            return;
+        }
+        if (err instanceof NotFoundError) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+            return;
+        }
         res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: err.message }));
+        res.end(JSON.stringify({ error: 'Internal server error' }));
     }
 }
 export async function parseBody(req) {
     return new Promise((resolve, reject) => {
         let data = '';
-        req.on('data', (chunk) => (data += chunk));
+        let size = 0;
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            fn();
+        };
+        req.on('data', (chunk) => {
+            if (settled)
+                return;
+            const chunkSize = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(String(chunk));
+            size += chunkSize;
+            if (size > MAX_BODY_SIZE) {
+                req.destroy();
+                settle(() => reject(new Error('Request body too large')));
+                return;
+            }
+            data += chunk;
+        });
         req.on('end', () => {
+            if (settled)
+                return;
             try {
-                resolve(data ? JSON.parse(data) : {});
+                const parsed = data ? JSON.parse(data) : {};
+                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                    settle(() => reject(new Error('Invalid request body')));
+                    return;
+                }
+                settle(() => resolve(parsed));
             }
-            catch (err) {
-                logWarn('daemon', 'Invalid JSON in HTTP request body', {
-                    error: err instanceof Error ? err.message : String(err),
-                });
-                resolve({});
+            catch {
+                settle(() => reject(new Error('Invalid request body')));
             }
         });
-        req.on('error', reject);
+        req.on('error', (error) => {
+            settle(() => reject(error));
+        });
     });
 }
 /** @internal Exported for testing */
 export async function routeRequest(method, pathname, searchParams, body) {
-    // Health check
-    if (pathname === '/health') {
-        return {
-            status: 'ok',
-            pid: process.pid,
-            uptime: Date.now() - (state?.startedAt || Date.now()),
-            activeSessions: sessionManager?.count() || 0,
-            cwd: state?.cwd || process.cwd(),
-        };
+    const routes = buildRoutes(createRouteContext());
+    const key = `${method} ${pathname}`;
+    const handler = routes[key];
+    if (!handler) {
+        throw new NotFoundError(`Unknown endpoint: ${method} ${pathname}`);
     }
-    // Session endpoints
-    if (pathname === '/api/session/register' && method === 'POST') {
-        const { session_id, transcript_path, is_service = false } = body;
-        if (!session_id) {
-            throw new ValidationError('session_id required');
-        }
-        const session = sessionManager.register(session_id, transcript_path || '', is_service);
-        log(`[session] Registered: ${session_id}${is_service ? ' (service)' : ''}`);
-        return { success: true, session };
-    }
-    if (pathname === '/api/session/unregister' && method === 'POST') {
-        const { session_id, transcript_path, run_reflection } = body;
-        if (!session_id) {
-            throw new ValidationError('session_id required');
-        }
-        const session = sessionManager.get(session_id);
-        const transcriptFile = transcript_path || session?.transcriptPath || '';
-        // Flush session counters to learning_deltas before unregister
-        try {
-            const d = await getStorageDispatcher();
-            await d.flushSessionCounters('daemon-session');
-        }
-        catch (err) {
-            log(`[session] Failed to flush session counters: ${err}`);
-        }
-        // Unregister the session immediately (don't block on processing)
-        const removed = sessionManager.unregister(session_id);
-        clearBriefingCache(session_id); // Clean up any cached briefing
-        removeBudget(session_id); // Clean up token budget
-        removeObservations(session_id); // Clean up observation JSONL
-        flushBudgets();
-        log(`[session] Unregistered: ${session_id} (removed=${removed})`);
-        // Process session asynchronously (summarize transcript, extract learnings, save to memory)
-        if (run_reflection && transcriptFile) {
-            sessionManager.incrementPendingWork();
-            log(`[session] Queuing async processing for ${session_id}`);
-            // Fire-and-forget async processing
-            (async () => {
-                try {
-                    const result = await processSessionEnd(transcriptFile, session_id, log);
-                    log(`[session] Processing complete for ${session_id}: summary=${result.summary.length}chars, learnings=${result.learnings.length}, saved=${result.saved}`);
-                }
-                catch (err) {
-                    log(`[session] Processing failed for ${session_id}: ${err}`);
-                }
-                finally {
-                    sessionManager.decrementPendingWork();
-                    // Check shutdown after work completes
-                    checkShutdown();
-                }
-            })();
-        }
-        else {
-            // No processing needed, check shutdown immediately
-            checkShutdown();
-        }
-        return { success: removed, remaining_sessions: sessionManager.count() };
-    }
-    if (pathname === '/api/session/activity' && method === 'POST') {
-        const { session_id, type, transcript_path, is_service = false } = body;
-        if (!session_id || !type) {
-            throw new ValidationError('session_id and type required');
-        }
-        let session = sessionManager.activity(session_id, type);
-        if (!session) {
-            // Auto-register if session not found (with transcript_path if provided)
-            sessionManager.register(session_id, transcript_path || '', is_service);
-            session = sessionManager.activity(session_id, type);
-            log(`[session] Auto-registered and activity: ${session_id} (${type})${is_service ? ' (service)' : ''}`);
-        }
-        else if (transcript_path && !session.transcriptPath) {
-            // Update transcript path if not set
-            session.transcriptPath = transcript_path;
-            log(`[session] Activity: ${session_id} (${type}) + updated transcript`);
-        }
-        else {
-            log(`[session] Activity: ${session_id} (${type})`);
-        }
-        return { success: true };
-    }
-    if (pathname === '/api/sessions' && method === 'GET') {
-        const includeService = searchParams.get('includeService') === 'true';
-        const sessions = {};
-        for (const [id, session] of sessionManager.getAll(includeService)) {
-            sessions[id] = session;
-        }
-        return { sessions, count: sessionManager.count(includeService) };
-    }
-    // Search endpoints
-    if (pathname === '/api/search' && method === 'POST') {
-        const { query, limit = 5, threshold = 0.3 } = body;
-        if (!query) {
-            throw new ValidationError('query required');
-        }
-        const queryEmbedding = await getEmbedding(query);
-        const results = await hybridSearchDocs(query, queryEmbedding, limit, threshold);
-        // Track access for returned memories
-        const accesses = results
-            .filter((r) => r.memory_id)
-            .map((r) => ({ memoryId: r.memory_id, weight: 0.5 }));
-        if (accesses.length > 0) {
-            await incrementMemoryAccessBatch(accesses);
-        }
-        return { results };
-    }
-    if (pathname === '/api/search-code' && method === 'POST') {
-        const { query, limit = 5, threshold = 0.3 } = body;
-        if (!query) {
-            throw new ValidationError('query required');
-        }
-        const queryEmbedding = await getEmbedding(query);
-        const results = await hybridSearchCode(query, queryEmbedding, limit, threshold);
-        return { results };
-    }
-    if (pathname === '/api/recall' && method === 'POST') {
-        const { query, limit = 5 } = body;
-        // Empty query returns recent memories
-        if (!query) {
-            const memories = await getRecentMemories(limit);
-            return { results: memories };
-        }
-        // Generate embedding for semantic search
-        const queryEmbedding = await getEmbedding(query);
-        const results = await hybridSearchMemories(query, queryEmbedding, limit, 0.3);
-        // Track access for returned memories
-        const accesses = results
-            .filter((r) => r.id)
-            .map((r) => ({ memoryId: r.id, weight: 1.0 }));
-        if (accesses.length > 0) {
-            await incrementMemoryAccessBatch(accesses);
-        }
-        return { results };
-    }
-    if (pathname === '/api/pinned' && method === 'GET') {
-        const pinned = await getPinnedMemories();
-        return { results: pinned };
-    }
-    if (pathname === '/api/pinned/cleanup' && method === 'POST') {
-        // Remove false invariant flags from observation-type memories
-        const pinned = await getPinnedMemories();
-        let cleaned = 0;
-        for (const mem of pinned) {
-            if (mem.type === 'observation' && mem.is_invariant) {
-                await setMemoryInvariant(mem.id, false);
-                cleaned++;
-            }
-        }
-        return { cleaned, total: pinned.length };
-    }
-    if (pathname === '/api/recall-by-tag' && method === 'POST') {
-        const { tag, limit = 5 } = body;
-        if (!tag) {
-            throw new ValidationError('tag required');
-        }
-        const results = await getMemoriesByTag(tag, limit);
-        return { results };
-    }
-    if (pathname === '/api/hook-rules' && method === 'POST') {
-        const { tool_name, tool_input: rawInput } = body;
-        if (!tool_name) {
-            throw new ValidationError('tool_name required');
-        }
-        const tool_input = rawInput && typeof rawInput === 'object' && !Array.isArray(rawInput)
-            ? rawInput
-            : {};
-        // Check cache
-        const now = Date.now();
-        if (!hookRulesCache || now - hookRulesCache.timestamp > HOOK_RULES_CACHE_TTL) {
-            const memories = await getMemoriesByTag('hook-rule', 50);
-            hookRulesCache = { memories, timestamp: now };
-        }
-        const rules = matchRules(hookRulesCache.memories, tool_name, tool_input);
-        return { rules };
-    }
-    if (pathname === '/api/remember' && method === 'POST') {
-        const { content, tags = [], type = 'observation', source, global = false, valid_from, valid_until, } = body;
-        if (!content) {
-            throw new ValidationError('content required');
-        }
-        // In-flight dedup: if an identical request is already being processed, wait for it
-        // Prevents race condition when hooks fire twice for the same tool_use
-        const contentHash = content.slice(0, 200) + '|' + (tags || []).join(',');
-        const existing = rememberInFlight.get(contentHash);
-        if (existing) {
-            const result = await existing;
-            return { success: false, id: result.id, isDuplicate: true, reason: 'in-flight dedup' };
-        }
-        const processRemember = async () => {
-            // Check for sensitive content
-            const config = getConfig();
-            let finalContent = content;
-            if (config.sensitive_filter_enabled !== false) {
-                const scanResult = scanSensitive(content);
-                if (scanResult.hasSensitive) {
-                    if (config.sensitive_auto_redact) {
-                        finalContent = scanResult.redactedText;
-                    }
-                    else {
-                        throw new ValidationError('Content contains sensitive information');
-                    }
-                }
-            }
-            // Get embedding
-            const embedding = await getEmbedding(finalContent);
-            // Score quality
-            const qualityResult = await scoreMemory(finalContent);
-            if (!passesQualityThreshold(qualityResult)) {
-                return { success: false, reason: 'Below quality threshold', score: qualityResult.score };
-            }
-            // Save to appropriate DB
-            let result;
-            if (global) {
-                result = await saveGlobalMemory(finalContent, embedding, tags, type);
-            }
-            else {
-                result = await saveMemory(finalContent, embedding, tags, source ?? type, {
-                    qualityScore: { score: qualityResult.score, factors: qualityResult.factors },
-                    validFrom: valid_from,
-                    validUntil: valid_until,
-                });
-            }
-            // Invalidate hook-rules cache if this memory is a hook rule
-            if (Array.isArray(tags) && tags.includes('hook-rule')) {
-                hookRulesCache = null;
-            }
-            return { success: !result.isDuplicate, id: result.id, isDuplicate: result.isDuplicate };
-        };
-        const promise = processRemember();
-        rememberInFlight.set(contentHash, promise);
-        setTimeout(() => rememberInFlight.delete(contentHash), REMEMBER_DEDUP_TTL_MS);
-        try {
-            return await promise;
-        }
-        finally {
-            rememberInFlight.delete(contentHash);
-        }
-    }
-    // Reflection endpoint
-    if (pathname === '/api/reflect' && method === 'POST') {
-        const { session_id } = body;
-        const watcherConfig = getIdleWatcherConfig();
-        if (session_id) {
-            const session = sessionManager.get(session_id);
-            if (!session) {
-                throw new NotFoundError('Session not found');
-            }
-            await handleReflection(session_id, session);
-            sessionManager.markReflection(session_id);
-            return { success: true, session_id };
-        }
-        else {
-            // Run for all idle sessions
-            const idleSessions = sessionManager.getIdleSessions(watcherConfig.idle_minutes);
-            for (const { sessionId, session } of idleSessions) {
-                await handleReflection(sessionId, session);
-                sessionManager.markReflection(sessionId);
-            }
-            return { success: true, sessions_processed: idleSessions.length };
-        }
-    }
-    // Compact briefing endpoint (for /compact hook)
-    // Supports pre-generated cache for instant responses
-    if (pathname === '/api/briefing' && method === 'POST') {
-        const { transcript, transcript_path, session_id, format, include_learnings, include_memories, max_memories, use_cache, } = body;
-        // Try cached briefing first if session_id provided and use_cache not explicitly false
-        if (session_id && use_cache !== false) {
-            const cached = briefingCache.get(session_id);
-            if (cached) {
-                const age = Date.now() - cached.generatedAt;
-                if (age < BRIEFING_CACHE_MAX_AGE_MS) {
-                    log(`[briefing] Serving cached briefing for ${session_id.slice(0, 8)} (age: ${Math.round(age / 1000)}s)`);
-                    return { success: true, briefing: cached.briefing, cached: true };
-                }
-            }
-        }
-        // Either transcript content or path to transcript file
-        let transcriptContent;
-        if (transcript) {
-            transcriptContent = transcript;
-        }
-        else if (transcript_path && fs.existsSync(transcript_path)) {
-            transcriptContent = fs.readFileSync(transcript_path, 'utf-8');
-        }
-        else {
-            throw new ValidationError('transcript or transcript_path required');
-        }
-        const result = await generateCompactBriefing(transcriptContent, {
-            format,
-            include_learnings,
-            include_memories,
-            max_memories,
-        });
-        // Cache the result if session_id provided
-        if (session_id && result.success && result.briefing && transcript_path) {
-            const stats = fs.existsSync(transcript_path) ? fs.statSync(transcript_path) : null;
-            briefingCache.set(session_id, {
-                briefing: result.briefing,
-                generatedAt: Date.now(),
-                transcriptSize: stats?.size || 0,
-            });
-        }
-        return { ...result, cached: false };
-    }
-    // Status endpoints
-    if (pathname === '/api/status' && method === 'GET') {
-        const stats = await getStats();
-        const memStats = await getMemoryStats();
-        const watchStatus = getWatcherStatus();
-        const analyzeStatus = getAnalyzerStatus();
-        return {
-            daemon: {
-                pid: process.pid,
-                uptime: Date.now() - (state?.startedAt || Date.now()),
-                sessions: sessionManager.count(),
-            },
-            index: stats,
-            memories: memStats,
-            services: {
-                watch: watchStatus,
-                analyze: analyzeStatus,
-            },
-        };
-    }
-    // Watch service endpoints
-    if (pathname === '/api/watch/start' && method === 'POST') {
-        const { patterns, includeCode } = body;
-        const watchState = await startWatcher({ patterns, includeCode }, log);
-        return {
-            success: true,
-            active: watchState.active,
-            patterns: watchState.patterns,
-            includeCode: watchState.includeCode,
-        };
-    }
-    if (pathname === '/api/watch/stop' && method === 'POST') {
-        await stopWatcher(log);
-        return { success: true };
-    }
-    if (pathname === '/api/watch/status' && method === 'GET') {
-        return getWatcherStatus();
-    }
-    if (pathname === '/api/watch/index' && method === 'POST') {
-        const { file } = body;
-        if (!file) {
-            throw new ValidationError('file required');
-        }
-        await indexFileOnDemand(file, log);
-        return { success: true, file };
-    }
-    // Analyze service endpoints
-    if (pathname === '/api/analyze/start' && method === 'POST') {
-        const { intervalMinutes, mode } = body;
-        const analyzeState = startAnalyzer({ intervalMinutes, mode }, log);
-        return {
-            success: true,
-            active: analyzeState.active,
-            runsCompleted: analyzeState.runsCompleted,
-        };
-    }
-    if (pathname === '/api/analyze/stop' && method === 'POST') {
-        stopAnalyzer(log);
-        return { success: true };
-    }
-    if (pathname === '/api/analyze/status' && method === 'GET') {
-        return getAnalyzerStatus();
-    }
-    if (pathname === '/api/analyze' && method === 'POST') {
-        const { mode = 'claude' } = body;
-        await triggerAnalysis(mode, log);
-        return { success: true };
-    }
-    // Skills endpoints
-    if (pathname === '/api/skills/suggest' && method === 'POST') {
-        const { prompt, limit = 2 } = body;
-        if (!prompt) {
-            throw new ValidationError('prompt required');
-        }
-        const { suggestSkills, getSkillsConfig } = await import('../lib/skills.js');
-        const config = getSkillsConfig();
-        if (!config.enabled || !config.auto_suggest?.enabled) {
-            return { success: true, skills: [], disabled: true };
-        }
-        const suggestions = await suggestSkills(prompt, config);
-        return {
-            success: true,
-            skills: suggestions.slice(0, limit),
-        };
-    }
-    if (pathname === '/api/skills/index' && method === 'POST') {
-        const { indexLocalSkills } = await import('../lib/skills.js');
-        const cwd = state?.cwd || process.cwd();
-        const count = indexLocalSkills(cwd);
-        return { success: true, indexed: count };
-    }
-    if (pathname === '/api/skills/track' && method === 'POST') {
-        const { skill_name } = body;
-        if (!skill_name) {
-            throw new ValidationError('skill_name required');
-        }
-        const { trackSkillUsage } = await import('../lib/skills.js');
-        trackSkillUsage(skill_name);
-        return { success: true };
-    }
-    // Skyll status endpoint
-    if (pathname === '/api/skills/skyll' && method === 'GET') {
-        const { getSkyllStatus } = await import('../lib/skyll-client.js');
-        return getSkyllStatus();
-    }
-    // Services endpoint (list all services status)
-    if (pathname === '/api/services' && method === 'GET') {
-        return {
-            watch: getWatcherStatus(),
-            analyze: getAnalyzerStatus(),
-            idle: {
-                enabled: true,
-                sessions: sessionManager.count(),
-            },
-        };
-    }
-    throw new NotFoundError(`Unknown endpoint: ${method} ${pathname}`);
+    return handler(body, searchParams);
 }
-// ============================================================================
-// Daemon Lifecycle
-// ============================================================================
 export async function startDaemon() {
     if (state?.server) {
         return { port: state.port, pid: process.pid };
     }
-    // Check if another daemon is already running (prevent duplicate processes)
     const existingPidFile = getDaemonPidFile();
     if (fs.existsSync(existingPidFile)) {
         try {
             const existingPid = parseInt(fs.readFileSync(existingPidFile, 'utf8').trim(), 10);
             if (existingPid && existingPid !== process.pid) {
-                // Check if process is actually running
                 try {
-                    process.kill(existingPid, 0); // Signal 0 = check if process exists
-                    // Process exists, read port and return
+                    process.kill(existingPid, 0);
                     const portFile = getDaemonPortFile();
                     if (fs.existsSync(portFile)) {
                         const port = parseInt(fs.readFileSync(portFile, 'utf8').trim(), 10);
                         log(`[daemon] Another daemon already running (pid=${existingPid}, port=${port})`);
-                        process.exit(0); // Exit silently - another daemon is handling things
+                        process.exit(0);
                     }
                 }
-                catch {
-                    // Process doesn't exist, clean up stale files
+                catch (error) {
+                    logWarn('service', 'Failed to signal existing daemon process for liveness check', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
                     log(`[daemon] Cleaning up stale PID file (pid=${existingPid} not running)`);
                     fs.unlinkSync(existingPidFile);
                     const portFile = getDaemonPortFile();
@@ -1051,15 +295,10 @@ export async function startDaemon() {
     const cwd = getProjectRoot();
     const watcherConfig = getIdleWatcherConfig();
     getIdleReflectionConfig();
-    // Initialize storage dispatcher (routes to SQLite or PG based on config)
     await initStorageDispatcher();
-    // Initialize session manager
     sessionManager = createSessionManager();
-    // Load token budgets from previous daemon run
     loadBudgets();
-    // Clean up stale observation files (>48h)
-    cleanupStaleObservations();
-    // Create HTTP server
+    initReflectionMaintenance();
     const server = http.createServer((req, res) => {
         handleRequest(req, res).catch((err) => {
             log(`[http] Unhandled error: ${err.message}`);
@@ -1067,14 +306,25 @@ export async function startDaemon() {
             res.end();
         });
     });
-    // Find available port
-    const portStart = DEFAULT_PORT_RANGE_START;
-    let port = portStart;
-    for (let i = 0; i < MAX_PORT_ATTEMPTS; i++) {
+    // Try stable port first (config or hash-based), then fall back to scan
+    const config = getConfig();
+    const stablePort = config.daemon?.port ?? getStablePort(cwd);
+    const fallbackStart = config.daemon?.port_range_start ?? DEFAULT_PORT_RANGE_START;
+    let port = stablePort;
+    let portAttempts = 0;
+    const maxAttempts = 1 + MAX_PORT_ATTEMPTS; // 1 stable + 100 fallback
+    for (let i = 0; i < maxAttempts; i++) {
         await new Promise((resolve, reject) => {
             server.once('error', (err) => {
                 if (err.code === 'EADDRINUSE') {
-                    port++;
+                    portAttempts++;
+                    if (portAttempts === 1) {
+                        // Stable port busy — switch to fallback range
+                        port = fallbackStart;
+                    }
+                    else {
+                        port++;
+                    }
                     resolve();
                 }
                 else {
@@ -1090,33 +340,28 @@ export async function startDaemon() {
         }
     }
     if (!server.listening) {
-        throw new NetworkError(`Could not find available port in range ${portStart}-${portStart + MAX_PORT_ATTEMPTS}`);
+        throw new NetworkError(`Could not find available port (tried ${stablePort}, then ${fallbackStart}-${fallbackStart + MAX_PORT_ATTEMPTS})`);
     }
-    // Save state
     state = {
         cwd,
         startedAt: Date.now(),
         port,
         server,
     };
-    // Write PID and port files
     fs.writeFileSync(getDaemonPidFile(), String(process.pid));
     fs.writeFileSync(getDaemonPortFile(), String(port));
-    // Start idle watcher with briefing pre-generation
     idleWatcher = createIdleWatcher({
         sessionManager,
-        onIdle: handleReflection,
-        onPreGenerateBriefing: preGenerateBriefing,
+        onIdle: (sessionId, session) => performReflection(createRouteContext(), sessionId, session),
+        onPreGenerateBriefing: (sessionId, transcriptPath) => preGenerateBriefing(createRouteContext(), sessionId, transcriptPath),
         checkIntervalSeconds: watcherConfig.check_interval,
         idleMinutes: watcherConfig.idle_minutes,
         reflectionCooldownMinutes: watcherConfig.reflection_cooldown_minutes,
-        preGenerateIdleSeconds: 120, // Pre-generate briefing after 2 min idle
+        preGenerateIdleSeconds: 120,
         log,
     });
     idleWatcher.start();
     log(`[daemon] Started on port ${port} (pid=${process.pid})`);
-    // Auto-start watch service if configured
-    const config = getConfig();
     if (config.daemon?.watch?.auto_start) {
         const watchConfig = config.daemon.watch;
         await startWatcher({
@@ -1126,7 +371,6 @@ export async function startDaemon() {
         }, log);
         log(`[daemon] Auto-started watch service`);
     }
-    // Auto-start analyze service if configured
     if (config.daemon?.analyze?.auto_start) {
         const analyzeConfig = config.daemon.analyze;
         startAnalyzer({
@@ -1135,7 +379,6 @@ export async function startDaemon() {
         }, log);
         log(`[daemon] Auto-started analyze service`);
     }
-    // Setup graceful shutdown
     setupShutdownHandlers();
     return { port, pid: process.pid };
 }
@@ -1143,14 +386,18 @@ function setupShutdownHandlers() {
     const shutdown = () => shutdownDaemon();
     process.on('SIGTERM', shutdown);
     process.on('SIGINT', shutdown);
-    // SIGHUP only exists on Unix
     if (process.platform !== 'win32') {
         process.on('SIGHUP', shutdown);
     }
+    // Prevent silent crashes — log and keep running
+    process.on('uncaughtException', (err) => {
+        log(`[daemon] UNCAUGHT EXCEPTION: ${err.message}\n${err.stack}`);
+    });
+    process.on('unhandledRejection', (reason) => {
+        const msg = reason instanceof Error ? `${reason.message}\n${reason.stack}` : String(reason);
+        log(`[daemon] UNHANDLED REJECTION: ${msg}`);
+    });
 }
-/**
- * Check if daemon should shutdown (no sessions and no pending work)
- */
 function checkShutdown() {
     if (sessionManager?.canShutdown()) {
         log(`[daemon] No more sessions and no pending work, scheduling shutdown`);
@@ -1158,54 +405,52 @@ function checkShutdown() {
             if (sessionManager?.canShutdown()) {
                 shutdownDaemon();
             }
-        }, 5000); // Give 5 seconds for new sessions to connect
+        }, 5000);
     }
 }
-export function shutdownDaemon() {
+export async function shutdownDaemon() {
     log('[daemon] Shutting down...');
-    // Stop idle watcher
     if (idleWatcher) {
         idleWatcher.stop();
         idleWatcher = null;
     }
-    // Stop watch service (async, but we're shutting down so fire-and-forget)
-    stopWatcher(log).catch((err) => log(`[shutdown] Watcher stop failed: ${err}`));
-    // Stop analyze service
+    const watcherPromise = stopWatcher(log).catch((err) => log(`[shutdown] Watcher stop failed: ${err}`));
     stopAnalyzer(log);
-    // Close HTTP server
-    if (state?.server) {
-        state.server.close();
-        state.server = null;
-    }
-    // Kill all spawned child processes (claude CLI, etc.)
+    const serverPromise = state?.server
+        ? new Promise((resolve) => {
+            state.server.close(() => resolve());
+            state.server = null;
+        })
+        : Promise.resolve();
     processRegistry.killAll();
-    // Cleanup DB connections
-    closeStorageDispatcher().catch((err) => log(`[shutdown] Storage close failed: ${err}`));
+    // Wait for watcher and HTTP server to finish before closing storage,
+    // so in-flight requests don't hit a closed DB.
+    await Promise.allSettled([watcherPromise, serverPromise]);
+    await closeStorageDispatcher().catch((err) => log(`[shutdown] Storage close failed: ${err}`));
     cleanupEmbeddings();
+    await cleanupReranker().catch((err) => log(`[shutdown] Reranker cleanup failed: ${err}`));
     cleanupQualityScoring();
     closeDb();
     closeGlobalDb();
-    // Remove PID and port files
     try {
         fs.unlinkSync(getDaemonPidFile());
     }
     catch (err) {
-        if (err.code !== 'ENOENT')
-            log(`[shutdown] PID file removal failed: ${err}`);
+        if (!isErrnoException(err) || err.code !== 'ENOENT') {
+            log(`[shutdown] PID file removal failed: ${getErrorMessage(err)}`);
+        }
     }
     try {
         fs.unlinkSync(getDaemonPortFile());
     }
     catch (err) {
-        if (err.code !== 'ENOENT')
-            log(`[shutdown] Port file removal failed: ${err}`);
+        if (!isErrnoException(err) || err.code !== 'ENOENT') {
+            log(`[shutdown] Port file removal failed: ${getErrorMessage(err)}`);
+        }
     }
     log('[daemon] Shutdown complete');
     process.exit(0);
 }
-// ============================================================================
-// Test Helpers (exported for unit testing)
-// ============================================================================
 /** @internal Initialize module state for testing without starting HTTP server */
 export function _initTestState(cwd = process.cwd()) {
     sessionManager = createSessionManager();
@@ -1216,13 +461,10 @@ export function _resetTestState() {
     sessionManager = null;
     idleWatcher = null;
     state = null;
-    briefingCache.clear();
-    briefingGenerationInProgress.clear();
+    resetReflectionRoutesState();
+    resetMemoryRoutesState();
+    resetSearchRoutesState();
 }
-// ============================================================================
-// CLI Entry Point
-// ============================================================================
-// If run directly, start daemon
 if (process.argv[1]?.endsWith('service.js') || process.argv[1]?.endsWith('service.ts')) {
     startDaemon()
         .then(({ port, pid }) => {