context-mode 1.0.98 → 1.0.100

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.98"
+    "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.98",
+      "version": "1.0.100",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.98",
+  "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.98",
+  "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.98",
+  "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/README.md

@@ -523,12 +523,14 @@ Full documentation: [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md)
      "hooks": {
        "PreToolUse": [{ "matcher": "local_shell|shell|shell_command|exec_command|container.exec|Bash|Shell|grep_files|mcp__plugin_context-mode_context-mode__ctx_execute|mcp__plugin_context-mode_context-mode__ctx_execute_file|mcp__plugin_context-mode_context-mode__ctx_batch_execute", "hooks": [{ "type": "command", "command": "context-mode hook codex pretooluse" }] }],
        "PostToolUse": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex posttooluse" }] }],
-       "SessionStart": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex sessionstart" }] }]
+       "SessionStart": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex sessionstart" }] }],
+       "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex userpromptsubmit" }] }],
+       "Stop": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex stop" }] }]
      }
    }
    ```
 
-   `PreToolUse` enforces deny/block routing today and is prepared for input rewrites once Codex supports them. `PostToolUse` captures session events. `SessionStart` restores state after compaction.
+   `PreToolUse` enforces deny/block routing today and is prepared for input rewrites once Codex supports them. `PostToolUse` captures session events. `SessionStart` restores state after compaction. `UserPromptSubmit` captures user decisions and corrections. `Stop` records turn-end state.
 
    > **Note:** Codex PreToolUse routing currently supports deny rules only (blocks dangerous commands). It still needs upstream `updatedInput` support before context-mode can rewrite tool input; track [openai/codex#18491](https://github.com/openai/codex/issues/18491). Context injection (`additionalContext`) is not supported in Codex PreToolUse — it works via PostToolUse and SessionStart instead. This is handled automatically.
 
@@ -912,12 +914,12 @@ Session continuity requires 4 hooks working together:
 |---|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
 | **PreToolUse** | Enforces sandbox routing before tool execution | Yes | -- | -- | -- | Yes | -- | -- | -- | Yes | -- | Yes | -- | ✓ (via tool_call event) |
 | **PostToolUse** | Captures events after each tool call | Yes | Yes | Yes | Yes | Yes | Plugin | Plugin | Plugin | Yes | -- | Yes | -- | ✓ (via tool_result event) |
-| **UserPromptSubmit** | Captures user decisions and corrections | Yes | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- |
+| **UserPromptSubmit** | Captures user decisions and corrections | Yes | -- | -- | -- | -- | -- | -- | -- | Yes | -- | -- | -- | -- |
 | **PreCompact** | Builds snapshot before compaction | Yes | Yes | Yes | Yes | -- | Plugin | Plugin | Plugin | -- | -- | -- | -- | ✓ (via session_before_compact) |
 | **SessionStart** | Restores state after compaction or resume | Yes | Yes | Yes | Yes | -- | -- | -- | Plugin | Yes | -- | -- | -- | ✓ (via session_start event) |
 | | **Session completeness** | **Full** | **High** | **High** | **High** | **Partial** | **High** | **High** | **High** | **Partial** | **--** | **Partial** | **--** | **High** |
 
-> **Note:** Full session continuity (capture + snapshot + restore) works on **Claude Code**, **Gemini CLI**, **VS Code Copilot**, and **JetBrains Copilot**. **OpenCode** provides **high** session continuity: it captures tool events and injects compaction snapshots via the plugin, but SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), so startup/resume restore is not supported. **KiloCode** shares the same plugin architecture as OpenCode via the OpenCodeAdapter, so its continuity level depends on KiloCode's SessionStart support. **Cursor** captures tool events via `preToolUse`/`postToolUse`, but `sessionStart` is currently rejected by Cursor's validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)), so session restore after compaction is not available yet. **OpenClaw** uses native gateway plugin hooks (`api.on()`) for full session continuity. **Pi Coding Agent** provides high session continuity via extension hooks (`tool_call`, `tool_result`, `session_start`, `session_before_compact`). **Codex CLI** provides partial hook-based session tracking through PreToolUse, PostToolUse, and SessionStart; MCP tools work. **Antigravity**, **Kiro**, and **Zed** have no hook support in the current release, so session tracking is not available.
+> **Note:** Full session continuity (capture + snapshot + restore) works on **Claude Code**, **Gemini CLI**, **VS Code Copilot**, and **JetBrains Copilot**. **OpenCode** provides **high** session continuity: it captures tool events and injects compaction snapshots via the plugin, but SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), so startup/resume restore is not supported. **KiloCode** shares the same plugin architecture as OpenCode via the OpenCodeAdapter, so its continuity level depends on KiloCode's SessionStart support. **Cursor** captures tool events via `preToolUse`/`postToolUse`, but `sessionStart` is currently rejected by Cursor's validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)), so session restore after compaction is not available yet. **OpenClaw** uses native gateway plugin hooks (`api.on()`) for full session continuity. **Pi Coding Agent** provides high session continuity via extension hooks (`tool_call`, `tool_result`, `session_start`, `session_before_compact`). **Codex CLI** provides partial hook-based session tracking through PreToolUse, PostToolUse, SessionStart, UserPromptSubmit, and Stop; MCP tools work. **Antigravity**, **Kiro**, and **Zed** have no hook support in the current release, so session tracking is not available.
 
 <details>
 <summary><strong>What gets captured</strong></summary>
@@ -979,7 +981,7 @@ After compaction, the model receives a **Session Guide** — a structured narrat
 - **Session Intent** — mode classification (implement, investigate, review, discuss)
 - **User Role** — behavioral directives set during the session
 
-Detailed event data is also indexed into FTS5 for on-demand retrieval via `search()`.
+Detailed event data is also indexed into FTS5 for on-demand retrieval via `ctx_search()`.
 
 </details>
 
@@ -1002,7 +1004,7 @@ Detailed event data is also indexed into FTS5 for on-demand retrieval via `searc
 
 **OpenClaw / Pi Agent** — High coverage. All tool lifecycle hooks (`after_tool_call`, `before_compaction`, `session_start`) fire via the native gateway plugin. User decisions aren't captured but file edits, git ops, errors, and tasks are fully tracked. Falls back to DB snapshot reconstruction if compaction hooks fail on older gateway versions. See [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md).
 
