@4da/mcp-server 5.0.1 → 5.0.2

package/README.md

@@ -172,7 +172,7 @@ The MCP server works without the desktop app. On first run it creates a local da
 | Agent memory (cross-session) | Yes | Yes |
 | Scored content feed (20+ sources) | -- | Yes |
 | Actionable signals + knowledge gaps | -- | Yes |
-| Compound intelligence (learns over time) | -- | Yes |
+| The analysis layer (Signal Chains, Knowledge Gaps, temporal analysis) | -- | Yes |
 
 > **[Download 4DA](https://github.com/4DA-Systems/4DA/releases/latest)** for the full experience.
 
@@ -229,7 +229,7 @@ npx @4da/mcp-server --version    # Print version
 No. The server sends package names and versions to public APIs ([OSV.dev](https://osv.dev), npm registry, crates.io, PyPI, Go proxy) and generic tech keywords to [HN Algolia](https://hn.algolia.com/api). The same public data visible in your `package.json`. No source code, no file paths, no personal data. Set `FOURDA_OFFLINE=true` to disable all network calls. (The sole exception is opt-in OpenAI embeddings — see the network note above.)
 
 **Do I need the 4DA desktop app?**
-No. 9 tools work standalone: vulnerability scanning, dependency health, upgrade planning, ecosystem news, pre-task briefings, project context, decision memory, alignment checking, and agent memory. The desktop app adds scored content from 20+ sources that compounds over time.
+No. 9 tools work standalone: vulnerability scanning, dependency health, upgrade planning, ecosystem news, pre-task briefings, project context, decision memory, alignment checking, and agent memory. The desktop app adds a scored content feed from 20+ sources, graded against your actual stack.
 
 **Which AI tools does this work with?**
 Any tool that supports [MCP](https://modelcontextprotocol.io): Claude Code, Claude Desktop, Cursor, Windsurf, VS Code (Copilot), and any custom MCP client.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4da/mcp-server",
-  "version": "5.0.1",
+  "version": "5.0.2",
   "mcpName": "io.github.4DA-Systems/4da-mcp-server",
   "description": "Dependency intelligence for AI coding agents. Live CVE scanning, dependency health, upgrade planning, ecosystem news, decision memory — zero config, privacy-first. 9 tools standalone, 14 total with desktop app.",
   "type": "module",
@@ -18,17 +18,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsc && pnpm run copy-schemas",
-    "copy-schemas": "node -e \"const fs=require('fs');const path=require('path');const src='src/schemas';const dst='dist/schemas';if(!fs.existsSync(dst))fs.mkdirSync(dst,{recursive:true});fs.readdirSync(src).filter(f=>f.endsWith('.json')).forEach(f=>fs.copyFileSync(path.join(src,f),path.join(dst,f)))\"",
-    "dev": "tsc --watch",
-    "start": "node dist/index.js",
-    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
-    "setup": "node dist/setup.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "prepublishOnly": "pnpm run build"
-  },
   "keywords": [
     "mcp",
     "mcp-server",
@@ -95,18 +84,14 @@
   "engines": {
     "node": ">=20.0.0"
   },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "better-sqlite3",
-      "esbuild"
-    ],
-    "overrides": {
-      "fast-uri": ">=3.1.2",
-      "ip-address": "^10.1.1",
-      "vite": ">=7.3.5 <8",
-      "esbuild": ">=0.28.1",
-      "hono": ">=4.12.34 <5",
-      "@hono/node-server": ">=2.0.5 <3"
-    }
+  "scripts": {
+    "build": "tsc && pnpm run copy-schemas",
+    "copy-schemas": "node -e \"const fs=require('fs');const path=require('path');const src='src/schemas';const dst='dist/schemas';if(!fs.existsSync(dst))fs.mkdirSync(dst,{recursive:true});fs.readdirSync(src).filter(f=>f.endsWith('.json')).forEach(f=>fs.copyFileSync(path.join(src,f),path.join(dst,f)))\"",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
+    "setup": "node dist/setup.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/dist/llm.d.ts

@@ -1,162 +0,0 @@
-/**
- * LLM Client for 4DA MCP Server
- *
- * Provides intelligence synthesis over raw tool data.
- * Supports Anthropic Claude, OpenAI, and Ollama (local).
- *
- * Features:
- * - Tiered model selection (use smaller models for simpler tasks)
- * - Optimized prompts for local models
- * - Automatic fallback
- */
-export interface LLMConfig {
-    provider: "anthropic" | "openai" | "ollama" | null;
-    anthropic_api_key?: string;
-    openai_api_key?: string;
-    ollama_url?: string;
-    model?: string;
-    model_light?: string;
-    model_heavy?: string;
-}
-export type TaskComplexity = "light" | "medium" | "heavy";
-export interface SynthesisRequest {
-    system: string;
-    prompt: string;
-    max_tokens?: number;
-    complexity?: TaskComplexity;
-}
-export interface SynthesisResult {
-    synthesis: string;
-    model_used: string;
-    tokens_used?: number;
-    latency_ms?: number;
-}
-/**
- * Default models for different task complexities
- * Optimized for 16GB VRAM
- */
-export declare const DEFAULT_OLLAMA_MODELS: {
-    light: string;
-    medium: string;
-    heavy: string;
-};
-/**
- * Task complexity by tool
- */
-export declare const TOOL_COMPLEXITY: Record<string, TaskComplexity>;
-/**
- * Get LLM configuration from settings.json file.
- *
- * Uses a cached approach: the file is only re-read if its mtime has changed,
- * avoiding unnecessary filesystem reads on every tool invocation.
- */
-export declare function getLLMConfig(_db?: {
-    prepare: (sql: string) => {
-        get: (...args: unknown[]) => unknown;
-    };
-}): LLMConfig;
-/**
- * Check if LLM synthesis is available
- */
-export declare function canSynthesize(config: LLMConfig): boolean;
-/**
- * Synthesize insights using LLM
- *
- * Accepts an optional AbortSignal to allow timeout/cancellation of the
- * underlying fetch calls.
- */
-export declare function synthesize(config: LLMConfig, request: SynthesisRequest, signal?: AbortSignal): Promise<SynthesisResult>;
-/**
- * Synthesize with a timeout wrapper.
- *
- * Wraps the LLM API call with an AbortController + configurable timeout.
- * On timeout, throws a descriptive error so callers can fall back to
- * data-only results.
- *
- * @param config  - LLM provider configuration
- * @param request - Synthesis request (system prompt, user prompt, etc.)
- * @param timeoutMs - Timeout in milliseconds (default: 30000)
- */
-export declare function synthesizeWithTimeout(config: LLMConfig, request: SynthesisRequest, timeoutMs?: number): Promise<SynthesisResult>;
-/**
- * Prompts are optimized for:
- * 1. Clear structure (local models need explicit formatting)
- * 2. Concise output (fewer tokens = faster inference)
- * 3. Specific instructions (reduce ambiguity)
- */
-export declare const SYNTHESIS_PROMPTS: {
-    /**
-     * Daily Briefing - Executive synthesis
-     * Complexity: MEDIUM
-     */
-    dailyBriefing: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown, context: unknown) => string;
-    };
-    /**
-     * Score Autopsy - Explain the reasoning
-     * Complexity: HEAVY (needs to reason about correctness)
-     */
-    scoreAutopsy: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown, context: unknown) => string;
-    };
-    /**
-     * Trend Analysis - Predict and explain
-     * Complexity: HEAVY (needs pattern recognition + prediction)
-     */
-    trendAnalysis: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown, context: unknown) => string;
-    };
-    /**
-     * Context Analysis - Personalized optimization advice
-     * Complexity: MEDIUM (structured recommendations)
-     */
-    contextAnalysis: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown) => string;
-    };
-    /**
-     * Topic Connections - Explain the knowledge graph
-     * Complexity: HEAVY (needs graph reasoning)
-     */
-    topicConnections: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown, context: unknown) => string;
-    };
-};
-/**
- * Check if Ollama is running and has required models
- */
-export declare function checkOllamaStatus(baseUrl?: string): Promise<{
-    available: boolean;
-    models: string[];
-    error?: string;
-}>;
-/**
- * Recommended models for 4DA synthesis tasks
- */
-export declare const RECOMMENDED_MODELS: {
-    "16GB_VRAM": {
-        primary: string;
-        fallback: string;
-        install: string;
-    };
-    "12GB_VRAM": {
-        primary: string;
-        fallback: string;
-        install: string;
-    };
-    "8GB_VRAM": {
-        primary: string;
-        fallback: string;
-        install: string;
-    };
-};
-//# sourceMappingURL=llm.d.ts.map

