context-mode 1.0.105 → 1.0.106

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.105",
+  "version": "1.0.106",
   "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/opencode-plugin.js

@@ -20,11 +20,27 @@
  */
 import { dirname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
 import { SessionDB } from "./session/db.js";
 import { extractEvents } from "./session/extract.js";
 import { buildResumeSnapshot } from "./session/snapshot.js";
 import { OpenCodeAdapter } from "./adapters/opencode/index.js";
 import { PLATFORM_ENV_VARS } from "./adapters/detect.js";
+// Read package.json version once at module load (not on every hook call).
+// Used in the resume-injection visible signal so users can confirm in
+// OPENCODE_DEBUG logs which plugin version actually injected.
+const VERSION = (() => {
+    try {
+        const pkgRoot = dirname(fileURLToPath(import.meta.url));
+        for (const rel of ["../package.json", "./package.json"]) {
+            const p = resolve(pkgRoot, rel);
+            if (existsSync(p))
+                return JSON.parse(readFileSync(p, "utf8")).version ?? "unknown";
+        }
+    }
+    catch { /* fall through */ }
+    return "unknown";
+})();
 // ── Helpers ───────────────────────────────────────────────
 /**
  * Detect whether the plugin is running under KiloCode or OpenCode.
@@ -166,12 +182,21 @@ async function createContextModePlugin(ctx) {
                 return;
             if (resumeInjected.has(sessionId))
                 return;
-            resumeInjected.add(sessionId);
             try {
-                const row = db.claimLatestUnconsumedResume();
+                // Pass current sessionId so SQL excludes self-injection (v1.0.106 — Mickey #376
+                // follow-up): if Session B compacts mid-flight and produces its own row,
+                // B's next system.transform must NOT claim that row back into B's prompt.
+                const row = db.claimLatestUnconsumedResume(sessionId);
                 if (!row || !row.snapshot)
-                    return;
+                    return; // no row → leave `resumeInjected` unset → retry on next turn
                 if (Array.isArray(output?.system)) {
+                    // Visible signal — without this, the injection is silent and users
+                    // cannot tell the feature is active (Mickey: "I can't find use case
+                    // for it"). The XML comment is harmless to the model and shows up in
+                    // OPENCODE_DEBUG logs as proof the snapshot landed.
+                    const eventCount = row.snapshot.match(/events="(\d+)"/)?.[1] ?? "?";
+                    const marker = `<!-- context-mode v${VERSION}: resumed prior session ${row.sessionId.slice(0, 8)} ` +
+                        `(${eventCount} events, ${row.snapshot.length} chars) -->\n`;
                     // Insert at index 1 (after the header) — NOT unshift.
                     // OpenCode's llm.ts:117-128 saves `header = system[0]` BEFORE this
                     // hook runs and then folds the rest into a 2-part structure
@@ -182,7 +207,9 @@ async function createContextModePlugin(ctx) {
                     // provider prompt cache is invalidated on every resume injection.
                     // Inserting at index 1 keeps the header invariant and lets the
                     // snapshot ride along inside the cached body block.
-                    output.system.splice(1, 0, row.snapshot);
+                    output.system.splice(1, 0, marker + row.snapshot);
+                    // Mark consumed only AFTER successful splice so failed paths can retry
+                    resumeInjected.add(sessionId);
                 }
             }
             catch {

package/build/server.js

@@ -2805,9 +2805,17 @@ async function main() {
         }
     }
     catch { /* best effort — _detectedAdapter stays null, falls back to .claude */ }
-    // Non-blocking version check — result stored for trackResponse warnings
+    // Non-blocking version check — result stored for trackResponse warnings.
+    // First fetch at startup, then refresh every hour so long-running sessions
+    // (some users keep the MCP server alive 24h+) catch new releases without a
+    // restart. `.unref()` lets the process exit normally on SIGTERM regardless
+    // of pending intervals.
     fetchLatestVersion().then(v => { if (v !== "unknown")
         _latestVersion = v; });