-**Codex CLI** — MCP active, hooks stable. Hook scripts (PreToolUse, PostToolUse, SessionStart) are implemented and tested. PreToolUse deny routing works; input rewriting still depends on upstream `updatedInput` support ([openai/codex#18491](https://github.com/openai/codex/issues/18491)).
+**Codex CLI** — MCP active, hooks stable. Hook scripts (PreToolUse, PostToolUse, SessionStart, UserPromptSubmit, Stop) are implemented and tested. PreToolUse deny routing works; input rewriting still depends on upstream `updatedInput` support ([openai/codex#18491](https://github.com/openai/codex/issues/18491)).
 
 **Antigravity** — No session support. No hooks, no event capture. Requires manually copying `GEMINI.md` to your project root. Auto-detected via MCP protocol handshake (`clientInfo.name`).
 
@@ -1035,7 +1037,7 @@ Detailed event data is also indexed into FTS5 for on-demand retrieval via `searc
 >
 > **OpenClaw** runs context-mode as a native gateway plugin targeting Pi Agent sessions. Hooks register via `api.on()` (tool/lifecycle) and `api.registerHook()` (commands). All tool interception and compaction hooks are supported. See [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md).
 >
-> **Codex CLI** hooks are stable. MCP tools work, and hook scripts activate through `~/.codex/hooks.json`. PreToolUse supports `permissionDecision: "deny"` only; input modification still needs upstream `updatedInput` support ([openai/codex#18491](https://github.com/openai/codex/issues/18491)). `additionalContext` is not supported in PreToolUse (context injection works via PostToolUse and SessionStart instead; the codex formatter handles this automatically). See the Codex install section for setup. **Antigravity** and **Zed** do not support hooks. They rely solely on manually-copied routing instruction files (`AGENTS.md` / `GEMINI.md`) for enforcement (~60% compliance). See each platform's install section for copy instructions. Antigravity and Zed are auto-detected via MCP protocol handshake — no manual platform configuration needed.
+> **Codex CLI** hooks are stable. MCP tools work, and hook scripts activate through `~/.codex/hooks.json`. PreToolUse supports `permissionDecision: "deny"` only; input modification still needs upstream `updatedInput` support ([openai/codex#18491](https://github.com/openai/codex/issues/18491)). `additionalContext` is not supported in PreToolUse (context injection works via PostToolUse and SessionStart instead; the codex formatter handles this automatically). UserPromptSubmit and Stop capture prompt and turn-end continuity events. See the Codex install section for setup. **Antigravity** and **Zed** do not support hooks. They rely solely on manually-copied routing instruction files (`AGENTS.md` / `GEMINI.md`) for enforcement (~60% compliance). See each platform's install section for copy instructions. Antigravity and Zed are auto-detected via MCP protocol handshake — no manual platform configuration needed.
 >
 > **Kiro** supports native `preToolUse` and `postToolUse` hooks for routing enforcement and tool event capture. `agentSpawn` (SessionStart equivalent) and `stop` are not yet wired. Requires manually copying `KIRO.md` to your project root. Kiro is auto-detected via MCP protocol handshake (`clientInfo.name`).
 >

package/build/adapters/claude-code-base.js

@@ -26,7 +26,7 @@ export class ClaudeCodeBaseAdapter extends BaseAdapter {
             toolName: input.tool_name ?? "",
             toolInput: input.tool_input ?? {},
             sessionId: this.extractSessionId(input),
-            projectDir: process.env[this.projectDirEnvVar],
+            projectDir: process.env[this.projectDirEnvVar] ?? process.cwd(),
             raw,
         };
     }
@@ -38,7 +38,7 @@ export class ClaudeCodeBaseAdapter extends BaseAdapter {
             toolOutput: input.tool_output,
             isError: input.is_error,
             sessionId: this.extractSessionId(input),
-            projectDir: process.env[this.projectDirEnvVar],
+            projectDir: process.env[this.projectDirEnvVar] ?? process.cwd(),
             raw,
         };
     }
@@ -46,7 +46,7 @@ export class ClaudeCodeBaseAdapter extends BaseAdapter {
         const input = raw;
         return {
             sessionId: this.extractSessionId(input),
-            projectDir: process.env[this.projectDirEnvVar],
+            projectDir: process.env[this.projectDirEnvVar] ?? process.cwd(),
             raw,
         };
     }
@@ -70,7 +70,7 @@ export class ClaudeCodeBaseAdapter extends BaseAdapter {
         return {
             sessionId: this.extractSessionId(input),
             source,
-            projectDir: process.env[this.projectDirEnvVar],
+            projectDir: process.env[this.projectDirEnvVar] ?? process.cwd(),
             raw,
         };
     }

package/build/adapters/codex/index.js

@@ -182,6 +182,28 @@ export class CodexAdapter extends BaseAdapter {
                     ],
                 },
             ],
+            UserPromptSubmit: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `node ${pluginRoot}/hooks/codex/userpromptsubmit.mjs`,
+                        },
+                    ],
+                },
+            ],
+            Stop: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `node ${pluginRoot}/hooks/codex/stop.mjs`,
+                        },
+                    ],
+                },
+            ],
         };
     }
     readSettings() {
@@ -208,7 +230,7 @@ export class CodexAdapter extends BaseAdapter {
             {
                 check: "Hook support",
                 status: "pass",
-                message: "Codex CLI hooks are stable. Configure ~/.codex/hooks.json for PreToolUse, PostToolUse, and SessionStart.",
+                message: "Codex CLI hooks are stable. Configure ~/.codex/hooks.json for PreToolUse, PostToolUse, SessionStart, UserPromptSubmit, and Stop.",
             },
         ];
     }

package/build/adapters/qwen-code/index.d.ts

@@ -27,7 +27,7 @@ export declare class QwenCodeAdapter extends ClaudeCodeBaseAdapter implements Ho
     validateHooks(_pluginRoot: string): DiagnosticResult[];
     checkPluginRegistration(): DiagnosticResult;
     getInstalledVersion(): string;
-    configureAllHooks(_pluginRoot: string): string[];
+    configureAllHooks(pluginRoot: string): string[];
     setHookPermissions(_pluginRoot: string): string[];
     updatePluginRegistry(_pluginRoot: string, _version: string): void;
     getRoutingInstructionsConfig(): {

package/build/adapters/qwen-code/index.js

@@ -12,7 +12,7 @@
  *   - MCP clientInfo: qwen-cli-mcp-client-* (pattern)
  *   - 12 hook events (superset of Claude's 5, but context-mode uses the shared 5)
  */
-import { readFileSync, } from "node:fs";
+import { readFileSync, existsSync, } from "node:fs";
 import { resolve, join } from "node:path";
 import { homedir } from "node:os";
 import { ClaudeCodeBaseAdapter } from "../claude-code-base.js";
@@ -63,7 +63,7 @@ export class QwenCodeAdapter extends ClaudeCodeBaseAdapter {
             ],
             PostToolUse: [
                 {
-                    matcher: "",
+                    matcher: "run_shell_command|read_file|write_file|edit|glob|grep_search|todo_write|agent|ask_user_question|mcp__",
                     hooks: [
                         { type: "command", command: `node ${pluginRoot}/hooks/posttooluse.mjs` },
                     ],
@@ -162,10 +162,116 @@ export class QwenCodeAdapter extends ClaudeCodeBaseAdapter {
         }
     }
     getInstalledVersion() {
+        const settings = this.readSettings();
+        if (!settings)
+            return "not installed";
+        const hooks = settings.hooks;
+        if (!hooks)
+            return "not installed";
+        // Check if any hook type has context-mode scripts configured
+        const contextModeScripts = [
+            "pretooluse.mjs",
+            "posttooluse.mjs",
+            "precompact.mjs",
+            "sessionstart.mjs",
+            "userpromptsubmit.mjs",
+        ];
+        for (const [, entries] of Object.entries(hooks)) {
+            if (!Array.isArray(entries))
+                continue;
+            for (const entry of entries) {
+                const e = entry;
+                if (e.hooks?.some((h) => h.command && contextModeScripts.some((s) => h.command.includes(s)))) {
+                    return "installed (hooks configured)";
+                }
+            }
+        }
         return "not installed";
     }
-    configureAllHooks(_pluginRoot) {
-        return [];
+    configureAllHooks(pluginRoot) {
+        const settings = this.readSettings() ?? {};
+        const hooks = (settings.hooks ?? {});
+        const changes = [];
+        // ── Phase 1: Clean stale context-mode hooks ──────────
+        // After an upgrade, settings.json may contain hardcoded paths
+        // pointing to deleted version directories. Remove those.
+        for (const hookType of Object.keys(hooks)) {
+            const entries = hooks[hookType];
+            if (!Array.isArray(entries))
+                continue;
+            const filtered = entries.filter((entry) => {
+                const e = entry;
+                const commands = e.hooks ?? [];
+                // Preserve entries that are not context-mode hooks
+                const isContextMode = commands.some((h) => h.command && /context-mode|pretooluse|posttooluse|precompact|sessionstart|userpromptsubmit/i.test(h.command));
+                if (!isContextMode)
+                    return true;
+                // For context-mode hooks, check if referenced script files exist
+                return commands.every((h) => {
+                    if (!h.command)
+                        return true;
+                    // Extract path from "node /path/to/script.mjs" format
+                    const match = h.command.match(/node\s+"?([^"]+\.mjs)"?/);
+                    if (!match)
+                        return true; // CLI dispatcher format, always valid
+                    return existsSync(match[1]);
+                });
+            });
+            const removed = entries.length - filtered.length;
+            if (removed > 0) {
+                hooks[hookType] = filtered;
+                changes.push(`Removed ${removed} stale ${hookType} hook(s)`);
+            }
+        }
+        // ── Phase 2: Register fresh hooks ────────────────────
+        const hookTypes = [
+            {
+                name: "PreToolUse",
+                script: "pretooluse.mjs",
+                matcher: [
+                    "run_shell_command", "read_file", "read_many_files", "grep_search",
+                    "web_fetch", "agent",
+                    "mcp__plugin_context-mode_context-mode__ctx_execute",
+                    "mcp__plugin_context-mode_context-mode__ctx_execute_file",
+                    "mcp__plugin_context-mode_context-mode__ctx_batch_execute",
+                ].join("|"),
+            },
+            {
+                name: "SessionStart",
+                script: "sessionstart.mjs",
+                matcher: "",
+            },
+        ];
+        for (const { name, script, matcher } of hookTypes) {
+            const entry = {
+                matcher,
+                hooks: [{ type: "command", command: `node ${pluginRoot}/hooks/${script}` }],
+            };
+            const existing = hooks[name];
+            if (existing && Array.isArray(existing)) {
+                // Replace existing context-mode entry or append
+                const idx = existing.findIndex((e) => {
+                    const typed = e;
+                    return typed.hooks?.some((h) => h.command?.includes(script)) ?? false;
+                });
+                if (idx >= 0) {
+                    existing[idx] = entry;
+                    changes.push(`Updated ${name} hook`);
+                }
+                else {
+                    existing.push(entry);
+                    changes.push(`Added ${name} hook`);
+                }
+                hooks[name] = existing;
+            }
+            else {
+                hooks[name] = [entry];
+                changes.push(`Created ${name} hooks`);
+            }
+        }
+        settings.hooks = hooks;
+        this.writeSettings(settings);
+        return changes;
     }
     setHookPermissions(_pluginRoot) {
         return [];

package/build/cli.js

@@ -55,6 +55,8 @@ const HOOK_MAP = {
         pretooluse: "hooks/codex/pretooluse.mjs",
         posttooluse: "hooks/codex/posttooluse.mjs",
         sessionstart: "hooks/codex/sessionstart.mjs",
+        userpromptsubmit: "hooks/codex/userpromptsubmit.mjs",
+        stop: "hooks/codex/stop.mjs",
     },
     "kiro": {
         pretooluse: "hooks/kiro/pretooluse.mjs",

package/build/opencode-plugin.js

@@ -27,7 +27,7 @@ import { buildResumeSnapshot } from "./session/snapshot.js";
 import { OpenCodeAdapter } from "./adapters/opencode/index.js";
 // ── Helpers ───────────────────────────────────────────────
 function getPlatform() {
-    return process.env.KILO ? "kilo" : "opencode";
+    return process.env.KILO_PID ? "kilo" : "opencode";
 }
 // ── Plugin Factory ────────────────────────────────────────
 /**

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);
+}