@goondocks/myco 0.2.6 → 0.2.8

package/dist/src/daemon/main.js

@@ -1,738 +1,10 @@
-import { DaemonServer } from './server.js';
-import { SessionRegistry } from './lifecycle.js';
-import { DaemonLogger } from './logger.js';
-import { loadConfig } from '../config/loader.js';
-import { BatchManager } from './batch.js';
-import { BufferProcessor } from './processor.js';
-import { VaultWriter } from '../vault/writer.js';
-import { MycoIndex } from '../index/sqlite.js';
-import { indexNote, rebuildIndex } from '../index/rebuild.js';
-import { initFts } from '../index/fts.js';
-import { createLlmProvider, createEmbeddingProvider } from '../intelligence/llm.js';
-import { VectorIndex } from '../index/vectors.js';
-import { generateEmbedding } from '../intelligence/embeddings.js';
-import { LineageGraph, LINEAGE_SIMILARITY_THRESHOLD, LINEAGE_SIMILARITY_HIGH_CONFIDENCE, LINEAGE_SIMILARITY_CANDIDATES, LINEAGE_SIMILARITY_MAX_TOKENS } from './lineage.js';
-import { PlanWatcher } from './watcher.js';
-import { buildSimilarityPrompt } from '../prompts/index.js';
-import { extractNumber } from '../intelligence/response.js';
-import { EMBEDDING_INPUT_LIMIT, CONTENT_SNIPPET_CHARS, STALE_BUFFER_MAX_AGE_MS, LINEAGE_RECENT_SESSIONS_LIMIT, RELATED_MEMORIES_LIMIT, CANDIDATE_CONTENT_PREVIEW, SESSION_CONTEXT_MAX_PLANS, PROMPT_CONTEXT_MAX_MEMORIES, PROMPT_CONTEXT_MIN_SIMILARITY, PROMPT_CONTEXT_MIN_LENGTH, CONTEXT_SESSION_PREVIEW_CHARS } from '../constants.js';
-import { TranscriptMiner, extractTurnsFromBuffer } from '../capture/transcript-miner.js';
-import { createPerProjectAdapter, extensionForMimeType } from '../agents/adapter.js';
-import { claudeCodeAdapter } from '../agents/claude-code.js';
-import { EventBuffer } from '../capture/buffer.js';
-import { formatSessionBody } from '../obsidian/formatter.js';
-import { writeObservationNotes } from '../vault/observations.js';
-import { collectArtifactCandidates } from '../artifacts/candidates.js';
-import { slugifyPath } from '../artifacts/slugify.js';
-import { sessionNoteId, bareSessionId, sessionWikilink, sessionRelativePath } from '../vault/session-id.js';
-import { z } from 'zod';
-import YAML from 'yaml';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-function indexAndEmbed(relativePath, noteId, embeddingText, metadata, deps) {
-    indexNote(deps.index, deps.vaultDir, relativePath);
-    if (deps.vectorIndex && embeddingText) {
-        generateEmbedding(deps.embeddingProvider, embeddingText.slice(0, EMBEDDING_INPUT_LIMIT))
-            .then((emb) => deps.vectorIndex.upsert(noteId, emb.embedding, metadata))
-            .catch((err) => deps.logger.debug('embeddings', 'Embedding failed', { id: noteId, error: err.message }));
-    }
-}
-function writeObservations(observations, sessionId, deps) {
-    const written = writeObservationNotes(observations, sessionId, deps.vault, deps.index, deps.vaultDir);
-    for (const note of written) {
-        indexAndEmbed(note.path, note.id, `${note.observation.title}\n${note.observation.content}`, { type: 'memory', importance: 'high', session_id: sessionId }, deps);
-        deps.logger.info('processor', 'Observation written', { type: note.observation.type, title: note.observation.title, session_id: sessionId });
-    }
-}
-async function captureArtifacts(candidates, classified, sessionId, deps, lineage) {
-    const candidateMap = new Map(candidates.map((c) => [c.path, c]));
-    for (const artifact of classified) {
-        const candidate = candidateMap.get(artifact.source_path);
-        if (!candidate)
-            continue;
-        const artifactId = slugifyPath(artifact.source_path);
-        const artifactPath = deps.vault.writeArtifact({
-            id: artifactId,
-            artifact_type: artifact.artifact_type,
-            source_path: artifact.source_path,
-            title: artifact.title,
-            session: sessionId,
-            tags: artifact.tags,
-            content: candidate.content,
-        });
-        indexAndEmbed(artifactPath, artifactId, `${artifact.title}\n${candidate.content}`, { type: 'artifact', artifact_type: artifact.artifact_type, session_id: sessionId }, deps);
-        deps.logger.info('processor', 'Artifact captured', {
-            id: artifactId,
-            type: artifact.artifact_type,
-            source: artifact.source_path,
-        });
-        // Register artifact-session association for lineage detection.
-        // Future sessions referencing this artifact ID link as children.
-        lineage?.registerArtifactForSession(sessionId, artifactId);
-    }
-}
-export function migrateMemoryFiles(vaultDir) {
-    const memoriesDir = path.join(vaultDir, 'memories');
-    if (!fs.existsSync(memoriesDir))
-        return 0;
-    let moved = 0;
-    const entries = fs.readdirSync(memoriesDir);
-    for (const entry of entries) {
-        const fullPath = path.join(memoriesDir, entry);
-        if (!entry.endsWith('.md'))
-            continue;
-        if (fs.statSync(fullPath).isDirectory())
-            continue;
-        try {
-            const content = fs.readFileSync(fullPath, 'utf-8');
-            const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-            if (!fmMatch)
-                continue;
-            const parsed = YAML.parse(fmMatch[1]);
-            const obsType = parsed.observation_type;
-            if (!obsType)
-                continue;
-            const normalizedType = obsType.replace(/_/g, '-');
-            const targetDir = path.join(memoriesDir, normalizedType);
-            fs.mkdirSync(targetDir, { recursive: true });
-            const targetPath = path.join(targetDir, entry);
-            fs.renameSync(fullPath, targetPath);
-            // Touch the file so Obsidian detects the move and re-indexes backlinks
-            const now = new Date();
-            fs.utimesSync(targetPath, now, now);
-            moved++;
-        }
-        catch {
-            // Skip files that can't be read or parsed
-        }
-    }
-    return moved;
-}
-async function main() {
-    const vaultArg = process.argv.find((_, i) => process.argv[i - 1] === '--vault');
-    if (!vaultArg) {
-        process.stderr.write('Usage: mycod --vault <path>\n');
-        process.exit(1);
-    }
-    const vaultDir = path.resolve(vaultArg);
-    const config = loadConfig(vaultDir);
-    const logger = new DaemonLogger(path.join(vaultDir, 'logs'), {
-        level: config.daemon.log_level,
-        maxSize: config.daemon.max_log_size,
-    });
-    const server = new DaemonServer({ vaultDir, logger });
-    const registry = new SessionRegistry({
-        gracePeriod: config.daemon.grace_period,
-        onEmpty: async () => {
-            logger.info('daemon', 'Grace period expired, shutting down');
-            planWatcher.stopFileWatcher();
-            await server.stop();
-            vectorIndex?.close();
-            index.close();
-            logger.close();
-            process.exit(0);
-        },
-    });
-    // Batch processing setup
-    const llmProvider = createLlmProvider(config.intelligence.llm);
-    const embeddingProvider = createEmbeddingProvider(config.intelligence.embedding);
-    let vectorIndex = null;
-    try {
-        const testEmbed = await embeddingProvider.embed('test');
-        vectorIndex = new VectorIndex(path.join(vaultDir, 'vectors.db'), testEmbed.dimensions);
-        logger.info('embeddings', 'Vector index initialized', { dimensions: testEmbed.dimensions });
-    }
-    catch (error) {
-        logger.warn('embeddings', 'Vector index unavailable', { error: error.message });
-    }
-    const processor = new BufferProcessor(llmProvider, config.intelligence.llm.context_window);
-    const vault = new VaultWriter(vaultDir);
-    const index = new MycoIndex(path.join(vaultDir, 'index.db'));
-    const lineageGraph = new LineageGraph(vaultDir);
-    const transcriptMiner = new TranscriptMiner({
-        additionalAdapters: config.capture.transcript_paths.map((p) => createPerProjectAdapter(p, claudeCodeAdapter.parseTurns)),
-    });
-    let activeStopProcessing = null;
-    const indexDeps = { index, vaultDir, vectorIndex, embeddingProvider, logger };
-    const bufferDir = path.join(vaultDir, 'buffer');
-    const sessionBuffers = new Map();
-    const sessionFilePaths = new Map();
-    // Clean up stale buffer files (>24h) on startup
-    if (fs.existsSync(bufferDir)) {
-        const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
-        for (const file of fs.readdirSync(bufferDir)) {
-            const filePath = path.join(bufferDir, file);
-            const stat = fs.statSync(filePath);
-            if (stat.mtimeMs < cutoff) {
-                fs.unlinkSync(filePath);
-                logger.debug('daemon', 'Cleaned stale buffer', { file });
-            }
-        }
-    }
-    // Migrate flat memory files into type subdirectories
-    const migrated = migrateMemoryFiles(vaultDir);
-    if (migrated > 0) {
-        logger.info('daemon', 'Migrated memory files to type subdirectories', { count: migrated });
-        // Rebuild FTS index to update stored paths (vectors are keyed by ID, unaffected)
-        initFts(index);
-        rebuildIndex(index, vaultDir);
-    }
-    // Route body schemas
-    const RegisterBody = z.object({
-        session_id: z.string(),
-        branch: z.string().optional(),
-        started_at: z.string().optional(),
-    });
-    const UnregisterBody = z.object({ session_id: z.string() });
-    const EventBody = z.object({ type: z.string(), session_id: z.string() }).passthrough();
-    const StopBody = z.object({
-        session_id: z.string(),
-        user: z.string().optional(),
-        transcript_path: z.string().optional(),
-        last_assistant_message: z.string().optional(),
-    });
-    const ContextBody = z.object({
-        session_id: z.string().optional(),
-        branch: z.string().optional(),
-        files: z.array(z.string()).optional(),
-    });
-    const planWatcher = new PlanWatcher({
-        projectRoot: process.cwd(),
-        watchPaths: config.capture.artifact_watch,
-        onPlan: (event) => {
-            logger.info('watcher', 'Plan detected', { source: event.source, file: event.filePath });
-            if (event.filePath) {
-                try {
-                    const content = fs.readFileSync(event.filePath, 'utf-8');
-                    const relativePath = path.relative(vaultDir, event.filePath);
-                    const title = content.match(/^#\s+(.+)$/m)?.[1] ?? path.basename(event.filePath);
-                    const planId = `plan-${path.basename(event.filePath, '.md')}`;
-                    indexAndEmbed(relativePath, planId, `${title}\n${content}`, { type: 'plan' }, indexDeps);
-                    // Register plan-session association for lineage detection.
-                    // When a future session's first prompt mentions this plan ID,
-                    // detectHeuristicParent links it as a child of this session.
-                    if (event.sessionId) {
-                        lineageGraph.registerArtifactForSession(event.sessionId, planId);
-                        logger.debug('lineage', 'Plan registered for session', { planId, session: event.sessionId });
-                    }
-                    logger.info('watcher', 'Plan indexed', { path: relativePath });
-                }
-                catch (err) {
-                    logger.debug('watcher', 'Plan index failed', { error: err.message });
-                }
-            }
-        },
-    });
-    planWatcher.startFileWatcher();
-    const batchManager = new BatchManager(async (closedBatch) => {
-        if (closedBatch.length === 0)
-            return;
-        const sessionId = closedBatch[0].session_id;
-        // Extract observations from this batch
-        const asRecords = closedBatch;
-        const result = await processor.process(asRecords, sessionId);
-        if (!result.degraded) {
-            writeObservations(result.observations, sessionId, { vault, ...indexDeps });
-        }
-        logger.debug('processor', 'Batch processed', {
-            session_id: sessionId,
-            events: closedBatch.length,
-            observations: result.observations.length,
-            degraded: result.degraded,
-        });
-    });
-    // Session routes
-    server.registerRoute('POST', '/sessions/register', async (body) => {
-        const { session_id, branch, started_at } = RegisterBody.parse(body);
-        const resolvedStartedAt = started_at ?? new Date().toISOString();
-        registry.register(session_id, { started_at: resolvedStartedAt, branch });
-        server.updateDaemonJsonSessions(registry.sessions);
-        // Heuristic lineage detection
-        try {
-            const recentSessions = index.query({ type: 'session', limit: LINEAGE_RECENT_SESSIONS_LIMIT })
-                .map((n) => {
-                const fm = n.frontmatter;
-                return { id: bareSessionId(n.id), ended: fm.ended, branch: fm.branch };
-            });
-            const activeSessions = registry.sessions
-                .filter((s) => s !== session_id)
-                .map((s) => registry.getSession(s))
-                .filter((s) => s !== undefined);
-            const link = lineageGraph.detectHeuristicParent(session_id, {
-                started_at: resolvedStartedAt,
-                branch,
-            }, recentSessions, activeSessions);
-            if (link) {
-                logger.info('lineage', 'Heuristic parent detected', { child: session_id, parent: link.parent, signal: link.signal });
-            }
-        }
-        catch (err) {
-            logger.debug('lineage', 'Heuristic detection failed', { error: err.message });
-        }
-        logger.info('lifecycle', 'Session registered', { session_id, branch });
-        return { ok: true, sessions: registry.sessions };
-    });
-    server.registerRoute('POST', '/sessions/unregister', async (body) => {
-        const { session_id } = UnregisterBody.parse(body);
-        registry.unregister(session_id);
-        // Note: we do NOT delete the buffer FILE for THIS session. Session reload
-        // (SessionEnd → SessionStart) reuses the same session_id, and deleting
-        // would wipe all prior events.
-        // We DO opportunistically clean stale buffers for OTHER sessions (>24h).
-        try {
-            const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
-            for (const file of fs.readdirSync(bufferDir)) {
-                if (!file.endsWith('.jsonl'))
-                    continue;
-                const bufferSessionId = file.replace('.jsonl', '');
-                if (bufferSessionId === session_id)
-                    continue; // skip current session
-                const filePath = path.join(bufferDir, file);
-                const stat = fs.statSync(filePath);
-                if (stat.mtimeMs < cutoff) {
-                    fs.unlinkSync(filePath);
-                    logger.debug('daemon', 'Cleaned stale buffer', { file });
-                }
-            }
-        }
-        catch { /* buffer dir may not exist */ }
-        // We DO prune the in-memory Map entries to avoid unbounded growth.
-        sessionBuffers.delete(session_id);
-        sessionFilePaths.delete(session_id);
-        server.updateDaemonJsonSessions(registry.sessions);
-        logger.info('lifecycle', 'Session unregistered', { session_id });
-        return { ok: true, sessions: registry.sessions };
-    });
-    // Event routes
-    server.registerRoute('POST', '/events', async (body) => {
-        const validated = EventBody.parse(body);
-        const event = { ...validated, timestamp: validated.timestamp ?? new Date().toISOString() };
-        logger.debug('hooks', 'Event received', { type: event.type, session_id: event.session_id });
-        // Ensure session is registered (idempotent — handles daemon restarts mid-session)
-        if (!registry.getSession(event.session_id)) {
-            registry.register(event.session_id, { started_at: event.timestamp });
-            logger.debug('lifecycle', 'Auto-registered session from event', { session_id: event.session_id });
-        }
-        // Persist to disk so events survive daemon restarts
-        if (!sessionBuffers.has(event.session_id)) {
-            sessionBuffers.set(event.session_id, new EventBuffer(bufferDir, event.session_id));
-        }
-        sessionBuffers.get(event.session_id).append(event);
-        batchManager.addEvent(event);
-        if (validated.type === 'tool_use') {
-            const v = validated;
-            planWatcher.checkToolEvent({ tool_name: String(v.tool_name ?? ''), tool_input: v.tool_input, session_id: validated.session_id });
-            const toolName = String(v.tool_name ?? '');
-            if (toolName === 'Write' || toolName === 'Edit') {
-                const filePath = v.tool_input?.file_path;
-                if (filePath) {
-                    if (!sessionFilePaths.has(event.session_id)) {
-                        sessionFilePaths.set(event.session_id, new Set());
-                    }
-                    sessionFilePaths.get(event.session_id).add(filePath);
-                }
-            }
-        }
-        return { ok: true };
-    });
-    server.registerRoute('POST', '/events/stop', async (body) => {
-        const { session_id: sessionId, user, transcript_path: hookTranscriptPath, last_assistant_message: lastAssistantMessage } = StopBody.parse(body);
-        // Ensure session is registered (handles daemon restarts mid-session)
-        if (!registry.getSession(sessionId)) {
-            registry.register(sessionId, { started_at: new Date().toISOString() });
-            logger.debug('lifecycle', 'Auto-registered session from stop event', { session_id: sessionId });
-        }
-        const sessionMeta = registry.getSession(sessionId);
-        logger.info('hooks', 'Stop received', { session_id: sessionId, has_transcript_path: !!hookTranscriptPath, has_response: !!lastAssistantMessage });
-        // Respond immediately — the hook should not block on LLM processing.
-        // Serialize stop processing: if a previous stop is still running, chain
-        // the new one to run after it completes. This prevents concurrent
-        // processStopEvent calls from racing on the same session file.
-        const run = () => processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage).catch((err) => {
-            logger.error('processor', 'Stop processing failed', { session_id: sessionId, error: err.message });
-        });
-        // Chain onto any in-flight processing. Only the tail of the chain clears the variable.
-        const prev = activeStopProcessing ?? Promise.resolve();
-        activeStopProcessing = prev.then(run).finally(() => { activeStopProcessing = null; });
-        return { ok: true };
-    });
-    async function processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage) {
-        // --- Phase 1: Gather data (I/O only, no LLM) ---
-        const lastBatch = batchManager.finalize(sessionId);
-        // Tiered turn extraction:
-        // 1. Read transcript for complete turns (with AI responses)
-        // 2. Check buffer for prompts newer than the transcript's last turn
-        //    (captures turns the transcript missed, e.g., after context compaction)
-        // 3. Fall back to buffer entirely if no transcript found
-        const transcriptResult = transcriptMiner.getAllTurnsWithSource(sessionId, hookTranscriptPath);
-        let allTurns = transcriptResult.turns;
-        let turnSource = transcriptResult.source;
-        const bufferEvents = sessionBuffers.get(sessionId)?.readAll() ?? [];
-        if (allTurns.length === 0) {
-            // No transcript — use buffer as primary source
-            allTurns = extractTurnsFromBuffer(bufferEvents);
-            turnSource = 'buffer';
-        }
-        else if (bufferEvents.length > 0) {
-            // Transcript exists — check for buffer events newer than the last transcript turn.
-            // These are prompts the transcript missed (e.g., after context compaction).
-            const lastTranscriptTs = allTurns[allTurns.length - 1].timestamp;
-            if (lastTranscriptTs) {
-                const newerEvents = bufferEvents.filter((e) => String(e.timestamp ?? '') > lastTranscriptTs);
-                if (newerEvents.length > 0) {
-                    const bufferTurns = extractTurnsFromBuffer(newerEvents);
-                    allTurns = [...allTurns, ...bufferTurns];
-                    turnSource = `${transcriptResult.source}+buffer`;
-                    logger.info('processor', 'Appended buffer turns missing from transcript', {
-                        session_id: sessionId, transcriptTurns: transcriptResult.turns.length, bufferTurns: bufferTurns.length,
-                    });
-                }
-            }
-        }
-        // Attach the last assistant message from the hook to the most recent turn
-        // that doesn't already have an AI response. This captures the response
-        // for turns the transcript missed (post-compaction) or buffer-sourced turns.
-        if (lastAssistantMessage && allTurns.length > 0) {
-            const lastTurn = allTurns[allTurns.length - 1];
-            if (!lastTurn.aiResponse) {
-                lastTurn.aiResponse = lastAssistantMessage;
-            }
-        }
-        const ended = new Date().toISOString();
-        let started = (allTurns.length > 0 && allTurns[0].timestamp) ? allTurns[0].timestamp : ended;
-        // Find existing session file and clean up cross-date duplicates in one pass.
-        const sessionsDir = path.join(vaultDir, 'sessions');
-        const sessionFileName = `${sessionNoteId(sessionId)}.md`;
-        let existingContent;
-        const duplicatePaths = [];
-        try {
-            for (const dateDir of fs.readdirSync(sessionsDir)) {
-                const candidate = path.join(sessionsDir, dateDir, sessionFileName);
-                try {
-                    const content = fs.readFileSync(candidate, 'utf-8');
-                    if (!existingContent || content.length > existingContent.length) {
-                        existingContent = content;
-                    }
-                    duplicatePaths.push(candidate);
-                }
-                catch { /* file doesn't exist in this date dir */ }
-            }
-        }
-        catch { /* sessions dir may not exist yet */ }
-        let existingTurnCount = 0;
-        if (existingContent) {
-            const startedMatch = existingContent.match(/^started:\s*"?(.+?)"?\s*$/m);
-            if (startedMatch)
-                started = startedMatch[1];
-            const turnMatches = existingContent.match(/^### Turn \d+/gm);
-            existingTurnCount = turnMatches?.length ?? 0;
-        }
-        // Collect artifact candidates (no LLM yet)
-        const writtenFiles = sessionFilePaths.get(sessionId) ?? new Set();
-        const artifactCandidates = collectArtifactCandidates(writtenFiles, { artifact_extensions: config.capture.artifact_extensions }, process.cwd());
-        // Guard: never overwrite an existing session with zero turns — the transcript
-        // is temporarily unreadable (daemon restart, file locked, etc.)
-        if (allTurns.length === 0 && existingTurnCount > 0) {
-            logger.warn('processor', 'Transcript unreadable, skipping rewrite to preserve existing data', { session_id: sessionId, existingTurns: existingTurnCount });
-            return;
-        }
-        // Skip if no new turns AND no batch to process AND no artifacts to classify
-        if (allTurns.length > 0 && allTurns.length === existingTurnCount && lastBatch.length === 0 && artifactCandidates.length === 0) {
-            logger.debug('processor', 'No new turns, skipping session rewrite', { session_id: sessionId, turns: allTurns.length });
-            return;
-        }
-        // --- Phase 2: LLM calls in parallel ---
-        // Build conversation text for summarization (pure string, no LLM)
-        const conversationText = allTurns.map((t, i) => {
-            const parts = [`### Turn ${i + 1}`];
-            if (t.prompt)
-                parts.push(`Prompt: ${t.prompt}`);
-            if (t.toolCount > 0)
-                parts.push(`Tools: ${t.toolCount} calls`);
-            if (t.aiResponse)
-                parts.push(`Response: ${t.aiResponse}`);
-            return parts.join('\n');
-        }).join('\n\n');
-        const conversationSection = `## Conversation\n\n${conversationText}`;
-        // Launch all LLM calls concurrently
-        const observationPromise = lastBatch.length > 0
-            ? processor.process(lastBatch, sessionId)
-                .catch((err) => { logger.warn('processor', 'Observation extraction failed', { session_id: sessionId, error: err.message }); return null; })
-            : Promise.resolve(null);
-        const artifactPromise = artifactCandidates.length > 0
-            ? processor.classifyArtifacts(artifactCandidates, sessionId)
-                .then((classified) => captureArtifacts(artifactCandidates, classified, sessionId, { vault, ...indexDeps }, lineageGraph))
-                .catch((err) => { logger.warn('processor', 'Artifact capture failed', { session_id: sessionId, error: err.message }); })
-            : Promise.resolve();
-        const summaryPromise = processor.summarizeSession(conversationSection, sessionId, user)
-            .catch((err) => { logger.warn('processor', 'Session summarization failed', { session_id: sessionId, error: err.message }); return null; });
-        // Wait for all LLM calls to complete
-        const [observationResult, , summaryResult] = await Promise.all([observationPromise, artifactPromise, summaryPromise]);
-        // --- Phase 3: Write results to vault ---
-        // Write observations
-        if (observationResult && !observationResult.degraded) {
-            writeObservations(observationResult.observations, sessionId, { vault, ...indexDeps });
-        }
-        // Compute canonical path
-        const date = started.slice(0, 10);
-        const relativePath = sessionRelativePath(sessionId, date);
-        const targetFullPath = path.join(vaultDir, relativePath);
-        // Remove cross-date duplicates
-        for (const dup of duplicatePaths) {
-            if (dup !== targetFullPath) {
-                try {
-                    fs.unlinkSync(dup);
-                    logger.debug('lifecycle', 'Removed duplicate session file', { path: dup });
-                }
-                catch { /* already gone */ }
-            }
-        }
-        // Write images to attachments
-        const attachmentsDir = path.join(vaultDir, 'attachments');
-        const hasImages = allTurns.some((t) => t.images?.length);
-        if (hasImages) {
-            fs.mkdirSync(attachmentsDir, { recursive: true });
-        }
-        const turnImageNames = new Map();
-        for (let i = 0; i < allTurns.length; i++) {
-            const turn = allTurns[i];
-            if (!turn.images?.length)
-                continue;
-            const names = [];
-            for (let j = 0; j < turn.images.length; j++) {
-                const img = turn.images[j];
-                const ext = extensionForMimeType(img.mediaType);
-                const filename = `${bareSessionId(sessionId)}-t${i + 1}-${j + 1}.${ext}`;
-                const filePath = path.join(attachmentsDir, filename);
-                if (!fs.existsSync(filePath)) {
-                    fs.writeFileSync(filePath, Buffer.from(img.data, 'base64'));
-                    logger.debug('processor', 'Image saved', { filename, turn: i + 1 });
-                }
-                names.push(filename);
-            }
-            turnImageNames.set(i, names);
-        }
-        // Build and write session note
-        let title = `Session ${sessionId}`;
-        let narrative = '';
-        if (summaryResult) {
-            title = summaryResult.title;
-            narrative = summaryResult.summary;
-        }
-        // Query related memories for this session
-        const relatedMemories = index.query({ type: 'memory', limit: RELATED_MEMORIES_LIMIT })
-            .filter((n) => {
-            const fm = n.frontmatter;
-            return fm.session === sessionNoteId(sessionId) || fm.session === sessionId;
-        })
-            .map((n) => ({ id: n.id, title: n.title }));
-        // The formatter always gets the full turn list — no more partial appending.
-        // existingConversation is no longer needed; we rebuild from the transcript each time.
-        const summary = formatSessionBody({
-            title,
-            narrative,
-            sessionId,
-            user,
-            started,
-            ended,
-            branch: sessionMeta?.branch,
-            relatedMemories,
-            turns: allTurns.map((t, i) => ({
-                prompt: t.prompt,
-                toolCount: t.toolCount,
-                aiResponse: t.aiResponse,
-                images: turnImageNames.get(i),
-            })),
-        });
-        const parentId = lineageGraph.getParent(sessionId);
-        const parentLink = parentId ? lineageGraph.getLinks().find((l) => l.child === sessionId) : undefined;
-        vault.writeSession({
-            id: sessionId,
-            user,
-            started,
-            ended,
-            branch: sessionMeta?.branch,
-            parent: parentId ? sessionWikilink(parentId) : undefined,
-            parent_reason: parentLink?.signal,
-            tools_used: allTurns.reduce((sum, t) => sum + t.toolCount, 0),
-            summary,
-        });
-        indexAndEmbed(relativePath, sessionNoteId(sessionId), narrative, { type: 'session', session_id: sessionId }, indexDeps);
-        logger.debug('processor', 'Session turns', { source: turnSource, total: allTurns.length });
-        // Wait for artifact capture (started concurrently with session building)
-        await artifactPromise;
-        // Phase 2: LLM similarity detection (fire-and-forget, only if no heuristic parent)
-        if (!parentId && vectorIndex && narrative) {
-            generateEmbedding(embeddingProvider, narrative)
-                .then(async (emb) => {
-                const candidates = vectorIndex.search(emb.embedding, { limit: LINEAGE_SIMILARITY_CANDIDATES })
-                    .filter((r) => r.metadata.type === 'session' && r.id !== sessionNoteId(sessionId));
-                if (candidates.length === 0)
-                    return;
-                // Score all candidates in parallel
-                const candidateNotes = index.queryByIds(candidates.map((c) => c.id));
-                const noteMap = new Map(candidateNotes.map((n) => [n.id, n]));
-                const scores = await Promise.all(candidates.map(async (candidate) => {
-                    const note = noteMap.get(candidate.id);
-                    if (!note)
-                        return { id: candidate.id, score: 0 };
-                    try {
-                        const prompt = buildSimilarityPrompt(narrative, note.content.slice(0, CANDIDATE_CONTENT_PREVIEW));
-                        const response = await llmProvider.summarize(prompt, { maxTokens: LINEAGE_SIMILARITY_MAX_TOKENS });
-                        const score = extractNumber(response.text);
-                        return { id: candidate.id, score: isNaN(score) ? 0 : score };
-                    }
-                    catch {
-                        return { id: candidate.id, score: 0 };
-                    }
-                }));
-                const best = scores.reduce((a, b) => (b.score > a.score ? b : a));
-                if (best.score >= LINEAGE_SIMILARITY_THRESHOLD) {
-                    const bestParentId = bareSessionId(best.id);
-                    const confidence = best.score >= LINEAGE_SIMILARITY_HIGH_CONFIDENCE ? 'high' : 'medium';
-                    lineageGraph.addLink({
-                        parent: bestParentId,
-                        child: sessionId,
-                        signal: 'semantic_similarity',
-                        confidence: confidence,
-                    });
-                    // Retroactively update session frontmatter with parent + re-index
-                    try {
-                        vault.updateNoteFrontmatter(relativePath, {
-                            parent: sessionWikilink(bestParentId),
-                            parent_reason: 'semantic_similarity',
-                        });
-                        indexNote(index, vaultDir, relativePath);
-                    }
-                    catch { /* frontmatter update failed — link still in lineage.json */ }
-                    logger.info('lineage', 'LLM similarity parent detected', {
-                        child: sessionId, parent: bestParentId, score: best.score,
-                    });
-                }
-            })
-                .catch((err) => logger.debug('lineage', 'Similarity detection failed', { error: err.message }));
-        }
-        logger.info('processor', 'Session note written', { session_id: sessionId, path: relativePath });
-    }
-    // Session-start context: structural facts only — active plans + parent session.
-    // Memories are injected per-prompt (more targeted, less noise).
-    server.registerRoute('POST', '/context', async (body) => {
-        const { session_id, branch } = ContextBody.parse(body);
-        logger.debug('hooks', 'Session context query', { session_id });
-        try {
-            const parts = [];
-            // Active plans — the agent needs to know what's in flight
-            const plans = index.query({ type: 'plan' });
-            const activePlans = plans.filter((p) => {
-                const status = p.frontmatter.status;
-                return status === 'active' || status === 'in_progress';
-            });
-            if (activePlans.length > 0) {
-                const planLines = activePlans.slice(0, SESSION_CONTEXT_MAX_PLANS).map((p) => {
-                    const status = p.frontmatter.status;
-                    return `- **${p.title}** (${status}) \`[${p.id}]\``;
-                });
-                parts.push(`### Active Plans\n${planLines.join('\n')}`);
-            }
-            // Parent session summary — lineage continuity
-            if (session_id) {
-                const parentId = lineageGraph.getParent(session_id);
-                if (parentId) {
-                    const parentNotes = index.queryByIds([sessionNoteId(parentId)]);
-                    if (parentNotes.length > 0) {
-                        const parent = parentNotes[0];
-                        parts.push(`### Previous Session\n- **${parent.title}**: ${parent.content.slice(0, CONTEXT_SESSION_PREVIEW_CHARS)} \`[${parent.id}]\``);
-                    }
-                }
-            }
-            // Branch info for awareness
-            if (branch) {
-                parts.push(`Branch:: \`${branch}\``);
-            }
-            if (parts.length > 0) {
-                return { text: parts.join('\n\n') };
-            }
-            return { text: '' };
-        }
-        catch (error) {
-            logger.error('daemon', 'Session context failed', { error: error.message });
-            return { text: '' };
-        }
-    });
-    // Per-prompt context: semantic search for memories relevant to THIS specific prompt.
-    // This is the primary intelligence delivery — targeted, high-confidence, token-efficient.
-    const PromptContextBody = z.object({
-        prompt: z.string(),
-        session_id: z.string().optional(),
-    });
-    server.registerRoute('POST', '/context/prompt', async (body) => {
-        const { prompt, session_id } = PromptContextBody.parse(body);
-        if (!prompt || prompt.length < PROMPT_CONTEXT_MIN_LENGTH || !vectorIndex) {
-            return { text: '' };
-        }
-        try {
-            const emb = await generateEmbedding(embeddingProvider, prompt.slice(0, EMBEDDING_INPUT_LIMIT));
-            const results = vectorIndex.search(emb.embedding, {
-                limit: PROMPT_CONTEXT_MAX_MEMORIES,
-                type: 'memory',
-                relativeThreshold: PROMPT_CONTEXT_MIN_SIMILARITY,
-            });
-            if (results.length === 0)
-                return { text: '' };
-            const noteMap = new Map(index.queryByIds(results.map((r) => r.id)).map((n) => [n.id, n]));
-            const lines = [];
-            for (const r of results) {
-                const note = noteMap.get(r.id);
-                if (!note)
-                    continue;
-                const fm = note.frontmatter;
-                if (fm.status === 'superseded' || fm.status === 'archived')
-                    continue;
-                const obsType = fm.observation_type ?? 'note';
-                lines.push(`- [${obsType}] ${note.title}: ${note.content.slice(0, CONTENT_SNIPPET_CHARS)} \`[${note.id}]\``);
-            }
-            if (lines.length === 0)
-                return { text: '' };
-            const injected = `**Relevant memories for this task:**\n${lines.join('\n')}`;
-            logger.debug('context', 'Prompt context injected', {
-                session_id,
-                memories: lines.length,
-                prompt_preview: prompt.slice(0, 50),
-            });
-            return { text: injected };
-        }
-        catch (err) {
-            logger.debug('context', 'Prompt context failed', { error: err.message });
-            return { text: '' };
-        }
-    });
-    await server.start();
-    logger.info('daemon', 'Daemon ready', { vault: vaultDir, port: server.port });
-    const shutdown = async (signal) => {
-        logger.info('daemon', `${signal} received`);
-        // Wait for any active stop processing to finish before shutting down
-        if (activeStopProcessing) {
-            logger.info('daemon', 'Waiting for active stop processing to complete...');
-            await activeStopProcessing;
-        }
-        planWatcher.stopFileWatcher();
-        registry.destroy();
-        await server.stop();
-        vectorIndex?.close();
-        index.close();
-        logger.close();
-        process.exit(0);
-    };
-    process.on('SIGTERM', () => shutdown('SIGTERM'));
-    process.on('SIGINT', () => shutdown('SIGINT'));
-}
-// Entry point guard — only run when executed directly, not when imported in tests
-const __filename = fileURLToPath(import.meta.url);
-if (process.argv[1] === __filename) {
-    main().catch((err) => {
-        process.stderr.write(`[mycod] Fatal: ${err.message}\n`);
-        process.exit(1);
-    });
-}
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  ensureNativeDeps
+} from "../../chunk-4JML636J.js";
+import "../../chunk-PZUWP5VK.js";
+
+// src/entries/daemon.ts
+ensureNativeDeps();
+await import("../../main-5W4ADOBG.js");
 //# sourceMappingURL=main.js.map