@a13xu/lucid 1.13.0 → 1.16.0

package/build/compression/semantic.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Semantic compression using LLMLingua-2
+ * Model: microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank
+ *
+ * Reduces text by identifying and dropping semantically unimportant tokens.
+ * Uses @huggingface/transformers (ONNX Runtime) for local inference.
+ *
+ * Pipeline is loaded lazily on first use and cached in memory.
+ * Model files are cached in ~/.lucid/models/ after first download (~700MB).
+ *
+ * Falls back to original text on any error — safe to call unconditionally.
+ */
+export interface SemanticCompressionResult {
+    compressed: string;
+    originalLength: number;
+    compressedLength: number;
+    /** Fraction of tokens kept (1.0 = no compression) */
+    ratio: number;
+    method: "llmlingua2" | "fallback";
+}
+/**
+ * Compress text using LLMLingua-2 token importance scoring.
+ *
+ * @param text         Input text to compress
+ * @param targetRatio  Target compression ratio (0.3 = keep 30%, 0.5 = keep 50%)
+ * @param minLength    Skip compression for texts shorter than this (chars)
+ */
+export declare function compressTextSemantic(text: string, targetRatio?: number, minLength?: number): Promise<SemanticCompressionResult>;
+export declare function tryCompressTextSemantic(text: string, targetRatio?: number, minLength?: number): Promise<string>;
+export declare function isSemanticCompressionAvailable(): Promise<boolean>;
+export declare function warmUpSemanticCompression(): void;

package/build/compression/semantic.js