package/dist/llm.js

@@ -1,502 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * LLM Client for 4DA MCP Server
- *
- * Provides intelligence synthesis over raw tool data.
- * Supports Anthropic Claude, OpenAI, and Ollama (local).
- *
- * Features:
- * - Tiered model selection (use smaller models for simpler tasks)
- * - Optimized prompts for local models
- * - Automatic fallback
- */
-// =============================================================================
-// Model Tiers - Optimized for 16GB VRAM (RTX 4080 Super)
-// =============================================================================
-/**
- * Default models for different task complexities
- * Optimized for 16GB VRAM
- */
-export const DEFAULT_OLLAMA_MODELS = {
-    light: "gemma3:4b",
-    medium: "qwen3:8b",
-    heavy: "qwen3:14b",
-};
-/**
- * Task complexity by tool
- */
-export const TOOL_COMPLEXITY = {
-    daily_briefing: "medium", // Needs to synthesize multiple themes
-    score_autopsy: "heavy", // Needs to reason about score correctness
-    trend_analysis: "heavy", // Needs pattern recognition + prediction
-    context_analysis: "medium", // Structured advice
-    topic_connections: "heavy", // Graph reasoning
-};
-// =============================================================================
-// Configuration
-// =============================================================================
-import { readFileSync, existsSync, statSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "node:url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-/**
- * Find settings.json by looking in common locations
- */
-function findSettingsFile() {
-    // 1. Environment variable (highest priority)
-    const envPath = process.env.FOURDA_SETTINGS_PATH;
-    if (envPath && existsSync(envPath)) {
-        return envPath;
-    }
-    // 2. Sibling to database path
-    const dbPath = process.env.FOURDA_DB_PATH;
-    if (dbPath) {
-        const settingsPath = join(dirname(dbPath), "settings.json");
-        if (existsSync(settingsPath)) {
-            return settingsPath;
-        }
-    }
-    // 3. Common relative locations (portable — no hardcoded dev paths)
-    const searchPaths = [
-        join(process.cwd(), "data", "settings.json"), // CWD/data/
-        join(__dirname, "..", "..", "data", "settings.json"), // Project root (mcp-4da-server/../data/)
-        join(process.cwd(), "..", "data", "settings.json"), // Parent/data/
-    ];
-    for (const candidate of searchPaths) {
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-// =============================================================================
-// Settings Cache — re-read only when file mtime changes
-// =============================================================================
-let _cachedConfig = null;
-let _cachedSettingsPath = null;
-let _cachedMtimeMs = 0;
-/**
- * Get LLM configuration from settings.json file.
- *
- * Uses a cached approach: the file is only re-read if its mtime has changed,
- * avoiding unnecessary filesystem reads on every tool invocation.
- */
-export function getLLMConfig(_db) {
-    const settingsPath = findSettingsFile();
-    if (!settingsPath) {
-        // Return environment-based config as fallback
-        return {
-            provider: process.env.LLM_PROVIDER || null,
-            anthropic_api_key: process.env.ANTHROPIC_API_KEY,
-            openai_api_key: process.env.OPENAI_API_KEY,
-            ollama_url: process.env.OLLAMA_URL || "http://localhost:11434",
-            model: process.env.LLM_MODEL,
-            model_light: process.env.LLM_MODEL_LIGHT,
-            model_heavy: process.env.LLM_MODEL_HEAVY,
-        };
-    }
-    // Check if we can use the cached config
-    try {
-        const currentMtimeMs = statSync(settingsPath).mtimeMs;
-        if (_cachedConfig &&
-            _cachedSettingsPath === settingsPath &&
-            _cachedMtimeMs === currentMtimeMs) {
-            return _cachedConfig;
-        }
-        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        const llm = settings.llm || {};
-        const config = {
-            provider: (llm.provider ?? null),
-            anthropic_api_key: llm.api_key || llm.anthropic_api_key,
-            openai_api_key: llm.openai_api_key,
-            ollama_url: llm.base_url || llm.ollama_url || "http://localhost:11434",
-            model: llm.model,
-            model_light: llm.model_light,
-            model_heavy: llm.model_heavy,
-        };
-        // Update cache
-        _cachedConfig = config;
-        _cachedSettingsPath = settingsPath;
-        _cachedMtimeMs = currentMtimeMs;
-        return config;
-    }
-    catch (error) {
-        console.error("Failed to read settings.json:", error);
-        return { provider: null };
-    }
-}
-/**
- * Check if LLM synthesis is available
- */
-export function canSynthesize(config) {
-    if (!config.provider)
-        return false;
-    switch (config.provider) {
-        case "anthropic":
-            return !!config.anthropic_api_key;
-        case "openai":
-            return !!config.openai_api_key;
-        case "ollama":
-            return true; // Ollama doesn't need a key
-        default:
-            return false;
-    }
-}
-/**
- * Get the appropriate model for task complexity
- */
-function getModelForComplexity(config, complexity) {
-    if (config.provider !== "ollama") {
-        // Cloud providers use the configured model
-        return config.model || (config.provider === "anthropic" ? "claude-sonnet-4-6" : "gpt-4o");
-    }
-    // Ollama: use tiered models
-    switch (complexity) {
-        case "light":
-            return config.model_light || config.model || DEFAULT_OLLAMA_MODELS.light;
-        case "medium":
-            return config.model || DEFAULT_OLLAMA_MODELS.medium;
-        case "heavy":
-            return config.model_heavy || config.model || DEFAULT_OLLAMA_MODELS.heavy;
-    }
-}
-// =============================================================================
-// Synthesis
-// =============================================================================
-/**
- * Synthesize insights using LLM
- *
- * Accepts an optional AbortSignal to allow timeout/cancellation of the
- * underlying fetch calls.
- */
-export async function synthesize(config, request, signal) {
-    if (!canSynthesize(config)) {
-        throw new Error("LLM not configured - cannot synthesize");
-    }
-    const startTime = Date.now();
-    const complexity = request.complexity || "medium";
-    let result;
-    switch (config.provider) {
-        case "anthropic":
-            result = await synthesizeAnthropic(config, request, signal);
-            break;
-        case "openai":
-            result = await synthesizeOpenAI(config, request, signal);
-            break;
-        case "ollama":
-            result = await synthesizeOllama(config, request, complexity, signal);
-            break;
-        default:
-            throw new Error(`Unknown LLM provider: ${config.provider}`);
-    }
-    result.latency_ms = Date.now() - startTime;
-    return result;
-}
-/**
- * Synthesize with a timeout wrapper.
- *
- * Wraps the LLM API call with an AbortController + configurable timeout.
- * On timeout, throws a descriptive error so callers can fall back to
- * data-only results.
- *
- * @param config  - LLM provider configuration
- * @param request - Synthesis request (system prompt, user prompt, etc.)
- * @param timeoutMs - Timeout in milliseconds (default: 30000)
- */
-export async function synthesizeWithTimeout(config, request, timeoutMs = 30000) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        return await synthesize(config, request, controller.signal);
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
-            throw new Error(`LLM timeout after ${timeoutMs / 1000}s`);
-        }
-        throw error;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-/**
- * Anthropic Claude synthesis
- */
-async function synthesizeAnthropic(config, request, signal) {
-    const model = config.model || "claude-sonnet-4-6";
-    const maxTokens = request.max_tokens || 1024;
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "x-api-key": config.anthropic_api_key,
-            "anthropic-version": "2023-06-01",
-        },
-        body: JSON.stringify({
-            model,
-            max_tokens: maxTokens,
-            system: request.system,
-            messages: [{ role: "user", content: request.prompt }],
-        }),
-        signal,
-    });
-    if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`Anthropic API error: ${error}`);
-    }
-    const data = (await response.json());
-    return {
-        synthesis: data.content[0]?.text || "",
-        model_used: model,
-        tokens_used: data.usage?.output_tokens,
-    };
-}
-/**
- * OpenAI synthesis
- */
-async function synthesizeOpenAI(config, request, signal) {
-    const model = config.model || "gpt-4o";
-    const maxTokens = request.max_tokens || 1024;
-    const response = await fetch("https://api.openai.com/v1/chat/completions", {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${config.openai_api_key}`,
-        },
-        body: JSON.stringify({
-            model,
-            max_tokens: maxTokens,
-            messages: [
-                { role: "system", content: request.system },
-                { role: "user", content: request.prompt },
-            ],
-        }),
-        signal,
-    });
-    if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`OpenAI API error: ${error}`);
-    }
-    const data = (await response.json());
-    return {
-        synthesis: data.choices[0]?.message?.content || "",
-        model_used: model,
-        tokens_used: data.usage?.completion_tokens,
-    };
-}
-/**
- * Ollama synthesis (local) - optimized for local models
- */
-async function synthesizeOllama(config, request, complexity, signal) {
-    const model = getModelForComplexity(config, complexity);
-    const baseUrl = config.ollama_url || "http://localhost:11434";
-    // Use chat endpoint for better instruction following
-    const response = await fetch(`${baseUrl}/api/chat`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            model,
-            messages: [
-                { role: "system", content: request.system },
-                { role: "user", content: request.prompt },
-            ],
-            stream: false,
-            options: {
-                num_predict: request.max_tokens || 512,
-                temperature: 0.7,
-                top_p: 0.9,
-            },
-        }),
-        signal,
-    });
-    if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`Ollama API error: ${error}`);
-    }
-    const data = (await response.json());
-    return {
-        synthesis: data.message?.content || "",
-        model_used: model,
-        tokens_used: data.eval_count,
-    };
-}
-// =============================================================================
-// Synthesis Prompts - Optimized for Local Models
-// =============================================================================
-/**
- * Prompts are optimized for:
- * 1. Clear structure (local models need explicit formatting)
- * 2. Concise output (fewer tokens = faster inference)
- * 3. Specific instructions (reduce ambiguity)
- */
-export const SYNTHESIS_PROMPTS = {
-    /**
-     * Daily Briefing - Executive synthesis
-     * Complexity: MEDIUM
-     */
-    dailyBriefing: {
-        complexity: "medium",
-        system: `You are an intelligence analyst. Synthesize data into actionable briefings.
-
-OUTPUT FORMAT:
-1. One-sentence summary of the day
-2. The single most important thing to review (with reason)
-3. One recommended action
-
-Be direct. No filler. Every word must add value.`,
-        buildPrompt: (data, context) => `
-DATA:
-${JSON.stringify(data, null, 2)}
-
-USER CONTEXT:
-${JSON.stringify(context, null, 2)}
-
-Generate briefing with:
-1. ONE-LINE SUMMARY
-2. TOP PRIORITY (title + why it matters to this user)
-3. RECOMMENDED ACTION`,
-    },
-    /**
-     * Score Autopsy - Explain the reasoning
-     * Complexity: HEAVY (needs to reason about correctness)
-     */
-    scoreAutopsy: {
-        complexity: "heavy",
-        system: `You are a scoring forensics expert. Analyze if relevance scores are correct.
-
-OUTPUT FORMAT:
-1. VERDICT: [ACCURATE / TOO HIGH / TOO LOW]
-2. REASONING: Why you reached this verdict (cite specific data)
-3. KEY FACTOR: The main thing driving this score
-4. SUGGESTION: How to get more/fewer items like this
-
-Be analytical. Cite numbers from the data.`,
-        buildPrompt: (data, context) => `
-SCORE DATA:
-${JSON.stringify(data, null, 2)}
-
-USER INTERESTS:
-${JSON.stringify(context, null, 2)}
-
-Analyze: Is this score correct given the user's interests?`,
-    },
-    /**
-     * Trend Analysis - Predict and explain
-     * Complexity: HEAVY (needs pattern recognition + prediction)
-     */
-    trendAnalysis: {
-        complexity: "heavy",
-        system: `You are a tech trend analyst. Interpret patterns and predict trajectories.
-
-OUTPUT FORMAT:
-1. KEY SIGNAL: The most important trend (one sentence)
-2. WHY IT'S HAPPENING: Brief explanation
-3. PREDICTION: What to expect in the next 1-2 weeks
-4. ACTION: Should the user adjust their focus?
-
-Ground predictions in the data. Don't speculate wildly.`,
-        buildPrompt: (data, context) => `
-TREND DATA:
-${JSON.stringify(data, null, 2)}
-
-USER CONTEXT:
-${JSON.stringify(context, null, 2)}
-
-Interpret: What do these trends mean for this specific user?`,
-    },
-    /**
-     * Context Analysis - Personalized optimization advice
-     * Complexity: MEDIUM (structured recommendations)
-     */
-    contextAnalysis: {
-        complexity: "medium",
-        system: `You are a personalization expert. Help users optimize their content filtering.
-
-OUTPUT FORMAT:
-1. BIGGEST GAP: What's missing from their context?
-2. HIGHEST IMPACT CHANGE: One specific thing to add/remove
-3. QUICK WIN: Something they can do in 30 seconds
-
-Be specific. Give exact examples they can copy-paste.`,
-        buildPrompt: (data) => `
-CONTEXT DATA:
-${JSON.stringify(data, null, 2)}
-
-Provide optimization recommendations. Be specific and actionable.`,
-    },
-    /**
-     * Topic Connections - Explain the knowledge graph
-     * Complexity: HEAVY (needs graph reasoning)
-     */
-    topicConnections: {
-        complexity: "heavy",
-        system: `You are a knowledge graph analyst. Find hidden patterns in topic relationships.
-
-OUTPUT FORMAT:
-1. SURPRISING CONNECTION: A non-obvious relationship and its significance
-2. MISSING LINK: Topics that should connect but don't
-3. EXPLORATION PATH: A topic worth investigating based on the graph
-4. PATTERN: What the graph structure reveals about their interests
-
-Look for insights the user wouldn't notice themselves.`,
-        buildPrompt: (data, context) => `
-GRAPH DATA:
-${JSON.stringify(data, null, 2)}
-
-USER CONTEXT:
-${JSON.stringify(context, null, 2)}
-
-Interpret: What hidden patterns does this graph reveal?`,
-    },
-};
-// =============================================================================
-// Utility: Check Ollama availability
-// =============================================================================
-/**
- * Check if Ollama is running and has required models
- */
-export async function checkOllamaStatus(baseUrl = "http://localhost:11434") {
-    try {
-        const response = await fetch(`${baseUrl}/api/tags`, {
-            method: "GET",
-            signal: AbortSignal.timeout(5000),
-        });
-        if (!response.ok) {
-            return { available: false, models: [], error: "Ollama not responding" };
-        }
-        const data = (await response.json());
-        const models = data.models?.map(m => m.name) || [];
-        return { available: true, models };
-    }
-    catch (error) {
-        return {
-            available: false,
-            models: [],
-            error: error instanceof Error ? error.message : "Connection failed",
-        };
-    }
-}
-/**
- * Recommended models for 4DA synthesis tasks
- */
-export const RECOMMENDED_MODELS = {
-    "16GB_VRAM": {
-        primary: "qwen3:14b",
-        fallback: "gemma3:12b",
-        install: "ollama pull qwen3:14b",
-    },
-    "12GB_VRAM": {
-        primary: "gemma3:12b",
-        fallback: "qwen3:8b",
-        install: "ollama pull gemma3:12b",
-    },
-    "8GB_VRAM": {
-        primary: "qwen3:8b",
-        fallback: "gemma3:4b",
-        install: "ollama pull qwen3:8b",
-    },
-};
-//# sourceMappingURL=llm.js.map

package/dist/output-manager.d.ts

@@ -1,156 +0,0 @@
-/**
- * Output Manager for Dynamic Context Discovery
- *
- * Reduces token usage by ~80% through:
- * - Writing full results to files (referenced by path)
- * - Returning compact summaries inline
- * - Providing retrieval hints for common queries
- *
- * Full results stored at: ~/.local/share/4da/context/results/
- */
-/**
- * Compact result format - what gets returned inline to Claude
- */
-export interface CompactResult<T> {
-    /** 2-3 sentence human-readable summary */
-    summary: string;
-    /** Essential 20% of data inline for immediate use */
-    key_data: T;
-    /** Path to complete JSON file */
-    full_result_path: string;
-    /** Hints for retrieving specific data (jq patterns, grep patterns) */
-    retrieval_hints: string[];
-}
-/**
- * Get the results directory path (for documentation)
- */
-export declare function getResultsDir(): string;
-/**
- * Daily Briefing compact output
- */
-export interface DailyBriefingKeyData {
-    total_items: number;
-    high_priority: number;
-    top_theme: string;
-    tldr: string;
-    executive_brief?: string;
-}
-export declare function createDailyBriefingCompact(result: {
-    summary: {
-        total_items_analyzed: number;
-        high_relevance_count: number;
-        tldr: string;
-    };
-    themes: {
-        name: string;
-        item_count: number;
-    }[];
-    ai_synthesis?: {
-        executive_brief: string;
-    };
-}): CompactResult<DailyBriefingKeyData>;
-/**
- * Trend Analysis compact output
- */
-export interface TrendAnalysisKeyData {
-    total_items: number;
-    volume_trend: string;
-    top_rising: string | null;
-    top_falling: string | null;
-    anomaly_count: number;
-    narrative?: string;
-}
-export declare function createTrendAnalysisCompact(result: {
-    summary: {
-        total_items: number;
-        volume_trend: string;
-        top_rising_topic: string | null;
-        top_falling_topic: string | null;
-    };
-    anomalies: unknown[];
-    ai_interpretation?: {
-        narrative: string;
-    };
-}): CompactResult<TrendAnalysisKeyData>;
-/**
- * Score Autopsy compact output
- */
-export interface ScoreAutopsyKeyData {
-    item_title: string;
-    final_score: number;
-    score_assessment?: "accurate" | "too_high" | "too_low" | "uncertain";
-    top_contributor: string;
-    verdict?: string;
-}
-export declare function createScoreAutopsyCompact(result: {
-    item: {
-        title: string;
-    };
-    final_score: number;
-    components: {
-        name: string;
-        contribution: number;
-    }[];
-    ai_analysis?: {
-        score_assessment: "accurate" | "too_high" | "too_low" | "uncertain";
-        verdict: string;
-    };
-}): CompactResult<ScoreAutopsyKeyData>;
-/**
- * Context Analysis compact output
- */
-export interface ContextAnalysisKeyData {
-    quality_score: number;
-    interests_count: number;
-    tech_count: number;
-    gap_count: number;
-    top_recommendation: string;
-    personalized_advice?: string;
-}
-export declare function createContextAnalysisCompact(result: {
-    context_summary: {
-        interests_count: number;
-        tech_stack_count: number;
-    };
-    quality_score: {
-        overall: number;
-    };
-    coverage_gaps: unknown[];
-    recommendations: {
-        action: string;
-    }[];
-    ai_advice?: {
-        personalized_recommendations: string;
-    };
-}): CompactResult<ContextAnalysisKeyData>;
-/**
- * Topic Connections compact output
- */
-export interface TopicConnectionsKeyData {
-    items_analyzed: number;
-    node_count: number;
-    edge_count: number;
-    central_topics: string[];
-    top_connection: {
-        from: string;
-        to: string;
-        strength: number;
-    } | null;
-    graph_narrative?: string;
-}
-export declare function createTopicConnectionsCompact(result: {
-    analysis_period: {
-        items_analyzed: number;
-    };
-    nodes: unknown[];
-    edges: {
-        from: string;
-        to: string;
-        co_occurrences: number;
-    }[];
-    central_topics: string[];
-    ai_insights?: {
-        graph_narrative: string;
-    };
-}): CompactResult<TopicConnectionsKeyData>;
-//# sourceMappingURL=output-manager.d.ts.map

package/dist/output-manager.js

@@ -1,157 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Output Manager for Dynamic Context Discovery
- *
- * Reduces token usage by ~80% through:
- * - Writing full results to files (referenced by path)
- * - Returning compact summaries inline
- * - Providing retrieval hints for common queries
- *
- * Full results stored at: ~/.local/share/4da/context/results/
- */
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-// Base directory for 4DA context files
-const CONTEXT_DIR = join(homedir(), ".local", "share", "4da", "context");
-const RESULTS_DIR = join(CONTEXT_DIR, "results");
-/**
- * Ensure the context directories exist
- */
-function ensureDirectories() {
-    if (!existsSync(CONTEXT_DIR)) {
-        mkdirSync(CONTEXT_DIR, { recursive: true });
-    }
-    if (!existsSync(RESULTS_DIR)) {
-        mkdirSync(RESULTS_DIR, { recursive: true });
-    }
-}
-/**
- * Write full result to file and return the file path
- */
-function writeResultFile(toolName, fullResult) {
-    ensureDirectories();
-    // Generate timestamped filename
-    const timestamp = Math.floor(Date.now() / 1000);
-    const filename = `${toolName}_${timestamp}.json`;
-    const filePath = join(RESULTS_DIR, filename);
-    // Write full result to file
-    writeFileSync(filePath, JSON.stringify(fullResult, null, 2), "utf-8");
-    return filePath;
-}
-/**
- * Get the results directory path (for documentation)
- */
-export function getResultsDir() {
-    return RESULTS_DIR;
-}
-export function createDailyBriefingCompact(result) {
-    const topTheme = result.themes[0]?.name || "general";
-    return {
-        summary: `${result.summary.total_items_analyzed} items analyzed, ${result.summary.high_relevance_count} high-priority. Top theme: ${topTheme}. ${result.ai_synthesis ? "AI synthesis included." : ""}`,
-        key_data: {
-            total_items: result.summary.total_items_analyzed,
-            high_priority: result.summary.high_relevance_count,
-            top_theme: result.themes[0]?.name || "none",
-            tldr: result.summary.tldr,
-            executive_brief: result.ai_synthesis?.executive_brief,
-        },
-        full_result_path: writeResultFile("daily_briefing", result),
-        retrieval_hints: [
-            "jq '.notable_items' - get high-priority items",
-            "jq '.themes' - get topic breakdown",
-            "jq '.recommendations' - get action items",
-            "jq '.ai_synthesis.executive_brief' - get AI summary",
-        ],
-    };
-}
-export function createTrendAnalysisCompact(result) {
-    const anomalyNote = result.anomalies.length > 0 ? ` ${result.anomalies.length} anomalies detected.` : "";
-    return {
-        summary: `Volume ${result.summary.volume_trend}. Rising: ${result.summary.top_rising_topic || "none"}. Falling: ${result.summary.top_falling_topic || "none"}.${anomalyNote}`,
-        key_data: {
-            total_items: result.summary.total_items,
-            volume_trend: result.summary.volume_trend,
-            top_rising: result.summary.top_rising_topic,
-            top_falling: result.summary.top_falling_topic,
-            anomaly_count: result.anomalies.length,
-            narrative: result.ai_interpretation?.narrative,
-        },
-        full_result_path: writeResultFile("trend_analysis", result),
-        retrieval_hints: [
-            "jq '.topic_trends' - get all topic trends",
-            "jq '.volume_by_day' - get daily volume data",
-            "jq '.anomalies' - get detected anomalies",
-            "jq '.ai_interpretation.forecast' - get predictions",
-        ],
-    };
-}
-export function createScoreAutopsyCompact(result) {
-    const topComponent = result.components.sort((a, b) => b.contribution - a.contribution)[0];
-    const assessment = result.ai_analysis?.score_assessment || "unanalyzed";
-    return {
-        summary: `"${result.item.title.substring(0, 40)}..." scored ${Math.round(result.final_score * 100)}%. Assessment: ${assessment}. Top contributor: ${topComponent?.name || "unknown"}.`,
-        key_data: {
-            item_title: result.item.title,
-            final_score: result.final_score,
-            score_assessment: result.ai_analysis?.score_assessment,
-            top_contributor: topComponent?.name || "unknown",
-            verdict: result.ai_analysis?.verdict,
-        },
-        full_result_path: writeResultFile("score_autopsy", result),
-        retrieval_hints: [
-            "jq '.components' - get score breakdown",
-            "jq '.matching_context' - get what matched",
-            "jq '.similar_items' - get comparison items",
-            "jq '.recommendations' - get improvement suggestions",
-        ],
-    };
-}
-export function createContextAnalysisCompact(result) {
-    const quality = Math.round(result.quality_score.overall * 100);
-    return {
-        summary: `Context quality: ${quality}%. ${result.context_summary.interests_count} interests, ${result.context_summary.tech_stack_count} tech. ${result.coverage_gaps.length} gaps found.`,
-        key_data: {
-            quality_score: result.quality_score.overall,
-            interests_count: result.context_summary.interests_count,
-            tech_count: result.context_summary.tech_stack_count,
-            gap_count: result.coverage_gaps.length,
-            top_recommendation: result.recommendations[0]?.action || "No recommendations",
-            personalized_advice: result.ai_advice?.personalized_recommendations,
-        },
-        full_result_path: writeResultFile("context_analysis", result),
-        retrieval_hints: [
-            "jq '.quality_score.dimensions' - get quality breakdown",
-            "jq '.coverage_gaps' - get what's missing",
-            "jq '.recommendations' - get all suggestions",
-            "jq '.top_affinities' - get learned preferences",
-        ],
-    };
-}
-export function createTopicConnectionsCompact(result) {
-    const topEdge = result.edges[0];
-    const connectionNote = topEdge
-        ? `Strongest: ${topEdge.from} ↔ ${topEdge.to}.`
-        : "No strong connections.";
-    return {
-        summary: `${result.nodes.length} topics, ${result.edges.length} connections. Central: ${result.central_topics.slice(0, 3).join(", ")}. ${connectionNote}`,
-        key_data: {
-            items_analyzed: result.analysis_period.items_analyzed,
-            node_count: result.nodes.length,
-            edge_count: result.edges.length,
-            central_topics: result.central_topics.slice(0, 5),
-            top_connection: topEdge
-                ? { from: topEdge.from, to: topEdge.to, strength: topEdge.co_occurrences }
-                : null,
-            graph_narrative: result.ai_insights?.graph_narrative,
-        },
-        full_result_path: writeResultFile("topic_connections", result),
-        retrieval_hints: [
-            "jq '.nodes' - get all topic nodes",
-            "jq '.edges' - get all connections",
-            "jq '.clusters' - get topic clusters",
-            "jq '.path' - get path between topics (if requested)",
-        ],
-    };
-}
-//# sourceMappingURL=output-manager.js.map

package/dist/scheduler/core.d.ts

@@ -1,25 +0,0 @@
-/**
- * Scheduler core — the cadence engine (S1).
- *
- * A minimal, dependency-free job scheduler: register named jobs with an interval, tick them
- * manually (tests, one-shots) or let start()/stop() drive them on timers. The one hard rule:
- * the SAME job never overlaps itself — a tick that arrives while the job's fn is still
- * running resolves as a no-op instead of double-running the pull.
- */
-type JobFn = () => Promise<void>;
-export interface SchedulerJobView {
-    name: string;
-    intervalMs: number;
-    lastRun: number | null;
-}
-export interface Scheduler {
-    register(name: string, intervalMs: number, fn: JobFn): void;
-    start(): void;
-    stop(): void;
-    tick(name: string): Promise<void>;
-    jobs(): SchedulerJobView[];
-    jobCount(): number;
-}
-export declare function createScheduler(): Scheduler;
-export {};
-//# sourceMappingURL=core.d.ts.map

package/dist/scheduler/core.js

@@ -1,61 +0,0 @@
-/**
- * Scheduler core — the cadence engine (S1).
- *
- * A minimal, dependency-free job scheduler: register named jobs with an interval, tick them
- * manually (tests, one-shots) or let start()/stop() drive them on timers. The one hard rule:
- * the SAME job never overlaps itself — a tick that arrives while the job's fn is still
- * running resolves as a no-op instead of double-running the pull.
- */
-export function createScheduler() {
-    const jobs = new Map();
-    async function tick(name) {
-        const job = jobs.get(name);
-        if (!job) {
-            throw new Error(`scheduler: no job registered under "${name}"`);
-        }
-        if (job.running) {
-            return; // the same job never overlaps — a concurrent tick is a no-op
-        }
-        job.running = true;
-        try {
-            await job.fn();
-            job.lastRun = Date.now();
-        }
-        finally {
-            job.running = false;
-        }
-    }
-    return {
-        register(name, intervalMs, fn) {
-            jobs.set(name, { name, intervalMs, fn, lastRun: null, running: false, timer: null });
-        },
-        start() {
-            for (const job of jobs.values()) {
-                if (job.timer)
-                    continue;
-                job.timer = setInterval(() => {
-                    void tick(job.name).catch(() => {
-                        // a failing scheduled run must never take the process down; the job's
-                        // freshness simply doesn't advance, which is the observable signal
-                    });
-                }, job.intervalMs);
-            }
-        },
-        stop() {
-            for (const job of jobs.values()) {
-                if (job.timer) {
-                    clearInterval(job.timer);
-                    job.timer = null;
-                }
-            }
-        },
-        tick,
-        jobs() {
-            return [...jobs.values()].map(({ name, intervalMs, lastRun }) => ({ name, intervalMs, lastRun }));
-        },
-        jobCount() {
-            return jobs.size;
-        },
-    };
-}
-//# sourceMappingURL=core.js.map

package/dist/scheduler/freshness.d.ts

@@ -1,17 +0,0 @@
-/**
- * Freshness watermarks (S2) — when was each named feed last refreshed, and is it stale?
- *
- * A tiny persistent map: mark a name fresh at a moment, ask how stale it is against a budget.
- * Persistence is an explicit save()/load() to a JSON file so the scheduler can survive a
- * restart without inventing freshness it does not have — a missing file simply means
- * "nothing is known", which reads as stale (the honest default).
- */
-export interface Freshness {
-    markFresh(name: string, at?: number): void;
-    lastFresh(name: string): number | null;
-    isStale(name: string, maxAgeMs: number, now?: number): boolean;
-    save(): void;
-    load(): void;
-}
-export declare function createFreshness(filePath?: string): Freshness;
-//# sourceMappingURL=freshness.d.ts.map

package/dist/scheduler/freshness.js

@@ -1,41 +0,0 @@
-/**
- * Freshness watermarks (S2) — when was each named feed last refreshed, and is it stale?
- *
- * A tiny persistent map: mark a name fresh at a moment, ask how stale it is against a budget.
- * Persistence is an explicit save()/load() to a JSON file so the scheduler can survive a
- * restart without inventing freshness it does not have — a missing file simply means
- * "nothing is known", which reads as stale (the honest default).
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-export function createFreshness(filePath) {
-    let marks = new Map();
-    return {
-        markFresh(name, at) {
-            marks.set(name, at ?? Date.now());
-        },
-        lastFresh(name) {
-            return marks.get(name) ?? null;
-        },
-        isStale(name, maxAgeMs, now) {
-            const last = marks.get(name);
-            if (last === undefined) {
-                return true; // never refreshed is the stalest state there is
-            }
-            return (now ?? Date.now()) - last > maxAgeMs;
-        },
-        save() {
-            if (!filePath)
-                return;
-            mkdirSync(dirname(filePath), { recursive: true });
-            writeFileSync(filePath, JSON.stringify(Object.fromEntries(marks)), "utf8");
-        },
-        load() {
-            if (!filePath || !existsSync(filePath))
-                return;
-            const raw = JSON.parse(readFileSync(filePath, "utf8"));
-            marks = new Map(Object.entries(raw));
-        },
-    };
-}
-//# sourceMappingURL=freshness.js.map

package/dist/scheduler/index.d.ts

@@ -1,21 +0,0 @@
-/**
- * Scheduler composition (S4) — wire core + freshness + refreshers into one switchable unit.
- *
- * The whole scheduler is OFF unless explicitly enabled (fail-safe: an MCP server must never
- * grow background network activity by surprise). Enabled, it registers every refresh unit on
- * the cadence engine, starts the timers, and exposes a status view the server (or a future
- * `scheduler_status` tool) can render: every unit, its cadence, and when it last ran.
- */
-import { type SchedulerJobView } from "./core.js";
-export interface InitSchedulerOpts {
-    enabled: boolean;
-    pull: Record<string, () => Promise<void>>;
-    freshnessPath?: string;
-}
-export interface RunningScheduler {
-    started: boolean;
-    status(): SchedulerJobView[];
-    stop(): void;
-}
-export declare function initScheduler(opts: InitSchedulerOpts): RunningScheduler;
-//# sourceMappingURL=index.d.ts.map

package/dist/scheduler/index.js

@@ -1,32 +0,0 @@
-/**
- * Scheduler composition (S4) — wire core + freshness + refreshers into one switchable unit.
- *
- * The whole scheduler is OFF unless explicitly enabled (fail-safe: an MCP server must never
- * grow background network activity by surprise). Enabled, it registers every refresh unit on
- * the cadence engine, starts the timers, and exposes a status view the server (or a future
- * `scheduler_status` tool) can render: every unit, its cadence, and when it last ran.
- */
-import { createScheduler } from "./core.js";
-import { createFreshness } from "./freshness.js";
-import { buildRefreshers } from "./refreshers.js";
-export function initScheduler(opts) {
-    if (!opts.enabled) {
-        return { started: false, status: () => [], stop: () => { } };
-    }
-    const freshness = createFreshness(opts.freshnessPath);
-    freshness.load();
-    const scheduler = createScheduler();
-    for (const unit of buildRefreshers({ pull: opts.pull, freshness })) {
-        scheduler.register(unit.name, unit.intervalMs, () => unit.run());
-    }
-    scheduler.start();
-    return {
-        started: true,
-        status: () => scheduler.jobs(),
-        stop: () => {
-            scheduler.stop();
-            freshness.save();
-        },
-    };
-}
-//# sourceMappingURL=index.js.map

package/dist/scheduler/refreshers.d.ts

@@ -1,21 +0,0 @@
-/**
- * Refresh adapters (S3) — wrap each named data pull into a schedulable refresh unit.
- *
- * Pure dependency injection: the pulls and the freshness sink are handed in, nothing is
- * imported from the fetcher layer and nothing touches the network here. A refresh unit runs
- * its pull and only THEN marks freshness — a failing pull rethrows and leaves the watermark
- * untouched, so staleness stays honest.
- */
-export interface RefreshDeps {
-    pull: Record<string, () => Promise<void>>;
-    freshness: {
-        markFresh(name: string, at?: number): void;
-    };
-}
-export interface RefreshUnit {
-    name: string;
-    intervalMs: number;
-    run(): Promise<void>;
-}
-export declare function buildRefreshers(deps: RefreshDeps): RefreshUnit[];
-//# sourceMappingURL=refreshers.d.ts.map

package/dist/scheduler/refreshers.js

@@ -1,21 +0,0 @@
-/**
- * Refresh adapters (S3) — wrap each named data pull into a schedulable refresh unit.
- *
- * Pure dependency injection: the pulls and the freshness sink are handed in, nothing is
- * imported from the fetcher layer and nothing touches the network here. A refresh unit runs
- * its pull and only THEN marks freshness — a failing pull rethrows and leaves the watermark
- * untouched, so staleness stays honest.
- */
-/** Default cadence per refresh unit; callers can re-register with their own interval. */
-const DEFAULT_INTERVAL_MS = 15 * 60 * 1000; // 15 minutes — fresh enough for feed data, kind to upstreams
-export function buildRefreshers(deps) {
-    return Object.entries(deps.pull).map(([name, pull]) => ({
-        name,
-        intervalMs: DEFAULT_INTERVAL_MS,
-        async run() {
-            await pull(); // a throw propagates — freshness must NOT advance on a failed pull
-            deps.freshness.markFresh(name);
-        },
-    }));
-}
-//# sourceMappingURL=refreshers.js.map