@a13xu/lucid 1.4.0 → 1.9.1

package/build/tools/context.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { assembleContext } from "../retrieval/context.js";
+import { loadConfig } from "../config.js";
+import { decompress } from "../store/content.js";
+import { createExperience } from "../memory/experience.js";
+// ---------------------------------------------------------------------------
+// get_context — smart token-efficient context retrieval
+// ---------------------------------------------------------------------------
+export const GetContextSchema = z.object({
+    query: z.string().min(1).describe("What you are working on or searching for"),
+    maxTokens: z.number().int().min(100).max(32000).optional()
+        .describe("Total token budget (default from lucid.config.json, typically 4000)"),
+    dirs: z.array(z.string()).optional()
+        .describe("Whitelist: only return files from these directories (e.g. [\"src\", \"backend\"])"),
+    recentOnly: z.boolean().optional()
+        .describe("Only return files modified within recentWindowHours"),
+    recentHours: z.number().optional()
+        .describe("Override recentWindowHours for this call"),
+    skeletonOnly: z.boolean().optional()
+        .describe("Always show skeleton (signatures only) even for small files"),
+    topK: z.number().int().min(1).max(50).optional()
+        .describe("Max files to consider (Qdrant: top-k chunks)"),
+});
+export async function handleGetContext(stmts, args) {
+    const cfg = loadConfig();
+    const result = await assembleContext(args.query, stmts, cfg, {
+        maxTokens: args.maxTokens,
+        dirs: args.dirs,
+        recentOnly: args.recentOnly,
+        recentHours: args.recentHours,
+        skeletonOnly: args.skeletonOnly,
+        topK: args.topK,
+    });
+    if (result.files.length === 0) {
+        return [
+            `⚠️  No relevant files found for: "${args.query}"`,
+            `   Strategy: ${result.strategy}`,
+            `   Tip: run init_project() or sync_project() first to index files`,
+        ].join("\n");
+    }
+    // Log experience for RL reward system
+    const contextFps = result.files.map((f) => f.filepath);
+    const expId = createExperience(args.query, contextFps, result.strategy, stmts);
+    const lines = [
+        `// get_context: "${args.query}"`,
+        `// Strategy: ${result.strategy} | ${result.files.length} files | ~${result.totalTokens} tokens`,
+        `// Experience #${expId} logged. Call reward() if this context helped, penalize() if not.`,
+        result.truncated ? `// ⚠️  Truncated (${result.skippedFiles} files skipped — increase maxTokens to see more)` : "",
+        "",
+    ].filter((l) => l !== undefined);
+    for (const f of result.files) {
+        lines.push(`// ─── ${f.filepath} [${f.language}] ~${f.tokens}t (${f.reason}) ───`);
+        lines.push(f.content);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// get_recent — recently modified files with diffs
+// ---------------------------------------------------------------------------
+export const GetRecentSchema = z.object({
+    hours: z.number().positive().optional()
+        .describe("Look back N hours (default 24)"),
+    withDiffs: z.boolean().optional()
+        .describe("Include line-level diffs (default true)"),
+});
+export function handleGetRecent(stmts, args) {
+    const cfg = loadConfig();
+    const hours = args.hours ?? cfg.recentWindowHours;
+    const withDiffs = args.withDiffs ?? true;
+    const cutoff = Math.floor(Date.now() / 1000) - hours * 3600;
+    const recentFiles = stmts.getRecentFiles.all(cutoff);
+    if (recentFiles.length === 0) {
+        return `No files modified in the last ${hours}h.\nTip: call sync_file(path) after each file change.`;
+    }
+    const recentDiffs = withDiffs
+        ? stmts.getRecentDiffs.all(cutoff)
+        : [];
+    const diffMap = new Map(recentDiffs.map((d) => [d.filepath, d]));
+    const lines = [
+        `// ${recentFiles.length} file(s) modified in the last ${hours}h`,
+        "",
+    ];
+    for (const f of recentFiles) {
+        const age = Math.round((Date.now() / 1000 - f.indexed_at) / 60);
+        const ageStr = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
+        lines.push(`// ─── ${f.filepath} [${f.language}] (${ageStr}) ───`);
+        const diff = diffMap.get(f.filepath);
+        if (diff) {
+            lines.push(diff.diff_text);
+        }
+        else {
+            // New file — show first ~20 lines
+            const row = stmts.getFileByPath.get(f.filepath);
+            if (row) {
+                const src = decompress(row.content).split("\n").slice(0, 20).join("\n");
+                lines.push(src);
+                if (row.original_size > src.length)
+                    lines.push("… [new file, showing first 20 lines]");
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/build/tools/init.d.ts

@@ -2,10 +2,50 @@ import { z } from "zod";
 import type { Statements } from "../database.js";
 export declare const InitProjectSchema: z.ZodObject<{
     directory: z.ZodOptional<z.ZodString>;
+    /** Display name of the security admin */
+    adminName: z.ZodOptional<z.ZodString>;
+    /** Email address to send security alerts to */
+    adminEmail: z.ZodOptional<z.ZodString>;
+    /** SMTP server hostname (e.g. smtp.gmail.com) */
+    smtpHost: z.ZodOptional<z.ZodString>;
+    /** SMTP port: 587 (STARTTLS, default) or 465 (direct TLS) */
+    smtpPort: z.ZodOptional<z.ZodNumber>;
+    /** SMTP login username (often same as adminEmail) */
+    smtpUser: z.ZodOptional<z.ZodString>;
+    /** "From" display name + address (e.g. "Lucid Security <alerts@co.com>") */
+    smtpFrom: z.ZodOptional<z.ZodString>;
+    /** Generic HTTP webhook URL (receives JSON POST, HMAC-signed if LUCID_WEBHOOK_SECRET is set) */
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    /** Slack incoming webhook URL */
+    slackWebhookUrl: z.ZodOptional<z.ZodString>;
+    /** Which severities trigger an alert: default ["critical","high"] */
+    alertOn: z.ZodOptional<z.ZodArray<z.ZodEnum<["critical", "high", "medium", "low"]>, "many">>;
+    /** Human-readable project name shown in alerts */
+    projectName: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     directory?: string | undefined;
+    adminName?: string | undefined;
+    adminEmail?: string | undefined;
+    smtpHost?: string | undefined;
+    smtpPort?: number | undefined;
+    smtpUser?: string | undefined;
+    smtpFrom?: string | undefined;
+    webhookUrl?: string | undefined;
+    slackWebhookUrl?: string | undefined;
+    alertOn?: ("low" | "medium" | "high" | "critical")[] | undefined;
+    projectName?: string | undefined;
 }, {
     directory?: string | undefined;
+    adminName?: string | undefined;
+    adminEmail?: string | undefined;
+    smtpHost?: string | undefined;
+    smtpPort?: number | undefined;
+    smtpUser?: string | undefined;
+    smtpFrom?: string | undefined;
+    webhookUrl?: string | undefined;
+    slackWebhookUrl?: string | undefined;
+    alertOn?: ("low" | "medium" | "high" | "critical")[] | undefined;
+    projectName?: string | undefined;
 }>;
 export type InitProjectInput = z.infer<typeof InitProjectSchema>;
-export declare function handleInitProject(stmts: Statements, input: InitProjectInput): string;
+export declare function handleInitProject(stmts: Statements, input: InitProjectInput): Promise<string>;

package/build/tools/init.js

@@ -2,22 +2,44 @@ import { z } from "zod";
 import { resolve, join } from "path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { indexProject } from "../indexer/project.js";
+import { saveAdminConfig, loadAdminConfig, isAdminConfigured, sendTestAlert, } from "../security/alerts.js";
 export const InitProjectSchema = z.object({
     directory: z.string().optional(),
+    // ── Admin alert configuration (asked once at project init) ──────────────
+    /** Display name of the security admin */
+    adminName: z.string().optional(),
+    /** Email address to send security alerts to */
+    adminEmail: z.string().email().optional(),
+    /** SMTP server hostname (e.g. smtp.gmail.com) */
+    smtpHost: z.string().optional(),
+    /** SMTP port: 587 (STARTTLS, default) or 465 (direct TLS) */
+    smtpPort: z.number().int().min(1).max(65535).optional(),
+    /** SMTP login username (often same as adminEmail) */
+    smtpUser: z.string().optional(),
+    /** "From" display name + address (e.g. "Lucid Security <alerts@co.com>") */
+    smtpFrom: z.string().optional(),
+    /** Generic HTTP webhook URL (receives JSON POST, HMAC-signed if LUCID_WEBHOOK_SECRET is set) */
+    webhookUrl: z.string().url().optional(),
+    /** Slack incoming webhook URL */
+    slackWebhookUrl: z.string().url().optional(),
+    /** Which severities trigger an alert: default ["critical","high"] */
+    alertOn: z.array(z.enum(["critical", "high", "medium", "low"])).optional(),
+    /** Human-readable project name shown in alerts */
+    projectName: z.string().optional(),
 });
-// ---------------------------------------------------------------------------
-// Instalează PostToolUse hook în .claude/settings.json
-// ---------------------------------------------------------------------------
+const LUCID_MARKER = "Lucid: call sync_file";
+const LUCID_HOOK = {
+    matcher: { tools: ["Write", "Edit", "NotebookEdit"] },
+    hooks: [
+        {
+            type: "command",
+            command: `echo '🔄 ${LUCID_MARKER}(path) to keep knowledge graph up to date'`,
+        },
+    ],
+};
 function installHook(dir) {
     const claudeDir = join(dir, ".claude");
     const settingsPath = join(claudeDir, "settings.json");
-    const HOOK_CMD = 'node -e "const p=process.argv[1]; if(p) require(\'child_process\').execSync(\'node \'+require(\'path\').resolve(\'node_modules/.bin/lucid\'||\'\')+\' --noop\', {stdio:\'ignore\'})" "$TOOL_INPUT_PATH" 2>/dev/null || true';
-    // Hook mai simplu și portabil: apelează sync_file prin claude mcp
-    const HOOK = {
-        matcher: "Write|Edit|NotebookEdit",
-        command: "echo '{\"tool\":\"sync_file\",\"path\":\"'\"$TOOL_INPUT_PATH\"'\"}' | true",
-    };
-    // Citim sau cream settings.json
     let settings = {};
     if (existsSync(settingsPath)) {
         try {
@@ -27,19 +49,17 @@ function installHook(dir) {
             return { installed: false, reason: "Could not parse .claude/settings.json" };
         }
     }
-    // Verifică dacă hook-ul e deja instalat
-    const hooks = settings["hooks"] ?? {};
+    const hooks = (settings["hooks"] ?? {});
     const postToolUse = hooks["PostToolUse"] ?? [];
-    const alreadyInstalled = postToolUse.some((h) => h.matcher?.includes("Write") && String(h).includes("lucid"));
+    // Detectează atât formatul vechi cât și cel nou
+    const alreadyInstalled = postToolUse.some((h) => {
+        const cmd = h.command ?? h.hooks?.[0]?.command ?? "";
+        return cmd.includes(LUCID_MARKER);
+    });
     if (alreadyInstalled) {
         return { installed: false, reason: "already installed" };
     }
-    // Adaugă hook-ul — notifică Claude să cheme sync_file
-    const lucidHook = {
-        matcher: "Write|Edit|NotebookEdit",
-        command: "echo '🔄 Lucid: call sync_file(path) to keep knowledge graph up to date'",
-    };
-    hooks["PostToolUse"] = [...postToolUse, lucidHook];
+    hooks["PostToolUse"] = [...postToolUse, LUCID_HOOK];
     settings["hooks"] = hooks;
     mkdirSync(claudeDir, { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
@@ -74,7 +94,7 @@ function injectClaudeMdInstruction(dir) {
 // ---------------------------------------------------------------------------
 // Main handler
 // ---------------------------------------------------------------------------
-export function handleInitProject(stmts, input) {
+export async function handleInitProject(stmts, input) {
     const dir = resolve(input.directory ?? process.cwd());
     const results = indexProject(dir, stmts);
     const lines = [`✅ Project indexed: ${dir}`, ``];
@@ -88,7 +108,7 @@ export function handleInitProject(stmts, input) {
             lines.push(`  • [${r.type}] "${r.entity}" — ${r.observations} observation(s) from ${r.source}`);
         }
     }
-    // Instalează hook PostToolUse
+    // ── Hook PostToolUse ──────────────────────────────────────────────────────
     lines.push(``);
     const hookResult = installHook(dir);
     if (hookResult.installed) {
@@ -98,13 +118,95 @@ export function handleInitProject(stmts, input) {
     else {
         lines.push(`🔗 Hook: ${hookResult.reason}`);
     }
-    // Injectează instrucțiune în CLAUDE.md
+    // ── CLAUDE.md injection ───────────────────────────────────────────────────
     const injected = injectClaudeMdInstruction(dir);
     if (injected) {
         lines.push(`📋 CLAUDE.md updated with sync_file() instruction`);
     }
+    // ── Security admin configuration ──────────────────────────────────────────
+    lines.push(``);
+    lines.push(`🔒 Security Alerts`);
+    // Save any admin params provided in this call
+    const adminFields = {
+        adminName: input.adminName,
+        adminEmail: input.adminEmail,
+        smtpHost: input.smtpHost,
+        smtpPort: input.smtpPort,
+        smtpUser: input.smtpUser,
+        smtpFrom: input.smtpFrom,
+        webhookUrl: input.webhookUrl,
+        slackWebhookUrl: input.slackWebhookUrl,
+        alertOn: input.alertOn,
+        projectName: input.projectName ?? results.find((r) => r.type === "project")?.entity,
+    };
+    const hasNewAdmin = Object.values(adminFields).some((v) => v !== undefined);
+    if (hasNewAdmin) {
+        // Strip undefined values before saving
+        const clean = Object.fromEntries(Object.entries(adminFields).filter(([, v]) => v !== undefined));
+        saveAdminConfig(dir, clean);
+        lines.push(`   Saved admin config → .claude/lucid-admin.json`);
+        // Test alert channels
+        const testResults = await sendTestAlert(dir);
+        lines.push(`   Test alert results:`);
+        for (const r of testResults)
+            lines.push(`     ${r}`);
+    }
+    else {
+        // Check existing config
+        const existing = loadAdminConfig(dir);
+        if (isAdminConfigured()) {
+            lines.push(`   Admin: ${existing.adminName ?? existing.adminEmail ?? "configured"}`);
+            lines.push(`   Channels: ${buildChannelSummary(existing)}`);
+            lines.push(`   Alerting on: ${(existing.alertOn ?? ["critical", "high"]).join(", ")}`);
+        }
+        else {
+            // Not configured — prompt user
+            lines.push(``);
+            lines.push(`   ⚠️  No security admin configured. Security alerts will only appear in logs.`);
+            lines.push(``);
+            lines.push(`   To enable alerts, re-run init_project() with admin parameters:`);
+            lines.push(``);
+            lines.push(`   Minimal (webhook only):`);
+            lines.push(`     init_project(`);
+            lines.push(`       adminName="Your Name",`);
+            lines.push(`       adminEmail="admin@yourcompany.com",`);
+            lines.push(`       webhookUrl="https://hooks.yourservice.com/...",`);
+            lines.push(`     )`);
+            lines.push(``);
+            lines.push(`   With Slack:`);
+            lines.push(`     init_project(`);
+            lines.push(`       adminName="Your Name",`);
+            lines.push(`       adminEmail="admin@yourcompany.com",`);
+            lines.push(`       slackWebhookUrl="https://hooks.slack.com/services/...",`);
+            lines.push(`     )`);
+            lines.push(``);
+            lines.push(`   With Email (SMTP):`);
+            lines.push(`     init_project(`);
+            lines.push(`       adminName="Your Name",`);
+            lines.push(`       adminEmail="admin@yourcompany.com",`);
+            lines.push(`       smtpHost="smtp.gmail.com",`);
+            lines.push(`       smtpPort=587,`);
+            lines.push(`       smtpUser="alerts@yourcompany.com",`);
+            lines.push(`     )`);
+            lines.push(`     # Then set in your environment:`);
+            lines.push(`     export LUCID_SMTP_PASS="your-app-password"`);
+            lines.push(``);
+            lines.push(`   SMTP password must be in LUCID_SMTP_PASS env var (never as a parameter).`);
+            lines.push(`   Webhook HMAC signing: set LUCID_WEBHOOK_SECRET env var.`);
+        }
+    }
     lines.push(``);
     lines.push(`From now on, call sync_file(path) after every file you write or edit.`);
     lines.push(`Use recall() to query accumulated project knowledge.`);
     return lines.join("\n");
 }
+function buildChannelSummary(cfg) {
+    const channels = [];
+    if (cfg.adminEmail && cfg.smtpHost)
+        channels.push(`email(${cfg.adminEmail})`);
+    if (cfg.webhookUrl)
+        channels.push(`webhook`);
+    if (cfg.slackWebhookUrl)
+        channels.push(`slack`);
+    return channels.length > 0 ? channels.join(", ") : "none";
+}

package/build/tools/remember.d.ts

@@ -5,13 +5,13 @@ export declare const RememberSchema: z.ZodObject<{
     entityType: z.ZodEnum<["person", "project", "decision", "pattern", "tool", "config", "bug", "convention"]>;
     observation: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    entity: string;
-    entityType: "person" | "project" | "decision" | "pattern" | "tool" | "config" | "bug" | "convention";
     observation: string;
-}, {
     entity: string;
-    entityType: "person" | "project" | "decision" | "pattern" | "tool" | "config" | "bug" | "convention";
+    entityType: "tool" | "pattern" | "person" | "project" | "decision" | "config" | "bug" | "convention";
+}, {
     observation: string;
+    entity: string;
+    entityType: "tool" | "pattern" | "person" | "project" | "decision" | "config" | "bug" | "convention";
 }>;
 export type RememberInput = z.infer<typeof RememberSchema>;
 export declare function remember(stmts: Statements, input: RememberInput): string;

package/build/tools/reward.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { Statements } from "../database.js";
+export declare const RewardSchema: z.ZodObject<{
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    note?: string | undefined;
+}, {
+    note?: string | undefined;
+}>;
+export declare const PenalizeSchema: z.ZodObject<{
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    note?: string | undefined;
+}, {
+    note?: string | undefined;
+}>;
+export declare const ShowRewardsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    topK: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query?: string | undefined;
+    topK?: number | undefined;
+}, {
+    query?: string | undefined;
+    topK?: number | undefined;
+}>;
+export declare function handleReward(stmts: Statements, args: z.infer<typeof RewardSchema>): string;
+export declare function handlePenalize(stmts: Statements, args: z.infer<typeof PenalizeSchema>): string;
+export declare function handleShowRewards(stmts: Statements, args: z.infer<typeof ShowRewardsSchema>): string;

package/build/tools/reward.js

@@ -0,0 +1,154 @@
+// Reward / penalize / show_rewards tool handlers
+import { z } from "zod";
+import { getLastExperienceId, rewardExperience, decayedReward, } from "../memory/experience.js";
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+export const RewardSchema = z.object({
+    note: z.string().optional().describe("Optional note about what worked"),
+});
+export const PenalizeSchema = z.object({
+    note: z.string().optional().describe("Optional note about what was missing or wrong"),
+});
+export const ShowRewardsSchema = z.object({
+    query: z.string().optional().describe("Filter experiences by query text"),
+    topK: z.number().int().min(1).max(50).optional().describe("Number of top results to show (default 10)"),
+});
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function formatAge(unixSec) {
+    const diffSec = Math.floor(Date.now() / 1000) - unixSec;
+    if (diffSec < 3600)
+        return `${Math.round(diffSec / 60)}m ago`;
+    if (diffSec < 86400)
+        return `${Math.round(diffSec / 3600)}h ago`;
+    return `${Math.round(diffSec / 86400)} days ago`;
+}
+function parseFps(contextFps) {
+    try {
+        return JSON.parse(contextFps);
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// reward — explicit +1 on the last experience
+// ---------------------------------------------------------------------------
+export function handleReward(stmts, args) {
+    const lastId = getLastExperienceId();
+    if (lastId === null) {
+        return "❌ No recent get_context() call to reward. Call get_context() first.";
+    }
+    const result = rewardExperience(lastId, 1.0, args.note ?? null, stmts);
+    if (!result) {
+        return `❌ Experience #${lastId} not found in database.`;
+    }
+    const lines = [
+        `✅ Experience #${lastId} rewarded (+1)`,
+        `   Query: "${result.query}"`,
+    ];
+    if (args.note)
+        lines.push(`   Note: ${args.note}`);
+    if (result.fps.length > 0) {
+        lines.push(`   Rewarded files:`);
+        for (const fp of result.fps.slice(0, 5)) {
+            lines.push(`     +1.0  ${fp}`);
+        }
+        if (result.fps.length > 5)
+            lines.push(`     … and ${result.fps.length - 5} more`);
+    }
+    // Show accumulated reward for these files
+    const allRewards = stmts.getFileRewards.all();
+    const relevant = allRewards.filter((fr) => result.fps.includes(fr.filepath));
+    if (relevant.length > 0) {
+        const total = relevant.reduce((sum, fr) => sum + fr.total_reward, 0);
+        lines.push(`   Total reward score for these files: ${total.toFixed(1)} (accumulated)`);
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// penalize — explicit -1 on the last experience
+// ---------------------------------------------------------------------------
+export function handlePenalize(stmts, args) {
+    const lastId = getLastExperienceId();
+    if (lastId === null) {
+        return "❌ No recent get_context() call to penalize. Call get_context() first.";
+    }
+    const result = rewardExperience(lastId, -1.0, args.note ?? null, stmts);
+    if (!result) {
+        return `❌ Experience #${lastId} not found in database.`;
+    }
+    const lines = [
+        `❌ Experience #${lastId} penalized (-1)`,
+        `   Query: "${result.query}"`,
+    ];
+    if (args.note)
+        lines.push(`   Note: ${args.note}`);
+    if (result.fps.length > 0) {
+        lines.push(`   Penalized files:`);
+        for (const fp of result.fps.slice(0, 5)) {
+            lines.push(`     -1.0  ${fp}`);
+        }
+        if (result.fps.length > 5)
+            lines.push(`     … and ${result.fps.length - 5} more`);
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// show_rewards — display top experiences + most rewarded files
+// ---------------------------------------------------------------------------
+export function handleShowRewards(stmts, args) {
+    const topK = args.topK ?? 10;
+    const lines = [];
+    // Get experiences
+    let experiences;
+    if (args.query) {
+        try {
+            // FTS search: append * for prefix match
+            const ftsQuery = args.query.trim().split(/\s+/).map((t) => `${t}*`).join(" ");
+            experiences = stmts.searchExperiencesFTS.all(ftsQuery, topK);
+        }
+        catch {
+            // Fall back to top by reward if FTS query is malformed
+            experiences = stmts.getTopExperiences.all(topK);
+        }
+    }
+    else {
+        experiences = stmts.getTopExperiences.all(topK);
+    }
+    if (experiences.length === 0) {
+        lines.push("No rewarded experiences yet. Use get_context() then reward() to start building context memory.");
+    }
+    else {
+        lines.push("🏆 Top rewarded experiences (decayed):", "");
+        for (const exp of experiences) {
+            const decayed = decayedReward(exp.reward, exp.rewarded_at);
+            const ageStr = exp.rewarded_at ? formatAge(exp.rewarded_at) : "never rewarded";
+            const sign = exp.reward >= 0 ? "+" : "";
+            lines.push(`#${exp.id}  ${sign}${decayed.toFixed(1)}  "${exp.query}"  (${ageStr})`);
+            const fps = parseFps(exp.context_fps);
+            if (fps.length > 0) {
+                const shown = fps.slice(0, 3).join(", ");
+                const extra = fps.length > 3 ? ` +${fps.length - 3} more` : "";
+                lines.push(`     → ${shown}${extra}`);
+            }
+            if (exp.feedback)
+                lines.push(`     note: ${exp.feedback}`);
+        }
+    }
+    // Most rewarded files (decayed)
+    lines.push("", "📁 Most rewarded files:");
+    const topFiles = stmts.getTopFileRewards.all(topK);
+    if (topFiles.length === 0) {
+        lines.push("  (none yet)");
+    }
+    else {
+        topFiles.forEach((fr, i) => {
+            const decayed = decayedReward(fr.total_reward, fr.last_rewarded);
+            lines.push(`  ${i + 1}. ${fr.filepath}  reward=${decayed.toFixed(1)}  used=${fr.use_count}x`);
+        });
+    }
+    return lines.join("\n");
+}

package/build/tools/sync.js

@@ -3,6 +3,9 @@ import { resolve, extname } from "path";
 import { existsSync, readFileSync } from "fs";
 import { indexFile, upsertFileIndex } from "../indexer/file.js";
 import { indexProject } from "../indexer/project.js";
+import { computeDiff } from "../retrieval/context.js";
+import { decompress } from "../store/content.js";
+import { implicitRewardFromSync } from "../memory/experience.js";
 const SUPPORTED_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"]);
 // ---------------------------------------------------------------------------
 // sync_file
@@ -21,10 +24,18 @@ export function handleSyncFile(stmts, args) {
     if (!index)
         return `Could not read file: ${filepath}`;
     const source = readFileSync(filepath, "utf-8");
+    // Capture previous content before upsert (for diff)
+    const prevRow = stmts.getFileByPath.get(filepath);
+    const prevSource = prevRow ? decompress(prevRow.content) : null;
     const result = upsertFileIndex(index, source, stmts);
     if (!result.stored) {
         return `⏭️  Unchanged: ${filepath} (hash match — skipped)`;
     }
+    // Store diff when file changed
+    if (prevRow && prevSource !== null) {
+        const diff = computeDiff(prevSource, source);
+        stmts.upsertDiff.run(filepath, prevRow.content_hash, diff);
+    }
     const ratio = Math.round((1 - (result.savedBytes + Buffer.byteLength(source, "utf-8") - result.savedBytes) / Buffer.byteLength(source, "utf-8")) * 100);
     const saved = Math.round(result.savedBytes / 1024 * 10) / 10;
     const lines = [
@@ -36,6 +47,10 @@ export function handleSyncFile(stmts, args) {
         lines.push(`   description: ${index.description}`);
     if (index.todos.length > 0)
         lines.push(`   TODOs: ${index.todos.length} open`);
+    // Implicit reward: if this file was in the last get_context result → +0.3
+    const implicitRewarded = implicitRewardFromSync(filepath, stmts);
+    if (implicitRewarded)
+        lines.push(`   🎯 Implicit reward +0.3 (file was in recent context)`);
     return lines.join("\n");
 }
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@a13xu/lucid",
-  "version": "1.4.0",
-  "description": "Persistent memory for Claude Code agents — SQLite + FTS5 knowledge graph via MCP",
+  "version": "1.9.1",
+  "description": "Token-efficient memory, code indexing, and validation for Claude Code agents — SQLite + FTS5, TF-IDF + Qdrant retrieval, AST skeleton pruning, diff-aware context, Logic Guardian drift detection",
   "type": "module",
   "bin": {
     "lucid": "./build/index.js"
@@ -22,6 +22,13 @@
     "memory",
     "sqlite",
     "knowledge-graph",
+    "code-indexing",
+    "logic-guardian",
+    "drift-detection",
+    "tfidf",
+    "qdrant",
+    "token-optimization",
+    "context-pruning",
     "ai",
     "anthropic"
   ],