context-mode 1.0.142 → 1.0.144

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.142",
+  "version": "1.0.144",
   "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/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.142",
+  "version": "1.0.144",
   "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.142",
+  "version": "1.0.144",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.142",
+  "version": "1.0.144",
   "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/adapters/pi/mcp-bridge.js

@@ -92,10 +92,16 @@ export function resolveJsRuntimeForBridge(deps = {}) {
         return execPath;
     return null;
 }
+// Bridge-imposed timeout for protocol-handshake methods (initialize,
+// tools/list). These MUST be bounded: a server that never replies to
+// initialize would otherwise block Pi's bridge bootstrap indefinitely.
+// `tools/call` deliberately has NO bridge ceiling (#643) — long-running
+// ctx_execute (test suites, builds, cargo test) was rejected by a 120s
+// hardcoded bound even though the executor child would have finished.
+// Responsibility for bounding a tool call belongs to the executor
+// layer (per-tool timeout / background mode / Pi-level cancel), not
+// to the transport.
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
-// Tools/call may run shell commands or fetch URLs — wider window than
-// initialize/list, but still bounded so a hung server can't block Pi.
-const DEFAULT_CALL_TIMEOUT_MS = 120_000;
 class PiTextComponent {
     text;
     constructor(text = "") {
@@ -349,19 +355,29 @@ export class MCPStdioClient {
             throw new Error("MCP client not started");
         const id = ++this.requestId;
         return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                if (!this.pending.has(id))
-                    return;
-                this.pending.delete(id);
-                reject(new Error(`MCP request timeout after ${timeoutMs}ms: ${method}`));
-            }, timeoutMs);
+            // Gate the timer on a finite ms value so callers can pass
+            // `Number.POSITIVE_INFINITY` to mean "no bridge ceiling" (#643).
+            // Node coerces both `undefined` and `Infinity` to a 1ms delay
+            // (TimeoutOverflowWarning), so we can't just pass them through —
+            // we must skip the setTimeout entirely. tools/call uses this path
+            // because long-running ctx_execute must not be bounded here.
+            const timer = Number.isFinite(timeoutMs)
+                ? setTimeout(() => {
+                    if (!this.pending.has(id))
+                        return;
+                    this.pending.delete(id);
+                    reject(new Error(`MCP request timeout after ${timeoutMs}ms: ${method}`));
+                }, timeoutMs)
+                : null;
             this.pending.set(id, {
                 resolve: (v) => {
-                    clearTimeout(timer);
+                    if (timer)
+                        clearTimeout(timer);
                     resolve(v);
                 },
                 reject: (e) => {
-                    clearTimeout(timer);
+                    if (timer)
+                        clearTimeout(timer);
                     reject(e);
                 },
             });
@@ -445,7 +461,15 @@ export class MCPStdioClient {
         // one layer covers `listTools` / `initialize` paths too, with a
         // single-flight guard against orphan child processes from
         // concurrent callers.
-        return this.request("tools/call", { name, arguments: args ?? {} }, DEFAULT_CALL_TIMEOUT_MS);
+        //
+        // No bridge-imposed timeout for tools/call (#643). The previous
+        // 120s ceiling rejected legitimate long-running ctx_execute calls
+        // (test suites, builds, large `cargo test`) even though the
+        // executor child would have finished. Bounding belongs to the
+        // executor layer (per-tool timeout / background mode / Pi cancel),
+        // not the transport. `Number.POSITIVE_INFINITY` instructs
+        // `request()` to skip the setTimeout entirely — see the gate there.
+        return this.request("tools/call", { name, arguments: args ?? {} }, Number.POSITIVE_INFINITY);
     }
     /**
      * Respawn the MCP child after an exit (clean shutdown or crash).

package/build/db-base.js

@@ -266,7 +266,18 @@ export function loadDatabase() {
                     const raw = new DatabaseSync(path, {
                         readOnly: opts?.readonly ?? false,
                     });
-                    return new NodeSQLiteAdapter(raw);
+                    const adapter = new NodeSQLiteAdapter(raw);
+                    // Propagate busy_timeout — node:sqlite's DatabaseSync constructor
+                    // silently ignores `{ timeout }` (unlike better-sqlite3's native
+                    // C++ constructor), so we set it via PRAGMA, mirroring the Bun
+                    // branch above. Without this, the default is 0 and the first
+                    // write contention surfaces as immediate `SQLITE_BUSY`/`database
+                    // is locked` — defeating the 30s grace `withRetry()` is built
+                    // around. See issue #642 and ADR-0001 (multi-writer contract).
+                    if (opts?.timeout) {
+                        adapter.pragma(`busy_timeout = ${opts.timeout}`);
+                    }
+                    return adapter;
                 };
             }
             else {

package/build/openclaw-plugin.d.ts

@@ -0,0 +1,130 @@
+/**
+ * OpenClaw TypeScript plugin entry point for context-mode.
+ *
+ * Exports an object with { id, name, configSchema, register(api) } for
+ * declarative metadata and config validation before code execution.
+ *
+ * register(api) registers:
+ *   - before_tool_call hook   — Routing enforcement (deny/modify/passthrough)
+ *   - after_tool_call hook    — Session event capture
+ *   - command:new hook         — Session initialization and cleanup
+ *   - session_start hook             — Re-key DB session to OpenClaw's session ID
+ *   - before_compaction hook         — Flush events to resume snapshot
+ *   - after_compaction hook          — Increment compact count
+ *   - before_prompt_build (p=10)  — Resume snapshot injection into system context
+ *   - before_prompt_build (p=5)   — Routing instruction injection into system context
+ *   - context-mode engine      — Context engine with compaction management
+ *   - /ctx-stats command       — Auto-reply command for session statistics
+ *   - /ctx-doctor command      — Auto-reply command for diagnostics
+ *   - /ctx-upgrade command     — Auto-reply command for upgrade
+ *
+ * Loaded by OpenClaw via: openclaw.extensions entry in package.json
+ *
+ * OpenClaw plugin paradigm:
+ *   - Plugins export { id, name, configSchema, register(api) } for metadata
+ *   - api.registerHook() for event-driven hooks
+ *   - api.on() for typed lifecycle hooks
+ *   - api.registerContextEngine() for compaction ownership
+ *   - api.registerCommand() for auto-reply slash commands
+ *   - Plugins run in-process with the Gateway (trusted code)
+ */
+import type { OpenClawToolDef } from "./openclaw/mcp-tools.js";
+/** Context for auto-reply command handlers. */
+interface CommandContext {
+    senderId?: string;
+    channel?: string;
+    isAuthorizedSender?: boolean;
+    args?: string;
+    commandBody?: string;
+    config?: Record<string, unknown>;
+}
+/** OpenClaw plugin API provided to the register function. */
+interface OpenClawPluginApi {
+    registerHook(event: string, handler: (...args: unknown[]) => unknown, meta: {
+        name: string;
+        description: string;
+    }): void;
+    /**
+     * Register a typed lifecycle hook.
+     * Supported names: "session_start", "before_compaction", "after_compaction",
+     * "before_prompt_build"
+     */
+    on(event: string, handler: (...args: unknown[]) => unknown, opts?: {
+        priority?: number;
+    }): void;
+    registerContextEngine(id: string, factory: () => ContextEngineInstance): void;
+    registerCommand?(cmd: {
+        name: string;
+        description: string;
+        acceptsArgs?: boolean;
+        requireAuth?: boolean;
+        handler: (ctx: CommandContext) => {
+            text: string;
+        } | Promise<{
+            text: string;
+        }>;
+    }): void;
+    registerCli?(factory: (ctx: {
+        program: unknown;
+    }) => void, meta: {
+        commands: string[];
+    }): void;
+    /**
+     * Register an agent tool (OpenClaw native registerTool) — see
+     * refs/platforms/openclaw/docs/plugins/building-plugins.md:116. Optional in
+     * the type so we degrade silently on legacy hosts that pre-date this API.
+     */
+    registerTool?(tool: OpenClawToolDef, opts?: {
+        optional?: boolean;
+    }): void;
+    logger?: {
+        info: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+        debug?: (...args: unknown[]) => void;
+        warn?: (...args: unknown[]) => void;
+    };
+}
+/** Context engine instance returned by the factory. */
+interface ContextEngineInstance {
+    info: {
+        id: string;
+        name: string;
+        ownsCompaction: boolean;
+    };
+    ingest(data: unknown): Promise<{
+        ingested: boolean;
+    }>;
+    assemble(ctx: {
+        messages: unknown[];
+    }): Promise<{
+        messages: unknown[];
+        estimatedTokens: number;
+    }>;
+    compact(): Promise<{
+        ok: boolean;
+        compacted: boolean;
+    }>;
+}
+/**
+ * OpenClaw plugin definition. The object form provides declarative metadata
+ * (id, name, configSchema) that OpenClaw can read without executing code.
+ * register() is called once per agent session with a fresh api object.
+ * Each call creates isolated closures (db, sessionId, hooks) — no shared state.
+ */
+declare const _default: {
+    id: string;
+    name: string;
+    configSchema: {
+        type: "object";
+        properties: {
+            enabled: {
+                type: "boolean";
+                default: boolean;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    register(api: OpenClawPluginApi): void;
+};
+export default _default;