@@ -0,0 +1,196 @@
+/**
+ * Semantic compression using LLMLingua-2
+ * Model: microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank
+ *
+ * Reduces text by identifying and dropping semantically unimportant tokens.
+ * Uses @huggingface/transformers (ONNX Runtime) for local inference.
+ *
+ * Pipeline is loaded lazily on first use and cached in memory.
+ * Model files are cached in ~/.lucid/models/ after first download (~700MB).
+ *
+ * Falls back to original text on any error — safe to call unconditionally.
+ */
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+const MODEL_ID = "microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank";
+const MODELS_DIR = join(homedir(), ".lucid", "models");
+let _pipeline = null;
+let _loadError = null;
+let _loading = false;
+async function getPipeline() {
+    if (_loadError)
+        throw _loadError;
+    if (_pipeline)
+        return _pipeline;
+    if (_loading) {
+        // Wait for concurrent load
+        await new Promise((resolve) => {
+            const check = setInterval(() => {
+                if (!_loading) {
+                    clearInterval(check);
+                    resolve();
+                }
+            }, 100);
+        });
+        if (_loadError)
+            throw _loadError;
+        if (_pipeline)
+            return _pipeline;
+    }
+    _loading = true;
+    try {
+        mkdirSync(MODELS_DIR, { recursive: true });
+        // Dynamic import keeps startup fast when compression is not used
+        const { pipeline, env } = await import("@huggingface/transformers");
+        env.cacheDir = MODELS_DIR;
+        env.allowRemoteModels = true;
+        process.stderr.write(`[Lucid] Loading LLMLingua-2 model (first run: downloads ~700MB to ${MODELS_DIR})…\n`);
+        _pipeline = (await pipeline("token-classification", MODEL_ID, {
+            dtype: "q8", // 8-bit quantization — smaller, faster, minimal quality loss
+            device: "cpu",
+        }));
+        process.stderr.write("[Lucid] LLMLingua-2 model ready.\n");
+        return _pipeline;
+    }
+    catch (e) {
+        _loadError = e instanceof Error ? e : new Error(String(e));
+        throw _loadError;
+    }
+    finally {
+        _loading = false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Core compression
+// ---------------------------------------------------------------------------
+/**
+ * Compress text using LLMLingua-2 token importance scoring.
+ *
+ * @param text         Input text to compress
+ * @param targetRatio  Target compression ratio (0.3 = keep 30%, 0.5 = keep 50%)
+ * @param minLength    Skip compression for texts shorter than this (chars)
+ */
+export async function compressTextSemantic(text, targetRatio = 0.5, minLength = 300) {
+    if (text.length < minLength) {
+        return {
+            compressed: text,
+            originalLength: text.length,
+            compressedLength: text.length,
+            ratio: 1.0,
+            method: "fallback",
+        };
+    }
+    const pipe = await getPipeline();
+    // Run token classification — each token gets entity "LABEL_0" (drop) / "LABEL_1" (keep)
+    const tokens = await pipe(text, {
+        // Disable aggregation to get per-sub-token results with offsets
+        aggregation_strategy: "none",
+    });
+    if (!tokens || tokens.length === 0) {
+        return {
+            compressed: text,
+            originalLength: text.length,
+            compressedLength: text.length,
+            ratio: 1.0,
+            method: "fallback",
+        };
+    }
+    // Determine importance threshold:
+    // Sort all "keep" scores descending, keep the top (targetRatio * N) tokens
+    const keepScores = tokens
+        .filter((t) => t.entity === "LABEL_1" || t.entity === "1")
+        .map((t) => t.score)
+        .sort((a, b) => b - a);
+    // If not enough LABEL_1 tokens, use score-based threshold
+    let threshold;
+    if (keepScores.length > 0) {
+        const cutoffIdx = Math.floor(tokens.length * targetRatio);
+        // Find the score at the cutoff rank among all tokens sorted by score
+        const allScores = tokens.map((t) => ({
+            score: t.entity === "LABEL_1" || t.entity === "1" ? t.score : 1 - t.score,
+        })).sort((a, b) => b.score - a.score);
+        threshold = allScores[Math.min(cutoffIdx, allScores.length - 1)]?.score ?? 0.5;
+    }
+    else {
+        // Fallback: use raw score threshold
+        threshold = 0.5;
+    }
+    // Mark characters to keep based on token offsets
+    const keepChars = new Uint8Array(text.length);
+    for (const token of tokens) {
+        const isImportant = token.entity === "LABEL_1" ||
+            token.entity === "1" ||
+            (token.entity !== "LABEL_0" && token.entity !== "0" && token.score >= threshold);
+        if (isImportant && token.start !== undefined && token.end !== undefined) {
+            keepChars.fill(1, token.start, token.end);
+        }
+    }
+    // Always keep structural markers (newlines, sentence boundaries)
+    const FORCE_KEEP = new Set(["\n", ".", "!", "?", ","]);
+    for (let i = 0; i < text.length; i++) {
+        if (FORCE_KEEP.has(text[i]))
+            keepChars[i] = 1;
+    }
+    // Reconstruct compressed text from character mask
+    let compressed = "";
+    let prevKept = false;
+    for (let i = 0; i < text.length; i++) {
+        if (keepChars[i]) {
+            // Preserve a single space when skipping tokens in mid-sentence
+            if (!prevKept && compressed.length > 0 && text[i] !== " " && !FORCE_KEEP.has(text[i - 1] ?? "")) {
+                compressed += " ";
+            }
+            compressed += text[i];
+            prevKept = true;
+        }
+        else {
+            prevKept = false;
+        }
+    }
+    // Clean up artefacts from compression
+    compressed = compressed
+        .replace(/  +/g, " ") // multiple spaces → single
+        .replace(/\n{3,}/g, "\n\n") // more than 2 newlines → 2
+        .replace(/ ([.,!?])/g, "$1") // space before punctuation → no space
+        .trim();
+    const keptCount = keepScores.length;
+    const actualRatio = tokens.length > 0 ? keptCount / tokens.length : 1.0;
+    return {
+        compressed,
+        originalLength: text.length,
+        compressedLength: compressed.length,
+        ratio: actualRatio,
+        method: "llmlingua2",
+    };
+}
+// ---------------------------------------------------------------------------
+// Safe wrapper — always returns a string, never throws
+// ---------------------------------------------------------------------------
+export async function tryCompressTextSemantic(text, targetRatio = 0.5, minLength = 300) {
+    try {
+        const result = await compressTextSemantic(text, targetRatio, minLength);
+        return result.compressed;
+    }
+    catch {
+        return text;
+    }
+}
+// ---------------------------------------------------------------------------
+// Availability check — call before bulk compression to fail fast
+// ---------------------------------------------------------------------------
+export async function isSemanticCompressionAvailable() {
+    try {
+        await getPipeline();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Warm-up (optional — call at startup to pre-load model)
+// ---------------------------------------------------------------------------
+export function warmUpSemanticCompression() {
+    getPipeline().catch(() => { });
+}

package/build/config.d.ts

@@ -12,6 +12,21 @@ export interface LucidConfig {
     recentWindowHours?: number;
     /** Security guard configuration */
     security?: SecurityConfig;
+    /**
+     * Semantic compression via LLMLingua-2 (microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank).
+     * When enabled, file content is compressed before being returned to Claude and before Qdrant embedding.
+     * Model is downloaded on first use (~700MB) and cached in ~/.lucid/models/.
+     */
+    semanticCompression?: {
+        /** Enable semantic compression (default: false — opt-in) */
+        enabled?: boolean;
+        /** Target compression ratio: 0.3 = keep 30%, 0.5 = keep 50% (default: 0.5) */
+        ratio?: number;
+        /** Skip compression for texts shorter than this in chars (default: 300) */
+        minLength?: number;
+        /** Also compress text before Qdrant embedding generation (default: true when enabled) */
+        applyToEmbeddings?: boolean;
+    };
     /** Optional Qdrant vector search (falls back to TF-IDF if not configured) */
     qdrant?: {
         url: string;

package/build/http/routes.d.ts

@@ -0,0 +1,3 @@
+import { Router } from "express";
+import type { Statements } from "../database.js";
+export declare function createRoutes(stmts: Statements): Router;

package/build/http/routes.js

@@ -0,0 +1,56 @@
+import { Router } from "express";
+import { handleSyncFile, handleSyncProject } from "../tools/sync.js";
+import { handleGetContext } from "../tools/context.js";
+import { handleValidateFile } from "../tools/guardian.js";
+import { getCurrentVersion } from "../tools/updater.js";
+export function createRoutes(stmts) {
+    const router = Router();
+    // POST /sync — sync a single file
+    router.post("/sync", (req, res) => {
+        try {
+            const result = handleSyncFile(stmts, req.body);
+            res.json({ ok: true, result });
+        }
+        catch (e) {
+            res.status(500).json({ ok: false, error: String(e) });
+        }
+    });
+    // POST /sync-project — sync entire project directory
+    router.post("/sync-project", (req, res) => {
+        try {
+            const result = handleSyncProject(stmts, req.body);
+            res.json({ ok: true, result });
+        }
+        catch (e) {
+            res.status(500).json({ ok: false, error: String(e) });
+        }
+    });
+    // GET /context?q=...&maxTokens=4000 — retrieve relevant context
+    router.get("/context", async (req, res) => {
+        try {
+            const result = await handleGetContext(stmts, {
+                query: String(req.query["q"] ?? ""),
+                maxTokens: req.query["maxTokens"] ? Number(req.query["maxTokens"]) : 4000,
+            });
+            res.json({ ok: true, result });
+        }
+        catch (e) {
+            res.status(500).json({ ok: false, error: String(e) });
+        }
+    });
+    // POST /validate — validate a file for drift/quality issues
+    router.post("/validate", (req, res) => {
+        try {
+            const result = handleValidateFile(req.body);
+            res.json({ ok: true, result });
+        }
+        catch (e) {
+            res.status(500).json({ ok: false, error: String(e) });
+        }
+    });
+    // GET /health — liveness check
+    router.get("/health", (_req, res) => {
+        res.json({ ok: true, version: getCurrentVersion() });
+    });
+    return router;
+}

package/build/http/server.d.ts

@@ -0,0 +1,7 @@
+import type { Server } from "http";
+import type { Statements } from "../database.js";
+export interface HttpServerOptions {
+    port?: number;
+    host?: string;
+}
+export declare function startHttpServer(stmts: Statements, options?: HttpServerOptions): Server;

package/build/http/server.js

@@ -0,0 +1,11 @@
+import express from "express";
+import { createRoutes } from "./routes.js";
+export function startHttpServer(stmts, options = {}) {
+    const { port = 7821, host = "127.0.0.1" } = options;
+    const app = express();
+    app.use(express.json());
+    app.use("/", createRoutes(stmts));
+    return app.listen(port, host, () => {
+        process.stderr.write(`[Lucid] HTTP server listening on ${host}:${port}\n`);
+    });
+}

package/build/index.js

@@ -23,6 +23,109 @@ import { handleGetCodingRules, handleCheckCodeQuality, CheckCodeQualitySchema, }
 import { handlePlanCreate, PlanCreateSchema, handlePlanList, PlanListSchema, handlePlanGet, PlanGetSchema, handlePlanUpdateTask, PlanUpdateTaskSchema, } from "./tools/plan.js";
 import { UpdateLucidSchema, handleUpdateLucid, checkForUpdatesOnStartup, getCurrentVersion, } from "./tools/updater.js";
 import { GenerateComponentSchema, handleGenerateComponent, ScaffoldPageSchema, handleScaffoldPage, SeoMetaSchema, handleSeoMeta, AccessibilityAuditSchema, handleAccessibilityAudit, ApiClientSchema, handleApiClient, TestGeneratorSchema, handleTestGenerator, ResponsiveLayoutSchema, handleResponsiveLayout, SecurityScanSchema, handleSecurityScan, DesignTokensSchema, handleDesignTokens, PerfHintsSchema, handlePerfHints, } from "./tools/webdev/index.js";
+import { handleSmartContext, SmartContextSchema } from "./tools/smart-context.js";
+import { handleSuggestModel, SuggestModelSchema } from "./tools/model-advisor.js";
+import { handleCompressText, CompressTextSchema } from "./tools/compress.js";
+// ---------------------------------------------------------------------------
+// CLI mode: lucid watch | lucid status | lucid stop
+// ---------------------------------------------------------------------------
+const [, , _cliCmd, ..._cliArgs] = process.argv;
+if (_cliCmd === "watch" || _cliCmd === "status" || _cliCmd === "stop") {
+    await runCli(_cliCmd, _cliArgs);
+    process.exit(0);
+}
+async function runCli(cmd, args) {
+    const { join } = await import("path");
+    const { homedir } = await import("os");
+    const { existsSync, mkdirSync, writeFileSync, readFileSync } = await import("fs");
+    const PID_DIR = join(homedir(), ".lucid");
+    const PID_FILE = join(PID_DIR, "watch.pid");
+    if (cmd === "status") {
+        if (!existsSync(PID_FILE)) {
+            console.log("Lucid daemon: not running");
+            return;
+        }
+        const pid = readFileSync(PID_FILE, "utf-8").trim();
+        try {
+            process.kill(Number(pid), 0);
+            console.log(`Lucid daemon: running (PID ${pid})`);
+        }
+        catch {
+            console.log("Lucid daemon: not running (stale PID file)");
+        }
+        return;
+    }
+    if (cmd === "stop") {
+        if (!existsSync(PID_FILE)) {
+            console.log("Lucid daemon: not running");
+            return;
+        }
+        const pid = readFileSync(PID_FILE, "utf-8").trim();
+        try {
+            process.kill(Number(pid), "SIGTERM");
+            console.log(`Lucid daemon stopped (PID ${pid})`);
+        }
+        catch {
+            console.log("Lucid daemon: not running (stale PID file)");
+        }
+        return;
+    }
+    // cmd === "watch"
+    const portIdx = args.indexOf("--port");
+    const port = portIdx >= 0 ? Number(args[portIdx + 1]) : 7821;
+    const noHttp = args.includes("--no-http");
+    const watchDir = args.find((a) => !a.startsWith("--")) ?? process.cwd();
+    const { initDatabase, prepareStatements } = await import("./database.js");
+    const db = initDatabase();
+    const stmts = prepareStatements(db);
+    if (!noHttp) {
+        const { startHttpServer } = await import("./http/server.js");
+        startHttpServer(stmts, { port });
+    }
+    mkdirSync(PID_DIR, { recursive: true });
+    writeFileSync(PID_FILE, String(process.pid), "utf-8");
+    const chokidar = await import("chokidar");
+    const watcher = chokidar.watch(watchDir, {
+        ignored: [/node_modules/, /\.git/, /[/\\]build[/\\]/, /[/\\]dist[/\\]/, /\.d\.ts$/],
+        persistent: true,
+        ignoreInitial: true,
+    });
+    const DEBOUNCE_MS = 300;
+    const timers = new Map();
+    const syncPath = (filePath) => {
+        const existing = timers.get(filePath);
+        if (existing)
+            clearTimeout(existing);
+        timers.set(filePath, setTimeout(() => {
+            timers.delete(filePath);
+            if (!noHttp) {
+                fetch(`http://localhost:${port}/sync`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: filePath }),
+                }).catch(() => { });
+            }
+            else {
+                import("./tools/sync.js").then(({ handleSyncFile }) => {
+                    handleSyncFile(stmts, { path: filePath });
+                }).catch(() => { });
+            }
+        }, DEBOUNCE_MS));
+    };
+    watcher.on("add", syncPath).on("change", syncPath);
+    process.stderr.write(`[Lucid] Watching ${watchDir}${noHttp ? " (no HTTP)" : ` on port ${port}`}\n`);
+    const shutdown = () => {
+        watcher.close().catch(() => { });
+        try {
+            db.pragma("wal_checkpoint(FULL)");
+        }
+        catch { /* ignore */ }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => { });
+}
 // ---------------------------------------------------------------------------
 // Init DB
 // ---------------------------------------------------------------------------
@@ -222,6 +325,69 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 },
             },
         },
