context-mode 1.0.99 → 1.0.100

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.99"
+    "version": "1.0.100"
   },
   "plugins": [
     {
       "name": "context-mode",
       "source": "./",
       "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-      "version": "1.0.99",
+      "version": "1.0.100",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.99",
+  "version": "1.0.100",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/.openclaw-plugin/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Context Mode",
   "kind": "tool",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-  "version": "1.0.99",
+  "version": "1.0.100",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.99",
+  "version": "1.0.100",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
   "author": {
     "name": "Mert Koseoğlu",

package/build/pi-extension.js

@@ -242,7 +242,7 @@ export default function piExtension(pi) {
             // Mark resume as consumed so it is not re-injected
             db.markResumeConsumed(_sessionId);
             // Build memory context from recent high-priority events
-            const allEvents = db.getEvents(_sessionId, { minPriority: 2, limit: 50 });
+            const allEvents = db.getEvents(_sessionId, { minPriority: 3, limit: 50 });
             let memoryContext = "";
             if (allEvents.length > 0) {
                 const memoryLines = ["<active_memory>"];

package/build/search/auto-memory.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Auto-memory search — searches CLAUDE.md and MEMORY.md files for
+ * persisted decisions, preferences, and context from prior sessions.
+ *
+ * Returns results in a format compatible with the unified search pipeline.
+ */
+export interface AutoMemoryResult {
+    title: string;
+    content: string;
+    source: string;
+    origin: "auto-memory";
+    timestamp?: string;
+}
+/**
+ * Search auto-memory files (CLAUDE.md, MEMORY.md, user identity files)
+ * for content matching any of the given queries.
+ *
+ * Scans:
+ *   1. Project-level: <projectDir>/CLAUDE.md
+ *   2. User-level: <configDir>/CLAUDE.md
+ *   3. User memory: <configDir>/memory/*.md
+ *
+ * @param queries  Array of search terms
+ * @param limit    Max results to return
+ * @param projectDir  Project directory path
+ * @param configDir   Config directory (e.g. ~/.claude)
+ * @returns Matching auto-memory results
+ */
+export declare function searchAutoMemory(queries: string[], limit?: number, projectDir?: string, configDir?: string): AutoMemoryResult[];

package/build/search/auto-memory.js

@@ -0,0 +1,121 @@
+/**
+ * Auto-memory search — searches CLAUDE.md and MEMORY.md files for
+ * persisted decisions, preferences, and context from prior sessions.
+ *
+ * Returns results in a format compatible with the unified search pipeline.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const DEBUG = process.env.DEBUG?.includes("context-mode");
+/**
+ * Search auto-memory files (CLAUDE.md, MEMORY.md, user identity files)
+ * for content matching any of the given queries.
+ *
+ * Scans:
+ *   1. Project-level: <projectDir>/CLAUDE.md
+ *   2. User-level: <configDir>/CLAUDE.md
+ *   3. User memory: <configDir>/memory/*.md
+ *
+ * @param queries  Array of search terms
+ * @param limit    Max results to return
+ * @param projectDir  Project directory path
+ * @param configDir   Config directory (e.g. ~/.claude)
+ * @returns Matching auto-memory results
+ */
+export function searchAutoMemory(queries, limit = 5, projectDir, configDir) {
+    const results = [];
+    const effectiveConfigDir = configDir || join(homedir(), ".claude");
+    // Collect candidate files
+    const candidates = [];
+    // 1. Project-level CLAUDE.md
+    if (projectDir) {
+        const projectClaude = join(projectDir, "CLAUDE.md");
+        if (existsSync(projectClaude)) {
+            candidates.push({ path: projectClaude, label: "project/CLAUDE.md" });
+        }
+    }
+    // 2. User-level CLAUDE.md
+    const userClaude = join(effectiveConfigDir, "CLAUDE.md");
+    if (existsSync(userClaude)) {
+        candidates.push({ path: userClaude, label: "user/CLAUDE.md" });
+    }
+    // 3. User memory directory
+    const memoryDir = join(effectiveConfigDir, "memory");
+    if (existsSync(memoryDir)) {
+        try {
+            const files = readdirSync(memoryDir).filter(f => f.endsWith(".md"));
+            for (const file of files) {
+                candidates.push({
+                    path: join(memoryDir, file),
+                    label: `memory/${file}`,
+                });
+            }
+        }
+        catch (e) {
+            if (DEBUG)
+                process.stderr.write(`[ctx] auto-memory dir scan failed: ${e}\n`);
+        }
+    }
+    // Search each candidate file for matching queries
+    for (const candidate of candidates) {
+        if (results.length >= limit)
+            break;
+        try {
+            // Skip files larger than 1MB to avoid memory issues
+            try {
+                if (statSync(candidate.path).size > 1_000_000)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const content = readFileSync(candidate.path, "utf-8");
+            const contentLower = content.toLowerCase();
+            for (const query of queries) {
+                if (results.length >= limit)
+                    break;
+                const queryLower = query.toLowerCase();
+                // Split query into terms, match if any term is found
+                const terms = queryLower.split(/\s+/).filter(t => t.length >= 3);
+                const matched = terms.some(term => {
+                    try {
+                        return new RegExp(`\\b${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, "i").test(content);
+                    }
+                    catch {
+                        return contentLower.includes(term); // fallback for invalid regex
+                    }
+                });
+                if (matched) {
+                    // Extract a relevant section around the first match
+                    const firstTermIdx = terms.reduce((best, term) => {
+                        const idx = contentLower.indexOf(term);
+                        return idx >= 0 && (best < 0 || idx < best) ? idx : best;
+                    }, -1);
+                    let start = Math.max(0, firstTermIdx - 200);
+                    let end = Math.min(content.length, firstTermIdx + 500);
+                    const prevBlank = content.lastIndexOf("\n\n", start);
+                    const nextBlank = content.indexOf("\n\n", end);
+                    if (prevBlank >= 0)
+                        start = prevBlank + 2;
+                    if (nextBlank >= 0)
+                        end = nextBlank;
+                    const snippet = content.slice(start, end).trim();
+                    results.push({
+                        title: `[auto-memory] ${candidate.label}`,
+                        content: snippet,
+                        source: candidate.label,
+                        origin: "auto-memory",
+                        timestamp: statSync(candidate.path).mtime.toISOString(),
+                    });
+                    break; // one result per file per query batch
+                }
+            }
+        }
+        catch (e) {
+            if (DEBUG)
+                process.stderr.write(`[ctx] auto-memory file read failed: ${e}\n`);
+        }
+    }
+    return results.slice(0, limit);
+}

package/build/search/unified.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Unified multi-source search — merges ContentStore, SessionDB, and
+ * auto-memory results into a single ranked or chronological result set.
+ *
+ * Used by ctx_search when sort="timeline" to search across all sources,
+ * or sort="relevance" (default) for ContentStore-only BM25 search.
+ */
+import type { ContentStore } from "../store.js";
+import type { SessionDB } from "../session/db.js";
+export interface UnifiedSearchResult {
+    title: string;
+    content: string;
+    source: string;
+    origin: "current-session" | "prior-session" | "auto-memory";
+    timestamp?: string;
+    rank?: number;
+    matchLayer?: string;
+    highlighted?: string;
+    contentType?: "code" | "prose";
+}
+export interface SearchAllSourcesOpts {
+    query: string;
+    limit: number;
+    store: ContentStore;
+    sort?: "relevance" | "timeline";
+    source?: string;
+    contentType?: "code" | "prose";
+    sessionDB?: SessionDB | null;
+    projectDir?: string;
+    configDir?: string;
+}
+/**
+ * Search across all available sources.
+ *
+ * - sort="relevance" (default): BM25-ranked results from ContentStore only.
+ * - sort="timeline": chronological merge of ContentStore + SessionDB + auto-memory.
+ *
+ * Errors in any single source are caught and logged — partial results
+ * are always returned.
+ */
+export declare function searchAllSources(opts: SearchAllSourcesOpts): UnifiedSearchResult[];

package/build/search/unified.js

@@ -0,0 +1,89 @@
+/**
+ * Unified multi-source search — merges ContentStore, SessionDB, and
+ * auto-memory results into a single ranked or chronological result set.
+ *
+ * Used by ctx_search when sort="timeline" to search across all sources,
+ * or sort="relevance" (default) for ContentStore-only BM25 search.
+ */
+import { searchAutoMemory } from "./auto-memory.js";
+const DEBUG = process.env.DEBUG?.includes("context-mode");
+// ─────────────────────────────────────────────────────────
+// Implementation
+// ─────────────────────────────────────────────────────────
+/**
+ * Search across all available sources.
+ *
+ * - sort="relevance" (default): BM25-ranked results from ContentStore only.
+ * - sort="timeline": chronological merge of ContentStore + SessionDB + auto-memory.
+ *
+ * Errors in any single source are caught and logged — partial results
+ * are always returned.
+ */
+export function searchAllSources(opts) {
+    const { query, limit, store, sort = "relevance", source, contentType, sessionDB, projectDir, configDir, } = opts;
+    const results = [];
+    // Capture session start time once — used as proxy for ContentStore items
+    // (we don't know exact indexing time, but all content is from current session)
+    const sessionStartTime = new Date().toISOString();
+    // ── Source 1: ContentStore (always, both modes) ──
+    try {
+        const storeResults = store.searchWithFallback(query, limit, source, contentType);
+        results.push(...storeResults.map((r) => ({
+            title: r.title,
+            content: r.content,
+            source: r.source,
+            origin: "current-session",
+            timestamp: r.timestamp || sessionStartTime,
+            rank: r.rank,
+            matchLayer: r.matchLayer,
+            highlighted: r.highlighted,
+            contentType: r.contentType,
+        })));
+    }
+    catch (e) {
+        if (DEBUG)
+            process.stderr.write(`[ctx] ContentStore search failed: ${e}\n`);
+    }
+    // ── Sources 2+3: timeline mode only ──
+    if (sort === "timeline") {
+        // Source 2: SessionDB — prior session events
+        try {
+            if (sessionDB) {
+                const dbResults = sessionDB.searchEvents(query, limit, projectDir || "", source);
+                results.push(...dbResults.map((r) => ({
+                    title: `[${r.category}] ${r.type}`,
+                    content: r.data,
+                    source: "prior-session",
+                    origin: "prior-session",
+                    timestamp: r.created_at,
+                })));
+            }
+        }
+        catch (e) {
+            if (DEBUG)
+                process.stderr.write(`[ctx] SessionDB search failed: ${e}\n`);
+        }
+        // Source 3: Auto-memory
+        try {
+            const memResults = searchAutoMemory([query], limit, projectDir, configDir);
+            results.push(...memResults);
+        }
+        catch (e) {
+            if (DEBUG)
+                process.stderr.write(`[ctx] auto-memory search failed: ${e}\n`);
+        }
+    }
+    // ── Normalize timestamps for consistent sorting ──
+    // SQLite datetime('now') → "YYYY-MM-DD HH:MM:SS" (no T, no Z)
+    // ISO → "YYYY-MM-DDTHH:MM:SS.sssZ"
+    for (const r of results) {
+        if (r.timestamp && !r.timestamp.includes("T")) {
+            r.timestamp = r.timestamp.replace(" ", "T") + "Z";
+        }
+    }
+    // ── Sort ──
+    if (sort === "timeline") {
+        results.sort((a, b) => (a.timestamp || "").localeCompare(b.timestamp || ""));
+    }
+    return results.slice(0, limit);
+}

package/build/server.js

@@ -16,7 +16,8 @@ import { readBashPolicies, evaluateCommandDenyOnly, extractShellCommands, readTo
 import { detectRuntimes, getRuntimeSummary, getAvailableLanguages, hasBunRuntime, } from "./runtime.js";
 import { classifyNonZeroExit } from "./exit-classify.js";
 import { startLifecycleGuard } from "./lifecycle.js";
-import { getWorktreeSuffix } from "./session/db.js";
+import { getWorktreeSuffix, SessionDB } from "./session/db.js";
+import { searchAllSources } from "./search/unified.js";
 import { loadDatabase } from "./db-base.js";
 import { AnalyticsEngine, formatReport } from "./session/analytics.js";
 const __pkg_dir = dirname(fileURLToPath(import.meta.url));
@@ -1081,6 +1082,7 @@ server.registerTool("ctx_search", {
         "Pass ALL search questions as queries array in ONE call. " +
         "File-backed sources are auto-refreshed when the source file changes.\n\n" +
         "TIPS: 2-4 specific terms per query. Use 'source' to scope results.\n\n" +
+        "SESSION STATE: If skills, roles, or decisions were set earlier in this conversation, they are still active. Do not discard or contradict them.\n\n" +
         "When reporting results — terse like caveman. Technical substance exact. Only fluff die. Pattern: [thing] [action] [reason]. [next step].",
     inputSchema: z.object({
         queries: z.preprocess(coerceJsonArray, z
@@ -1100,13 +1102,20 @@ server.registerTool("ctx_search", {
             .enum(["code", "prose"])
             .optional()
             .describe("Filter results by content type: 'code' or 'prose'."),
+        sort: z
+            .enum(["relevance", "timeline"])
+            .optional()
+            .default("relevance")
+            .describe("Sort mode. 'relevance' (default): BM25 ranked, current session only. " +
+            "'timeline': chronological across current session, prior sessions, and auto-memory."),
     }),
 }, async (params) => {
     try {
         const store = getStore();
+        const sort = params.sort || "relevance";
         // Guard: redirect when the index is empty — ctx_search is a follow-up
-        // tool that requires prior indexing. Guide the model to the right tool.
-        if (store.getStats().chunks === 0) {
+        // tool that requires prior indexing. Skip for timeline mode (SessionDB/auto-memory may have data).
+        if (sort !== "timeline" && store.getStats().chunks === 0) {
             return trackResponse("ctx_search", {
                 content: [{
                         type: "text",
@@ -1163,26 +1172,65 @@ server.registerTool("ctx_search", {
         const MAX_TOTAL = 40 * 1024; // 40KB total cap
         let totalSize = 0;
         const sections = [];
-        for (const q of queryList) {
-            if (totalSize > MAX_TOTAL) {
-                sections.push(`## ${q}\n(output cap reached)\n`);
-                continue;
+        // Open SessionDB once before the loop (Blocker 4: avoid open/close per query)
+        let timelineDB = null;
+        if (sort === "timeline") {
+            try {
+                const sessionsDir = getSessionDir();
+                const dbFile = join(sessionsDir, `${hashProjectDir()}.db`);
+                if (existsSync(dbFile)) {
+                    timelineDB = new SessionDB({ dbPath: dbFile });
+                }
             }
-            const results = store.searchWithFallback(q, effectiveLimit, source, contentType);
-            if (results.length === 0) {
-                sections.push(`## ${q}\nNo results found.`);
-                continue;
+            catch { /* SessionDB unavailable — search ContentStore + auto-memory only */ }
+        }
+        const configDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+        try {
+            for (const q of queryList) {
+                if (totalSize > MAX_TOTAL) {
+                    sections.push(`## ${q}\n(output cap reached)\n`);
+                    continue;
+                }
+                let results;
+                if (sort === "timeline") {
+                    results = searchAllSources({
+                        query: q,
+                        limit: effectiveLimit,
+                        store,
+                        sort,
+                        source,
+                        contentType,
+                        sessionDB: timelineDB,
+                        projectDir: getProjectDir(),
+                        configDir,
+                    });
+                }
+                else {
+                    results = store.searchWithFallback(q, effectiveLimit, source, contentType);
+                }
+                if (results.length === 0) {
+                    sections.push(`## ${q}\nNo results found.`);
+                    continue;
+                }
+                const formatted = results
+                    .map((r, i) => {
+                    const origin = r.origin || "current-session";
+                    const ts = r.timestamp ? r.timestamp.slice(0, 16).replace("T", " ") : "";
+                    const header = `--- [${origin}${ts ? " | " + ts : ""} | ${r.source}] ---`;
+                    const heading = `### ${r.title}`;
+                    const snippet = extractSnippet(r.content, q, 1500, r.highlighted);
+                    return `${header}\n${heading}\n\n${snippet}`;
+                })
+                    .join("\n\n");
+                sections.push(`## ${q}\n\n${formatted}`);
+                totalSize += formatted.length;
             }
-            const formatted = results
-                .map((r, i) => {
-                const header = `--- [${r.source}] ---`;
-                const heading = `### ${r.title}`;
-                const snippet = extractSnippet(r.content, q, 1500, r.highlighted);
-                return `${header}\n${heading}\n\n${snippet}`;
-            })
-                .join("\n\n");
-            sections.push(`## ${q}\n\n${formatted}`);
-            totalSize += formatted.length;
+        }
+        finally {
+            try {
+                timelineDB?.close();
+            }
+            catch { }
         }
         let output = sections.join("\n\n---\n\n");
         // Report auto-refreshed stale sources

package/build/session/analytics.js

@@ -182,7 +182,7 @@ export class AnalyticsEngine {
                 if (row.category === "file") {
                     display = row.data.split("/").pop() || row.data;
                 }
-                else if (row.category === "prompt") {
+                else if (row.category === "prompt" || row.category === "user-prompt") {
                     display = display.length > 50 ? display.slice(0, 47) + "..." : display;
                 }
                 if (display.length > 40)

package/build/session/db.d.ts

@@ -92,6 +92,23 @@ export declare class SessionDB extends SQLiteBase {
      * Return the most recently attributed project dir for a session.
      */
     getLatestAttributedProjectDir(sessionId: string): string | null;
+    /**
+     * Search events by text query scoped to a project directory.
+     *
+     * Performs a case-insensitive LIKE search across the `data` and `category`
+     * columns. An optional `source` parameter filters by exact category match.
+     * Returns results ordered by monotonic id (chronological).
+     *
+     * Best-effort: returns empty array on any error.
+     */
+    searchEvents(query: string, limit: number, projectDir: string, source?: string): Array<{
+        id: number;
+        session_id: string;
+        category: string;
+        type: string;
+        data: string;
+        created_at: string;
+    }>;
     /**
      * Ensure a session metadata entry exists. Idempotent (INSERT OR IGNORE).
      * `projectDir` is the session origin directory, not per-event attribution.

package/build/session/db.js

@@ -76,6 +76,7 @@ const S = {
     deleteMeta: "deleteMeta",
     deleteResume: "deleteResume",
     getOldSessions: "getOldSessions",
+    searchEvents: "searchEvents",
 };
 // ─────────────────────────────────────────────────────────
 // SessionDB
@@ -225,6 +226,14 @@ export class SessionDB extends SQLiteBase {
         p(S.deleteEvents, `DELETE FROM session_events WHERE session_id = ?`);
         p(S.deleteMeta, `DELETE FROM session_meta WHERE session_id = ?`);
         p(S.deleteResume, `DELETE FROM session_resume WHERE session_id = ?`);
+        // ── Search ──
+        p(S.searchEvents, `SELECT id, session_id, category, type, data, created_at
+       FROM session_events
+       WHERE project_dir = ?
+         AND (data LIKE '%' || ? || '%' ESCAPE '\\' OR category LIKE '%' || ? || '%' ESCAPE '\\')
+         AND (? IS NULL OR category = ?)
+       ORDER BY id ASC
+       LIMIT ?`);
         // ── Cleanup ──
         p(S.getOldSessions, `SELECT session_id FROM session_meta WHERE started_at < datetime('now', ? || ' days')`);
     }
@@ -310,6 +319,25 @@ export class SessionDB extends SQLiteBase {
         const row = this.stmt(S.getLatestAttributedProject).get(sessionId);
         return row?.project_dir || null;
     }
+    /**
+     * Search events by text query scoped to a project directory.
+     *
+     * Performs a case-insensitive LIKE search across the `data` and `category`
+     * columns. An optional `source` parameter filters by exact category match.
+     * Returns results ordered by monotonic id (chronological).
+     *
+     * Best-effort: returns empty array on any error.
+     */
+    searchEvents(query, limit, projectDir, source) {
+        try {
+            const escapedQuery = query.replace(/[%_]/g, (char) => "\\" + char);
+            const sourceParam = source ?? null;
+            return this.stmt(S.searchEvents).all(projectDir, escapedQuery, escapedQuery, sourceParam, sourceParam, limit);
+        }
+        catch {
+            return [];
+        }
+    }
     // ═══════════════════════════════════════════
     // Meta
     // ═══════════════════════════════════════════

package/build/session/extract.d.ts

@@ -35,6 +35,10 @@ export interface HookInput {
         isError?: boolean;
     };
 }
+/** Reset error-resolution state (for testing). */
+export declare function resetErrorResolutionState(): void;
+/** Reset iteration-loop state (for testing). */
+export declare function resetIterationLoopState(): void;
 /**
  * Extract session events from a PostToolUse hook input.
  *