@a13xu/lucid 1.13.0 → 1.16.1

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. */

package/build/retrieval/qdrant.js

@@ -2,6 +2,7 @@
 // Only active when QDRANT_URL is set (via env var or lucid.config.json)
 // Falls back silently to TF-IDF when unavailable
 import { safeFetch } from "../security/ssrf.js";
+import { tryCompressTextSemantic } from "../compression/semantic.js";
 // ---------------------------------------------------------------------------
 // Embedding generation (OpenAI-compatible endpoint)
 // ---------------------------------------------------------------------------
@@ -85,16 +86,24 @@ function stableId(s) {
 // Public API
 // ---------------------------------------------------------------------------
 /** Index one file into Qdrant (called by sync_file when Qdrant is configured). */
-export async function indexFileInQdrant(filepath, text, cfg) {
+export async function indexFileInQdrant(filepath, text, cfg, compressionCfg) {
     await ensureCollection(cfg);
     const chunks = chunkFile(filepath, text);
     if (chunks.length === 0)
         return;
+    const compressForEmbedding = compressionCfg?.enabled && compressionCfg.applyToEmbeddings !== false;
     // Batch embed (max 96 texts per request for most providers)
     const BATCH = 32;
     for (let b = 0; b < chunks.length; b += BATCH) {
         const batch = chunks.slice(b, b + BATCH);
-        const vectors = await embed(batch.map((c) => c.text), cfg);
+        let textsToEmbed;
+        if (compressForEmbedding) {
+            textsToEmbed = await Promise.all(batch.map((c) => tryCompressTextSemantic(c.text, compressionCfg.ratio ?? 0.5, compressionCfg.minLength ?? 300)));
+        }
+        else {
+            textsToEmbed = batch.map((c) => c.text);
+        }
+        const vectors = await embed(textsToEmbed, cfg);
         const points = batch.map((c, idx) => ({
             id: c.id,
             vector: vectors[idx],

package/build/tools/compress.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const CompressTextSchema: z.ZodObject<{
+    text: z.ZodString;
+    ratio: z.ZodOptional<z.ZodNumber>;
+    min_length: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    ratio?: number | undefined;
+    min_length?: number | undefined;
+}, {
+    text: string;
+    ratio?: number | undefined;
+    min_length?: number | undefined;
+}>;
+export declare function handleCompressText(args: z.infer<typeof CompressTextSchema>): Promise<string>;

package/build/tools/compress.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { compressTextSemantic } from "../compression/semantic.js";
+export const CompressTextSchema = z.object({
+    text: z.string().min(1).describe("Text to compress"),
+    ratio: z.number().min(0.1).max(0.9).optional().describe("Target compression ratio: 0.3 = keep 30%, 0.5 = keep 50% (default: 0.5)"),
+    min_length: z.number().int().optional().describe("Skip compression for texts shorter than this in chars (default: 300)"),
+});
+export async function handleCompressText(args) {
+    const result = await compressTextSemantic(args.text, args.ratio ?? 0.5, args.min_length ?? 300);
+    return JSON.stringify({
+        compressed: result.compressed,
+        original_length: result.originalLength,
+        compressed_length: result.compressedLength,
+        ratio_kept: result.ratio,
+        method: result.method,
+        tokens_saved: Math.ceil((result.originalLength - result.compressedLength) / 4),
+    }, null, 2);
+}

package/build/tools/init.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { resolve, join } from "path";
+import { homedir } from "os";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { indexProject } from "../indexer/project.js";
@@ -35,7 +36,7 @@ const LUCID_HOOK = {
     hooks: [
         {
             type: "command",
-            command: `echo '🔄 ${LUCID_MARKER}(path) to keep knowledge graph up to date'`,
+            command: `lucid-sync 2>/dev/null || echo '🔄 ${LUCID_MARKER}(path) — install lucid globally: npm i -g @a13xu/lucid'`,
         },
     ],
 };
@@ -167,6 +168,17 @@ export async function handleInitProject(stmts, input) {
     else if (skillsResult.skipped.length > 0) {
         lines.push(`📚 Skills: already installed (${skillsResult.skipped.length} skill(s))`);
     }
+    // ── Global skills (~/.claude/skills/) ────────────────────────────────────
+    const globalSkillsResult = installGlobalSkills();
+    if (globalSkillsResult.installed.length > 0) {
+        lines.push(`🌐 Global skills installed in ~/.claude/skills/:`);
+        for (const s of globalSkillsResult.installed) {
+            lines.push(`   • /${s} (available in all projects)`);
+        }
+    }
+    else if (globalSkillsResult.skipped.length > 0) {
+        lines.push(`🌐 Global skills: already installed (${globalSkillsResult.skipped.length} skill(s))`);
+    }
     // ── CLAUDE.md injection ───────────────────────────────────────────────────
     const injected = injectClaudeMdInstruction(dir);
     if (injected) {
@@ -277,6 +289,9 @@ function installSkills(projectDir) {
     }
     return result;
 }
+function installGlobalSkills() {
+    return installSkills(homedir());
+}
 function buildChannelSummary(cfg) {
     const channels = [];
     if (cfg.adminEmail && cfg.smtpHost)

package/build/tools/model-advisor.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const SuggestModelSchema: z.ZodObject<{
+    task_description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    task_description: string;
+}, {
+    task_description: string;
+}>;
+export declare function handleSuggestModel(args: z.infer<typeof SuggestModelSchema>): string;

package/build/tools/model-advisor.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export const SuggestModelSchema = z.object({
+    task_description: z.string().min(1).describe("Natural language description of the task you are about to perform"),
+});
+const HAIKU_TRIGGERS = [
+    "list", "show", "find", "search", "where", "what is",
+    "recall", "get recent", "status",
+];
+const MODEL_IDS = {
+    haiku: "claude-haiku-4-5-20251001",
+    sonnet: "claude-sonnet-4-6",
+};
+const CONTEXT_BUDGETS = {
+    haiku: 2000,
+    sonnet: 8000,
+};
+export function handleSuggestModel(args) {
+    const lower = args.task_description.toLowerCase();
+    const haikuTrigger = HAIKU_TRIGGERS.find((t) => lower.includes(t));
+    const model = haikuTrigger ? "haiku" : "sonnet";
+    const reasoning = haikuTrigger
+        ? `Task matches retrieval/lookup pattern ("${haikuTrigger}") — Haiku is faster for read-only queries.`
+        : "No simple retrieval trigger detected — defaulting to Sonnet for reasoning, code generation, and analysis.";
+    return JSON.stringify({
+        model,
+        model_id: MODEL_IDS[model],
+        reasoning,
+        context_budget: CONTEXT_BUDGETS[model],
+    }, null, 2);
+}

package/build/tools/smart-context.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { Statements } from "../database.js";
+export declare const SmartContextSchema: z.ZodObject<{
+    query: z.ZodString;
+    task_type: z.ZodOptional<z.ZodEnum<["simple", "moderate", "complex"]>>;
+    dirs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    dirs?: string[] | undefined;
+    task_type?: "simple" | "moderate" | "complex" | undefined;
+}, {
+    query: string;
+    dirs?: string[] | undefined;
+    task_type?: "simple" | "moderate" | "complex" | undefined;
+}>;
+export declare function handleSmartContext(stmts: Statements, args: z.infer<typeof SmartContextSchema>): Promise<string>;

package/build/tools/smart-context.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { assembleContext } from "../retrieval/context.js";
+import { recall } from "./recall.js";
+import { loadConfig } from "../config.js";
+import { createExperience } from "../memory/experience.js";
+export const SmartContextSchema = z.object({
+    query: z.string().min(1).describe("What you are working on — used for both code retrieval and knowledge graph search"),
+    task_type: z.enum(["simple", "moderate", "complex"]).optional().describe("Token budget: simple=2000, moderate=6000 (default), complex=12000"),
+    dirs: z.array(z.string()).optional().describe("Whitelist: only return files from these directories"),
+});
+const TASK_BUDGETS = {
+    simple: 2000,
+    moderate: 6000,
+    complex: 12000,
+};
+export async function handleSmartContext(stmts, args) {
+    const cfg = loadConfig();
+    const maxTokens = TASK_BUDGETS[args.task_type ?? "moderate"] ?? 6000;
+    // 1. Knowledge graph entities (synchronous)
+    const recallResult = recall(stmts, { query: args.query });
+    // 2. Code context with adaptive budget (async)
+    const contextResult = await assembleContext(args.query, stmts, cfg, {
+        maxTokens,
+        dirs: args.dirs,
+    });
+    // 3. Log experience so reward()/penalize() work after this call
+    const expId = createExperience(args.query, contextResult.files.map((f) => f.filepath), contextResult.strategy, stmts);
+    const budgetUsedPct = Math.round((contextResult.totalTokens / maxTokens) * 100);
+    const sections = [
+        "## Knowledge Context (entities)",
+        recallResult,
+        "",
+        "## Code Context (files)",
+    ];
+    if (contextResult.files.length === 0) {
+        sections.push("No relevant files found. Run init_project() or sync_project() first.");
+    }
+    else {
+        for (const f of contextResult.files) {
+            sections.push(`// ─── ${f.filepath} [${f.language}] ~${f.tokens}t (${f.reason}) ───`);
+            sections.push(f.content);
+            sections.push("");
+        }
+        if (contextResult.truncated) {
+            sections.push(`// ⚠️  Truncated — ${contextResult.skippedFiles} files skipped. Use task_type="complex" for more.`);
+        }
+    }
+    sections.push("", "---");
+    sections.push(`Strategy: ${contextResult.strategy}`);
+    sections.push(`Files: ${contextResult.files.length} files, ${contextResult.totalTokens} tokens`);
+    sections.push(`Budget used: ${budgetUsedPct}%`);
+    sections.push(`Experience #${expId} logged. Call reward() if helpful, penalize() if not.`);
+    return sections.join("\n");
+}

package/build/tools/sync.js

@@ -6,6 +6,8 @@ import { indexProject } from "../indexer/project.js";
 import { computeDiff } from "../retrieval/context.js";
 import { decompress } from "../store/content.js";
 import { implicitRewardFromSync } from "../memory/experience.js";
+import { indexFileInQdrant } from "../retrieval/qdrant.js";
+import { loadConfig, getQdrantConfig } from "../config.js";
 const SUPPORTED_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".vue", ".py", ".go", ".rs"]);
 // ---------------------------------------------------------------------------
 // sync_file
@@ -51,6 +53,12 @@ export function handleSyncFile(stmts, args) {
     const implicitRewarded = implicitRewardFromSync(filepath, stmts);
     if (implicitRewarded)
         lines.push(`   🎯 Implicit reward +0.3 (file was in recent context)`);
+    // Qdrant vector indexing — fire-and-forget (Qdrant is optional, silent on failure)
+    const cfg = loadConfig();
+    const qdrantCfg = getQdrantConfig(cfg);
+    if (qdrantCfg) {
+        void indexFileInQdrant(filepath, source, qdrantCfg, cfg.semanticCompression).catch(() => { });
+    }
     return lines.join("\n");
 }
 // ---------------------------------------------------------------------------