+        // ── Smart Context + Model Advisor ─────────────────────────────────────────
+        {
+            name: "smart_context",
+            description: "Combined: knowledge graph (recall) + code files (get_context) in one call. " +
+                "Use instead of calling recall() + get_context() separately. " +
+                "task_type adjusts token budget: simple=2000, moderate=6000, complex=12000. " +
+                "Logs an experience so reward()/penalize() work after this call.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "What you are working on" },
+                    task_type: {
+                        type: "string",
+                        enum: ["simple", "moderate", "complex"],
+                        description: "Token budget: simple=2000, moderate=6000 (default), complex=12000",
+                    },
+                    dirs: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Whitelist directories (e.g. [\"src\", \"backend\"])",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "suggest_model",
+            description: "Classify task complexity → recommend Claude model. " +
+                "Returns { model, model_id, reasoning, context_budget }. " +
+                "Call at the start of any workflow. Simple lookups → Haiku; everything else → Sonnet (default).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_description: {
+                        type: "string",
+                        description: "Natural language description of the task you are about to perform",
+                    },
+                },
+                required: ["task_description"],
+            },
+        },
+        {
+            name: "compress_text",
+            description: "Compress text using LLMLingua-2 semantic compression (microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank). " +
+                "Identifies and drops semantically unimportant tokens while preserving meaning. " +
+                "Model downloads ~700MB on first use and is cached in ~/.lucid/models/. " +
+                "Returns compressed text with stats (original/compressed length, ratio, tokens saved).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    text: { type: "string", description: "Text to compress" },
+                    ratio: {
+                        type: "number",
+                        description: "Target compression ratio: 0.3 = keep 30%, 0.5 = keep 50% (default: 0.5)",
+                    },
+                    min_length: {
+                        type: "number",
+                        description: "Skip compression for texts shorter than this in chars (default: 300)",
+                    },
+                },
+                required: ["text"],
+            },
+        },
         // ── Reward System ────────────────────────────────────────────────────────
         {
             name: "reward",
@@ -632,6 +798,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_recent":
                 text = handleGetRecent(stmts, GetRecentSchema.parse(args));
                 break;
+            // Smart Context + Model Advisor
+            case "smart_context":
+                text = await handleSmartContext(stmts, SmartContextSchema.parse(args));
+                break;
+            case "suggest_model":
+                text = handleSuggestModel(SuggestModelSchema.parse(args));
+                break;
+            case "compress_text":
+                text = await handleCompressText(CompressTextSchema.parse(args));
+                break;
             // Reward System
             case "reward":
                 text = handleReward(stmts, RewardSchema.parse(args));

package/build/lucid-sync.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * lucid-sync — PostToolUse hook script for Lucid.
+ *
+ * Called by Claude Code's PostToolUse hook after Write/Edit/NotebookEdit.
+ * Reads tool input from stdin (JSON), extracts the modified file path,
+ * then syncs it to Lucid's SQLite index.
+ *
+ * Fallback chain:
+ *   1. POST http://localhost:7821/sync  (if lucid watch daemon is running)
+ *   2. Direct SQLite write             (always works, no daemon needed)
+ *
+ * Never throws — hook failures must not interrupt Claude Code.
+ */
+export {};

package/build/lucid-sync.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * lucid-sync — PostToolUse hook script for Lucid.
+ *
+ * Called by Claude Code's PostToolUse hook after Write/Edit/NotebookEdit.
+ * Reads tool input from stdin (JSON), extracts the modified file path,
+ * then syncs it to Lucid's SQLite index.
+ *
+ * Fallback chain:
+ *   1. POST http://localhost:7821/sync  (if lucid watch daemon is running)
+ *   2. Direct SQLite write             (always works, no daemon needed)
+ *
+ * Never throws — hook failures must not interrupt Claude Code.
+ */
+import { readFileSync } from "fs";
+function getFilePathFromStdin() {
+    try {
+        const raw = readFileSync("/dev/stdin", "utf-8").trim();
+        if (!raw)
+            return process.argv[2] ?? null;
+        const data = JSON.parse(raw);
+        const ti = data.tool_input ?? {};
+        return ti.file_path ?? ti.notebook_path ?? ti.path ?? process.argv[2] ?? null;
+    }
+    catch {
+        return process.argv[2] ?? null;
+    }
+}
+// ---------------------------------------------------------------------------
+// HTTP sync (fast — daemon must be running on port 7821)
+// ---------------------------------------------------------------------------
+async function tryHttpSync(filePath, port = 7821) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 500);
+        const res = await fetch(`http://localhost:${port}/sync`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ path: filePath }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Direct SQLite sync (fallback — always available)
+// ---------------------------------------------------------------------------
+async function syncDirect(filePath) {
+    const { initDatabase, prepareStatements } = await import("./database.js");
+    const { handleSyncFile } = await import("./tools/sync.js");
+    const db = initDatabase();
+    const stmts = prepareStatements(db);
+    handleSyncFile(stmts, { path: filePath });
+    db.close();
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    const filePath = getFilePathFromStdin();
+    if (!filePath)
+        return;
+    const httpOk = await tryHttpSync(filePath);
+    if (!httpOk) {
+        await syncDirect(filePath);
+    }
+}
+main().catch(() => { }); // never propagate errors to Claude Code