+    setInterval(() => {
+        fetchLatestVersion().then(v => { if (v !== "unknown")
+            _latestVersion = v; });
+    }, 60 * 60 * 1000).unref();
     console.error(`Context Mode MCP server v${VERSION} running on stdio`);
     console.error(`Detected runtimes:\n${getRuntimeSummary(runtimes)}`);
     if (!hasBunRuntime()) {

package/build/session/db.d.ts

@@ -149,16 +149,25 @@ export declare class SessionDB extends SQLiteBase {
      */
     markResumeConsumed(sessionId: string): void;
     /**
-     * Atomically claim the most recent unconsumed resume snapshot in this DB.
+     * Atomically claim the most recent unconsumed resume snapshot in this DB,
+     * EXCLUDING any row that belongs to `currentSessionId`.
      *
      * `SessionDB` is sharded per project (see `getSessionDBPath` — SHA-256 of
      * project dir), so "this DB" already implies "this project". The atomic
      * `UPDATE … RETURNING` ensures concurrent processes for the same project
      * cannot both inject the same snapshot (Mickey / PR #376 race).
      *
-     * Returns null when no unconsumed snapshot exists.
+     * The `currentSessionId` parameter prevents self-injection: when a session
+     * compacts mid-flight and produces its own row, that session's next chat
+     * turn must NOT claim that row back (wasted tokens AND it would consume
+     * the snapshot meant for the next fresh session).
+     *
+     * Pass an empty string to allow self-claim (legacy behaviour, only useful
+     * in tests or one-off harnesses).
+     *
+     * Returns null when no unconsumed snapshot exists for any other session.
      */
-    claimLatestUnconsumedResume(): {
+    claimLatestUnconsumedResume(currentSessionId: string): {
         sessionId: string;
         snapshot: string;
     } | null;

package/build/session/db.js

@@ -256,11 +256,17 @@ export class SessionDB extends SQLiteBase {
         // statement". Required for race-safe cross-session resume injection
         // (Mickey / PR #376) — two parallel chat-turn hooks must not both read
         // the same row before either one writes consumed=1.
+        //
+        // The `session_id != ?` clause prevents self-injection (v1.0.106): when
+        // Session B compacts mid-flight and produces its own row, B's next chat
+        // turn must NOT claim that row back into its own prompt — that's wasted
+        // tokens and steals the snapshot meant for the next fresh session.
         p(S.claimLatestUnconsumedResume, `UPDATE session_resume
        SET consumed = 1
        WHERE id = (
          SELECT id FROM session_resume
          WHERE consumed = 0
+           AND session_id != ?
          ORDER BY created_at DESC, id DESC
          LIMIT 1
        )
@@ -493,17 +499,26 @@ export class SessionDB extends SQLiteBase {
         this.stmt(S.markResumeConsumed).run(sessionId);
     }
     /**
-     * Atomically claim the most recent unconsumed resume snapshot in this DB.
+     * Atomically claim the most recent unconsumed resume snapshot in this DB,
+     * EXCLUDING any row that belongs to `currentSessionId`.
      *
      * `SessionDB` is sharded per project (see `getSessionDBPath` — SHA-256 of
      * project dir), so "this DB" already implies "this project". The atomic
      * `UPDATE … RETURNING` ensures concurrent processes for the same project
      * cannot both inject the same snapshot (Mickey / PR #376 race).
      *
-     * Returns null when no unconsumed snapshot exists.
+     * The `currentSessionId` parameter prevents self-injection: when a session
+     * compacts mid-flight and produces its own row, that session's next chat
+     * turn must NOT claim that row back (wasted tokens AND it would consume
+     * the snapshot meant for the next fresh session).
+     *
+     * Pass an empty string to allow self-claim (legacy behaviour, only useful
+     * in tests or one-off harnesses).
+     *
+     * Returns null when no unconsumed snapshot exists for any other session.
      */
-    claimLatestUnconsumedResume() {
-        const row = this.stmt(S.claimLatestUnconsumedResume).get();
+    claimLatestUnconsumedResume(currentSessionId) {
+        const row = this.stmt(S.claimLatestUnconsumedResume).get(currentSessionId);
         if (!row)
             return null;
         return { sessionId: row.session_id, snapshot: row.snapshot };