package/build/retrieval/context.js

@@ -6,6 +6,7 @@ import { extractSkeleton, renderSkeleton } from "../indexer/ast.js";
 import { searchQdrant } from "./qdrant.js";
 import { getQdrantConfig } from "../config.js";
 import { getFileRewardsMap } from "../memory/experience.js";
+import { tryCompressTextSemantic } from "../compression/semantic.js";
 // ---------------------------------------------------------------------------
 // Token estimation (1 token ≈ 4 chars is the standard heuristic)
 // ---------------------------------------------------------------------------
@@ -183,6 +184,11 @@ export async function assembleContext(query, stmts, cfg, opts = {}) {
         }
         if (isRecent)
             reason += " +recent";
+        // Semantic compression — applied after skeleton/full decision, before token counting
+        if (cfg.semanticCompression?.enabled) {
+            content = await tryCompressTextSemantic(content, cfg.semanticCompression.ratio ?? 0.5, cfg.semanticCompression.minLength ?? 300);
+            reason += " +compressed";
+        }
         const contentTokens = estimateTokens(content);
         if (contentTokens < 10) {
             skippedFiles++;

package/build/retrieval/qdrant.d.ts

@@ -8,7 +8,7 @@ export interface VectorChunk {
     score: number;
 }
 /** Index one file into Qdrant (called by sync_file when Qdrant is configured). */
-export declare function indexFileInQdrant(filepath: string, text: string, cfg: QdrantCfg): Promise<void>;
+export declare function indexFileInQdrant(filepath: string, text: string, cfg: QdrantCfg, compressionCfg?: ResolvedConfig["semanticCompression"]): Promise<void>;
 /** Top-k semantic search across all indexed chunks. */
 export declare function searchQdrant(query: string, topK: number, cfg: QdrantCfg): Promise<VectorChunk[]>;
 /** Check if Qdrant collection exists and is reachable. */